Added order martching to Maker actor. Also fixed the joinStakingPool to record the pool id.

contracts/integrations/test/framework/actors/maker.ts

@@ -20,6 +20,7 @@ export interface MakerInterface {
     cancelOrderAsync: (order: SignedOrder) => Promise<TransactionReceiptWithDecodedLogs>;
     joinStakingPoolAsync: (poolId: string) => Promise<TransactionReceiptWithDecodedLogs>;
     createFillableOrderAsync: (taker: Actor) => Promise<SignedOrder>;
+    createMatchableOrdersAsync(taker: Actor): Promise<[SignedOrder, SignedOrder]>;
 }
 
 /**
@@ -138,6 +139,92 @@ export function MakerMixin<TBase extends Constructor>(Base: TBase): TBase & Cons
             });
         }
 
+        public async createMatchableOrdersAsync(taker: Actor): Promise<[SignedOrder, SignedOrder]> {
+            const { actors, balanceStore } = this.actor.simulationEnvironment!;
+            await balanceStore.updateErc20BalancesAsync();
+
+            // Choose the assets for the orders
+            const [leftMakerToken, leftTakerToken, makerFeeToken, takerFeeToken] = Pseudorandom.sampleSize(
+                this.actor.deployment.tokens.erc20,
+                4, // tslint:disable-line:custom-no-magic-numbers
+            );
+            const rightMakerToken = leftTakerToken;
+            const rightTakerToken = leftMakerToken;
+
+            // Maker and taker set balances/allowances to guarantee that the fill succeeds.
+            // Amounts are chosen to be within each actor's balance (divided by 2, in case
+            // e.g. makerAsset = makerFeeAsset)
+            const [leftMakerAssetAmount, makerFee, leftTakerAssetAmount, takerFee] = await Promise.all(
+                [
+                    [this.actor, leftMakerToken],
+                    [this.actor, rightMakerToken],
+                    [this.actor, makerFeeToken],
+                    [taker, takerFeeToken],
+                ].map(async ([owner, token]) => {
+                    let balance = balanceStore.balances.erc20[owner.address][token.address];
+                    await (owner as Actor).configureERC20TokenAsync(token as DummyERC20TokenContract);
+                    balance = balanceStore.balances.erc20[owner.address][token.address] =
+                        constants.INITIAL_ERC20_BALANCE;
+                    return Pseudorandom.integer(0, balance.dividedToIntegerBy(8));
+                }),
+            );
+
+            // Select random amounts for the right order. The only constraint is that the slope
+            // of the left price curve is greater or equal to the inverse right price curve.
+            //   leftMakerAssetAmount/leftTakerAssetAmount >= rightTakerAssetAmount/rightMakerAssetAmount.
+            // We set the `rightMakerAssetAmount` equal to the `leftTakerAssetAmount` with probability 1/10,
+            // otherwise this scenario will never occur.
+            const shouldSetRightMakerEqualToLeftTakerAmount = Pseudorandom.integer(1, 10).eq(1);
+            const rightMakerAssetAmount = shouldSetRightMakerEqualToLeftTakerAmount
+                ? leftTakerAssetAmount
+                : Pseudorandom.integer(1, constants.INITIAL_ERC20_BALANCE.dividedToIntegerBy(8));
+            const rightTakerAssetAmount = Pseudorandom.integer(
+                1,
+                rightMakerAssetAmount.times(leftMakerAssetAmount).dividedToIntegerBy(leftTakerAssetAmount),
+            );
+
+            // Encode asset data
+            const [
+                leftMakerAssetData,
+                leftTakerAssetData,
+                rightMakerAssetData,
+                rightTakerAssetData,
+                makerFeeAssetData,
+                takerFeeAssetData,
+            ] = [leftMakerToken, leftTakerToken, rightMakerToken, rightTakerToken, makerFeeToken, takerFeeToken].map(
+                token =>
+                    this.actor.deployment.assetDataEncoder.ERC20Token(token.address).getABIEncodedTransactionData(),
+            );
+
+            // Construct and sign the left order
+            const leftOrder = await this.signOrderAsync({
+                makerAssetData: leftMakerAssetData,
+                takerAssetData: leftTakerAssetData,
+                makerFeeAssetData,
+                takerFeeAssetData,
+                makerAssetAmount: leftMakerAssetAmount,
+                takerAssetAmount: leftTakerAssetAmount,
+                makerFee,
+                takerFee,
+                feeRecipientAddress: Pseudorandom.sample(actors)!.address,
+            });
+
+            // Construct and sign the right order
+            const rightOrder = await this.signOrderAsync({
+                makerAssetData: rightMakerAssetData,
+                takerAssetData: rightTakerAssetData,
+                makerFeeAssetData,
+                takerFeeAssetData,
+                makerAssetAmount: rightMakerAssetAmount,
+                takerAssetAmount: rightTakerAssetAmount,
+                makerFee,
+                takerFee,
+                feeRecipientAddress: Pseudorandom.sample(actors)!.address,
+            });
+
+            return [leftOrder, rightOrder];
+        }
+
         private async *_validJoinStakingPool(): AsyncIterableIterator<AssertionResult | void> {
             const { stakingPools } = this.actor.simulationEnvironment!;
             const assertion = validJoinStakingPoolAssertion(this.actor.deployment);
@@ -146,6 +233,7 @@ export function MakerMixin<TBase extends Constructor>(Base: TBase): TBase & Cons
                 if (poolId === undefined) {
                     yield;
                 } else {
+                    this.makerPoolId = poolId;
                     yield assertion.executeAsync([poolId], { from: this.actor.address });
                 }
             }