regenerate artifacts and wrappers

packages/abi-gen/test-cli/output/typescript/abi_gen_dummy.ts

@@ -53,6 +53,7 @@ export interface AbiGenDummyWithdrawalEventArgs extends DecodedLogArgs {
 }
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class AbiGenDummyContract extends BaseContract {

packages/abi-gen/test-cli/output/typescript/lib_dummy.ts

@@ -34,6 +34,7 @@ import * as ethers from 'ethers';
 // tslint:enable:no-unused-variable
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class LibDummyContract extends BaseContract {

packages/abi-gen/test-cli/output/typescript/test_lib_dummy.ts

@@ -34,6 +34,7 @@ import * as ethers from 'ethers';
 // tslint:enable:no-unused-variable
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class TestLibDummyContract extends BaseContract {

packages/contract-wrappers/src/generated-wrappers/coordinator.ts

@@ -34,6 +34,7 @@ import * as ethers from 'ethers';
 // tslint:enable:no-unused-variable
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class CoordinatorContract extends BaseContract {

packages/contract-wrappers/src/generated-wrappers/erc20_token.ts

@@ -55,6 +55,7 @@ export interface ERC20TokenTransferEventArgs extends DecodedLogArgs {
 }
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class ERC20TokenContract extends BaseContract {

packages/contract-wrappers/src/generated-wrappers/erc721_token.ts

@@ -65,6 +65,7 @@ export interface ERC721TokenTransferEventArgs extends DecodedLogArgs {
 }
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class ERC721TokenContract extends BaseContract {

packages/contract-wrappers/src/generated-wrappers/exchange.ts

@@ -121,6 +121,7 @@ export interface ExchangeTransactionExecutionEventArgs extends DecodedLogArgs {
 }
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class ExchangeContract extends BaseContract {

packages/contract-wrappers/src/generated-wrappers/forwarder.ts

@@ -47,6 +47,7 @@ export interface ForwarderOwnershipTransferredEventArgs extends DecodedLogArgs {
 }
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class ForwarderContract extends BaseContract {
@@ -238,6 +239,34 @@ export class ForwarderContract extends BaseContract {
                 stateMutability: 'payable',
                 type: 'fallback',
             },
+            {
+                constant: true,
+                inputs: [],
+                name: 'ERC1155_BATCH_RECEIVED',
+                outputs: [
+                    {
+                        name: '',
+                        type: 'bytes4',
+                    },
+                ],
+                payable: false,
+                stateMutability: 'view',
+                type: 'function',
+            },
+            {
+                constant: true,
+                inputs: [],
+                name: 'ERC1155_RECEIVED',
+                outputs: [
+                    {
+                        name: '',
+                        type: 'bytes4',
+                    },
+                ],
+                payable: false,
+                stateMutability: 'view',
+                type: 'function',
+            },
             {
                 constant: true,
                 inputs: [],
@@ -456,6 +485,76 @@ export class ForwarderContract extends BaseContract {
                 stateMutability: 'payable',
                 type: 'function',
             },
+            {
+                constant: false,
+                inputs: [
+                    {
+                        name: 'operator',
+                        type: 'address',
+                    },
+                    {
+                        name: 'from',
+                        type: 'address',
+                    },
+                    {
+                        name: 'ids',
+                        type: 'uint256[]',
+                    },
+                    {
+                        name: 'values',
+                        type: 'uint256[]',
+                    },
+                    {
+                        name: 'data',
+                        type: 'bytes',
+                    },
+                ],
+                name: 'onERC1155BatchReceived',
+                outputs: [
+                    {
+                        name: '',
+                        type: 'bytes4',
+                    },
+                ],
+                payable: false,
+                stateMutability: 'nonpayable',
+                type: 'function',
+            },
+            {
+                constant: false,
+                inputs: [
+                    {
+                        name: 'operator',
+                        type: 'address',
+                    },
+                    {
+                        name: 'from',
+                        type: 'address',
+                    },
+                    {
+                        name: 'id',
+                        type: 'uint256',
+                    },
+                    {
+                        name: 'value',
+                        type: 'uint256',
+                    },
+                    {
+                        name: 'data',
+                        type: 'bytes',
+                    },
+                ],
+                name: 'onERC1155Received',
+                outputs: [
+                    {
+                        name: '',
+                        type: 'bytes4',
+                    },
+                ],
+                payable: false,
+                stateMutability: 'nonpayable',
+                type: 'function',
+            },
             {
                 constant: true,
                 inputs: [],
@@ -581,6 +680,46 @@ export class ForwarderContract extends BaseContract {
         return abiEncoder.getSelector();
     }
 
+    public ERC1155_BATCH_RECEIVED(): ContractFunctionObj<string> {
+        const self = (this as any) as ForwarderContract;
+        const functionSignature = 'ERC1155_BATCH_RECEIVED()';
+
+        return {
+            async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+                BaseContract._assertCallParams(callData, defaultBlock);
+                const rawCallResult = await self._performCallAsync(
+                    { ...callData, data: this.getABIEncodedTransactionData() },
+                    defaultBlock,
+                );
+                const abiEncoder = self._lookupAbiEncoder(functionSignature);
+                BaseContract._throwIfUnexpectedEmptyCallResult(rawCallResult, abiEncoder);
+                return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
+            },
+            getABIEncodedTransactionData(): string {
+                return self._strictEncodeArguments(functionSignature, []);
+            },
+        };
+    }
+    public ERC1155_RECEIVED(): ContractFunctionObj<string> {
+        const self = (this as any) as ForwarderContract;
+        const functionSignature = 'ERC1155_RECEIVED()';
+
+        return {
+            async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+                BaseContract._assertCallParams(callData, defaultBlock);
+                const rawCallResult = await self._performCallAsync(
+                    { ...callData, data: this.getABIEncodedTransactionData() },
+                    defaultBlock,
+                );
+                const abiEncoder = self._lookupAbiEncoder(functionSignature);
+                BaseContract._throwIfUnexpectedEmptyCallResult(rawCallResult, abiEncoder);
+                return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
+            },
+            getABIEncodedTransactionData(): string {
+                return self._strictEncodeArguments(functionSignature, []);
+            },
+        };
+    }
     public EXCHANGE_V2_ORDER_ID(): ContractFunctionObj<string> {
         const self = (this as any) as ForwarderContract;
         const functionSignature = 'EXCHANGE_V2_ORDER_ID()';
@@ -842,6 +981,150 @@ export class ForwarderContract extends BaseContract {
             },
         };
     }
+    /**
+     * The smart contract calls this function on the recipient after a `safeTransferFrom`. This function MAY throw to revert and reject the transfer. Return of other than the magic value MUST result in the transaction being reverted Note: the contract address is always the message sender
+     * @param operator The address which called `safeTransferFrom` function
+     * @param from The address which previously owned the token
+     * @param ids An array containing ids of each token being transferred
+     * @param values An array containing amounts of each token being transferred
+     * @param data Additional data with no specified format
+     * @returns &#x60;bytes4(keccak256(&quot;onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)&quot;))&#x60;
+     */
+    public onERC1155BatchReceived(
+        operator: string,
+        from: string,
+        ids: BigNumber[],
+        values: BigNumber[],
+        data: string,
+    ): ContractTxFunctionObj<string> {
+        const self = (this as any) as ForwarderContract;
+        assert.isString('operator', operator);
+        assert.isString('from', from);
+        assert.isArray('ids', ids);
+        assert.isArray('values', values);
+        assert.isString('data', data);
+        const functionSignature = 'onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)';
+
+        return {
+            async sendTransactionAsync(
+                txData?: Partial<TxData> | undefined,
+                opts: SendTransactionOpts = { shouldValidate: true },
+            ): Promise<string> {
+                const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+                    { ...txData, data: this.getABIEncodedTransactionData() },
+                    this.estimateGasAsync.bind(this),
+                );
+                if (opts.shouldValidate !== false) {
+                    await this.callAsync(txDataWithDefaults);
+                }
+                return self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+            },
+            awaitTransactionSuccessAsync(
+                txData?: Partial<TxData>,
+                opts: AwaitTransactionSuccessOpts = { shouldValidate: true },
+            ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
+                return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
+            },
+            async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
+                const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+                    ...txData,
+                    data: this.getABIEncodedTransactionData(),
+                });
+                return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+            },
+            async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+                BaseContract._assertCallParams(callData, defaultBlock);
+                const rawCallResult = await self._performCallAsync(
+                    { ...callData, data: this.getABIEncodedTransactionData() },
+                    defaultBlock,
+                );
+                const abiEncoder = self._lookupAbiEncoder(functionSignature);
+                BaseContract._throwIfUnexpectedEmptyCallResult(rawCallResult, abiEncoder);
+                return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
+            },
+            getABIEncodedTransactionData(): string {
+                return self._strictEncodeArguments(functionSignature, [
+                    operator.toLowerCase(),
+                    from.toLowerCase(),
+                    ids,
+                    values,
+                    data,
+                ]);
+            },
+        };
+    }
+    /**
+     * The smart contract calls this function on the recipient after a `safeTransferFrom`. This function MAY throw to revert and reject the transfer. Return of other than the magic value MUST result in the transaction being reverted Note: the contract address is always the message sender
+     * @param operator The address which called `safeTransferFrom` function
+     * @param from The address which previously owned the token
+     * @param id An array containing the ids of the token being transferred
+     * @param value An array containing the amount of tokens being transferred
+     * @param data Additional data with no specified format
+     * @returns &#x60;bytes4(keccak256(&quot;onERC1155Received(address,address,uint256,uint256,bytes)&quot;))&#x60;
+     */
+    public onERC1155Received(
+        operator: string,
+        from: string,
+        id: BigNumber,
+        value: BigNumber,
+        data: string,
+    ): ContractTxFunctionObj<string> {
+        const self = (this as any) as ForwarderContract;
+        assert.isString('operator', operator);
+        assert.isString('from', from);
+        assert.isBigNumber('id', id);
+        assert.isBigNumber('value', value);
+        assert.isString('data', data);
+        const functionSignature = 'onERC1155Received(address,address,uint256,uint256,bytes)';
+
+        return {
+            async sendTransactionAsync(
+                txData?: Partial<TxData> | undefined,
+                opts: SendTransactionOpts = { shouldValidate: true },
+            ): Promise<string> {
+                const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+                    { ...txData, data: this.getABIEncodedTransactionData() },
+                    this.estimateGasAsync.bind(this),
+                );
+                if (opts.shouldValidate !== false) {
+                    await this.callAsync(txDataWithDefaults);
+                }
+                return self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+            },
+            awaitTransactionSuccessAsync(
+                txData?: Partial<TxData>,
+                opts: AwaitTransactionSuccessOpts = { shouldValidate: true },
+            ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
+                return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
+            },
+            async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
+                const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+                    ...txData,
+                    data: this.getABIEncodedTransactionData(),
+                });
+                return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+            },
+            async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+                BaseContract._assertCallParams(callData, defaultBlock);
+                const rawCallResult = await self._performCallAsync(
+                    { ...callData, data: this.getABIEncodedTransactionData() },
+                    defaultBlock,
+                );
+                const abiEncoder = self._lookupAbiEncoder(functionSignature);
+                BaseContract._throwIfUnexpectedEmptyCallResult(rawCallResult, abiEncoder);
+                return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
+            },
+            getABIEncodedTransactionData(): string {
+                return self._strictEncodeArguments(functionSignature, [
+                    operator.toLowerCase(),
+                    from.toLowerCase(),
+                    id,
+                    value,
+                    data,
+                ]);
+            },
+        };
+    }
     public owner(): ContractFunctionObj<string> {
         const self = (this as any) as ForwarderContract;
         const functionSignature = 'owner()';

packages/contract-wrappers/src/generated-wrappers/i_asset_data.ts

@@ -34,6 +34,7 @@ import * as ethers from 'ethers';
 // tslint:enable:no-unused-variable
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class IAssetDataContract extends BaseContract {

packages/contract-wrappers/src/generated-wrappers/i_erc20_bridge_sampler.ts

@@ -34,6 +34,7 @@ import * as ethers from 'ethers';
 // tslint:enable:no-unused-variable
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class IERC20BridgeSamplerContract extends BaseContract {
@@ -952,7 +953,7 @@ export class IERC20BridgeSamplerContract extends BaseContract {
      * @returns ordersAndSamples How much taker asset can be filled         by each order in `orders`. Taker amounts sold for each source at         each maker token amount. First indexed by source index, then sample         index
      */
     public queryBatchOrdersAndSampleBuys(
-        orders: Array<Array<{
+        orders: Array<{
             makerAddress: string;
             takerAddress: string;
             feeRecipientAddress: string;
@@ -967,7 +968,7 @@ export class IERC20BridgeSamplerContract extends BaseContract {
             takerAssetData: string;
             makerFeeAssetData: string;
             takerFeeAssetData: string;
-        }>>,
+        }>[],
         orderSignatures: string[][],
         sources: string[],
         makerTokenAmounts: BigNumber[][],
@@ -1017,7 +1018,7 @@ export class IERC20BridgeSamplerContract extends BaseContract {
      * @returns ordersAndSamples How much taker asset can be filled         by each order in &#x60;orders&#x60;. Maker amounts bought for each source at         each taker token amount. First indexed by source index, then sample         index.
      */
     public queryBatchOrdersAndSampleSells(
-        orders: Array<Array<{
+        orders: Array<{
             makerAddress: string;
             takerAddress: string;
             feeRecipientAddress: string;
@@ -1032,7 +1033,7 @@ export class IERC20BridgeSamplerContract extends BaseContract {
             takerAssetData: string;
             makerFeeAssetData: string;
             takerFeeAssetData: string;
-        }>>,
+        }>[],
         orderSignatures: string[][],
         sources: string[],
         takerTokenAmounts: BigNumber[][],

packages/contract-wrappers/src/generated-wrappers/staking.ts

@@ -166,6 +166,7 @@ export interface StakingUnstakeEventArgs extends DecodedLogArgs {
 }
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class StakingContract extends BaseContract {

packages/contract-wrappers/src/generated-wrappers/staking_proxy.ts

@@ -72,6 +72,7 @@ export interface StakingProxyStakingContractAttachedToProxyEventArgs extends Dec
 export interface StakingProxyStakingContractDetachedFromProxyEventArgs extends DecodedLogArgs {}
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class StakingProxyContract extends BaseContract {

packages/contract-wrappers/src/generated-wrappers/weth9.ts

@@ -71,6 +71,7 @@ export interface WETH9WithdrawalEventArgs extends DecodedLogArgs {
 }
 
 /* istanbul ignore next */
+// tslint:disable:array-type
 // tslint:disable:no-parameter-reassignment
 // tslint:disable-next-line:class-name
 export class WETH9Contract extends BaseContract {