import { encodeERC20AssetData } from '@0x/contracts-asset-proxy'; import { DummyERC20TokenContract } from '@0x/contracts-erc20'; import { constants, OrderFactory } from '@0x/contracts-test-utils'; import { Order, SignedOrder } from '@0x/types'; import { TransactionReceiptWithDecodedLogs } from 'ethereum-types'; import { AssertionResult } from '../assertions/function_assertion'; import { validJoinStakingPoolAssertion } from '../assertions/joinStakingPool'; import { Pseudorandom } from '../utils/pseudorandom'; import { Actor, ActorConfig, Constructor } from './base'; interface MakerConfig extends ActorConfig { orderConfig: Partial; } export interface MakerInterface { makerPoolId?: string; orderFactory: OrderFactory; signOrderAsync: (customOrderParams?: Partial) => Promise; cancelOrderAsync: (order: SignedOrder) => Promise; joinStakingPoolAsync: (poolId: string) => Promise; createFillableOrderAsync: (taker: Actor) => Promise; createMatchableOrdersAsync(taker: Actor): Promise<[SignedOrder, SignedOrder]>; } /** * This mixin encapsulates functionality associated with makers within the 0x ecosystem. * This includes signing and canceling orders, as well as joining a staking pool as a maker. */ export function MakerMixin(Base: TBase): TBase & Constructor { return class extends Base { public makerPoolId?: string; public readonly actor: Actor; public readonly orderFactory: OrderFactory; /** * The mixin pattern requires that this constructor uses `...args: any[]`, but this class * really expects a single `MakerConfig` parameter (assuming `Actor` is used as the base * class). */ constructor(...args: any[]) { // tslint:disable-next-line:no-inferred-empty-object-type super(...args); this.actor = (this as any) as Actor; this.actor.mixins.push('Maker'); const { orderConfig } = args[0] as MakerConfig; const defaultOrderParams = { ...constants.STATIC_ORDER_PARAMS, makerAddress: this.actor.address, exchangeAddress: this.actor.deployment.exchange.address, chainId: this.actor.deployment.chainId, ...orderConfig, }; this.orderFactory = new OrderFactory(this.actor.privateKey, defaultOrderParams); // Register this mixin's assertion generators this.actor.simulationActions = { ...this.actor.simulationActions, validJoinStakingPool: this._validJoinStakingPool(), }; } /** * Signs an order (optionally, with custom parameters) as the maker. */ public async signOrderAsync(customOrderParams: Partial = {}): Promise { return this.orderFactory.newSignedOrderAsync(customOrderParams); } /** * Cancels one of the maker's orders. */ public async cancelOrderAsync(order: SignedOrder): Promise { return this.actor.deployment.exchange.cancelOrder(order).awaitTransactionSuccessAsync({ from: this.actor.address, }); } /** * Joins the staking pool specified by the given ID. */ public async joinStakingPoolAsync(poolId: string): Promise { const stakingContract = this.actor.deployment.staking.stakingWrapper; this.makerPoolId = poolId; return stakingContract.joinStakingPoolAsMaker(poolId).awaitTransactionSuccessAsync({ from: this.actor.address, }); } public async createFillableOrderAsync(taker: Actor): Promise { const { actors, balanceStore } = this.actor.simulationEnvironment!; await balanceStore.updateErc20BalancesAsync(); // Choose the assets for the order const [makerToken, makerFeeToken, takerToken, takerFeeToken] = Pseudorandom.sampleSize( this.actor.deployment.tokens.erc20, 4, // tslint:disable-line:custom-no-magic-numbers ); // Maker and taker set balances/allowances to guarantee that the fill succeeds. // Amounts are chosen to be within each actor's balance (divided by 8, in case // e.g. makerAsset = makerFeeAsset) const [makerAssetAmount, makerFee, takerAssetAmount, takerFee] = await Promise.all( [ [this.actor, makerToken], [this.actor, makerFeeToken], [taker, takerToken], [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(2)); }), ); // Encode asset data const [makerAssetData, makerFeeAssetData, takerAssetData, takerFeeAssetData] = [ makerToken, makerFeeToken, takerToken, takerFeeToken, ].map(token => encodeERC20AssetData(token.address)); // Maker signs the order return this.signOrderAsync({ makerAssetData, takerAssetData, makerFeeAssetData, takerFeeAssetData, makerAssetAmount, takerAssetAmount, makerFee, takerFee, feeRecipientAddress: Pseudorandom.sample(actors)!.address, }); } 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 => encodeERC20AssetData(token.address), ); // 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 { const { stakingPools } = this.actor.simulationEnvironment!; const assertion = validJoinStakingPoolAssertion(this.actor.deployment); while (true) { const poolId = Pseudorandom.sample(Object.keys(stakingPools)); if (poolId === undefined) { yield; } else { this.makerPoolId = poolId; yield assertion.executeAsync([poolId], { from: this.actor.address }); } } } }; } export class Maker extends MakerMixin(Actor) {}