aboutsummaryrefslogtreecommitdiffstats
path: root/packages/contract-wrappers/src/contract_wrappers
diff options
context:
space:
mode:
authorFabio Berger <me@fabioberger.com>2018-05-10 02:36:28 +0800
committerFabio Berger <me@fabioberger.com>2018-05-10 02:36:28 +0800
commit209266dbed9d7d038c90c2da8d9b99acab77c80c (patch)
treecfefd5ab15bc237716b15687629e0f41362a8e86 /packages/contract-wrappers/src/contract_wrappers
parent69a6166b6a1d39afc24b8dd950ec5d8539a03420 (diff)
downloaddexon-sol-tools-209266dbed9d7d038c90c2da8d9b99acab77c80c.tar
dexon-sol-tools-209266dbed9d7d038c90c2da8d9b99acab77c80c.tar.gz
dexon-sol-tools-209266dbed9d7d038c90c2da8d9b99acab77c80c.tar.bz2
dexon-sol-tools-209266dbed9d7d038c90c2da8d9b99acab77c80c.tar.lz
dexon-sol-tools-209266dbed9d7d038c90c2da8d9b99acab77c80c.tar.xz
dexon-sol-tools-209266dbed9d7d038c90c2da8d9b99acab77c80c.tar.zst
dexon-sol-tools-209266dbed9d7d038c90c2da8d9b99acab77c80c.zip
Split 0x.js into contract-wrappers, order-watcher but keep 0x.js as a unifying library with the same interface
Diffstat (limited to 'packages/contract-wrappers/src/contract_wrappers')
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/contract_wrapper.ts208
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/ether_token_wrapper.ts207
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/exchange_wrapper.ts945
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/generated/dummy_token.ts84
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/generated/ether_token.ts621
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/generated/exchange.ts1459
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/generated/token.ts432
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/generated/token_registry.ts799
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/generated/token_transfer_proxy.ts447
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/token_registry_wrapper.ts134
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/token_transfer_proxy_wrapper.ts75
-rw-r--r--packages/contract-wrappers/src/contract_wrappers/token_wrapper.ts441
12 files changed, 5852 insertions, 0 deletions
diff --git a/packages/contract-wrappers/src/contract_wrappers/contract_wrapper.ts b/packages/contract-wrappers/src/contract_wrappers/contract_wrapper.ts
new file mode 100644
index 000000000..f255ced62
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/contract_wrapper.ts
@@ -0,0 +1,208 @@
+import {
+ Artifact,
+ BlockParamLiteral,
+ ContractAbi,
+ FilterObject,
+ LogEntry,
+ LogWithDecodedArgs,
+ RawLog,
+} from '@0xproject/types';
+import { AbiDecoder, intervalUtils } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import { Block, BlockAndLogStreamer } from 'ethereumjs-blockstream';
+import * as _ from 'lodash';
+
+import {
+ BlockRange,
+ ContractEventArgs,
+ ContractEvents,
+ ContractWrappersError,
+ EventCallback,
+ IndexedFilterValues,
+ InternalContractWrappersError,
+} from '../types';
+import { constants } from '../utils/constants';
+import { filterUtils } from '../utils/filter_utils';
+
+const CONTRACT_NAME_TO_NOT_FOUND_ERROR: {
+ [contractName: string]: ContractWrappersError;
+} = {
+ ZRX: ContractWrappersError.ZRXContractDoesNotExist,
+ EtherToken: ContractWrappersError.EtherTokenContractDoesNotExist,
+ Token: ContractWrappersError.TokenContractDoesNotExist,
+ TokenRegistry: ContractWrappersError.TokenRegistryContractDoesNotExist,
+ TokenTransferProxy: ContractWrappersError.TokenTransferProxyContractDoesNotExist,
+ Exchange: ContractWrappersError.ExchangeContractDoesNotExist,
+};
+
+export class ContractWrapper {
+ protected _web3Wrapper: Web3Wrapper;
+ protected _networkId: number;
+ private _blockAndLogStreamerIfExists?: BlockAndLogStreamer;
+ private _blockAndLogStreamIntervalIfExists?: NodeJS.Timer;
+ private _filters: { [filterToken: string]: FilterObject };
+ private _filterCallbacks: {
+ [filterToken: string]: EventCallback<ContractEventArgs>;
+ };
+ private _onLogAddedSubscriptionToken: string | undefined;
+ private _onLogRemovedSubscriptionToken: string | undefined;
+ constructor(web3Wrapper: Web3Wrapper, networkId: number) {
+ this._web3Wrapper = web3Wrapper;
+ this._networkId = networkId;
+ this._filters = {};
+ this._filterCallbacks = {};
+ this._blockAndLogStreamerIfExists = undefined;
+ this._onLogAddedSubscriptionToken = undefined;
+ this._onLogRemovedSubscriptionToken = undefined;
+ }
+ protected _unsubscribeAll(): void {
+ const filterTokens = _.keys(this._filterCallbacks);
+ _.each(filterTokens, filterToken => {
+ this._unsubscribe(filterToken);
+ });
+ }
+ protected _unsubscribe(filterToken: string, err?: Error): void {
+ if (_.isUndefined(this._filters[filterToken])) {
+ throw new Error(ContractWrappersError.SubscriptionNotFound);
+ }
+ if (!_.isUndefined(err)) {
+ const callback = this._filterCallbacks[filterToken];
+ callback(err, undefined);
+ }
+ delete this._filters[filterToken];
+ delete this._filterCallbacks[filterToken];
+ if (_.isEmpty(this._filters)) {
+ this._stopBlockAndLogStream();
+ }
+ }
+ protected _subscribe<ArgsType extends ContractEventArgs>(
+ address: string,
+ eventName: ContractEvents,
+ indexFilterValues: IndexedFilterValues,
+ abi: ContractAbi,
+ callback: EventCallback<ArgsType>,
+ ): string {
+ const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi);
+ if (_.isUndefined(this._blockAndLogStreamerIfExists)) {
+ this._startBlockAndLogStream();
+ }
+ const filterToken = filterUtils.generateUUID();
+ this._filters[filterToken] = filter;
+ this._filterCallbacks[filterToken] = callback as EventCallback<ContractEventArgs>;
+ return filterToken;
+ }
+ protected async _getLogsAsync<ArgsType extends ContractEventArgs>(
+ address: string,
+ eventName: ContractEvents,
+ blockRange: BlockRange,
+ indexFilterValues: IndexedFilterValues,
+ abi: ContractAbi,
+ ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
+ const filter = filterUtils.getFilter(address, eventName, indexFilterValues, abi, blockRange);
+ const logs = await this._web3Wrapper.getLogsAsync(filter);
+ const logsWithDecodedArguments = _.map(logs, this._tryToDecodeLogOrNoop.bind(this));
+ return logsWithDecodedArguments;
+ }
+ protected _tryToDecodeLogOrNoop<ArgsType extends ContractEventArgs>(
+ log: LogEntry,
+ ): LogWithDecodedArgs<ArgsType> | RawLog {
+ if (_.isUndefined(this._web3Wrapper.abiDecoder)) {
+ throw new Error(InternalContractWrappersError.NoAbiDecoder);
+ }
+ const logWithDecodedArgs = this._web3Wrapper.abiDecoder.tryToDecodeLogOrNoop(log);
+ return logWithDecodedArgs;
+ }
+ protected async _getContractAbiAndAddressFromArtifactsAsync(
+ artifact: Artifact,
+ addressIfExists?: string,
+ ): Promise<[ContractAbi, string]> {
+ let contractAddress: string;
+ if (_.isUndefined(addressIfExists)) {
+ if (_.isUndefined(artifact.networks[this._networkId])) {
+ throw new Error(ContractWrappersError.ContractNotDeployedOnNetwork);
+ }
+ contractAddress = artifact.networks[this._networkId].address.toLowerCase();
+ } else {
+ contractAddress = addressIfExists;
+ }
+ const doesContractExist = await this._web3Wrapper.doesContractExistAtAddressAsync(contractAddress);
+ if (!doesContractExist) {
+ throw new Error(CONTRACT_NAME_TO_NOT_FOUND_ERROR[artifact.contract_name]);
+ }
+ const abiAndAddress: [ContractAbi, string] = [artifact.abi, contractAddress];
+ return abiAndAddress;
+ }
+ protected _getContractAddress(artifact: Artifact, addressIfExists?: string): string {
+ if (_.isUndefined(addressIfExists)) {
+ const contractAddress = artifact.networks[this._networkId].address;
+ if (_.isUndefined(contractAddress)) {
+ throw new Error(ContractWrappersError.ExchangeContractDoesNotExist);
+ }
+ return contractAddress;
+ } else {
+ return addressIfExists;
+ }
+ }
+ private _onLogStateChanged<ArgsType extends ContractEventArgs>(isRemoved: boolean, log: LogEntry): void {
+ _.forEach(this._filters, (filter: FilterObject, filterToken: string) => {
+ if (filterUtils.matchesFilter(log, filter)) {
+ const decodedLog = this._tryToDecodeLogOrNoop(log) as LogWithDecodedArgs<ArgsType>;
+ const logEvent = {
+ log: decodedLog,
+ isRemoved,
+ };
+ this._filterCallbacks[filterToken](null, logEvent);
+ }
+ });
+ }
+ private _startBlockAndLogStream(): void {
+ if (!_.isUndefined(this._blockAndLogStreamerIfExists)) {
+ throw new Error(ContractWrappersError.SubscriptionAlreadyPresent);
+ }
+ this._blockAndLogStreamerIfExists = new BlockAndLogStreamer(
+ this._web3Wrapper.getBlockAsync.bind(this._web3Wrapper),
+ this._web3Wrapper.getLogsAsync.bind(this._web3Wrapper),
+ );
+ const catchAllLogFilter = {};
+ this._blockAndLogStreamerIfExists.addLogFilter(catchAllLogFilter);
+ this._blockAndLogStreamIntervalIfExists = intervalUtils.setAsyncExcludingInterval(
+ this._reconcileBlockAsync.bind(this),
+ constants.DEFAULT_BLOCK_POLLING_INTERVAL,
+ this._onReconcileBlockError.bind(this),
+ );
+ let isRemoved = false;
+ this._onLogAddedSubscriptionToken = this._blockAndLogStreamerIfExists.subscribeToOnLogAdded(
+ this._onLogStateChanged.bind(this, isRemoved),
+ );
+ isRemoved = true;
+ this._onLogRemovedSubscriptionToken = this._blockAndLogStreamerIfExists.subscribeToOnLogRemoved(
+ this._onLogStateChanged.bind(this, isRemoved),
+ );
+ }
+ private _onReconcileBlockError(err: Error): void {
+ const filterTokens = _.keys(this._filterCallbacks);
+ _.each(filterTokens, filterToken => {
+ this._unsubscribe(filterToken, err);
+ });
+ }
+ private _setNetworkId(networkId: number): void {
+ this._networkId = networkId;
+ }
+ private _stopBlockAndLogStream(): void {
+ if (_.isUndefined(this._blockAndLogStreamerIfExists)) {
+ throw new Error(ContractWrappersError.SubscriptionNotFound);
+ }
+ this._blockAndLogStreamerIfExists.unsubscribeFromOnLogAdded(this._onLogAddedSubscriptionToken as string);
+ this._blockAndLogStreamerIfExists.unsubscribeFromOnLogRemoved(this._onLogRemovedSubscriptionToken as string);
+ intervalUtils.clearAsyncExcludingInterval(this._blockAndLogStreamIntervalIfExists as NodeJS.Timer);
+ delete this._blockAndLogStreamerIfExists;
+ }
+ private async _reconcileBlockAsync(): Promise<void> {
+ const latestBlock = await this._web3Wrapper.getBlockAsync(BlockParamLiteral.Latest);
+ // We need to coerce to Block type cause Web3.Block includes types for mempool blocks
+ if (!_.isUndefined(this._blockAndLogStreamerIfExists)) {
+ // If we clear the interval while fetching the block - this._blockAndLogStreamer will be undefined
+ await this._blockAndLogStreamerIfExists.reconcileNewBlock((latestBlock as any) as Block);
+ }
+ }
+}
diff --git a/packages/contract-wrappers/src/contract_wrappers/ether_token_wrapper.ts b/packages/contract-wrappers/src/contract_wrappers/ether_token_wrapper.ts
new file mode 100644
index 000000000..1bd65270b
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/ether_token_wrapper.ts
@@ -0,0 +1,207 @@
+import { schemas } from '@0xproject/json-schemas';
+import { LogWithDecodedArgs } from '@0xproject/types';
+import { AbiDecoder, BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as _ from 'lodash';
+
+import { artifacts } from '../artifacts';
+import { BlockRange, ContractWrappersError, EventCallback, IndexedFilterValues, TransactionOpts } from '../types';
+import { assert } from '../utils/assert';
+
+import { ContractWrapper } from './contract_wrapper';
+import { EtherTokenContract, EtherTokenContractEventArgs, EtherTokenEvents } from './generated/ether_token';
+import { TokenWrapper } from './token_wrapper';
+
+/**
+ * This class includes all the functionality related to interacting with a wrapped Ether ERC20 token contract.
+ * The caller can convert ETH into the equivalent number of wrapped ETH ERC20 tokens and back.
+ */
+export class EtherTokenWrapper extends ContractWrapper {
+ private _etherTokenContractsByAddress: {
+ [address: string]: EtherTokenContract;
+ } = {};
+ private _tokenWrapper: TokenWrapper;
+ constructor(web3Wrapper: Web3Wrapper, networkId: number, tokenWrapper: TokenWrapper) {
+ super(web3Wrapper, networkId);
+ this._tokenWrapper = tokenWrapper;
+ }
+ /**
+ * Deposit ETH into the Wrapped ETH smart contract and issues the equivalent number of wrapped ETH tokens
+ * to the depositor address. These wrapped ETH tokens can be used in 0x trades and are redeemable for 1-to-1
+ * for ETH.
+ * @param etherTokenAddress EtherToken address you wish to deposit into.
+ * @param amountInWei Amount of ETH in Wei the caller wishes to deposit.
+ * @param depositor The hex encoded user Ethereum address that would like to make the deposit.
+ * @param txOpts Transaction parameters.
+ * @return Transaction hash.
+ */
+ public async depositAsync(
+ etherTokenAddress: string,
+ amountInWei: BigNumber,
+ depositor: string,
+ txOpts: TransactionOpts = {},
+ ): Promise<string> {
+ assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
+ assert.isValidBaseUnitAmount('amountInWei', amountInWei);
+ await assert.isSenderAddressAsync('depositor', depositor, this._web3Wrapper);
+ const normalizedEtherTokenAddress = etherTokenAddress.toLowerCase();
+ const normalizedDepositorAddress = depositor.toLowerCase();
+
+ const ethBalanceInWei = await this._web3Wrapper.getBalanceInWeiAsync(normalizedDepositorAddress);
+ assert.assert(ethBalanceInWei.gte(amountInWei), ContractWrappersError.InsufficientEthBalanceForDeposit);
+
+ const wethContract = await this._getEtherTokenContractAsync(normalizedEtherTokenAddress);
+ const txHash = await wethContract.deposit.sendTransactionAsync({
+ from: normalizedDepositorAddress,
+ value: amountInWei,
+ gas: txOpts.gasLimit,
+ gasPrice: txOpts.gasPrice,
+ });
+ return txHash;
+ }
+ /**
+ * Withdraw ETH to the withdrawer's address from the wrapped ETH smart contract in exchange for the
+ * equivalent number of wrapped ETH tokens.
+ * @param etherTokenAddress EtherToken address you wish to withdraw from.
+ * @param amountInWei Amount of ETH in Wei the caller wishes to withdraw.
+ * @param withdrawer The hex encoded user Ethereum address that would like to make the withdrawal.
+ * @param txOpts Transaction parameters.
+ * @return Transaction hash.
+ */
+ public async withdrawAsync(
+ etherTokenAddress: string,
+ amountInWei: BigNumber,
+ withdrawer: string,
+ txOpts: TransactionOpts = {},
+ ): Promise<string> {
+ assert.isValidBaseUnitAmount('amountInWei', amountInWei);
+ assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
+ await assert.isSenderAddressAsync('withdrawer', withdrawer, this._web3Wrapper);
+ const normalizedEtherTokenAddress = etherTokenAddress.toLowerCase();
+ const normalizedWithdrawerAddress = withdrawer.toLowerCase();
+
+ const WETHBalanceInBaseUnits = await this._tokenWrapper.getBalanceAsync(
+ normalizedEtherTokenAddress,
+ normalizedWithdrawerAddress,
+ );
+ assert.assert(
+ WETHBalanceInBaseUnits.gte(amountInWei),
+ ContractWrappersError.InsufficientWEthBalanceForWithdrawal,
+ );
+
+ const wethContract = await this._getEtherTokenContractAsync(normalizedEtherTokenAddress);
+ const txHash = await wethContract.withdraw.sendTransactionAsync(amountInWei, {
+ from: normalizedWithdrawerAddress,
+ gas: txOpts.gasLimit,
+ gasPrice: txOpts.gasPrice,
+ });
+ return txHash;
+ }
+ /**
+ * Gets historical logs without creating a subscription
+ * @param etherTokenAddress An address of the ether token that emitted the logs.
+ * @param eventName The ether token contract event you would like to subscribe to.
+ * @param blockRange Block range to get logs from.
+ * @param indexFilterValues An object where the keys are indexed args returned by the event and
+ * the value is the value you are interested in. E.g `{_owner: aUserAddressHex}`
+ * @return Array of logs that match the parameters
+ */
+ public async getLogsAsync<ArgsType extends EtherTokenContractEventArgs>(
+ etherTokenAddress: string,
+ eventName: EtherTokenEvents,
+ blockRange: BlockRange,
+ indexFilterValues: IndexedFilterValues,
+ ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
+ assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
+ const normalizedEtherTokenAddress = etherTokenAddress.toLowerCase();
+ assert.doesBelongToStringEnum('eventName', eventName, EtherTokenEvents);
+ assert.doesConformToSchema('blockRange', blockRange, schemas.blockRangeSchema);
+ assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
+ const logs = await this._getLogsAsync<ArgsType>(
+ normalizedEtherTokenAddress,
+ eventName,
+ blockRange,
+ indexFilterValues,
+ artifacts.EtherToken.abi,
+ );
+ return logs;
+ }
+ /**
+ * Subscribe to an event type emitted by the Token contract.
+ * @param etherTokenAddress The hex encoded address where the ether token is deployed.
+ * @param eventName The ether token contract event you would like to subscribe to.
+ * @param indexFilterValues An object where the keys are indexed args returned by the event and
+ * the value is the value you are interested in. E.g `{_owner: aUserAddressHex}`
+ * @param callback Callback that gets called when a log is added/removed
+ * @return Subscription token used later to unsubscribe
+ */
+ public subscribe<ArgsType extends EtherTokenContractEventArgs>(
+ etherTokenAddress: string,
+ eventName: EtherTokenEvents,
+ indexFilterValues: IndexedFilterValues,
+ callback: EventCallback<ArgsType>,
+ ): string {
+ assert.isETHAddressHex('etherTokenAddress', etherTokenAddress);
+ const normalizedEtherTokenAddress = etherTokenAddress.toLowerCase();
+ assert.doesBelongToStringEnum('eventName', eventName, EtherTokenEvents);
+ assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
+ assert.isFunction('callback', callback);
+ const subscriptionToken = this._subscribe<ArgsType>(
+ normalizedEtherTokenAddress,
+ eventName,
+ indexFilterValues,
+ artifacts.EtherToken.abi,
+ callback,
+ );
+ return subscriptionToken;
+ }
+ /**
+ * Cancel a subscription
+ * @param subscriptionToken Subscription token returned by `subscribe()`
+ */
+ public unsubscribe(subscriptionToken: string): void {
+ this._unsubscribe(subscriptionToken);
+ }
+ /**
+ * Cancels all existing subscriptions
+ */
+ public unsubscribeAll(): void {
+ super._unsubscribeAll();
+ }
+ /**
+ * Retrieves the Ethereum address of the EtherToken contract deployed on the network
+ * that the user-passed web3 provider is connected to. If it's not Kovan, Ropsten, Rinkeby, Mainnet or TestRPC
+ * (networkId: 50), it will return undefined (e.g a private network).
+ * @returns The Ethereum address of the EtherToken contract or undefined.
+ */
+ public getContractAddressIfExists(): string | undefined {
+ const networkSpecificArtifact = artifacts.EtherToken.networks[this._networkId];
+ const contractAddressIfExists = _.isUndefined(networkSpecificArtifact)
+ ? undefined
+ : networkSpecificArtifact.address;
+ return contractAddressIfExists;
+ }
+ private _invalidateContractInstance(): void {
+ this.unsubscribeAll();
+ this._etherTokenContractsByAddress = {};
+ }
+ private async _getEtherTokenContractAsync(etherTokenAddress: string): Promise<EtherTokenContract> {
+ let etherTokenContract = this._etherTokenContractsByAddress[etherTokenAddress];
+ if (!_.isUndefined(etherTokenContract)) {
+ return etherTokenContract;
+ }
+ const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
+ artifacts.EtherToken,
+ etherTokenAddress,
+ );
+ const contractInstance = new EtherTokenContract(
+ abi,
+ address,
+ this._web3Wrapper.getProvider(),
+ this._web3Wrapper.getContractDefaults(),
+ );
+ etherTokenContract = contractInstance;
+ this._etherTokenContractsByAddress[etherTokenAddress] = etherTokenContract;
+ return etherTokenContract;
+ }
+}
diff --git a/packages/contract-wrappers/src/contract_wrappers/exchange_wrapper.ts b/packages/contract-wrappers/src/contract_wrappers/exchange_wrapper.ts
new file mode 100644
index 000000000..f2b64fc37
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/exchange_wrapper.ts
@@ -0,0 +1,945 @@
+import { schemas } from '@0xproject/json-schemas';
+import { formatters, getOrderHashHex, OrderStateUtils } from '@0xproject/order-utils';
+import {
+ BlockParamLiteral,
+ DecodedLogArgs,
+ ECSignature,
+ ExchangeContractErrs,
+ LogEntry,
+ LogWithDecodedArgs,
+ Order,
+ OrderAddresses,
+ OrderState,
+ OrderValues,
+ SignedOrder,
+} from '@0xproject/types';
+import { AbiDecoder, BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as _ from 'lodash';
+
+import { artifacts } from '../artifacts';
+import { SimpleBalanceAndProxyAllowanceFetcher } from '../fetchers/simple_balance_and_proxy_allowance_fetcher';
+import { SimpleOrderFilledCancelledFetcher } from '../fetchers/simple_order_filled_cancelled_fetcher';
+import {
+ BlockRange,
+ EventCallback,
+ ExchangeContractErrCodes,
+ IndexedFilterValues,
+ MethodOpts,
+ OrderCancellationRequest,
+ OrderFillRequest,
+ OrderTransactionOpts,
+ ValidateOrderFillableOpts,
+} from '../types';
+import { assert } from '../utils/assert';
+import { decorators } from '../utils/decorators';
+import { ExchangeTransferSimulator } from '../utils/exchange_transfer_simulator';
+import { OrderValidationUtils } from '../utils/order_validation_utils';
+import { utils } from '../utils/utils';
+
+import { ContractWrapper } from './contract_wrapper';
+import {
+ ExchangeContract,
+ ExchangeContractEventArgs,
+ ExchangeEvents,
+ LogErrorContractEventArgs,
+} from './generated/exchange';
+import { TokenWrapper } from './token_wrapper';
+const SHOULD_VALIDATE_BY_DEFAULT = true;
+
+interface ExchangeContractErrCodesToMsgs {
+ [exchangeContractErrCodes: number]: string;
+}
+
+/**
+ * This class includes all the functionality related to calling methods and subscribing to
+ * events of the 0x Exchange smart contract.
+ */
+export class ExchangeWrapper extends ContractWrapper {
+ private _exchangeContractIfExists?: ExchangeContract;
+ private _orderValidationUtils: OrderValidationUtils;
+ private _tokenWrapper: TokenWrapper;
+ private _exchangeContractErrCodesToMsg: ExchangeContractErrCodesToMsgs = {
+ [ExchangeContractErrCodes.ERROR_FILL_EXPIRED]: ExchangeContractErrs.OrderFillExpired,
+ [ExchangeContractErrCodes.ERROR_CANCEL_EXPIRED]: ExchangeContractErrs.OrderFillExpired,
+ [ExchangeContractErrCodes.ERROR_FILL_NO_VALUE]: ExchangeContractErrs.OrderRemainingFillAmountZero,
+ [ExchangeContractErrCodes.ERROR_CANCEL_NO_VALUE]: ExchangeContractErrs.OrderRemainingFillAmountZero,
+ [ExchangeContractErrCodes.ERROR_FILL_TRUNCATION]: ExchangeContractErrs.OrderFillRoundingError,
+ [ExchangeContractErrCodes.ERROR_FILL_BALANCE_ALLOWANCE]: ExchangeContractErrs.FillBalanceAllowanceError,
+ };
+ private _contractAddressIfExists?: string;
+ private _zrxContractAddressIfExists?: string;
+ constructor(
+ web3Wrapper: Web3Wrapper,
+ networkId: number,
+ tokenWrapper: TokenWrapper,
+ contractAddressIfExists?: string,
+ zrxContractAddressIfExists?: string,
+ ) {
+ super(web3Wrapper, networkId);
+ this._tokenWrapper = tokenWrapper;
+ this._orderValidationUtils = new OrderValidationUtils(this);
+ this._contractAddressIfExists = contractAddressIfExists;
+ this._zrxContractAddressIfExists = zrxContractAddressIfExists;
+ }
+ /**
+ * Returns the unavailable takerAmount of an order. Unavailable amount is defined as the total
+ * amount that has been filled or cancelled. The remaining takerAmount can be calculated by
+ * subtracting the unavailable amount from the total order takerAmount.
+ * @param orderHash The hex encoded orderHash for which you would like to retrieve the
+ * unavailable takerAmount.
+ * @param methodOpts Optional arguments this method accepts.
+ * @return The amount of the order (in taker tokens) that has either been filled or cancelled.
+ */
+ public async getUnavailableTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
+ assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
+
+ const exchangeContract = await this._getExchangeContractAsync();
+ const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
+ const txData = {};
+ let unavailableTakerTokenAmount = await exchangeContract.getUnavailableTakerTokenAmount.callAsync(
+ orderHash,
+ txData,
+ defaultBlock,
+ );
+ // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
+ unavailableTakerTokenAmount = new BigNumber(unavailableTakerTokenAmount);
+ return unavailableTakerTokenAmount;
+ }
+ /**
+ * Retrieve the takerAmount of an order that has already been filled.
+ * @param orderHash The hex encoded orderHash for which you would like to retrieve the filled takerAmount.
+ * @param methodOpts Optional arguments this method accepts.
+ * @return The amount of the order (in taker tokens) that has already been filled.
+ */
+ public async getFilledTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
+ assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
+
+ const exchangeContract = await this._getExchangeContractAsync();
+ const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
+ const txData = {};
+ let fillAmountInBaseUnits = await exchangeContract.filled.callAsync(orderHash, txData, defaultBlock);
+ // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
+ fillAmountInBaseUnits = new BigNumber(fillAmountInBaseUnits);
+ return fillAmountInBaseUnits;
+ }
+ /**
+ * Retrieve the takerAmount of an order that has been cancelled.
+ * @param orderHash The hex encoded orderHash for which you would like to retrieve the
+ * cancelled takerAmount.
+ * @param methodOpts Optional arguments this method accepts.
+ * @return The amount of the order (in taker tokens) that has been cancelled.
+ */
+ public async getCancelledTakerAmountAsync(orderHash: string, methodOpts?: MethodOpts): Promise<BigNumber> {
+ assert.doesConformToSchema('orderHash', orderHash, schemas.orderHashSchema);
+
+ const exchangeContract = await this._getExchangeContractAsync();
+ const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
+ const txData = {};
+ let cancelledAmountInBaseUnits = await exchangeContract.cancelled.callAsync(orderHash, txData, defaultBlock);
+ // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
+ cancelledAmountInBaseUnits = new BigNumber(cancelledAmountInBaseUnits);
+ return cancelledAmountInBaseUnits;
+ }
+ /**
+ * Fills a signed order with an amount denominated in baseUnits of the taker token.
+ * Since the order in which transactions are included in the next block is indeterminate, race-conditions
+ * could arise where a users balance or allowance changes before the fillOrder executes. Because of this,
+ * we allow you to specify `shouldThrowOnInsufficientBalanceOrAllowance`.
+ * If false, the smart contract will not throw if the parties
+ * do not have sufficient balances/allowances, preserving gas costs. Setting it to true forgoes this check
+ * and causes the smart contract to throw (using all the gas supplied) instead.
+ * @param signedOrder An object that conforms to the SignedOrder interface.
+ * @param fillTakerTokenAmount The amount of the order (in taker tokens baseUnits) that
+ * you wish to fill.
+ * @param shouldThrowOnInsufficientBalanceOrAllowance Whether or not you wish for the contract call to throw
+ * if upon execution the tokens cannot be transferred.
+ * @param takerAddress The user Ethereum address who would like to fill this order.
+ * Must be available via the supplied Provider
+ * passed to 0x.js.
+ * @param orderTransactionOpts Optional arguments this method accepts.
+ * @return Transaction hash.
+ */
+ @decorators.asyncZeroExErrorHandler
+ public async fillOrderAsync(
+ signedOrder: SignedOrder,
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ takerAddress: string,
+ orderTransactionOpts: OrderTransactionOpts = {},
+ ): Promise<string> {
+ assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
+ assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
+ assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
+ await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
+ const normalizedTakerAddress = takerAddress.toLowerCase();
+
+ const exchangeInstance = await this._getExchangeContractAsync();
+ const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
+ ? SHOULD_VALIDATE_BY_DEFAULT
+ : orderTransactionOpts.shouldValidate;
+ if (shouldValidate) {
+ const zrxTokenAddress = this.getZRXTokenAddress();
+ const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+ await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
+ exchangeTradeEmulator,
+ signedOrder,
+ fillTakerTokenAmount,
+ normalizedTakerAddress,
+ zrxTokenAddress,
+ );
+ }
+
+ const [orderAddresses, orderValues] = formatters.getOrderAddressesAndValues(signedOrder);
+
+ const txHash: string = await exchangeInstance.fillOrder.sendTransactionAsync(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ signedOrder.ecSignature.v,
+ signedOrder.ecSignature.r,
+ signedOrder.ecSignature.s,
+ {
+ from: normalizedTakerAddress,
+ gas: orderTransactionOpts.gasLimit,
+ gasPrice: orderTransactionOpts.gasPrice,
+ },
+ );
+ return txHash;
+ }
+ /**
+ * Sequentially and atomically fills signedOrders up to the specified takerTokenFillAmount.
+ * If the fill amount is reached - it succeeds and does not fill the rest of the orders.
+ * If fill amount is not reached - it fills as much of the fill amount as possible and succeeds.
+ * @param signedOrders The array of signedOrders that you would like to fill until
+ * takerTokenFillAmount is reached.
+ * @param fillTakerTokenAmount The total amount of the takerTokens you would like to fill.
+ * @param shouldThrowOnInsufficientBalanceOrAllowance Whether or not you wish for the contract call to throw if
+ * upon execution any of the tokens cannot be transferred.
+ * If set to false, the call will continue to fill subsequent
+ * signedOrders even when some cannot be filled.
+ * @param takerAddress The user Ethereum address who would like to fill these
+ * orders. Must be available via the supplied Provider
+ * passed to 0x.js.
+ * @param orderTransactionOpts Optional arguments this method accepts.
+ * @return Transaction hash.
+ */
+ @decorators.asyncZeroExErrorHandler
+ public async fillOrdersUpToAsync(
+ signedOrders: SignedOrder[],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ takerAddress: string,
+ orderTransactionOpts: OrderTransactionOpts = {},
+ ): Promise<string> {
+ assert.doesConformToSchema('signedOrders', signedOrders, schemas.signedOrdersSchema);
+ const takerTokenAddresses = _.map(signedOrders, signedOrder => signedOrder.takerTokenAddress);
+ assert.hasAtMostOneUniqueValue(
+ takerTokenAddresses,
+ ExchangeContractErrs.MultipleTakerTokensInFillUpToDisallowed,
+ );
+ const exchangeContractAddresses = _.map(signedOrders, signedOrder => signedOrder.exchangeContractAddress);
+ assert.hasAtMostOneUniqueValue(
+ exchangeContractAddresses,
+ ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
+ );
+ assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
+ assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
+ await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
+ const normalizedTakerAddress = takerAddress.toLowerCase();
+
+ const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
+ ? SHOULD_VALIDATE_BY_DEFAULT
+ : orderTransactionOpts.shouldValidate;
+ if (shouldValidate) {
+ let filledTakerTokenAmount = new BigNumber(0);
+ const zrxTokenAddress = this.getZRXTokenAddress();
+ const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+ for (const signedOrder of signedOrders) {
+ const singleFilledTakerTokenAmount = await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
+ exchangeTradeEmulator,
+ signedOrder,
+ fillTakerTokenAmount.minus(filledTakerTokenAmount),
+ normalizedTakerAddress,
+ zrxTokenAddress,
+ );
+ filledTakerTokenAmount = filledTakerTokenAmount.plus(singleFilledTakerTokenAmount);
+ if (filledTakerTokenAmount.eq(fillTakerTokenAmount)) {
+ break;
+ }
+ }
+ }
+
+ if (_.isEmpty(signedOrders)) {
+ throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
+ }
+
+ const orderAddressesValuesAndSignatureArray = _.map(signedOrders, signedOrder => {
+ return [
+ ...formatters.getOrderAddressesAndValues(signedOrder),
+ signedOrder.ecSignature.v,
+ signedOrder.ecSignature.r,
+ signedOrder.ecSignature.s,
+ ];
+ });
+ // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
+ const [orderAddressesArray, orderValuesArray, vArray, rArray, sArray] = _.unzip<any>(
+ orderAddressesValuesAndSignatureArray,
+ );
+
+ const exchangeInstance = await this._getExchangeContractAsync();
+ const txHash = await exchangeInstance.fillOrdersUpTo.sendTransactionAsync(
+ orderAddressesArray,
+ orderValuesArray,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ vArray,
+ rArray,
+ sArray,
+ {
+ from: normalizedTakerAddress,
+ gas: orderTransactionOpts.gasLimit,
+ gasPrice: orderTransactionOpts.gasPrice,
+ },
+ );
+ return txHash;
+ }
+ /**
+ * Batch version of fillOrderAsync.
+ * Executes multiple fills atomically in a single transaction.
+ * If shouldThrowOnInsufficientBalanceOrAllowance is set to false, it will continue filling subsequent orders even
+ * when earlier ones fail.
+ * When shouldThrowOnInsufficientBalanceOrAllowance is set to true, if any fill fails, the entire batch fails.
+ * @param orderFillRequests An array of objects that conform to the
+ * OrderFillRequest interface.
+ * @param shouldThrowOnInsufficientBalanceOrAllowance Whether or not you wish for the contract call to throw
+ * if upon execution any of the tokens cannot be
+ * transferred. If set to false, the call will continue to
+ * fill subsequent signedOrders even when some
+ * cannot be filled.
+ * @param takerAddress The user Ethereum address who would like to fill
+ * these orders. Must be available via the supplied
+ * Provider passed to 0x.js.
+ * @param orderTransactionOpts Optional arguments this method accepts.
+ * @return Transaction hash.
+ */
+ @decorators.asyncZeroExErrorHandler
+ public async batchFillOrdersAsync(
+ orderFillRequests: OrderFillRequest[],
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ takerAddress: string,
+ orderTransactionOpts: OrderTransactionOpts = {},
+ ): Promise<string> {
+ assert.doesConformToSchema('orderFillRequests', orderFillRequests, schemas.orderFillRequestsSchema);
+ const exchangeContractAddresses = _.map(
+ orderFillRequests,
+ orderFillRequest => orderFillRequest.signedOrder.exchangeContractAddress,
+ );
+ assert.hasAtMostOneUniqueValue(
+ exchangeContractAddresses,
+ ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
+ );
+ assert.isBoolean('shouldThrowOnInsufficientBalanceOrAllowance', shouldThrowOnInsufficientBalanceOrAllowance);
+ await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
+ const normalizedTakerAddress = takerAddress.toLowerCase();
+ const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
+ ? SHOULD_VALIDATE_BY_DEFAULT
+ : orderTransactionOpts.shouldValidate;
+ if (shouldValidate) {
+ const zrxTokenAddress = this.getZRXTokenAddress();
+ const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+ for (const orderFillRequest of orderFillRequests) {
+ await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
+ exchangeTradeEmulator,
+ orderFillRequest.signedOrder,
+ orderFillRequest.takerTokenFillAmount,
+ normalizedTakerAddress,
+ zrxTokenAddress,
+ );
+ }
+ }
+ if (_.isEmpty(orderFillRequests)) {
+ throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
+ }
+
+ const orderAddressesValuesAmountsAndSignatureArray = _.map(orderFillRequests, orderFillRequest => {
+ return [
+ ...formatters.getOrderAddressesAndValues(orderFillRequest.signedOrder),
+ orderFillRequest.takerTokenFillAmount,
+ orderFillRequest.signedOrder.ecSignature.v,
+ orderFillRequest.signedOrder.ecSignature.r,
+ orderFillRequest.signedOrder.ecSignature.s,
+ ];
+ });
+ // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
+ const [orderAddressesArray, orderValuesArray, fillTakerTokenAmounts, vArray, rArray, sArray] = _.unzip<any>(
+ orderAddressesValuesAmountsAndSignatureArray,
+ );
+
+ const exchangeInstance = await this._getExchangeContractAsync();
+ const txHash = await exchangeInstance.batchFillOrders.sendTransactionAsync(
+ orderAddressesArray,
+ orderValuesArray,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ vArray,
+ rArray,
+ sArray,
+ {
+ from: normalizedTakerAddress,
+ gas: orderTransactionOpts.gasLimit,
+ gasPrice: orderTransactionOpts.gasPrice,
+ },
+ );
+ return txHash;
+ }
+ /**
+ * Attempts to fill a specific amount of an order. If the entire amount specified cannot be filled,
+ * the fill order is abandoned.
+ * @param signedOrder An object that conforms to the SignedOrder interface. The
+ * signedOrder you wish to fill.
+ * @param fillTakerTokenAmount The total amount of the takerTokens you would like to fill.
+ * @param takerAddress The user Ethereum address who would like to fill this order.
+ * Must be available via the supplied Provider passed to 0x.js.
+ * @param orderTransactionOpts Optional arguments this method accepts.
+ * @return Transaction hash.
+ */
+ @decorators.asyncZeroExErrorHandler
+ public async fillOrKillOrderAsync(
+ signedOrder: SignedOrder,
+ fillTakerTokenAmount: BigNumber,
+ takerAddress: string,
+ orderTransactionOpts: OrderTransactionOpts = {},
+ ): Promise<string> {
+ assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
+ assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
+ await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
+ const normalizedTakerAddress = takerAddress.toLowerCase();
+
+ const exchangeInstance = await this._getExchangeContractAsync();
+
+ const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
+ ? SHOULD_VALIDATE_BY_DEFAULT
+ : orderTransactionOpts.shouldValidate;
+ if (shouldValidate) {
+ const zrxTokenAddress = this.getZRXTokenAddress();
+ const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+ await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
+ exchangeTradeEmulator,
+ signedOrder,
+ fillTakerTokenAmount,
+ normalizedTakerAddress,
+ zrxTokenAddress,
+ );
+ }
+
+ const [orderAddresses, orderValues] = formatters.getOrderAddressesAndValues(signedOrder);
+ const txHash = await exchangeInstance.fillOrKillOrder.sendTransactionAsync(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ signedOrder.ecSignature.v,
+ signedOrder.ecSignature.r,
+ signedOrder.ecSignature.s,
+ {
+ from: normalizedTakerAddress,
+ gas: orderTransactionOpts.gasLimit,
+ gasPrice: orderTransactionOpts.gasPrice,
+ },
+ );
+ return txHash;
+ }
+ /**
+ * Batch version of fillOrKill. Allows a taker to specify a batch of orders that will either be atomically
+ * filled (each to the specified fillAmount) or aborted.
+ * @param orderFillRequests An array of objects that conform to the OrderFillRequest interface.
+ * @param takerAddress The user Ethereum address who would like to fill there orders.
+ * Must be available via the supplied Provider passed to 0x.js.
+ * @param orderTransactionOpts Optional arguments this method accepts.
+ * @return Transaction hash.
+ */
+ @decorators.asyncZeroExErrorHandler
+ public async batchFillOrKillAsync(
+ orderFillRequests: OrderFillRequest[],
+ takerAddress: string,
+ orderTransactionOpts: OrderTransactionOpts = {},
+ ): Promise<string> {
+ assert.doesConformToSchema('orderFillRequests', orderFillRequests, schemas.orderFillRequestsSchema);
+ const exchangeContractAddresses = _.map(
+ orderFillRequests,
+ orderFillRequest => orderFillRequest.signedOrder.exchangeContractAddress,
+ );
+ assert.hasAtMostOneUniqueValue(
+ exchangeContractAddresses,
+ ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
+ );
+ await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
+ const normalizedTakerAddress = takerAddress.toLowerCase();
+ if (_.isEmpty(orderFillRequests)) {
+ throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
+ }
+ const exchangeInstance = await this._getExchangeContractAsync();
+
+ const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
+ ? SHOULD_VALIDATE_BY_DEFAULT
+ : orderTransactionOpts.shouldValidate;
+ if (shouldValidate) {
+ const zrxTokenAddress = this.getZRXTokenAddress();
+ const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+ for (const orderFillRequest of orderFillRequests) {
+ await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
+ exchangeTradeEmulator,
+ orderFillRequest.signedOrder,
+ orderFillRequest.takerTokenFillAmount,
+ normalizedTakerAddress,
+ zrxTokenAddress,
+ );
+ }
+ }
+
+ const orderAddressesValuesAndTakerTokenFillAmounts = _.map(orderFillRequests, request => {
+ return [
+ ...formatters.getOrderAddressesAndValues(request.signedOrder),
+ request.takerTokenFillAmount,
+ request.signedOrder.ecSignature.v,
+ request.signedOrder.ecSignature.r,
+ request.signedOrder.ecSignature.s,
+ ];
+ });
+
+ // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
+ const [orderAddresses, orderValues, fillTakerTokenAmounts, vParams, rParams, sParams] = _.unzip<any>(
+ orderAddressesValuesAndTakerTokenFillAmounts,
+ );
+ const txHash = await exchangeInstance.batchFillOrKillOrders.sendTransactionAsync(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ vParams,
+ rParams,
+ sParams,
+ {
+ from: normalizedTakerAddress,
+ gas: orderTransactionOpts.gasLimit,
+ gasPrice: orderTransactionOpts.gasPrice,
+ },
+ );
+ return txHash;
+ }
+ /**
+ * Cancel a given fill amount of an order. Cancellations are cumulative.
+ * @param order An object that conforms to the Order or SignedOrder interface.
+ * The order you would like to cancel.
+ * @param cancelTakerTokenAmount The amount (specified in taker tokens) that you would like to cancel.
+ * @param transactionOpts Optional arguments this method accepts.
+ * @return Transaction hash.
+ */
+ @decorators.asyncZeroExErrorHandler
+ public async cancelOrderAsync(
+ order: Order | SignedOrder,
+ cancelTakerTokenAmount: BigNumber,
+ orderTransactionOpts: OrderTransactionOpts = {},
+ ): Promise<string> {
+ assert.doesConformToSchema('order', order, schemas.orderSchema);
+ assert.isValidBaseUnitAmount('takerTokenCancelAmount', cancelTakerTokenAmount);
+ await assert.isSenderAddressAsync('order.maker', order.maker, this._web3Wrapper);
+ const normalizedMakerAddress = order.maker.toLowerCase();
+
+ const exchangeInstance = await this._getExchangeContractAsync();
+
+ const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
+ ? SHOULD_VALIDATE_BY_DEFAULT
+ : orderTransactionOpts.shouldValidate;
+ if (shouldValidate) {
+ const orderHash = getOrderHashHex(order);
+ const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
+ OrderValidationUtils.validateCancelOrderThrowIfInvalid(
+ order,
+ cancelTakerTokenAmount,
+ unavailableTakerTokenAmount,
+ );
+ }
+
+ const [orderAddresses, orderValues] = formatters.getOrderAddressesAndValues(order);
+ const txHash = await exchangeInstance.cancelOrder.sendTransactionAsync(
+ orderAddresses,
+ orderValues,
+ cancelTakerTokenAmount,
+ {
+ from: normalizedMakerAddress,
+ gas: orderTransactionOpts.gasLimit,
+ gasPrice: orderTransactionOpts.gasPrice,
+ },
+ );
+ return txHash;
+ }
+ /**
+ * Batch version of cancelOrderAsync. Atomically cancels multiple orders in a single transaction.
+ * All orders must be from the same maker.
+ * @param orderCancellationRequests An array of objects that conform to the OrderCancellationRequest
+ * interface.
+ * @param transactionOpts Optional arguments this method accepts.
+ * @return Transaction hash.
+ */
+ @decorators.asyncZeroExErrorHandler
+ public async batchCancelOrdersAsync(
+ orderCancellationRequests: OrderCancellationRequest[],
+ orderTransactionOpts: OrderTransactionOpts = {},
+ ): Promise<string> {
+ assert.doesConformToSchema(
+ 'orderCancellationRequests',
+ orderCancellationRequests,
+ schemas.orderCancellationRequestsSchema,
+ );
+ const exchangeContractAddresses = _.map(
+ orderCancellationRequests,
+ orderCancellationRequest => orderCancellationRequest.order.exchangeContractAddress,
+ );
+ assert.hasAtMostOneUniqueValue(
+ exchangeContractAddresses,
+ ExchangeContractErrs.BatchOrdersMustHaveSameExchangeAddress,
+ );
+ const makers = _.map(orderCancellationRequests, cancellationRequest => cancellationRequest.order.maker);
+ assert.hasAtMostOneUniqueValue(makers, ExchangeContractErrs.MultipleMakersInSingleCancelBatchDisallowed);
+ const maker = makers[0];
+ await assert.isSenderAddressAsync('maker', maker, this._web3Wrapper);
+ const normalizedMakerAddress = maker.toLowerCase();
+
+ const shouldValidate = _.isUndefined(orderTransactionOpts.shouldValidate)
+ ? SHOULD_VALIDATE_BY_DEFAULT
+ : orderTransactionOpts.shouldValidate;
+ if (shouldValidate) {
+ for (const orderCancellationRequest of orderCancellationRequests) {
+ const orderHash = getOrderHashHex(orderCancellationRequest.order);
+ const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
+ OrderValidationUtils.validateCancelOrderThrowIfInvalid(
+ orderCancellationRequest.order,
+ orderCancellationRequest.takerTokenCancelAmount,
+ unavailableTakerTokenAmount,
+ );
+ }
+ }
+ if (_.isEmpty(orderCancellationRequests)) {
+ throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
+ }
+ const exchangeInstance = await this._getExchangeContractAsync();
+ const orderAddressesValuesAndTakerTokenCancelAmounts = _.map(orderCancellationRequests, cancellationRequest => {
+ return [
+ ...formatters.getOrderAddressesAndValues(cancellationRequest.order),
+ cancellationRequest.takerTokenCancelAmount,
+ ];
+ });
+ // We use _.unzip<any> because _.unzip doesn't type check if values have different types :'(
+ const [orderAddresses, orderValues, cancelTakerTokenAmounts] = _.unzip<any>(
+ orderAddressesValuesAndTakerTokenCancelAmounts,
+ );
+ const txHash = await exchangeInstance.batchCancelOrders.sendTransactionAsync(
+ orderAddresses,
+ orderValues,
+ cancelTakerTokenAmounts,
+ {
+ from: normalizedMakerAddress,
+ gas: orderTransactionOpts.gasLimit,
+ gasPrice: orderTransactionOpts.gasPrice,
+ },
+ );
+ return txHash;
+ }
+ /**
+ * Subscribe to an event type emitted by the Exchange contract.
+ * @param eventName The exchange contract event you would like to subscribe to.
+ * @param indexFilterValues An object where the keys are indexed args returned by the event and
+ * the value is the value you are interested in. E.g `{maker: aUserAddressHex}`
+ * @param callback Callback that gets called when a log is added/removed
+ * @return Subscription token used later to unsubscribe
+ */
+ public subscribe<ArgsType extends ExchangeContractEventArgs>(
+ eventName: ExchangeEvents,
+ indexFilterValues: IndexedFilterValues,
+ callback: EventCallback<ArgsType>,
+ ): string {
+ assert.doesBelongToStringEnum('eventName', eventName, ExchangeEvents);
+ assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
+ assert.isFunction('callback', callback);
+ const exchangeContractAddress = this.getContractAddress();
+ const subscriptionToken = this._subscribe<ArgsType>(
+ exchangeContractAddress,
+ eventName,
+ indexFilterValues,
+ artifacts.Exchange.abi,
+ callback,
+ );
+ return subscriptionToken;
+ }
+ /**
+ * Cancel a subscription
+ * @param subscriptionToken Subscription token returned by `subscribe()`
+ */
+ public unsubscribe(subscriptionToken: string): void {
+ this._unsubscribe(subscriptionToken);
+ }
+ /**
+ * Cancels all existing subscriptions
+ */
+ public unsubscribeAll(): void {
+ super._unsubscribeAll();
+ }
+ /**
+ * Gets historical logs without creating a subscription
+ * @param eventName The exchange contract event you would like to subscribe to.
+ * @param blockRange Block range to get logs from.
+ * @param indexFilterValues An object where the keys are indexed args returned by the event and
+ * the value is the value you are interested in. E.g `{_from: aUserAddressHex}`
+ * @return Array of logs that match the parameters
+ */
+ public async getLogsAsync<ArgsType extends ExchangeContractEventArgs>(
+ eventName: ExchangeEvents,
+ blockRange: BlockRange,
+ indexFilterValues: IndexedFilterValues,
+ ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
+ assert.doesBelongToStringEnum('eventName', eventName, ExchangeEvents);
+ assert.doesConformToSchema('blockRange', blockRange, schemas.blockRangeSchema);
+ assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
+ const exchangeContractAddress = this.getContractAddress();
+ const logs = await this._getLogsAsync<ArgsType>(
+ exchangeContractAddress,
+ eventName,
+ blockRange,
+ indexFilterValues,
+ artifacts.Exchange.abi,
+ );
+ return logs;
+ }
+ /**
+ * Retrieves the Ethereum address of the Exchange contract deployed on the network
+ * that the user-passed web3 provider is connected to.
+ * @returns The Ethereum address of the Exchange contract being used.
+ */
+ public getContractAddress(): string {
+ const contractAddress = this._getContractAddress(artifacts.Exchange, this._contractAddressIfExists);
+ return contractAddress;
+ }
+ /**
+ * Checks if order is still fillable and throws an error otherwise. Useful for orderbook
+ * pruning where you want to remove stale orders without knowing who the taker will be.
+ * @param signedOrder An object that conforms to the SignedOrder interface. The
+ * signedOrder you wish to validate.
+ * @param opts An object that conforms to the ValidateOrderFillableOpts
+ * interface. Allows specifying a specific fillTakerTokenAmount
+ * to validate for.
+ */
+ public async validateOrderFillableOrThrowAsync(
+ signedOrder: SignedOrder,
+ opts?: ValidateOrderFillableOpts,
+ ): Promise<void> {
+ assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
+ const zrxTokenAddress = this.getZRXTokenAddress();
+ const expectedFillTakerTokenAmount = !_.isUndefined(opts) ? opts.expectedFillTakerTokenAmount : undefined;
+ const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+ await this._orderValidationUtils.validateOrderFillableOrThrowAsync(
+ exchangeTradeEmulator,
+ signedOrder,
+ zrxTokenAddress,
+ expectedFillTakerTokenAmount,
+ );
+ }
+ /**
+ * Checks if order fill will succeed and throws an error otherwise.
+ * @param signedOrder An object that conforms to the SignedOrder interface. The
+ * signedOrder you wish to fill.
+ * @param fillTakerTokenAmount The total amount of the takerTokens you would like to fill.
+ * @param takerAddress The user Ethereum address who would like to fill this order.
+ * Must be available via the supplied Provider passed to 0x.js.
+ */
+ public async validateFillOrderThrowIfInvalidAsync(
+ signedOrder: SignedOrder,
+ fillTakerTokenAmount: BigNumber,
+ takerAddress: string,
+ ): Promise<void> {
+ assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
+ assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
+ await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
+ const normalizedTakerAddress = takerAddress.toLowerCase();
+ const zrxTokenAddress = this.getZRXTokenAddress();
+ const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+ await this._orderValidationUtils.validateFillOrderThrowIfInvalidAsync(
+ exchangeTradeEmulator,
+ signedOrder,
+ fillTakerTokenAmount,
+ normalizedTakerAddress,
+ zrxTokenAddress,
+ );
+ }
+ /**
+ * Checks if cancelling a given order will succeed and throws an informative error if it won't.
+ * @param order An object that conforms to the Order or SignedOrder interface.
+ * The order you would like to cancel.
+ * @param cancelTakerTokenAmount The amount (specified in taker tokens) that you would like to cancel.
+ */
+ public async validateCancelOrderThrowIfInvalidAsync(
+ order: Order,
+ cancelTakerTokenAmount: BigNumber,
+ ): Promise<void> {
+ assert.doesConformToSchema('order', order, schemas.orderSchema);
+ assert.isValidBaseUnitAmount('cancelTakerTokenAmount', cancelTakerTokenAmount);
+ const orderHash = getOrderHashHex(order);
+ const unavailableTakerTokenAmount = await this.getUnavailableTakerAmountAsync(orderHash);
+ OrderValidationUtils.validateCancelOrderThrowIfInvalid(
+ order,
+ cancelTakerTokenAmount,
+ unavailableTakerTokenAmount,
+ );
+ }
+ /**
+ * Checks if calling fillOrKill on a given order will succeed and throws an informative error if it won't.
+ * @param signedOrder An object that conforms to the SignedOrder interface. The
+ * signedOrder you wish to fill.
+ * @param fillTakerTokenAmount The total amount of the takerTokens you would like to fill.
+ * @param takerAddress The user Ethereum address who would like to fill this order.
+ * Must be available via the supplied Provider passed to 0x.js.
+ */
+ public async validateFillOrKillOrderThrowIfInvalidAsync(
+ signedOrder: SignedOrder,
+ fillTakerTokenAmount: BigNumber,
+ takerAddress: string,
+ ): Promise<void> {
+ assert.doesConformToSchema('signedOrder', signedOrder, schemas.signedOrderSchema);
+ assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
+ await assert.isSenderAddressAsync('takerAddress', takerAddress, this._web3Wrapper);
+ const normalizedTakerAddress = takerAddress.toLowerCase();
+ const zrxTokenAddress = this.getZRXTokenAddress();
+ const exchangeTradeEmulator = new ExchangeTransferSimulator(this._tokenWrapper, BlockParamLiteral.Latest);
+ await this._orderValidationUtils.validateFillOrKillOrderThrowIfInvalidAsync(
+ exchangeTradeEmulator,
+ signedOrder,
+ fillTakerTokenAmount,
+ normalizedTakerAddress,
+ zrxTokenAddress,
+ );
+ }
+ /**
+ * Checks if rounding error will be > 0.1% when computing makerTokenAmount by doing:
+ * `(fillTakerTokenAmount * makerTokenAmount) / takerTokenAmount`.
+ * 0x Protocol does not accept any trades that result in large rounding errors. This means that tokens with few or
+ * no decimals can only be filled in quantities and ratios that avoid large rounding errors.
+ * @param fillTakerTokenAmount The amount of the order (in taker tokens baseUnits) that you wish to fill.
+ * @param takerTokenAmount The order size on the taker side
+ * @param makerTokenAmount The order size on the maker side
+ */
+ public async isRoundingErrorAsync(
+ fillTakerTokenAmount: BigNumber,
+ takerTokenAmount: BigNumber,
+ makerTokenAmount: BigNumber,
+ ): Promise<boolean> {
+ assert.isValidBaseUnitAmount('fillTakerTokenAmount', fillTakerTokenAmount);
+ assert.isValidBaseUnitAmount('takerTokenAmount', takerTokenAmount);
+ assert.isValidBaseUnitAmount('makerTokenAmount', makerTokenAmount);
+ const exchangeInstance = await this._getExchangeContractAsync();
+ const isRoundingError = await exchangeInstance.isRoundingError.callAsync(
+ fillTakerTokenAmount,
+ takerTokenAmount,
+ makerTokenAmount,
+ );
+ return isRoundingError;
+ }
+ /**
+ * Checks if logs contain LogError, which is emitted by Exchange contract on transaction failure.
+ * @param logs Transaction logs as returned by `zeroEx.awaitTransactionMinedAsync`
+ */
+ public throwLogErrorsAsErrors(logs: Array<LogWithDecodedArgs<DecodedLogArgs> | LogEntry>): void {
+ const errLog = _.find(logs, {
+ event: ExchangeEvents.LogError,
+ });
+ if (!_.isUndefined(errLog)) {
+ const logArgs = (errLog as LogWithDecodedArgs<LogErrorContractEventArgs>).args;
+ const errCode = logArgs.errorId;
+ const errMessage = this._exchangeContractErrCodesToMsg[errCode];
+ throw new Error(errMessage);
+ }
+ }
+ /**
+ * Gets the latest OrderState of a signedOrder
+ * @param signedOrder The signedOrder
+ * @param stateLayer Optional, desired blockchain state layer (defaults to latest).
+ * @return OrderState of the signedOrder
+ */
+ public async getOrderStateAsync(
+ signedOrder: SignedOrder,
+ stateLayer: BlockParamLiteral = BlockParamLiteral.Latest,
+ ): Promise<OrderState> {
+ const simpleBalanceAndProxyAllowanceFetcher = new SimpleBalanceAndProxyAllowanceFetcher(
+ this._tokenWrapper,
+ stateLayer,
+ );
+ const simpleOrderFilledCancelledFetcher = new SimpleOrderFilledCancelledFetcher(this, stateLayer);
+ const orderStateUtils = new OrderStateUtils(
+ simpleBalanceAndProxyAllowanceFetcher,
+ simpleOrderFilledCancelledFetcher,
+ );
+ const orderState = orderStateUtils.getOrderStateAsync(signedOrder);
+ return orderState;
+ }
+ /**
+ * Returns the ZRX token address used by the exchange contract.
+ * @return Address of ZRX token
+ */
+ public getZRXTokenAddress(): string {
+ const contractAddress = this._getContractAddress(artifacts.ZRX, this._zrxContractAddressIfExists);
+ return contractAddress;
+ }
+ private _invalidateContractInstances(): void {
+ this.unsubscribeAll();
+ delete this._exchangeContractIfExists;
+ }
+ private async _isValidSignatureUsingContractCallAsync(
+ dataHex: string,
+ ecSignature: ECSignature,
+ signerAddressHex: string,
+ ): Promise<boolean> {
+ assert.isHexString('dataHex', dataHex);
+ assert.doesConformToSchema('ecSignature', ecSignature, schemas.ecSignatureSchema);
+ assert.isETHAddressHex('signerAddressHex', signerAddressHex);
+ const normalizedSignerAddress = signerAddressHex.toLowerCase();
+
+ const exchangeInstance = await this._getExchangeContractAsync();
+
+ const isValidSignature = await exchangeInstance.isValidSignature.callAsync(
+ normalizedSignerAddress,
+ dataHex,
+ ecSignature.v,
+ ecSignature.r,
+ ecSignature.s,
+ );
+ return isValidSignature;
+ }
+ private async _getOrderHashHexUsingContractCallAsync(order: Order | SignedOrder): Promise<string> {
+ const exchangeInstance = await this._getExchangeContractAsync();
+ const [orderAddresses, orderValues] = formatters.getOrderAddressesAndValues(order);
+ const orderHashHex = await exchangeInstance.getOrderHash.callAsync(orderAddresses, orderValues);
+ return orderHashHex;
+ }
+ private async _getExchangeContractAsync(): Promise<ExchangeContract> {
+ if (!_.isUndefined(this._exchangeContractIfExists)) {
+ return this._exchangeContractIfExists;
+ }
+ const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
+ artifacts.Exchange,
+ this._contractAddressIfExists,
+ );
+ const contractInstance = new ExchangeContract(
+ abi,
+ address,
+ this._web3Wrapper.getProvider(),
+ this._web3Wrapper.getContractDefaults(),
+ );
+ this._exchangeContractIfExists = contractInstance;
+ return this._exchangeContractIfExists;
+ }
+ private async _getTokenTransferProxyAddressAsync(): Promise<string> {
+ const exchangeInstance = await this._getExchangeContractAsync();
+ const tokenTransferProxyAddress = await exchangeInstance.TOKEN_TRANSFER_PROXY_CONTRACT.callAsync();
+ const tokenTransferProxyAddressLowerCase = tokenTransferProxyAddress.toLowerCase();
+ return tokenTransferProxyAddressLowerCase;
+ }
+} // tslint:disable:max-file-line-count
diff --git a/packages/contract-wrappers/src/contract_wrappers/generated/dummy_token.ts b/packages/contract-wrappers/src/contract_wrappers/generated/dummy_token.ts
new file mode 100644
index 000000000..ca923c7c5
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/generated/dummy_token.ts
@@ -0,0 +1,84 @@
+/**
+ * This file is auto-generated using abi-gen. Don't edit directly.
+ * Templates can be found at https://github.com/0xProject/0x-monorepo/tree/development/packages/contract_templates.
+ */
+// tslint:disable:no-consecutive-blank-lines
+// tslint:disable-next-line:no-unused-variable
+import { BaseContract } from '@0xproject/base-contract';
+import {
+ BlockParam,
+ BlockParamLiteral,
+ CallData,
+ ContractAbi,
+ DataItem,
+ MethodAbi,
+ Provider,
+ TxData,
+ TxDataPayable,
+} from '@0xproject/types';
+import { BigNumber, classUtils, promisify } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as ethers from 'ethers';
+import * as _ from 'lodash';
+
+// tslint:disable:no-parameter-reassignment
+export class DummyTokenContract extends BaseContract {
+ public setBalance = {
+ async sendTransactionAsync(_target: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as DummyTokenContract;
+ const inputAbi = self._lookupAbi('setBalance(address,uint256)').inputs;
+ [_target, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_target, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setBalance(address,uint256)')
+ .functions.setBalance(_target, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.setBalance.estimateGasAsync.bind(self, _target, _value),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_target: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as DummyTokenContract;
+ const inputAbi = self._lookupAbi('setBalance(address,uint256)').inputs;
+ [_target, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_target, _value],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setBalance(address,uint256)')
+ .functions.setBalance(_target, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_target: string, _value: BigNumber): string {
+ const self = (this as any) as DummyTokenContract;
+ const inputAbi = self._lookupAbi('setBalance(address,uint256)').inputs;
+ [_target, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_target, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('setBalance(address,uint256)')
+ .functions.setBalance(_target, _value).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ constructor(abi: ContractAbi, address: string, provider: Provider, defaults?: Partial<TxData>) {
+ super(abi, address, provider, defaults);
+ classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
+ }
+} // tslint:disable:max-file-line-count
diff --git a/packages/contract-wrappers/src/contract_wrappers/generated/ether_token.ts b/packages/contract-wrappers/src/contract_wrappers/generated/ether_token.ts
new file mode 100644
index 000000000..df95ba937
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/generated/ether_token.ts
@@ -0,0 +1,621 @@
+/**
+ * This file is auto-generated using abi-gen. Don't edit directly.
+ * Templates can be found at https://github.com/0xProject/0x-monorepo/tree/development/packages/contract_templates.
+ */
+// tslint:disable:no-consecutive-blank-lines
+// tslint:disable-next-line:no-unused-variable
+import { BaseContract } from '@0xproject/base-contract';
+import {
+ BlockParam,
+ BlockParamLiteral,
+ CallData,
+ ContractAbi,
+ DataItem,
+ MethodAbi,
+ Provider,
+ TxData,
+ TxDataPayable,
+} from '@0xproject/types';
+import { BigNumber, classUtils, promisify } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as ethers from 'ethers';
+import * as _ from 'lodash';
+
+export type EtherTokenContractEventArgs =
+ | TransferContractEventArgs
+ | ApprovalContractEventArgs
+ | DepositContractEventArgs
+ | WithdrawalContractEventArgs;
+
+export enum EtherTokenEvents {
+ Transfer = 'Transfer',
+ Approval = 'Approval',
+ Deposit = 'Deposit',
+ Withdrawal = 'Withdrawal',
+}
+
+export interface TransferContractEventArgs {
+ _from: string;
+ _to: string;
+ _value: BigNumber;
+}
+
+export interface ApprovalContractEventArgs {
+ _owner: string;
+ _spender: string;
+ _value: BigNumber;
+}
+
+export interface DepositContractEventArgs {
+ _owner: string;
+ _value: BigNumber;
+}
+
+export interface WithdrawalContractEventArgs {
+ _owner: string;
+ _value: BigNumber;
+}
+
+// tslint:disable:no-parameter-reassignment
+export class EtherTokenContract extends BaseContract {
+ public name = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'name()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.name() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'name' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public approve = {
+ async sendTransactionAsync(_spender: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
+ [_spender, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_spender, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('approve(address,uint256)')
+ .functions.approve(_spender, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.approve.estimateGasAsync.bind(self, _spender, _value),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_spender: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
+ [_spender, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_spender, _value],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('approve(address,uint256)')
+ .functions.approve(_spender, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_spender: string, _value: BigNumber): string {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
+ [_spender, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_spender, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('approve(address,uint256)')
+ .functions.approve(_spender, _value).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ _spender: string,
+ _value: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'approve(address,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_spender, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_spender, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.approve(_spender, _value) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'approve' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public totalSupply = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'totalSupply()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.totalSupply() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'totalSupply' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public transferFrom = {
+ async sendTransactionAsync(
+ _from: string,
+ _to: string,
+ _value: BigNumber,
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
+ [_from, _to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_from, _to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferFrom(address,address,uint256)')
+ .functions.transferFrom(_from, _to, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.transferFrom.estimateGasAsync.bind(self, _from, _to, _value),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ _from: string,
+ _to: string,
+ _value: BigNumber,
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
+ [_from, _to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_from, _to, _value],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferFrom(address,address,uint256)')
+ .functions.transferFrom(_from, _to, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_from: string, _to: string, _value: BigNumber): string {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
+ [_from, _to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_from, _to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('transferFrom(address,address,uint256)')
+ .functions.transferFrom(_from, _to, _value).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ _from: string,
+ _to: string,
+ _value: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'transferFrom(address,address,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_from, _to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_from, _to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.transferFrom(_from, _to, _value) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'transferFrom' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public withdraw = {
+ async sendTransactionAsync(amount: BigNumber, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('withdraw(uint256)').inputs;
+ [amount] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [amount],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self._lookupEthersInterface('withdraw(uint256)').functions.withdraw(amount).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.withdraw.estimateGasAsync.bind(self, amount),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(amount: BigNumber, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('withdraw(uint256)').inputs;
+ [amount] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [amount],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self._lookupEthersInterface('withdraw(uint256)').functions.withdraw(amount).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(amount: BigNumber): string {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('withdraw(uint256)').inputs;
+ [amount] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [amount],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('withdraw(uint256)')
+ .functions.withdraw(amount).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public decimals = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'decimals()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.decimals() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'decimals' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public balanceOf = {
+ async callAsync(
+ _owner: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'balanceOf(address)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_owner] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_owner],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.balanceOf(_owner) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'balanceOf' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public symbol = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'symbol()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.symbol() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'symbol' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public transfer = {
+ async sendTransactionAsync(_to: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
+ [_to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer(_to, _value)
+ .data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.transfer.estimateGasAsync.bind(self, _to, _value),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_to: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
+ [_to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_to, _value],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer(_to, _value)
+ .data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_to: string, _value: BigNumber): string {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
+ [_to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('transfer(address,uint256)')
+ .functions.transfer(_to, _value).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ _to: string,
+ _value: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'transfer(address,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.transfer(_to, _value) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'transfer' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public deposit = {
+ async sendTransactionAsync(txData: Partial<TxDataPayable> = {}): Promise<string> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('deposit()').inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const encodedData = self._lookupEthersInterface('deposit()').functions.deposit().data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.deposit.estimateGasAsync.bind(self),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('deposit()').inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(this));
+ const encodedData = self._lookupEthersInterface('deposit()').functions.deposit().data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(): string {
+ const self = (this as any) as EtherTokenContract;
+ const inputAbi = self._lookupAbi('deposit()').inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const abiEncodedTransactionData = self._lookupEthersInterface('deposit()').functions.deposit().data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public allowance = {
+ async callAsync(
+ _owner: string,
+ _spender: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as EtherTokenContract;
+ const functionSignature = 'allowance(address,address)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_owner, _spender] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_owner, _spender],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.allowance(_owner, _spender) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'allowance' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ constructor(abi: ContractAbi, address: string, provider: Provider, defaults?: Partial<TxData>) {
+ super(abi, address, provider, defaults);
+ classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
+ }
+} // tslint:disable:max-file-line-count
diff --git a/packages/contract-wrappers/src/contract_wrappers/generated/exchange.ts b/packages/contract-wrappers/src/contract_wrappers/generated/exchange.ts
new file mode 100644
index 000000000..da2fc1754
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/generated/exchange.ts
@@ -0,0 +1,1459 @@
+/**
+ * This file is auto-generated using abi-gen. Don't edit directly.
+ * Templates can be found at https://github.com/0xProject/0x-monorepo/tree/development/packages/contract_templates.
+ */
+// tslint:disable:no-consecutive-blank-lines
+// tslint:disable-next-line:no-unused-variable
+import { BaseContract } from '@0xproject/base-contract';
+import {
+ BlockParam,
+ BlockParamLiteral,
+ CallData,
+ ContractAbi,
+ DataItem,
+ MethodAbi,
+ Provider,
+ TxData,
+ TxDataPayable,
+} from '@0xproject/types';
+import { BigNumber, classUtils, promisify } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as ethers from 'ethers';
+import * as _ from 'lodash';
+
+export type ExchangeContractEventArgs =
+ | LogFillContractEventArgs
+ | LogCancelContractEventArgs
+ | LogErrorContractEventArgs;
+
+export enum ExchangeEvents {
+ LogFill = 'LogFill',
+ LogCancel = 'LogCancel',
+ LogError = 'LogError',
+}
+
+export interface LogFillContractEventArgs {
+ maker: string;
+ taker: string;
+ feeRecipient: string;
+ makerToken: string;
+ takerToken: string;
+ filledMakerTokenAmount: BigNumber;
+ filledTakerTokenAmount: BigNumber;
+ paidMakerFee: BigNumber;
+ paidTakerFee: BigNumber;
+ tokens: string;
+ orderHash: string;
+}
+
+export interface LogCancelContractEventArgs {
+ maker: string;
+ feeRecipient: string;
+ makerToken: string;
+ takerToken: string;
+ cancelledMakerTokenAmount: BigNumber;
+ cancelledTakerTokenAmount: BigNumber;
+ tokens: string;
+ orderHash: string;
+}
+
+export interface LogErrorContractEventArgs {
+ errorId: number;
+ orderHash: string;
+}
+
+// tslint:disable:no-parameter-reassignment
+export class ExchangeContract extends BaseContract {
+ public isRoundingError = {
+ async callAsync(
+ numerator: BigNumber,
+ denominator: BigNumber,
+ target: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'isRoundingError(uint256,uint256,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [numerator, denominator, target] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [numerator, denominator, target],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.isRoundingError(numerator, denominator, target) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'isRoundingError' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public filled = {
+ async callAsync(
+ index_0: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'filled(bytes32)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [index_0] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [index_0],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.filled(index_0) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'filled' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public cancelled = {
+ async callAsync(
+ index_0: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'cancelled(bytes32)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [index_0] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [index_0],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.cancelled(index_0) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'cancelled' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public fillOrdersUpTo = {
+ async sendTransactionAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'fillOrdersUpTo(address[5][],uint256[6][],uint256,bool,uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface(
+ 'fillOrdersUpTo(address[5][],uint256[6][],uint256,bool,uint8[],bytes32[],bytes32[])',
+ )
+ .functions.fillOrdersUpTo(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.fillOrdersUpTo.estimateGasAsync.bind(
+ self,
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'fillOrdersUpTo(address[5][],uint256[6][],uint256,bool,uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface(
+ 'fillOrdersUpTo(address[5][],uint256[6][],uint256,bool,uint8[],bytes32[],bytes32[])',
+ )
+ .functions.fillOrdersUpTo(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ ): string {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'fillOrdersUpTo(address[5][],uint256[6][],uint256,bool,uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface(
+ 'fillOrdersUpTo(address[5][],uint256[6][],uint256,bool,uint8[],bytes32[],bytes32[])',
+ )
+ .functions.fillOrdersUpTo(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature =
+ 'fillOrdersUpTo(address[5][],uint256[6][],uint256,bool,uint8[],bytes32[],bytes32[])';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.fillOrdersUpTo(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'fillOrdersUpTo' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public cancelOrder = {
+ async sendTransactionAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ cancelTakerTokenAmount: BigNumber,
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('cancelOrder(address[5],uint256[6],uint256)').inputs;
+ [orderAddresses, orderValues, cancelTakerTokenAmount] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, cancelTakerTokenAmount],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('cancelOrder(address[5],uint256[6],uint256)')
+ .functions.cancelOrder(orderAddresses, orderValues, cancelTakerTokenAmount).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.cancelOrder.estimateGasAsync.bind(self, orderAddresses, orderValues, cancelTakerTokenAmount),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ cancelTakerTokenAmount: BigNumber,
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('cancelOrder(address[5],uint256[6],uint256)').inputs;
+ [orderAddresses, orderValues, cancelTakerTokenAmount] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, cancelTakerTokenAmount],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('cancelOrder(address[5],uint256[6],uint256)')
+ .functions.cancelOrder(orderAddresses, orderValues, cancelTakerTokenAmount).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ cancelTakerTokenAmount: BigNumber,
+ ): string {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('cancelOrder(address[5],uint256[6],uint256)').inputs;
+ [orderAddresses, orderValues, cancelTakerTokenAmount] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, cancelTakerTokenAmount],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('cancelOrder(address[5],uint256[6],uint256)')
+ .functions.cancelOrder(orderAddresses, orderValues, cancelTakerTokenAmount).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ cancelTakerTokenAmount: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'cancelOrder(address[5],uint256[6],uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [orderAddresses, orderValues, cancelTakerTokenAmount] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, cancelTakerTokenAmount],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.cancelOrder(orderAddresses, orderValues, cancelTakerTokenAmount) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'cancelOrder' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public ZRX_TOKEN_CONTRACT = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'ZRX_TOKEN_CONTRACT()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.ZRX_TOKEN_CONTRACT() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'ZRX_TOKEN_CONTRACT' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public batchFillOrKillOrders = {
+ async sendTransactionAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmounts: BigNumber[],
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'batchFillOrKillOrders(address[5][],uint256[6][],uint256[],uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface(
+ 'batchFillOrKillOrders(address[5][],uint256[6][],uint256[],uint8[],bytes32[],bytes32[])',
+ )
+ .functions.batchFillOrKillOrders(orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.batchFillOrKillOrders.estimateGasAsync.bind(
+ self,
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ v,
+ r,
+ s,
+ ),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmounts: BigNumber[],
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'batchFillOrKillOrders(address[5][],uint256[6][],uint256[],uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface(
+ 'batchFillOrKillOrders(address[5][],uint256[6][],uint256[],uint8[],bytes32[],bytes32[])',
+ )
+ .functions.batchFillOrKillOrders(orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmounts: BigNumber[],
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ ): string {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'batchFillOrKillOrders(address[5][],uint256[6][],uint256[],uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface(
+ 'batchFillOrKillOrders(address[5][],uint256[6][],uint256[],uint8[],bytes32[],bytes32[])',
+ )
+ .functions.batchFillOrKillOrders(orderAddresses, orderValues, fillTakerTokenAmounts, v, r, s).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public fillOrKillOrder = {
+ async sendTransactionAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ fillTakerTokenAmount: BigNumber,
+ v: number | BigNumber,
+ r: string,
+ s: string,
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('fillOrKillOrder(address[5],uint256[6],uint256,uint8,bytes32,bytes32)')
+ .inputs;
+ [orderAddresses, orderValues, fillTakerTokenAmount, v, r, s] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, fillTakerTokenAmount, v, r, s],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('fillOrKillOrder(address[5],uint256[6],uint256,uint8,bytes32,bytes32)')
+ .functions.fillOrKillOrder(orderAddresses, orderValues, fillTakerTokenAmount, v, r, s).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.fillOrKillOrder.estimateGasAsync.bind(
+ self,
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ v,
+ r,
+ s,
+ ),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ fillTakerTokenAmount: BigNumber,
+ v: number | BigNumber,
+ r: string,
+ s: string,
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('fillOrKillOrder(address[5],uint256[6],uint256,uint8,bytes32,bytes32)')
+ .inputs;
+ [orderAddresses, orderValues, fillTakerTokenAmount, v, r, s] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, fillTakerTokenAmount, v, r, s],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('fillOrKillOrder(address[5],uint256[6],uint256,uint8,bytes32,bytes32)')
+ .functions.fillOrKillOrder(orderAddresses, orderValues, fillTakerTokenAmount, v, r, s).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ fillTakerTokenAmount: BigNumber,
+ v: number | BigNumber,
+ r: string,
+ s: string,
+ ): string {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('fillOrKillOrder(address[5],uint256[6],uint256,uint8,bytes32,bytes32)')
+ .inputs;
+ [orderAddresses, orderValues, fillTakerTokenAmount, v, r, s] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, fillTakerTokenAmount, v, r, s],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('fillOrKillOrder(address[5],uint256[6],uint256,uint8,bytes32,bytes32)')
+ .functions.fillOrKillOrder(orderAddresses, orderValues, fillTakerTokenAmount, v, r, s).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public getUnavailableTakerTokenAmount = {
+ async callAsync(
+ orderHash: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'getUnavailableTakerTokenAmount(bytes32)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [orderHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderHash],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getUnavailableTakerTokenAmount(orderHash) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getUnavailableTakerTokenAmount' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public isValidSignature = {
+ async callAsync(
+ signer: string,
+ hash: string,
+ v: number | BigNumber,
+ r: string,
+ s: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'isValidSignature(address,bytes32,uint8,bytes32,bytes32)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [signer, hash, v, r, s] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [signer, hash, v, r, s],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.isValidSignature(signer, hash, v, r, s) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'isValidSignature' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public getPartialAmount = {
+ async callAsync(
+ numerator: BigNumber,
+ denominator: BigNumber,
+ target: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'getPartialAmount(uint256,uint256,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [numerator, denominator, target] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [numerator, denominator, target],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getPartialAmount(numerator, denominator, target) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getPartialAmount' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public TOKEN_TRANSFER_PROXY_CONTRACT = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'TOKEN_TRANSFER_PROXY_CONTRACT()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.TOKEN_TRANSFER_PROXY_CONTRACT() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'TOKEN_TRANSFER_PROXY_CONTRACT' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public batchFillOrders = {
+ async sendTransactionAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmounts: BigNumber[],
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'batchFillOrders(address[5][],uint256[6][],uint256[],bool,uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface(
+ 'batchFillOrders(address[5][],uint256[6][],uint256[],bool,uint8[],bytes32[],bytes32[])',
+ )
+ .functions.batchFillOrders(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.batchFillOrders.estimateGasAsync.bind(
+ self,
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmounts: BigNumber[],
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'batchFillOrders(address[5][],uint256[6][],uint256[],bool,uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface(
+ 'batchFillOrders(address[5][],uint256[6][],uint256[],bool,uint8[],bytes32[],bytes32[])',
+ )
+ .functions.batchFillOrders(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ fillTakerTokenAmounts: BigNumber[],
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: Array<number | BigNumber>,
+ r: string[],
+ s: string[],
+ ): string {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi(
+ 'batchFillOrders(address[5][],uint256[6][],uint256[],bool,uint8[],bytes32[],bytes32[])',
+ ).inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface(
+ 'batchFillOrders(address[5][],uint256[6][],uint256[],bool,uint8[],bytes32[],bytes32[])',
+ )
+ .functions.batchFillOrders(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmounts,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public batchCancelOrders = {
+ async sendTransactionAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ cancelTakerTokenAmounts: BigNumber[],
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('batchCancelOrders(address[5][],uint256[6][],uint256[])').inputs;
+ [orderAddresses, orderValues, cancelTakerTokenAmounts] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, cancelTakerTokenAmounts],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('batchCancelOrders(address[5][],uint256[6][],uint256[])')
+ .functions.batchCancelOrders(orderAddresses, orderValues, cancelTakerTokenAmounts).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.batchCancelOrders.estimateGasAsync.bind(
+ self,
+ orderAddresses,
+ orderValues,
+ cancelTakerTokenAmounts,
+ ),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ cancelTakerTokenAmounts: BigNumber[],
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('batchCancelOrders(address[5][],uint256[6][],uint256[])').inputs;
+ [orderAddresses, orderValues, cancelTakerTokenAmounts] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, cancelTakerTokenAmounts],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('batchCancelOrders(address[5][],uint256[6][],uint256[])')
+ .functions.batchCancelOrders(orderAddresses, orderValues, cancelTakerTokenAmounts).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(
+ orderAddresses: string[][],
+ orderValues: BigNumber[][],
+ cancelTakerTokenAmounts: BigNumber[],
+ ): string {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('batchCancelOrders(address[5][],uint256[6][],uint256[])').inputs;
+ [orderAddresses, orderValues, cancelTakerTokenAmounts] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues, cancelTakerTokenAmounts],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('batchCancelOrders(address[5][],uint256[6][],uint256[])')
+ .functions.batchCancelOrders(orderAddresses, orderValues, cancelTakerTokenAmounts).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public fillOrder = {
+ async sendTransactionAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: number | BigNumber,
+ r: string,
+ s: string,
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('fillOrder(address[5],uint256[6],uint256,bool,uint8,bytes32,bytes32)')
+ .inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('fillOrder(address[5],uint256[6],uint256,bool,uint8,bytes32,bytes32)')
+ .functions.fillOrder(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.fillOrder.estimateGasAsync.bind(
+ self,
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: number | BigNumber,
+ r: string,
+ s: string,
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('fillOrder(address[5],uint256[6],uint256,bool,uint8,bytes32,bytes32)')
+ .inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('fillOrder(address[5],uint256[6],uint256,bool,uint8,bytes32,bytes32)')
+ .functions.fillOrder(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: number | BigNumber,
+ r: string,
+ s: string,
+ ): string {
+ const self = (this as any) as ExchangeContract;
+ const inputAbi = self._lookupAbi('fillOrder(address[5],uint256[6],uint256,bool,uint8,bytes32,bytes32)')
+ .inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('fillOrder(address[5],uint256[6],uint256,bool,uint8,bytes32,bytes32)')
+ .functions.fillOrder(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ fillTakerTokenAmount: BigNumber,
+ shouldThrowOnInsufficientBalanceOrAllowance: boolean,
+ v: number | BigNumber,
+ r: string,
+ s: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'fillOrder(address[5],uint256[6],uint256,bool,uint8,bytes32,bytes32)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.fillOrder(
+ orderAddresses,
+ orderValues,
+ fillTakerTokenAmount,
+ shouldThrowOnInsufficientBalanceOrAllowance,
+ v,
+ r,
+ s,
+ ) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'fillOrder' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public getOrderHash = {
+ async callAsync(
+ orderAddresses: string[],
+ orderValues: BigNumber[],
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'getOrderHash(address[5],uint256[6])';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [orderAddresses, orderValues] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [orderAddresses, orderValues],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getOrderHash(orderAddresses, orderValues) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getOrderHash' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public EXTERNAL_QUERY_GAS_LIMIT = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'EXTERNAL_QUERY_GAS_LIMIT()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.EXTERNAL_QUERY_GAS_LIMIT() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'EXTERNAL_QUERY_GAS_LIMIT' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public VERSION = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as ExchangeContract;
+ const functionSignature = 'VERSION()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.VERSION() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'VERSION' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ constructor(abi: ContractAbi, address: string, provider: Provider, defaults?: Partial<TxData>) {
+ super(abi, address, provider, defaults);
+ classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
+ }
+} // tslint:disable:max-file-line-count
diff --git a/packages/contract-wrappers/src/contract_wrappers/generated/token.ts b/packages/contract-wrappers/src/contract_wrappers/generated/token.ts
new file mode 100644
index 000000000..130265d4d
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/generated/token.ts
@@ -0,0 +1,432 @@
+/**
+ * This file is auto-generated using abi-gen. Don't edit directly.
+ * Templates can be found at https://github.com/0xProject/0x-monorepo/tree/development/packages/contract_templates.
+ */
+// tslint:disable:no-consecutive-blank-lines
+// tslint:disable-next-line:no-unused-variable
+import { BaseContract } from '@0xproject/base-contract';
+import {
+ BlockParam,
+ BlockParamLiteral,
+ CallData,
+ ContractAbi,
+ DataItem,
+ MethodAbi,
+ Provider,
+ TxData,
+ TxDataPayable,
+} from '@0xproject/types';
+import { BigNumber, classUtils, promisify } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as ethers from 'ethers';
+import * as _ from 'lodash';
+
+export type TokenContractEventArgs = TransferContractEventArgs | ApprovalContractEventArgs;
+
+export enum TokenEvents {
+ Transfer = 'Transfer',
+ Approval = 'Approval',
+}
+
+export interface TransferContractEventArgs {
+ _from: string;
+ _to: string;
+ _value: BigNumber;
+}
+
+export interface ApprovalContractEventArgs {
+ _owner: string;
+ _spender: string;
+ _value: BigNumber;
+}
+
+// tslint:disable:no-parameter-reassignment
+export class TokenContract extends BaseContract {
+ public approve = {
+ async sendTransactionAsync(_spender: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
+ [_spender, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_spender, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('approve(address,uint256)')
+ .functions.approve(_spender, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.approve.estimateGasAsync.bind(self, _spender, _value),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_spender: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
+ [_spender, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_spender, _value],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('approve(address,uint256)')
+ .functions.approve(_spender, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_spender: string, _value: BigNumber): string {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
+ [_spender, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_spender, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('approve(address,uint256)')
+ .functions.approve(_spender, _value).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ _spender: string,
+ _value: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as TokenContract;
+ const functionSignature = 'approve(address,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_spender, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_spender, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.approve(_spender, _value) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'approve' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public totalSupply = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
+ const self = (this as any) as TokenContract;
+ const functionSignature = 'totalSupply()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.totalSupply() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'totalSupply' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public transferFrom = {
+ async sendTransactionAsync(
+ _from: string,
+ _to: string,
+ _value: BigNumber,
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
+ [_from, _to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_from, _to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferFrom(address,address,uint256)')
+ .functions.transferFrom(_from, _to, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.transferFrom.estimateGasAsync.bind(self, _from, _to, _value),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ _from: string,
+ _to: string,
+ _value: BigNumber,
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
+ [_from, _to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_from, _to, _value],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferFrom(address,address,uint256)')
+ .functions.transferFrom(_from, _to, _value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_from: string, _to: string, _value: BigNumber): string {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
+ [_from, _to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_from, _to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('transferFrom(address,address,uint256)')
+ .functions.transferFrom(_from, _to, _value).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ _from: string,
+ _to: string,
+ _value: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as TokenContract;
+ const functionSignature = 'transferFrom(address,address,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_from, _to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_from, _to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.transferFrom(_from, _to, _value) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'transferFrom' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public balanceOf = {
+ async callAsync(
+ _owner: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as TokenContract;
+ const functionSignature = 'balanceOf(address)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_owner] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_owner],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.balanceOf(_owner) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'balanceOf' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public transfer = {
+ async sendTransactionAsync(_to: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
+ [_to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer(_to, _value)
+ .data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.transfer.estimateGasAsync.bind(self, _to, _value),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_to: string, _value: BigNumber, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
+ [_to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_to, _value],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer(_to, _value)
+ .data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_to: string, _value: BigNumber): string {
+ const self = (this as any) as TokenContract;
+ const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
+ [_to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('transfer(address,uint256)')
+ .functions.transfer(_to, _value).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ _to: string,
+ _value: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as TokenContract;
+ const functionSignature = 'transfer(address,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_to, _value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_to, _value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.transfer(_to, _value) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'transfer' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public allowance = {
+ async callAsync(
+ _owner: string,
+ _spender: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<BigNumber> {
+ const self = (this as any) as TokenContract;
+ const functionSignature = 'allowance(address,address)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_owner, _spender] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_owner, _spender],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.allowance(_owner, _spender) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'allowance' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ constructor(abi: ContractAbi, address: string, provider: Provider, defaults?: Partial<TxData>) {
+ super(abi, address, provider, defaults);
+ classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
+ }
+} // tslint:disable:max-file-line-count
diff --git a/packages/contract-wrappers/src/contract_wrappers/generated/token_registry.ts b/packages/contract-wrappers/src/contract_wrappers/generated/token_registry.ts
new file mode 100644
index 000000000..243f81088
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/generated/token_registry.ts
@@ -0,0 +1,799 @@
+/**
+ * This file is auto-generated using abi-gen. Don't edit directly.
+ * Templates can be found at https://github.com/0xProject/0x-monorepo/tree/development/packages/contract_templates.
+ */
+// tslint:disable:no-consecutive-blank-lines
+// tslint:disable-next-line:no-unused-variable
+import { BaseContract } from '@0xproject/base-contract';
+import {
+ BlockParam,
+ BlockParamLiteral,
+ CallData,
+ ContractAbi,
+ DataItem,
+ MethodAbi,
+ Provider,
+ TxData,
+ TxDataPayable,
+} from '@0xproject/types';
+import { BigNumber, classUtils, promisify } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as ethers from 'ethers';
+import * as _ from 'lodash';
+
+export type TokenRegistryContractEventArgs =
+ | LogAddTokenContractEventArgs
+ | LogRemoveTokenContractEventArgs
+ | LogTokenNameChangeContractEventArgs
+ | LogTokenSymbolChangeContractEventArgs
+ | LogTokenIpfsHashChangeContractEventArgs
+ | LogTokenSwarmHashChangeContractEventArgs;
+
+export enum TokenRegistryEvents {
+ LogAddToken = 'LogAddToken',
+ LogRemoveToken = 'LogRemoveToken',
+ LogTokenNameChange = 'LogTokenNameChange',
+ LogTokenSymbolChange = 'LogTokenSymbolChange',
+ LogTokenIpfsHashChange = 'LogTokenIpfsHashChange',
+ LogTokenSwarmHashChange = 'LogTokenSwarmHashChange',
+}
+
+export interface LogAddTokenContractEventArgs {
+ token: string;
+ name: string;
+ symbol: string;
+ decimals: number;
+ ipfsHash: string;
+ swarmHash: string;
+}
+
+export interface LogRemoveTokenContractEventArgs {
+ token: string;
+ name: string;
+ symbol: string;
+ decimals: number;
+ ipfsHash: string;
+ swarmHash: string;
+}
+
+export interface LogTokenNameChangeContractEventArgs {
+ token: string;
+ oldName: string;
+ newName: string;
+}
+
+export interface LogTokenSymbolChangeContractEventArgs {
+ token: string;
+ oldSymbol: string;
+ newSymbol: string;
+}
+
+export interface LogTokenIpfsHashChangeContractEventArgs {
+ token: string;
+ oldIpfsHash: string;
+ newIpfsHash: string;
+}
+
+export interface LogTokenSwarmHashChangeContractEventArgs {
+ token: string;
+ oldSwarmHash: string;
+ newSwarmHash: string;
+}
+
+// tslint:disable:no-parameter-reassignment
+export class TokenRegistryContract extends BaseContract {
+ public removeToken = {
+ async sendTransactionAsync(_token: string, _index: BigNumber, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('removeToken(address,uint256)').inputs;
+ [_token, _index] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _index],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('removeToken(address,uint256)')
+ .functions.removeToken(_token, _index).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.removeToken.estimateGasAsync.bind(self, _token, _index),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_token: string, _index: BigNumber, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('removeToken(address,uint256)').inputs;
+ [_token, _index] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _index],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('removeToken(address,uint256)')
+ .functions.removeToken(_token, _index).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_token: string, _index: BigNumber): string {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('removeToken(address,uint256)').inputs;
+ [_token, _index] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _index],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('removeToken(address,uint256)')
+ .functions.removeToken(_token, _index).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public getTokenAddressByName = {
+ async callAsync(_name: string, callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'getTokenAddressByName(string)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_name] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_name],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getTokenAddressByName(_name) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getTokenAddressByName' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public getTokenAddressBySymbol = {
+ async callAsync(_symbol: string, callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'getTokenAddressBySymbol(string)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_symbol] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_symbol],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getTokenAddressBySymbol(_symbol) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getTokenAddressBySymbol' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public setTokenSwarmHash = {
+ async sendTransactionAsync(_token: string, _swarmHash: string, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenSwarmHash(address,bytes)').inputs;
+ [_token, _swarmHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _swarmHash],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setTokenSwarmHash(address,bytes)')
+ .functions.setTokenSwarmHash(_token, _swarmHash).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.setTokenSwarmHash.estimateGasAsync.bind(self, _token, _swarmHash),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_token: string, _swarmHash: string, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenSwarmHash(address,bytes)').inputs;
+ [_token, _swarmHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _swarmHash],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setTokenSwarmHash(address,bytes)')
+ .functions.setTokenSwarmHash(_token, _swarmHash).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_token: string, _swarmHash: string): string {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenSwarmHash(address,bytes)').inputs;
+ [_token, _swarmHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _swarmHash],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('setTokenSwarmHash(address,bytes)')
+ .functions.setTokenSwarmHash(_token, _swarmHash).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public getTokenMetaData = {
+ async callAsync(
+ _token: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<[string, string, string, number, string, string]> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'getTokenMetaData(address)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_token] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getTokenMetaData(_token) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getTokenMetaData' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray;
+ },
+ };
+ public owner = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'owner()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.owner() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'owner' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public addToken = {
+ async sendTransactionAsync(
+ _token: string,
+ _name: string,
+ _symbol: string,
+ _decimals: number | BigNumber,
+ _ipfsHash: string,
+ _swarmHash: string,
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('addToken(address,string,string,uint8,bytes,bytes)').inputs;
+ [_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('addToken(address,string,string,uint8,bytes,bytes)')
+ .functions.addToken(_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.addToken.estimateGasAsync.bind(self, _token, _name, _symbol, _decimals, _ipfsHash, _swarmHash),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ _token: string,
+ _name: string,
+ _symbol: string,
+ _decimals: number | BigNumber,
+ _ipfsHash: string,
+ _swarmHash: string,
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('addToken(address,string,string,uint8,bytes,bytes)').inputs;
+ [_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('addToken(address,string,string,uint8,bytes,bytes)')
+ .functions.addToken(_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(
+ _token: string,
+ _name: string,
+ _symbol: string,
+ _decimals: number | BigNumber,
+ _ipfsHash: string,
+ _swarmHash: string,
+ ): string {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('addToken(address,string,string,uint8,bytes,bytes)').inputs;
+ [_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('addToken(address,string,string,uint8,bytes,bytes)')
+ .functions.addToken(_token, _name, _symbol, _decimals, _ipfsHash, _swarmHash).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public setTokenName = {
+ async sendTransactionAsync(_token: string, _name: string, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenName(address,string)').inputs;
+ [_token, _name] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _name],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setTokenName(address,string)')
+ .functions.setTokenName(_token, _name).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.setTokenName.estimateGasAsync.bind(self, _token, _name),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_token: string, _name: string, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenName(address,string)').inputs;
+ [_token, _name] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _name],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setTokenName(address,string)')
+ .functions.setTokenName(_token, _name).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_token: string, _name: string): string {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenName(address,string)').inputs;
+ [_token, _name] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _name],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('setTokenName(address,string)')
+ .functions.setTokenName(_token, _name).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public tokens = {
+ async callAsync(
+ index_0: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<[string, string, string, number, string, string]> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'tokens(address)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [index_0] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [index_0],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.tokens(index_0) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'tokens' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray;
+ },
+ };
+ public tokenAddresses = {
+ async callAsync(
+ index_0: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'tokenAddresses(uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [index_0] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [index_0],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.tokenAddresses(index_0) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'tokenAddresses' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public getTokenByName = {
+ async callAsync(
+ _name: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<[string, string, string, number, string, string]> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'getTokenByName(string)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_name] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_name],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getTokenByName(_name) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getTokenByName' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray;
+ },
+ };
+ public getTokenAddresses = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'getTokenAddresses()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getTokenAddresses() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getTokenAddresses' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public setTokenIpfsHash = {
+ async sendTransactionAsync(_token: string, _ipfsHash: string, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenIpfsHash(address,bytes)').inputs;
+ [_token, _ipfsHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _ipfsHash],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setTokenIpfsHash(address,bytes)')
+ .functions.setTokenIpfsHash(_token, _ipfsHash).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.setTokenIpfsHash.estimateGasAsync.bind(self, _token, _ipfsHash),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_token: string, _ipfsHash: string, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenIpfsHash(address,bytes)').inputs;
+ [_token, _ipfsHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _ipfsHash],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setTokenIpfsHash(address,bytes)')
+ .functions.setTokenIpfsHash(_token, _ipfsHash).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_token: string, _ipfsHash: string): string {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenIpfsHash(address,bytes)').inputs;
+ [_token, _ipfsHash] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _ipfsHash],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('setTokenIpfsHash(address,bytes)')
+ .functions.setTokenIpfsHash(_token, _ipfsHash).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public getTokenBySymbol = {
+ async callAsync(
+ _symbol: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<[string, string, string, number, string, string]> {
+ const self = (this as any) as TokenRegistryContract;
+ const functionSignature = 'getTokenBySymbol(string)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [_symbol] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_symbol],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getTokenBySymbol(_symbol) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getTokenBySymbol' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray;
+ },
+ };
+ public setTokenSymbol = {
+ async sendTransactionAsync(_token: string, _symbol: string, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenSymbol(address,string)').inputs;
+ [_token, _symbol] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _symbol],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setTokenSymbol(address,string)')
+ .functions.setTokenSymbol(_token, _symbol).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.setTokenSymbol.estimateGasAsync.bind(self, _token, _symbol),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(_token: string, _symbol: string, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenSymbol(address,string)').inputs;
+ [_token, _symbol] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _symbol],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('setTokenSymbol(address,string)')
+ .functions.setTokenSymbol(_token, _symbol).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(_token: string, _symbol: string): string {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('setTokenSymbol(address,string)').inputs;
+ [_token, _symbol] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [_token, _symbol],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('setTokenSymbol(address,string)')
+ .functions.setTokenSymbol(_token, _symbol).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public transferOwnership = {
+ async sendTransactionAsync(newOwner: string, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
+ [newOwner] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [newOwner],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferOwnership(address)')
+ .functions.transferOwnership(newOwner).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.transferOwnership.estimateGasAsync.bind(self, newOwner),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(newOwner: string, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
+ [newOwner] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [newOwner],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferOwnership(address)')
+ .functions.transferOwnership(newOwner).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(newOwner: string): string {
+ const self = (this as any) as TokenRegistryContract;
+ const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
+ [newOwner] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [newOwner],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('transferOwnership(address)')
+ .functions.transferOwnership(newOwner).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ constructor(abi: ContractAbi, address: string, provider: Provider, defaults?: Partial<TxData>) {
+ super(abi, address, provider, defaults);
+ classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
+ }
+} // tslint:disable:max-file-line-count
diff --git a/packages/contract-wrappers/src/contract_wrappers/generated/token_transfer_proxy.ts b/packages/contract-wrappers/src/contract_wrappers/generated/token_transfer_proxy.ts
new file mode 100644
index 000000000..e533430ff
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/generated/token_transfer_proxy.ts
@@ -0,0 +1,447 @@
+/**
+ * This file is auto-generated using abi-gen. Don't edit directly.
+ * Templates can be found at https://github.com/0xProject/0x-monorepo/tree/development/packages/contract_templates.
+ */
+// tslint:disable:no-consecutive-blank-lines
+// tslint:disable-next-line:no-unused-variable
+import { BaseContract } from '@0xproject/base-contract';
+import {
+ BlockParam,
+ BlockParamLiteral,
+ CallData,
+ ContractAbi,
+ DataItem,
+ MethodAbi,
+ Provider,
+ TxData,
+ TxDataPayable,
+} from '@0xproject/types';
+import { BigNumber, classUtils, promisify } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as ethers from 'ethers';
+import * as _ from 'lodash';
+
+export type TokenTransferProxyContractEventArgs =
+ | LogAuthorizedAddressAddedContractEventArgs
+ | LogAuthorizedAddressRemovedContractEventArgs;
+
+export enum TokenTransferProxyEvents {
+ LogAuthorizedAddressAdded = 'LogAuthorizedAddressAdded',
+ LogAuthorizedAddressRemoved = 'LogAuthorizedAddressRemoved',
+}
+
+export interface LogAuthorizedAddressAddedContractEventArgs {
+ target: string;
+ caller: string;
+}
+
+export interface LogAuthorizedAddressRemovedContractEventArgs {
+ target: string;
+ caller: string;
+}
+
+// tslint:disable:no-parameter-reassignment
+export class TokenTransferProxyContract extends BaseContract {
+ public transferFrom = {
+ async sendTransactionAsync(
+ token: string,
+ from: string,
+ to: string,
+ value: BigNumber,
+ txData: Partial<TxData> = {},
+ ): Promise<string> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,address,uint256)').inputs;
+ [token, from, to, value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [token, from, to, value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferFrom(address,address,address,uint256)')
+ .functions.transferFrom(token, from, to, value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.transferFrom.estimateGasAsync.bind(self, token, from, to, value),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(
+ token: string,
+ from: string,
+ to: string,
+ value: BigNumber,
+ txData: Partial<TxData> = {},
+ ): Promise<number> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,address,uint256)').inputs;
+ [token, from, to, value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [token, from, to, value],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferFrom(address,address,address,uint256)')
+ .functions.transferFrom(token, from, to, value).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(token: string, from: string, to: string, value: BigNumber): string {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('transferFrom(address,address,address,uint256)').inputs;
+ [token, from, to, value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [token, from, to, value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('transferFrom(address,address,address,uint256)')
+ .functions.transferFrom(token, from, to, value).data;
+ return abiEncodedTransactionData;
+ },
+ async callAsync(
+ token: string,
+ from: string,
+ to: string,
+ value: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const functionSignature = 'transferFrom(address,address,address,uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [token, from, to, value] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [token, from, to, value],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.transferFrom(token, from, to, value) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'transferFrom' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public addAuthorizedAddress = {
+ async sendTransactionAsync(target: string, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
+ [target] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [target],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('addAuthorizedAddress(address)')
+ .functions.addAuthorizedAddress(target).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.addAuthorizedAddress.estimateGasAsync.bind(self, target),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(target: string, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
+ [target] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [target],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('addAuthorizedAddress(address)')
+ .functions.addAuthorizedAddress(target).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(target: string): string {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
+ [target] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [target],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('addAuthorizedAddress(address)')
+ .functions.addAuthorizedAddress(target).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public authorities = {
+ async callAsync(
+ index_0: BigNumber,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<string> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const functionSignature = 'authorities(uint256)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [index_0] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [index_0],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.authorities(index_0) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'authorities' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public removeAuthorizedAddress = {
+ async sendTransactionAsync(target: string, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
+ [target] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [target],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('removeAuthorizedAddress(address)')
+ .functions.removeAuthorizedAddress(target).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.removeAuthorizedAddress.estimateGasAsync.bind(self, target),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(target: string, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
+ [target] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [target],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('removeAuthorizedAddress(address)')
+ .functions.removeAuthorizedAddress(target).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(target: string): string {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
+ [target] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [target],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('removeAuthorizedAddress(address)')
+ .functions.removeAuthorizedAddress(target).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ public owner = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const functionSignature = 'owner()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.owner() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'owner' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public authorized = {
+ async callAsync(
+ index_0: string,
+ callData: Partial<CallData> = {},
+ defaultBlock?: BlockParam,
+ ): Promise<boolean> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const functionSignature = 'authorized(address)';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [index_0] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [index_0],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.authorized(index_0) as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'authorized' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public getAuthorizedAddresses = {
+ async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const functionSignature = 'getAuthorizedAddresses()';
+ const inputAbi = self._lookupAbi(functionSignature).inputs;
+ [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
+ const ethersFunction = self
+ ._lookupEthersInterface(functionSignature)
+ .functions.getAuthorizedAddresses() as ethers.CallDescription;
+ const encodedData = ethersFunction.data;
+ const callDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ data: encodedData,
+ });
+ const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
+ let resultArray = ethersFunction.parse(rawCallResult);
+ const outputAbi = (_.find(self.abi, { name: 'getAuthorizedAddresses' }) as MethodAbi).outputs;
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._lowercaseAddress.bind(this),
+ );
+ resultArray = BaseContract._formatABIDataItemList(
+ outputAbi,
+ resultArray,
+ BaseContract._bnToBigNumber.bind(this),
+ );
+ return resultArray[0];
+ },
+ };
+ public transferOwnership = {
+ async sendTransactionAsync(newOwner: string, txData: Partial<TxData> = {}): Promise<string> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
+ [newOwner] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [newOwner],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferOwnership(address)')
+ .functions.transferOwnership(newOwner).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
+ {
+ ...txData,
+ data: encodedData,
+ },
+ self.transferOwnership.estimateGasAsync.bind(self, newOwner),
+ );
+ const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
+ return txHash;
+ },
+ async estimateGasAsync(newOwner: string, txData: Partial<TxData> = {}): Promise<number> {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
+ [newOwner] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [newOwner],
+ BaseContract._bigNumberToString.bind(this),
+ );
+ const encodedData = self
+ ._lookupEthersInterface('transferOwnership(address)')
+ .functions.transferOwnership(newOwner).data;
+ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
+ ...txData,
+ data: encodedData,
+ });
+ const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
+ return gas;
+ },
+ getABIEncodedTransactionData(newOwner: string): string {
+ const self = (this as any) as TokenTransferProxyContract;
+ const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
+ [newOwner] = BaseContract._formatABIDataItemList(
+ inputAbi,
+ [newOwner],
+ BaseContract._bigNumberToString.bind(self),
+ );
+ const abiEncodedTransactionData = self
+ ._lookupEthersInterface('transferOwnership(address)')
+ .functions.transferOwnership(newOwner).data;
+ return abiEncodedTransactionData;
+ },
+ };
+ constructor(abi: ContractAbi, address: string, provider: Provider, defaults?: Partial<TxData>) {
+ super(abi, address, provider, defaults);
+ classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
+ }
+} // tslint:disable:max-file-line-count
diff --git a/packages/contract-wrappers/src/contract_wrappers/token_registry_wrapper.ts b/packages/contract-wrappers/src/contract_wrappers/token_registry_wrapper.ts
new file mode 100644
index 000000000..5ae488172
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/token_registry_wrapper.ts
@@ -0,0 +1,134 @@
+import { Token } from '@0xproject/types';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as _ from 'lodash';
+
+import { artifacts } from '../artifacts';
+import { TokenMetadata } from '../types';
+import { assert } from '../utils/assert';
+import { constants } from '../utils/constants';
+
+import { ContractWrapper } from './contract_wrapper';
+import { TokenRegistryContract } from './generated/token_registry';
+
+/**
+ * This class includes all the functionality related to interacting with the 0x Token Registry smart contract.
+ */
+export class TokenRegistryWrapper extends ContractWrapper {
+ private _tokenRegistryContractIfExists?: TokenRegistryContract;
+ private _contractAddressIfExists?: string;
+ private static _createTokenFromMetadata(metadata: TokenMetadata): Token | undefined {
+ if (metadata[0] === constants.NULL_ADDRESS) {
+ return undefined;
+ }
+ const token = {
+ address: metadata[0],
+ name: metadata[1],
+ symbol: metadata[2],
+ decimals: metadata[3],
+ };
+ return token;
+ }
+ constructor(web3Wrapper: Web3Wrapper, networkId: number, contractAddressIfExists?: string) {
+ super(web3Wrapper, networkId);
+ this._contractAddressIfExists = contractAddressIfExists;
+ }
+ /**
+ * Retrieves all the tokens currently listed in the Token Registry smart contract
+ * @return An array of objects that conform to the Token interface.
+ */
+ public async getTokensAsync(): Promise<Token[]> {
+ const addresses = await this.getTokenAddressesAsync();
+ const tokenPromises: Array<Promise<Token | undefined>> = _.map(addresses, async (address: string) =>
+ this.getTokenIfExistsAsync(address),
+ );
+ const tokens = await Promise.all(tokenPromises);
+ return tokens as Token[];
+ }
+ /**
+ * Retrieves all the addresses of the tokens currently listed in the Token Registry smart contract
+ * @return An array of token addresses.
+ */
+ public async getTokenAddressesAsync(): Promise<string[]> {
+ const tokenRegistryContract = await this._getTokenRegistryContractAsync();
+ const addresses = await tokenRegistryContract.getTokenAddresses.callAsync();
+ const lowerCaseAddresses = _.map(addresses, address => address.toLowerCase());
+ return lowerCaseAddresses;
+ }
+ /**
+ * Retrieves a token by address currently listed in the Token Registry smart contract
+ * @return An object that conforms to the Token interface or undefined if token not found.
+ */
+ public async getTokenIfExistsAsync(address: string): Promise<Token | undefined> {
+ assert.isETHAddressHex('address', address);
+ const normalizedAddress = address.toLowerCase();
+
+ const tokenRegistryContract = await this._getTokenRegistryContractAsync();
+ const metadata = await tokenRegistryContract.getTokenMetaData.callAsync(normalizedAddress);
+ const token = TokenRegistryWrapper._createTokenFromMetadata(metadata);
+ return token;
+ }
+ public async getTokenAddressBySymbolIfExistsAsync(symbol: string): Promise<string | undefined> {
+ assert.isString('symbol', symbol);
+ const tokenRegistryContract = await this._getTokenRegistryContractAsync();
+ const addressIfExists = await tokenRegistryContract.getTokenAddressBySymbol.callAsync(symbol);
+ if (addressIfExists === constants.NULL_ADDRESS) {
+ return undefined;
+ }
+ return addressIfExists;
+ }
+ public async getTokenAddressByNameIfExistsAsync(name: string): Promise<string | undefined> {
+ assert.isString('name', name);
+ const tokenRegistryContract = await this._getTokenRegistryContractAsync();
+ const addressIfExists = await tokenRegistryContract.getTokenAddressByName.callAsync(name);
+ if (addressIfExists === constants.NULL_ADDRESS) {
+ return undefined;
+ }
+ return addressIfExists;
+ }
+ public async getTokenBySymbolIfExistsAsync(symbol: string): Promise<Token | undefined> {
+ assert.isString('symbol', symbol);
+ const tokenRegistryContract = await this._getTokenRegistryContractAsync();
+ const metadata = await tokenRegistryContract.getTokenBySymbol.callAsync(symbol);
+ const token = TokenRegistryWrapper._createTokenFromMetadata(metadata);
+ return token;
+ }
+ public async getTokenByNameIfExistsAsync(name: string): Promise<Token | undefined> {
+ assert.isString('name', name);
+ const tokenRegistryContract = await this._getTokenRegistryContractAsync();
+ const metadata = await tokenRegistryContract.getTokenByName.callAsync(name);
+ const token = TokenRegistryWrapper._createTokenFromMetadata(metadata);
+ return token;
+ }
+ /**
+ * Retrieves the Ethereum address of the TokenRegistry contract deployed on the network
+ * that the user-passed web3 provider is connected to.
+ * @returns The Ethereum address of the TokenRegistry contract being used.
+ */
+ public getContractAddress(): string {
+ const contractAddress = this._getContractAddress(
+ artifacts.TokenRegistry,
+ this._contractAddressIfExists,
+ );
+ return contractAddress;
+ }
+ private _invalidateContractInstance(): void {
+ delete this._tokenRegistryContractIfExists;
+ }
+ private async _getTokenRegistryContractAsync(): Promise<TokenRegistryContract> {
+ if (!_.isUndefined(this._tokenRegistryContractIfExists)) {
+ return this._tokenRegistryContractIfExists;
+ }
+ const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
+ artifacts.TokenRegistry,
+ this._contractAddressIfExists,
+ );
+ const contractInstance = new TokenRegistryContract(
+ abi,
+ address,
+ this._web3Wrapper.getProvider(),
+ this._web3Wrapper.getContractDefaults(),
+ );
+ this._tokenRegistryContractIfExists = contractInstance;
+ return this._tokenRegistryContractIfExists;
+ }
+}
diff --git a/packages/contract-wrappers/src/contract_wrappers/token_transfer_proxy_wrapper.ts b/packages/contract-wrappers/src/contract_wrappers/token_transfer_proxy_wrapper.ts
new file mode 100644
index 000000000..ebd40e4d2
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/token_transfer_proxy_wrapper.ts
@@ -0,0 +1,75 @@
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as _ from 'lodash';
+
+import { artifacts } from '../artifacts';
+import { assert } from '../utils/assert';
+
+import { ContractWrapper } from './contract_wrapper';
+import { TokenTransferProxyContract } from './generated/token_transfer_proxy';
+
+/**
+ * This class includes the functionality related to interacting with the TokenTransferProxy contract.
+ */
+export class TokenTransferProxyWrapper extends ContractWrapper {
+ private _tokenTransferProxyContractIfExists?: TokenTransferProxyContract;
+ private _contractAddressIfExists?: string;
+ constructor(web3Wrapper: Web3Wrapper, networkId: number, contractAddressIfExists?: string) {
+ super(web3Wrapper, networkId);
+ this._contractAddressIfExists = contractAddressIfExists;
+ }
+ /**
+ * Check if the Exchange contract address is authorized by the TokenTransferProxy contract.
+ * @param exchangeContractAddress The hex encoded address of the Exchange contract to call.
+ * @return Whether the exchangeContractAddress is authorized.
+ */
+ public async isAuthorizedAsync(exchangeContractAddress: string): Promise<boolean> {
+ assert.isETHAddressHex('exchangeContractAddress', exchangeContractAddress);
+ const normalizedExchangeContractAddress = exchangeContractAddress.toLowerCase();
+ const tokenTransferProxyContractInstance = await this._getTokenTransferProxyContractAsync();
+ const isAuthorized = await tokenTransferProxyContractInstance.authorized.callAsync(
+ normalizedExchangeContractAddress,
+ );
+ return isAuthorized;
+ }
+ /**
+ * Get the list of all Exchange contract addresses authorized by the TokenTransferProxy contract.
+ * @return The list of authorized addresses.
+ */
+ public async getAuthorizedAddressesAsync(): Promise<string[]> {
+ const tokenTransferProxyContractInstance = await this._getTokenTransferProxyContractAsync();
+ const authorizedAddresses = await tokenTransferProxyContractInstance.getAuthorizedAddresses.callAsync();
+ return authorizedAddresses;
+ }
+ /**
+ * Retrieves the Ethereum address of the TokenTransferProxy contract deployed on the network
+ * that the user-passed web3 provider is connected to.
+ * @returns The Ethereum address of the TokenTransferProxy contract being used.
+ */
+ public getContractAddress(): string {
+ const contractAddress = this._getContractAddress(
+ artifacts.TokenTransferProxy,
+ this._contractAddressIfExists,
+ );
+ return contractAddress;
+ }
+ private _invalidateContractInstance(): void {
+ delete this._tokenTransferProxyContractIfExists;
+ }
+ private async _getTokenTransferProxyContractAsync(): Promise<TokenTransferProxyContract> {
+ if (!_.isUndefined(this._tokenTransferProxyContractIfExists)) {
+ return this._tokenTransferProxyContractIfExists;
+ }
+ const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
+ artifacts.TokenTransferProxy,
+ this._contractAddressIfExists,
+ );
+ const contractInstance = new TokenTransferProxyContract(
+ abi,
+ address,
+ this._web3Wrapper.getProvider(),
+ this._web3Wrapper.getContractDefaults(),
+ );
+ this._tokenTransferProxyContractIfExists = contractInstance;
+ return this._tokenTransferProxyContractIfExists;
+ }
+}
diff --git a/packages/contract-wrappers/src/contract_wrappers/token_wrapper.ts b/packages/contract-wrappers/src/contract_wrappers/token_wrapper.ts
new file mode 100644
index 000000000..844318c79
--- /dev/null
+++ b/packages/contract-wrappers/src/contract_wrappers/token_wrapper.ts
@@ -0,0 +1,441 @@
+import { schemas } from '@0xproject/json-schemas';
+import { LogWithDecodedArgs } from '@0xproject/types';
+import { AbiDecoder, BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as _ from 'lodash';
+
+import { artifacts } from '../artifacts';
+import {
+ BlockRange,
+ ContractWrappersError,
+ EventCallback,
+ IndexedFilterValues,
+ MethodOpts,
+ TransactionOpts,
+} from '../types';
+import { assert } from '../utils/assert';
+import { constants } from '../utils/constants';
+
+import { ContractWrapper } from './contract_wrapper';
+import { TokenContract, TokenContractEventArgs, TokenEvents } from './generated/token';
+import { TokenTransferProxyWrapper } from './token_transfer_proxy_wrapper';
+
+/**
+ * This class includes all the functionality related to interacting with ERC20 token contracts.
+ * All ERC20 method calls are supported, along with some convenience methods for getting/setting allowances
+ * to the 0x Proxy smart contract.
+ */
+export class TokenWrapper extends ContractWrapper {
+ public UNLIMITED_ALLOWANCE_IN_BASE_UNITS = constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS;
+ private _tokenContractsByAddress: { [address: string]: TokenContract };
+ private _tokenTransferProxyWrapper: TokenTransferProxyWrapper;
+ constructor(web3Wrapper: Web3Wrapper, networkId: number, tokenTransferProxyWrapper: TokenTransferProxyWrapper) {
+ super(web3Wrapper, networkId);
+ this._tokenContractsByAddress = {};
+ this._tokenTransferProxyWrapper = tokenTransferProxyWrapper;
+ }
+ /**
+ * Retrieves an owner's ERC20 token balance.
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param ownerAddress The hex encoded user Ethereum address whose balance you would like to check.
+ * @param methodOpts Optional arguments this method accepts.
+ * @return The owner's ERC20 token balance in base units.
+ */
+ public async getBalanceAsync(
+ tokenAddress: string,
+ ownerAddress: string,
+ methodOpts?: MethodOpts,
+ ): Promise<BigNumber> {
+ assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedOwnerAddress = ownerAddress.toLowerCase();
+
+ const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+ const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
+ const txData = {};
+ let balance = await tokenContract.balanceOf.callAsync(normalizedOwnerAddress, txData, defaultBlock);
+ // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
+ balance = new BigNumber(balance);
+ return balance;
+ }
+ /**
+ * Sets the spender's allowance to a specified number of baseUnits on behalf of the owner address.
+ * Equivalent to the ERC20 spec method `approve`.
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param ownerAddress The hex encoded user Ethereum address who would like to set an allowance
+ * for spenderAddress.
+ * @param spenderAddress The hex encoded user Ethereum address who will be able to spend the set allowance.
+ * @param amountInBaseUnits The allowance amount you would like to set.
+ * @param txOpts Transaction parameters.
+ * @return Transaction hash.
+ */
+ public async setAllowanceAsync(
+ tokenAddress: string,
+ ownerAddress: string,
+ spenderAddress: string,
+ amountInBaseUnits: BigNumber,
+ txOpts: TransactionOpts = {},
+ ): Promise<string> {
+ assert.isETHAddressHex('spenderAddress', spenderAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ await assert.isSenderAddressAsync('ownerAddress', ownerAddress, this._web3Wrapper);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedSpenderAddress = spenderAddress.toLowerCase();
+ const normalizedOwnerAddress = ownerAddress.toLowerCase();
+ assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
+
+ const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+ const txHash = await tokenContract.approve.sendTransactionAsync(normalizedSpenderAddress, amountInBaseUnits, {
+ from: normalizedOwnerAddress,
+ gas: txOpts.gasLimit,
+ gasPrice: txOpts.gasPrice,
+ });
+ return txHash;
+ }
+ /**
+ * Sets the spender's allowance to an unlimited number of baseUnits on behalf of the owner address.
+ * Equivalent to the ERC20 spec method `approve`.
+ * Setting an unlimited allowance will lower the gas cost for filling orders involving tokens that forego updating
+ * allowances set to the max amount (e.g ZRX, WETH)
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param ownerAddress The hex encoded user Ethereum address who would like to set an allowance
+ * for spenderAddress.
+ * @param spenderAddress The hex encoded user Ethereum address who will be able to spend the set allowance.
+ * @param txOpts Transaction parameters.
+ * @return Transaction hash.
+ */
+ public async setUnlimitedAllowanceAsync(
+ tokenAddress: string,
+ ownerAddress: string,
+ spenderAddress: string,
+ txOpts: TransactionOpts = {},
+ ): Promise<string> {
+ assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ assert.isETHAddressHex('spenderAddress', spenderAddress);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedOwnerAddress = ownerAddress.toLowerCase();
+ const normalizedSpenderAddress = spenderAddress.toLowerCase();
+ const txHash = await this.setAllowanceAsync(
+ normalizedTokenAddress,
+ normalizedOwnerAddress,
+ normalizedSpenderAddress,
+ this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
+ txOpts,
+ );
+ return txHash;
+ }
+ /**
+ * Retrieves the owners allowance in baseUnits set to the spender's address.
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param ownerAddress The hex encoded user Ethereum address whose allowance to spenderAddress
+ * you would like to retrieve.
+ * @param spenderAddress The hex encoded user Ethereum address who can spend the allowance you are fetching.
+ * @param methodOpts Optional arguments this method accepts.
+ */
+ public async getAllowanceAsync(
+ tokenAddress: string,
+ ownerAddress: string,
+ spenderAddress: string,
+ methodOpts?: MethodOpts,
+ ): Promise<BigNumber> {
+ assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ assert.isETHAddressHex('spenderAddress', spenderAddress);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedOwnerAddress = ownerAddress.toLowerCase();
+ const normalizedSpenderAddress = spenderAddress.toLowerCase();
+
+ const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+ const defaultBlock = _.isUndefined(methodOpts) ? undefined : methodOpts.defaultBlock;
+ const txData = {};
+ let allowanceInBaseUnits = await tokenContract.allowance.callAsync(
+ normalizedOwnerAddress,
+ normalizedSpenderAddress,
+ txData,
+ defaultBlock,
+ );
+ // Wrap BigNumbers returned from web3 with our own (later) version of BigNumber
+ allowanceInBaseUnits = new BigNumber(allowanceInBaseUnits);
+ return allowanceInBaseUnits;
+ }
+ /**
+ * Retrieves the owner's allowance in baseUnits set to the 0x proxy contract.
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param ownerAddress The hex encoded user Ethereum address whose proxy contract allowance we are retrieving.
+ * @param methodOpts Optional arguments this method accepts.
+ */
+ public async getProxyAllowanceAsync(
+ tokenAddress: string,
+ ownerAddress: string,
+ methodOpts?: MethodOpts,
+ ): Promise<BigNumber> {
+ assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedOwnerAddress = ownerAddress.toLowerCase();
+
+ const proxyAddress = this._tokenTransferProxyWrapper.getContractAddress();
+ const allowanceInBaseUnits = await this.getAllowanceAsync(
+ normalizedTokenAddress,
+ normalizedOwnerAddress,
+ proxyAddress,
+ methodOpts,
+ );
+ return allowanceInBaseUnits;
+ }
+ /**
+ * Sets the 0x proxy contract's allowance to a specified number of a tokens' baseUnits on behalf
+ * of an owner address.
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param ownerAddress The hex encoded user Ethereum address who is setting an allowance
+ * for the Proxy contract.
+ * @param amountInBaseUnits The allowance amount specified in baseUnits.
+ * @param txOpts Transaction parameters.
+ * @return Transaction hash.
+ */
+ public async setProxyAllowanceAsync(
+ tokenAddress: string,
+ ownerAddress: string,
+ amountInBaseUnits: BigNumber,
+ txOpts: TransactionOpts = {},
+ ): Promise<string> {
+ assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedOwnerAddress = ownerAddress.toLowerCase();
+ assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
+
+ const proxyAddress = this._tokenTransferProxyWrapper.getContractAddress();
+ const txHash = await this.setAllowanceAsync(
+ normalizedTokenAddress,
+ normalizedOwnerAddress,
+ proxyAddress,
+ amountInBaseUnits,
+ txOpts,
+ );
+ return txHash;
+ }
+ /**
+ * Sets the 0x proxy contract's allowance to a unlimited number of a tokens' baseUnits on behalf
+ * of an owner address.
+ * Setting an unlimited allowance will lower the gas cost for filling orders involving tokens that forego updating
+ * allowances set to the max amount (e.g ZRX, WETH)
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param ownerAddress The hex encoded user Ethereum address who is setting an allowance
+ * for the Proxy contract.
+ * @param txOpts Transaction parameters.
+ * @return Transaction hash.
+ */
+ public async setUnlimitedProxyAllowanceAsync(
+ tokenAddress: string,
+ ownerAddress: string,
+ txOpts: TransactionOpts = {},
+ ): Promise<string> {
+ assert.isETHAddressHex('ownerAddress', ownerAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedOwnerAddress = ownerAddress.toLowerCase();
+ const txHash = await this.setProxyAllowanceAsync(
+ normalizedTokenAddress,
+ normalizedOwnerAddress,
+ this.UNLIMITED_ALLOWANCE_IN_BASE_UNITS,
+ txOpts,
+ );
+ return txHash;
+ }
+ /**
+ * Transfers `amountInBaseUnits` ERC20 tokens from `fromAddress` to `toAddress`.
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param fromAddress The hex encoded user Ethereum address that will send the funds.
+ * @param toAddress The hex encoded user Ethereum address that will receive the funds.
+ * @param amountInBaseUnits The amount (specified in baseUnits) of the token to transfer.
+ * @param txOpts Transaction parameters.
+ * @return Transaction hash.
+ */
+ public async transferAsync(
+ tokenAddress: string,
+ fromAddress: string,
+ toAddress: string,
+ amountInBaseUnits: BigNumber,
+ txOpts: TransactionOpts = {},
+ ): Promise<string> {
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ assert.isETHAddressHex('toAddress', toAddress);
+ await assert.isSenderAddressAsync('fromAddress', fromAddress, this._web3Wrapper);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedFromAddress = fromAddress.toLowerCase();
+ const normalizedToAddress = toAddress.toLowerCase();
+ assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
+
+ const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+
+ const fromAddressBalance = await this.getBalanceAsync(normalizedTokenAddress, normalizedFromAddress);
+ if (fromAddressBalance.lessThan(amountInBaseUnits)) {
+ throw new Error(ContractWrappersError.InsufficientBalanceForTransfer);
+ }
+
+ const txHash = await tokenContract.transfer.sendTransactionAsync(normalizedToAddress, amountInBaseUnits, {
+ from: normalizedFromAddress,
+ gas: txOpts.gasLimit,
+ gasPrice: txOpts.gasPrice,
+ });
+ return txHash;
+ }
+ /**
+ * Transfers `amountInBaseUnits` ERC20 tokens from `fromAddress` to `toAddress`.
+ * Requires the fromAddress to have sufficient funds and to have approved an allowance of
+ * `amountInBaseUnits` to `senderAddress`.
+ * @param tokenAddress The hex encoded contract Ethereum address where the ERC20 token is deployed.
+ * @param fromAddress The hex encoded user Ethereum address whose funds are being sent.
+ * @param toAddress The hex encoded user Ethereum address that will receive the funds.
+ * @param senderAddress The hex encoded user Ethereum address whose initiates the fund transfer. The
+ * `fromAddress` must have set an allowance to the `senderAddress`
+ * before this call.
+ * @param amountInBaseUnits The amount (specified in baseUnits) of the token to transfer.
+ * @param txOpts Transaction parameters.
+ * @return Transaction hash.
+ */
+ public async transferFromAsync(
+ tokenAddress: string,
+ fromAddress: string,
+ toAddress: string,
+ senderAddress: string,
+ amountInBaseUnits: BigNumber,
+ txOpts: TransactionOpts = {},
+ ): Promise<string> {
+ assert.isETHAddressHex('toAddress', toAddress);
+ assert.isETHAddressHex('fromAddress', fromAddress);
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ await assert.isSenderAddressAsync('senderAddress', senderAddress, this._web3Wrapper);
+ const normalizedToAddress = toAddress.toLowerCase();
+ const normalizedFromAddress = fromAddress.toLowerCase();
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ const normalizedSenderAddress = senderAddress.toLowerCase();
+ assert.isValidBaseUnitAmount('amountInBaseUnits', amountInBaseUnits);
+
+ const tokenContract = await this._getTokenContractAsync(normalizedTokenAddress);
+
+ const fromAddressAllowance = await this.getAllowanceAsync(
+ normalizedTokenAddress,
+ normalizedFromAddress,
+ normalizedSenderAddress,
+ );
+ if (fromAddressAllowance.lessThan(amountInBaseUnits)) {
+ throw new Error(ContractWrappersError.InsufficientAllowanceForTransfer);
+ }
+
+ const fromAddressBalance = await this.getBalanceAsync(normalizedTokenAddress, normalizedFromAddress);
+ if (fromAddressBalance.lessThan(amountInBaseUnits)) {
+ throw new Error(ContractWrappersError.InsufficientBalanceForTransfer);
+ }
+
+ const txHash = await tokenContract.transferFrom.sendTransactionAsync(
+ normalizedFromAddress,
+ normalizedToAddress,
+ amountInBaseUnits,
+ {
+ from: normalizedSenderAddress,
+ gas: txOpts.gasLimit,
+ gasPrice: txOpts.gasPrice,
+ },
+ );
+ return txHash;
+ }
+ /**
+ * Subscribe to an event type emitted by the Token contract.
+ * @param tokenAddress The hex encoded address where the ERC20 token is deployed.
+ * @param eventName The token contract event you would like to subscribe to.
+ * @param indexFilterValues An object where the keys are indexed args returned by the event and
+ * the value is the value you are interested in. E.g `{maker: aUserAddressHex}`
+ * @param callback Callback that gets called when a log is added/removed
+ * @return Subscription token used later to unsubscribe
+ */
+ public subscribe<ArgsType extends TokenContractEventArgs>(
+ tokenAddress: string,
+ eventName: TokenEvents,
+ indexFilterValues: IndexedFilterValues,
+ callback: EventCallback<ArgsType>,
+ ): string {
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ assert.doesBelongToStringEnum('eventName', eventName, TokenEvents);
+ assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
+ assert.isFunction('callback', callback);
+ const subscriptionToken = this._subscribe<ArgsType>(
+ normalizedTokenAddress,
+ eventName,
+ indexFilterValues,
+ artifacts.Token.abi,
+ callback,
+ );
+ return subscriptionToken;
+ }
+ /**
+ * Cancel a subscription
+ * @param subscriptionToken Subscription token returned by `subscribe()`
+ */
+ public unsubscribe(subscriptionToken: string): void {
+ this._unsubscribe(subscriptionToken);
+ }
+ /**
+ * Cancels all existing subscriptions
+ */
+ public unsubscribeAll(): void {
+ super._unsubscribeAll();
+ }
+ /**
+ * Gets historical logs without creating a subscription
+ * @param tokenAddress An address of the token that emitted the logs.
+ * @param eventName The token contract event you would like to subscribe to.
+ * @param blockRange Block range to get logs from.
+ * @param indexFilterValues An object where the keys are indexed args returned by the event and
+ * the value is the value you are interested in. E.g `{_from: aUserAddressHex}`
+ * @return Array of logs that match the parameters
+ */
+ public async getLogsAsync<ArgsType extends TokenContractEventArgs>(
+ tokenAddress: string,
+ eventName: TokenEvents,
+ blockRange: BlockRange,
+ indexFilterValues: IndexedFilterValues,
+ ): Promise<Array<LogWithDecodedArgs<ArgsType>>> {
+ assert.isETHAddressHex('tokenAddress', tokenAddress);
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ assert.doesBelongToStringEnum('eventName', eventName, TokenEvents);
+ assert.doesConformToSchema('blockRange', blockRange, schemas.blockRangeSchema);
+ assert.doesConformToSchema('indexFilterValues', indexFilterValues, schemas.indexFilterValuesSchema);
+ const logs = await this._getLogsAsync<ArgsType>(
+ normalizedTokenAddress,
+ eventName,
+ blockRange,
+ indexFilterValues,
+ artifacts.Token.abi,
+ );
+ return logs;
+ }
+ private _invalidateContractInstances(): void {
+ this.unsubscribeAll();
+ this._tokenContractsByAddress = {};
+ }
+ private async _getTokenContractAsync(tokenAddress: string): Promise<TokenContract> {
+ const normalizedTokenAddress = tokenAddress.toLowerCase();
+ let tokenContract = this._tokenContractsByAddress[normalizedTokenAddress];
+ if (!_.isUndefined(tokenContract)) {
+ return tokenContract;
+ }
+ const [abi, address] = await this._getContractAbiAndAddressFromArtifactsAsync(
+ artifacts.Token,
+ normalizedTokenAddress,
+ );
+ const contractInstance = new TokenContract(
+ abi,
+ address,
+ this._web3Wrapper.getProvider(),
+ this._web3Wrapper.getContractDefaults(),
+ );
+ tokenContract = contractInstance;
+ this._tokenContractsByAddress[normalizedTokenAddress] = tokenContract;
+ return tokenContract;
+ }
+}