Merge pull request #887 from 0xProject/feature/order-watcher-v2

Order watcher v2

5 files changed, 308 insertions, 226 deletions

diff --git a/packages/fill-scenarios/package.json b/packages/fill-scenarios/package.json
index 63ae9d4ad..3a29d68ca 100644
--- a/packages/fill-scenarios/package.json
+++ b/packages/fill-scenarios/package.json
@@ -9,14 +9,14 @@
         "build": "yarn pre_build && tsc",
         "pre_build": "run-s update_artifacts generate_contract_wrappers",
         "update_artifacts": "for i in ${npm_package_config_contracts}; do copyfiles -u 4 ../migrations/artifacts/2.0.0/$i.json lib/artifacts; done;",
-        "generate_contract_wrappers": "abi-gen --abis 'lib/artifacts/@(Exchange|ERC20Token).json' --template ../contract_templates/contract.handlebars --partials '../contract_templates/partials/**/*.handlebars' --output src/generated_contract_wrappers --backend ethers",
+        "generate_contract_wrappers": "abi-gen --abis 'lib/artifacts/@(Exchange|DummyERC20Token|DummyERC721Token).json' --template ../contract_templates/contract.handlebars --partials '../contract_templates/partials/**/*.handlebars' --output src/generated_contract_wrappers --backend ethers",
         "copy_monorepo_scripts": "copyfiles -u 3 './lib/src/monorepo_scripts/**/*' ./scripts",
         "clean": "shx rm -rf lib scripts src/generated_contract_wrappers",
         "lint": "tslint --project . --exclude **/src/generated_contract_wrappers/**/*",
         "manual:postpublish": "yarn build; node ./scripts/postpublish.js"
     },
     "config": {
-        "contracts": "Exchange ERC20Token"
+        "contracts": "Exchange DummyERC20Token DummyERC721Token"
     },
     "license": "Apache-2.0",
     "repository": {
diff --git a/packages/fill-scenarios/src/artifacts.ts b/packages/fill-scenarios/src/artifacts.ts
index f75374ba2..7f68ae26a 100644
--- a/packages/fill-scenarios/src/artifacts.ts
+++ b/packages/fill-scenarios/src/artifacts.ts
@@ -1,9 +1,11 @@
 import { ContractArtifact } from '@0xproject/sol-compiler';
 
-import * as ERC20Token from './artifacts/ERC20Token.json';
+import * as DummyERC20Token from './artifacts/DummyERC20Token.json';
+import * as DummyERC721Token from './artifacts/DummyERC721Token.json';
 import * as Exchange from './artifacts/Exchange.json';
 
 export const artifacts = {
-    ERC20Token: (ERC20Token as any) as ContractArtifact,
+    DummyERC20Token: (DummyERC20Token as any) as ContractArtifact,
+    DummyERC721Token: (DummyERC721Token as any) as ContractArtifact,
     Exchange: (Exchange as any) as ContractArtifact,
 };
diff --git a/packages/fill-scenarios/src/constants.ts b/packages/fill-scenarios/src/constants.ts
index ec2fe744a..5661b059f 100644
--- a/packages/fill-scenarios/src/constants.ts
+++ b/packages/fill-scenarios/src/constants.ts
@@ -1,3 +1,4 @@
 export const constants = {
+    AWAIT_TRANSACTION_MINED_MS: 0,
     NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
 };
diff --git a/packages/fill-scenarios/src/fill_scenarios.ts b/packages/fill-scenarios/src/fill_scenarios.ts
new file mode 100644
index 000000000..8f2766e24
--- /dev/null
+++ b/packages/fill-scenarios/src/fill_scenarios.ts
@@ -0,0 +1,300 @@
+import { assetDataUtils, orderFactory } from '@0xproject/order-utils';
+import { AssetProxyId, ERC721AssetData, OrderWithoutExchangeAddress, SignedOrder } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import { Provider } from 'ethereum-types';
+import * as _ from 'lodash';
+
+import { artifacts } from './artifacts';
+import { constants } from './constants';
+import { DummyERC20TokenContract } from './generated_contract_wrappers/dummy_erc20_token';
+import { DummyERC721TokenContract } from './generated_contract_wrappers/dummy_erc721_token';
+import { ExchangeContract } from './generated_contract_wrappers/exchange';
+
+export class FillScenarios {
+    private readonly _web3Wrapper: Web3Wrapper;
+    private readonly _userAddresses: string[];
+    private readonly _coinbase: string;
+    private readonly _zrxTokenAddress: string;
+    private readonly _exchangeAddress: string;
+    private readonly _erc20ProxyAddress: string;
+    private readonly _erc721ProxyAddress: string;
+    constructor(
+        provider: Provider,
+        userAddresses: string[],
+        zrxTokenAddress: string,
+        exchangeAddress: string,
+        erc20ProxyAddress: string,
+        erc721ProxyAddress: string,
+    ) {
+        this._web3Wrapper = new Web3Wrapper(provider);
+        this._userAddresses = userAddresses;
+        this._coinbase = userAddresses[0];
+        this._zrxTokenAddress = zrxTokenAddress;
+        this._exchangeAddress = exchangeAddress;
+        this._erc20ProxyAddress = erc20ProxyAddress;
+        this._erc721ProxyAddress = erc721ProxyAddress;
+    }
+    public async createFillableSignedOrderAsync(
+        makerAssetData: string,
+        takerAssetData: string,
+        makerAddress: string,
+        takerAddress: string,
+        fillableAmount: BigNumber,
+        expirationTimeSeconds?: BigNumber,
+    ): Promise<SignedOrder> {
+        return this.createAsymmetricFillableSignedOrderAsync(
+            makerAssetData,
+            takerAssetData,
+            makerAddress,
+            takerAddress,
+            fillableAmount,
+            fillableAmount,
+            expirationTimeSeconds,
+        );
+    }
+    public async createFillableSignedOrderWithFeesAsync(
+        makerAssetData: string,
+        takerAssetData: string,
+        makerFee: BigNumber,
+        takerFee: BigNumber,
+        makerAddress: string,
+        takerAddress: string,
+        fillableAmount: BigNumber,
+        feeRecepientAddress: string,
+        expirationTimeSeconds?: BigNumber,
+    ): Promise<SignedOrder> {
+        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
+            makerAssetData,
+            takerAssetData,
+            makerFee,
+            takerFee,
+            makerAddress,
+            takerAddress,
+            fillableAmount,
+            fillableAmount,
+            feeRecepientAddress,
+            expirationTimeSeconds,
+        );
+    }
+    public async createAsymmetricFillableSignedOrderAsync(
+        makerAssetData: string,
+        takerAssetData: string,
+        makerAddress: string,
+        takerAddress: string,
+        makerFillableAmount: BigNumber,
+        takerFillableAmount: BigNumber,
+        expirationTimeSeconds?: BigNumber,
+    ): Promise<SignedOrder> {
+        const makerFee = new BigNumber(0);
+        const takerFee = new BigNumber(0);
+        const feeRecepientAddress = constants.NULL_ADDRESS;
+        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
+            makerAssetData,
+            takerAssetData,
+            makerFee,
+            takerFee,
+            makerAddress,
+            takerAddress,
+            makerFillableAmount,
+            takerFillableAmount,
+            feeRecepientAddress,
+            expirationTimeSeconds,
+        );
+    }
+    public async createPartiallyFilledSignedOrderAsync(
+        makerAssetData: string,
+        takerAssetData: string,
+        takerAddress: string,
+        fillableAmount: BigNumber,
+        partialFillAmount: BigNumber,
+    ): Promise<SignedOrder> {
+        const [makerAddress] = this._userAddresses;
+        const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
+            makerAssetData,
+            takerAssetData,
+            makerAddress,
+            takerAddress,
+            fillableAmount,
+            fillableAmount,
+        );
+        const exchangeInstance = new ExchangeContract(
+            artifacts.Exchange.compilerOutput.abi,
+            signedOrder.exchangeAddress,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
+
+        const orderWithoutExchangeAddress = _.omit(signedOrder, [
+            'signature',
+            'exchangeAddress',
+        ]) as OrderWithoutExchangeAddress;
+
+        const txHash = await exchangeInstance.fillOrder.sendTransactionAsync(
+            orderWithoutExchangeAddress,
+            partialFillAmount,
+            signedOrder.signature,
+            { from: takerAddress },
+        );
+        await this._web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
+        return signedOrder;
+    }
+    private async _createAsymmetricFillableSignedOrderWithFeesAsync(
+        makerAssetData: string,
+        takerAssetData: string,
+        makerFee: BigNumber,
+        takerFee: BigNumber,
+        makerAddress: string,
+        takerAddress: string,
+        makerFillableAmount: BigNumber,
+        takerFillableAmount: BigNumber,
+        feeRecepientAddress: string,
+        expirationTimeSeconds?: BigNumber,
+    ): Promise<SignedOrder> {
+        const decodedMakerAssetData = assetDataUtils.decodeAssetDataOrThrow(makerAssetData);
+        if (decodedMakerAssetData.assetProxyId === AssetProxyId.ERC20) {
+            await this._increaseERC20BalanceAndAllowanceAsync(
+                decodedMakerAssetData.tokenAddress,
+                makerAddress,
+                makerFillableAmount,
+            );
+        } else {
+            if (!makerFillableAmount.equals(1)) {
+                throw new Error(`ERC721 makerFillableAmount should be equal 1. Found: ${makerFillableAmount}`);
+            }
+            await this._increaseERC721BalanceAndAllowanceAsync(
+                decodedMakerAssetData.tokenAddress,
+                makerAddress,
+                // tslint:disable-next-line:no-unnecessary-type-assertion
+                (decodedMakerAssetData as ERC721AssetData).tokenId,
+            );
+        }
+        const decodedTakerAssetData = assetDataUtils.decodeAssetDataOrThrow(takerAssetData);
+        if (decodedTakerAssetData.assetProxyId === AssetProxyId.ERC20) {
+            const takerTokenAddress = decodedTakerAssetData.tokenAddress;
+            await this._increaseERC20BalanceAndAllowanceAsync(takerTokenAddress, takerAddress, takerFillableAmount);
+        } else {
+            if (!takerFillableAmount.equals(1)) {
+                throw new Error(`ERC721 takerFillableAmount should be equal 1. Found: ${takerFillableAmount}`);
+            }
+            await this._increaseERC721BalanceAndAllowanceAsync(
+                decodedTakerAssetData.tokenAddress,
+                takerAddress,
+                // tslint:disable-next-line:no-unnecessary-type-assertion
+                (decodedMakerAssetData as ERC721AssetData).tokenId,
+            );
+        }
+        // Fees
+        await Promise.all([
+            this._increaseERC20BalanceAndAllowanceAsync(this._zrxTokenAddress, makerAddress, makerFee),
+            this._increaseERC20BalanceAndAllowanceAsync(this._zrxTokenAddress, takerAddress, takerFee),
+        ]);
+        const senderAddress = constants.NULL_ADDRESS;
+
+        const signedOrder = await orderFactory.createSignedOrderAsync(
+            this._web3Wrapper.getProvider(),
+            makerAddress,
+            takerAddress,
+            senderAddress,
+            makerFee,
+            takerFee,
+            makerFillableAmount,
+            makerAssetData,
+            takerFillableAmount,
+            takerAssetData,
+            this._exchangeAddress,
+            feeRecepientAddress,
+            expirationTimeSeconds,
+        );
+        return signedOrder;
+    }
+    private async _increaseERC721BalanceAndAllowanceAsync(
+        tokenAddress: string,
+        address: string,
+        tokenId: BigNumber,
+    ): Promise<void> {
+        await this._increaseERC721BalanceAsync(tokenAddress, address, tokenId);
+        await this._increaseERC721AllowanceAsync(tokenAddress, address, tokenId);
+    }
+    private async _increaseERC721AllowanceAsync(
+        tokenAddress: string,
+        address: string,
+        tokenId: BigNumber,
+    ): Promise<void> {
+        const erc721Token = new DummyERC721TokenContract(
+            artifacts.DummyERC721Token.compilerOutput.abi,
+            tokenAddress,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
+        const txHash = await erc721Token.approve.sendTransactionAsync(this._erc721ProxyAddress, tokenId, {
+            from: address,
+        });
+        await this._web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
+    }
+    private async _increaseERC721BalanceAsync(
+        tokenAddress: string,
+        address: string,
+        tokenId: BigNumber,
+    ): Promise<void> {
+        const erc721Token = new DummyERC721TokenContract(
+            artifacts.DummyERC721Token.compilerOutput.abi,
+            tokenAddress,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
+        try {
+            const currentOwner = await erc721Token.ownerOf.callAsync(tokenId);
+            if (currentOwner !== address) {
+                throw new Error(`Token ${tokenAddress}:${tokenId} is already owner by ${currentOwner}`);
+            }
+        } catch (err) {
+            const txHash = await erc721Token.mint.sendTransactionAsync(address, tokenId, { from: this._coinbase });
+            await this._web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
+        }
+    }
+    private async _increaseERC20BalanceAndAllowanceAsync(
+        tokenAddress: string,
+        address: string,
+        amount: BigNumber,
+    ): Promise<void> {
+        if (amount.isZero() || address === constants.NULL_ADDRESS) {
+            return; // noop
+        }
+        await Promise.all([
+            this._increaseERC20BalanceAsync(tokenAddress, address, amount),
+            this._increaseERC20AllowanceAsync(tokenAddress, address, amount),
+        ]);
+    }
+    private async _increaseERC20BalanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
+        const erc20Token = new DummyERC20TokenContract(
+            artifacts.DummyERC20Token.compilerOutput.abi,
+            tokenAddress,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
+        const txHash = await erc20Token.transfer.sendTransactionAsync(address, amount, {
+            from: this._coinbase,
+        });
+        await this._web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
+    }
+    private async _increaseERC20AllowanceAsync(
+        tokenAddress: string,
+        address: string,
+        amount: BigNumber,
+    ): Promise<void> {
+        const erc20Token = new DummyERC20TokenContract(
+            artifacts.DummyERC20Token.compilerOutput.abi,
+            tokenAddress,
+            this._web3Wrapper.getProvider(),
+            this._web3Wrapper.getContractDefaults(),
+        );
+        const oldMakerAllowance = await erc20Token.allowance.callAsync(address, this._erc20ProxyAddress);
+        const newMakerAllowance = oldMakerAllowance.plus(amount);
+
+        const txHash = await erc20Token.approve.sendTransactionAsync(this._erc20ProxyAddress, newMakerAllowance, {
+            from: address,
+        });
+        await this._web3Wrapper.awaitTransactionSuccessAsync(txHash, constants.AWAIT_TRANSACTION_MINED_MS);
+    }
+}
diff --git a/packages/fill-scenarios/src/index.ts b/packages/fill-scenarios/src/index.ts
index f4d085b68..c51145cdb 100644
--- a/packages/fill-scenarios/src/index.ts
+++ b/packages/fill-scenarios/src/index.ts
@@ -1,222 +1 @@
-import { assetDataUtils, orderFactory } from '@0xproject/order-utils';
-import { OrderWithoutExchangeAddress, SignedOrder } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import { Web3Wrapper } from '@0xproject/web3-wrapper';
-import { Provider } from 'ethereum-types';
-import * as _ from 'lodash';
-
-import { artifacts } from './artifacts';
-import { constants } from './constants';
-import { ERC20TokenContract } from './generated_contract_wrappers/erc20_token';
-import { ExchangeContract } from './generated_contract_wrappers/exchange';
-
-export class FillScenarios {
-    private readonly _web3Wrapper: Web3Wrapper;
-    private readonly _userAddresses: string[];
-    private readonly _coinbase: string;
-    private readonly _zrxTokenAddress: string;
-    private readonly _exchangeAddress: string;
-    private readonly _erc20ProxyAddress: string;
-    constructor(
-        provider: Provider,
-        userAddresses: string[],
-        zrxTokenAddress: string,
-        exchangeAddress: string,
-        erc20ProxyAddress: string,
-    ) {
-        this._web3Wrapper = new Web3Wrapper(provider);
-        this._userAddresses = userAddresses;
-        this._coinbase = userAddresses[0];
-        this._zrxTokenAddress = zrxTokenAddress;
-        this._exchangeAddress = exchangeAddress;
-        this._erc20ProxyAddress = erc20ProxyAddress;
-    }
-    public async createFillableSignedOrderAsync(
-        makerAssetData: string,
-        takerAssetData: string,
-        makerAddress: string,
-        takerAddress: string,
-        fillableAmount: BigNumber,
-        expirationTimeSeconds?: BigNumber,
-    ): Promise<SignedOrder> {
-        return this.createAsymmetricFillableSignedOrderAsync(
-            makerAssetData,
-            takerAssetData,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
-            expirationTimeSeconds,
-        );
-    }
-    public async createFillableSignedOrderWithFeesAsync(
-        makerAssetData: string,
-        takerAssetData: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
-        makerAddress: string,
-        takerAddress: string,
-        fillableAmount: BigNumber,
-        feeRecepientAddress: string,
-        expirationTimeSeconds?: BigNumber,
-    ): Promise<SignedOrder> {
-        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
-            makerAssetData,
-            takerAssetData,
-            makerFee,
-            takerFee,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
-            feeRecepientAddress,
-            expirationTimeSeconds,
-        );
-    }
-    public async createAsymmetricFillableSignedOrderAsync(
-        makerAssetData: string,
-        takerAssetData: string,
-        makerAddress: string,
-        takerAddress: string,
-        makerFillableAmount: BigNumber,
-        takerFillableAmount: BigNumber,
-        expirationTimeSeconds?: BigNumber,
-    ): Promise<SignedOrder> {
-        const makerFee = new BigNumber(0);
-        const takerFee = new BigNumber(0);
-        const feeRecepientAddress = constants.NULL_ADDRESS;
-        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
-            makerAssetData,
-            takerAssetData,
-            makerFee,
-            takerFee,
-            makerAddress,
-            takerAddress,
-            makerFillableAmount,
-            takerFillableAmount,
-            feeRecepientAddress,
-            expirationTimeSeconds,
-        );
-    }
-    public async createPartiallyFilledSignedOrderAsync(
-        makerAssetData: string,
-        takerAssetData: string,
-        takerAddress: string,
-        fillableAmount: BigNumber,
-        partialFillAmount: BigNumber,
-    ): Promise<SignedOrder> {
-        const [makerAddress] = this._userAddresses;
-        const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
-            makerAssetData,
-            takerAssetData,
-            makerAddress,
-            takerAddress,
-            fillableAmount,
-            fillableAmount,
-        );
-        const exchangeInstance = new ExchangeContract(
-            artifacts.Exchange.compilerOutput.abi,
-            signedOrder.exchangeAddress,
-            this._web3Wrapper.getProvider(),
-            this._web3Wrapper.getContractDefaults(),
-        );
-
-        const orderWithoutExchangeAddress = _.omit(signedOrder, [
-            'signature',
-            'exchangeAddress',
-        ]) as OrderWithoutExchangeAddress;
-
-        await exchangeInstance.fillOrder.sendTransactionAsync(
-            orderWithoutExchangeAddress,
-            partialFillAmount,
-            signedOrder.signature,
-            { from: takerAddress },
-        );
-        return signedOrder;
-    }
-    private async _createAsymmetricFillableSignedOrderWithFeesAsync(
-        makerAssetData: string,
-        takerAssetData: string,
-        makerFee: BigNumber,
-        takerFee: BigNumber,
-        makerAddress: string,
-        takerAddress: string,
-        makerFillableAmount: BigNumber,
-        takerFillableAmount: BigNumber,
-        feeRecepientAddress: string,
-        expirationTimeSeconds?: BigNumber,
-    ): Promise<SignedOrder> {
-        const makerERC20AssetData = assetDataUtils.decodeERC20AssetData(makerAssetData);
-        const makerTokenAddress = makerERC20AssetData.tokenAddress;
-        const takerERC20AssetData = assetDataUtils.decodeERC20AssetData(takerAssetData);
-        const takerTokenAddress = takerERC20AssetData.tokenAddress;
-        await Promise.all([
-            this._increaseERC20BalanceAndAllowanceAsync(makerTokenAddress, makerAddress, makerFillableAmount),
-            this._increaseERC20BalanceAndAllowanceAsync(takerTokenAddress, takerAddress, takerFillableAmount),
-        ]);
-        await Promise.all([
-            this._increaseERC20BalanceAndAllowanceAsync(this._zrxTokenAddress, makerAddress, makerFee),
-            this._increaseERC20BalanceAndAllowanceAsync(this._zrxTokenAddress, takerAddress, takerFee),
-        ]);
-        const senderAddress = constants.NULL_ADDRESS;
-
-        const signedOrder = await orderFactory.createSignedOrderAsync(
-            this._web3Wrapper.getProvider(),
-            makerAddress,
-            takerAddress,
-            senderAddress,
-            makerFee,
-            takerFee,
-            makerFillableAmount,
-            makerAssetData,
-            takerFillableAmount,
-            takerAssetData,
-            this._exchangeAddress,
-            feeRecepientAddress,
-            expirationTimeSeconds,
-        );
-        return signedOrder;
-    }
-    private async _increaseERC20BalanceAndAllowanceAsync(
-        tokenAddress: string,
-        address: string,
-        amount: BigNumber,
-    ): Promise<void> {
-        if (amount.isZero() || address === constants.NULL_ADDRESS) {
-            return; // noop
-        }
-        await Promise.all([
-            this._increaseERC20BalanceAsync(tokenAddress, address, amount),
-            this._increaseERC20AllowanceAsync(tokenAddress, address, amount),
-        ]);
-    }
-    private async _increaseERC20BalanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
-        const token = new ERC20TokenContract(
-            artifacts.ERC20Token.compilerOutput.abi,
-            tokenAddress,
-            this._web3Wrapper.getProvider(),
-            this._web3Wrapper.getContractDefaults(),
-        );
-        await token.transfer.sendTransactionAsync(address, amount, {
-            from: this._coinbase,
-        });
-    }
-    private async _increaseERC20AllowanceAsync(
-        tokenAddress: string,
-        address: string,
-        amount: BigNumber,
-    ): Promise<void> {
-        const tokenInstance = new ERC20TokenContract(
-            artifacts.ERC20Token.compilerOutput.abi,
-            tokenAddress,
-            this._web3Wrapper.getProvider(),
-            this._web3Wrapper.getContractDefaults(),
-        );
-        const oldMakerAllowance = await tokenInstance.allowance.callAsync(address, this._erc20ProxyAddress);
-        const newMakerAllowance = oldMakerAllowance.plus(amount);
-
-        await tokenInstance.approve.sendTransactionAsync(this._erc20ProxyAddress, newMakerAllowance, {
-            from: address,
-        });
-    }
-}
+export { FillScenarios } from './fill_scenarios';