From 0fc356740aa59cdef0ec193a83468ef0f261ca6b Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 22:43:45 -0600 Subject: Add generated contract wrappers --- .../contract_wrappers/generated/base_contract.ts | 36 + .../src/contract_wrappers/generated/ether_token.ts | 359 ++++++++++ .../src/contract_wrappers/generated/exchange.ts | 726 +++++++++++++++++++++ .../0x.js/src/contract_wrappers/generated/token.ts | 228 +++++++ .../contract_wrappers/generated/token_registry.ts | 546 ++++++++++++++++ .../generated/token_transfer_proxy.ts | 281 ++++++++ 6 files changed, 2176 insertions(+) create mode 100644 packages/0x.js/src/contract_wrappers/generated/base_contract.ts create mode 100644 packages/0x.js/src/contract_wrappers/generated/ether_token.ts create mode 100644 packages/0x.js/src/contract_wrappers/generated/exchange.ts create mode 100644 packages/0x.js/src/contract_wrappers/generated/token.ts create mode 100644 packages/0x.js/src/contract_wrappers/generated/token_registry.ts create mode 100644 packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/contract_wrappers/generated/base_contract.ts b/packages/0x.js/src/contract_wrappers/generated/base_contract.ts new file mode 100644 index 000000000..e5f536448 --- /dev/null +++ b/packages/0x.js/src/contract_wrappers/generated/base_contract.ts @@ -0,0 +1,36 @@ +import * as _ from 'lodash'; +import * as Web3 from 'web3'; + +import {TxData, TxDataPayable} from '../../types'; + +// TODO: Gas Margin +// TODO: Abi check +export class BaseContract { + protected web3ContractInstance: Web3.ContractInstance; + protected defaults: Partial; + protected async applyDefaultsToTxDataAsync( + txData: T, + estimateGasAsync?: (txData: T) => Promise, + ): Promise { + // Gas amount sourced with the following priorities: + // 1. Optional param passed in to public method call + // 2. Global config passed in at library instantiation + // 3. Gas estimate calculation + safety margin + const removeUndefinedProperties = _.pickBy; + const txDataWithDefaults = { + ...removeUndefinedProperties(this.defaults), + ...removeUndefinedProperties(txData as any), + // HACK: TS can't prove that T is speadable. + // Awaiting https://github.com/Microsoft/TypeScript/pull/13288 to be merged + }; + if (_.isUndefined(txDataWithDefaults.gas) && !_.isUndefined(estimateGasAsync)) { + const estimatedGas = await estimateGasAsync(txData); + txDataWithDefaults.gas = estimatedGas; + } + return txDataWithDefaults; + } + constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { + this.web3ContractInstance = web3ContractInstance; + this.defaults = defaults; + } +} diff --git a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts new file mode 100644 index 000000000..e613f453f --- /dev/null +++ b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts @@ -0,0 +1,359 @@ +import {BigNumber} from 'bignumber.js'; +import * as Web3 from 'web3'; + +import {TxData, TxDataPayable} from '../../types'; +import {classUtils} from '../../utils/class_utils'; +import {promisify} from '../../utils/promisify'; + +import {BaseContract} from './base_contract'; + +export class EtherTokenContract extends BaseContract { + public name = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as EtherTokenContract; + const result = await promisify( + self.web3ContractInstance.name.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public approve = { + async sendTransactionAsync( + _spender: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.approve.estimateGasAsync.bind( + self, + _spender, + _value, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.approve, self.web3ContractInstance, + )( + _spender, + _value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _spender: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.approve.estimateGas, self.web3ContractInstance, + )( + _spender, + _value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _spender: string, + _value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as EtherTokenContract; + const abiEncodedTransactionData = self.web3ContractInstance.approve.getData(); + return abiEncodedTransactionData; + }, + }; + public totalSupply = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as EtherTokenContract; + const result = await promisify( + self.web3ContractInstance.totalSupply.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public transferFrom = { + async sendTransactionAsync( + _from: string, + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.transferFrom.estimateGasAsync.bind( + self, + _from, + _to, + _value, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.transferFrom, self.web3ContractInstance, + )( + _from, + _to, + _value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _from: string, + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.transferFrom.estimateGas, self.web3ContractInstance, + )( + _from, + _to, + _value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _from: string, + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as EtherTokenContract; + const abiEncodedTransactionData = self.web3ContractInstance.transferFrom.getData(); + return abiEncodedTransactionData; + }, + }; + public withdraw = { + async sendTransactionAsync( + amount: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.withdraw.estimateGasAsync.bind( + self, + amount, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.withdraw, self.web3ContractInstance, + )( + amount, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + amount: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.withdraw.estimateGas, self.web3ContractInstance, + )( + amount, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + amount: BigNumber, + txData: TxData = {}, + ): string { + const self = this as EtherTokenContract; + const abiEncodedTransactionData = self.web3ContractInstance.withdraw.getData(); + return abiEncodedTransactionData; + }, + }; + public decimals = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as EtherTokenContract; + const result = await promisify( + self.web3ContractInstance.decimals.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public balanceOf = { + async callAsync( + _owner: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as EtherTokenContract; + const result = await promisify( + self.web3ContractInstance.balanceOf.call, + self.web3ContractInstance, + )( + _owner, + ); + return result; + }, + }; + public symbol = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as EtherTokenContract; + const result = await promisify( + self.web3ContractInstance.symbol.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public transfer = { + async sendTransactionAsync( + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.transfer.estimateGasAsync.bind( + self, + _to, + _value, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.transfer, self.web3ContractInstance, + )( + _to, + _value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.transfer.estimateGas, self.web3ContractInstance, + )( + _to, + _value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as EtherTokenContract; + const abiEncodedTransactionData = self.web3ContractInstance.transfer.getData(); + return abiEncodedTransactionData; + }, + }; + public deposit = { + async sendTransactionAsync( + txData: TxDataPayable = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.deposit.estimateGasAsync.bind( + self, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.deposit, self.web3ContractInstance, + )( + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + txData: TxData = {}, + ): Promise { + const self = this as EtherTokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.deposit.estimateGas, self.web3ContractInstance, + )( + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + txData: TxData = {}, + ): string { + const self = this as EtherTokenContract; + const abiEncodedTransactionData = self.web3ContractInstance.deposit.getData(); + return abiEncodedTransactionData; + }, + }; + public allowance = { + async callAsync( + _owner: string, + _spender: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as EtherTokenContract; + const result = await promisify( + self.web3ContractInstance.allowance.call, + self.web3ContractInstance, + )( + _owner, + _spender, + ); + return result; + }, + }; + constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { + super(web3ContractInstance, defaults); + classUtils.bindAll(this, ['web3ContractInstance', 'defaults']); + } +} // tslint:disable:max-file-line-count diff --git a/packages/0x.js/src/contract_wrappers/generated/exchange.ts b/packages/0x.js/src/contract_wrappers/generated/exchange.ts new file mode 100644 index 000000000..8bb2a24a3 --- /dev/null +++ b/packages/0x.js/src/contract_wrappers/generated/exchange.ts @@ -0,0 +1,726 @@ +import {BigNumber} from 'bignumber.js'; +import * as Web3 from 'web3'; + +import {TxData, TxDataPayable} from '../../types'; +import {classUtils} from '../../utils/class_utils'; +import {promisify} from '../../utils/promisify'; + +import {BaseContract} from './base_contract'; + +export class ExchangeContract extends BaseContract { + public isRoundingError = { + async callAsync( + numerator: BigNumber, + denominator: BigNumber, + target: BigNumber, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.isRoundingError.call, + self.web3ContractInstance, + )( + numerator, + denominator, + target, + ); + return result; + }, + }; + public filled = { + async callAsync( + index: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.filled.call, + self.web3ContractInstance, + )( + index, + ); + return result; + }, + }; + public cancelled = { + async callAsync( + index: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.cancelled.call, + self.web3ContractInstance, + )( + index, + ); + return result; + }, + }; + public fillOrdersUpTo = { + async sendTransactionAsync( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmount: BigNumber, + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.fillOrdersUpTo.estimateGasAsync.bind( + self, + orderAddresses, + orderValues, + fillTakerTokenAmount, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.fillOrdersUpTo, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmount, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmount: BigNumber, + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.fillOrdersUpTo.estimateGas, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmount, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmount: BigNumber, + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): string { + const self = this as ExchangeContract; + const abiEncodedTransactionData = self.web3ContractInstance.fillOrdersUpTo.getData(); + return abiEncodedTransactionData; + }, + }; + public cancelOrder = { + async sendTransactionAsync( + orderAddresses: string[], + orderValues: BigNumber[], + cancelTakerTokenAmount: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.cancelOrder.estimateGasAsync.bind( + self, + orderAddresses, + orderValues, + cancelTakerTokenAmount, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.cancelOrder, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + cancelTakerTokenAmount, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + orderAddresses: string[], + orderValues: BigNumber[], + cancelTakerTokenAmount: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.cancelOrder.estimateGas, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + cancelTakerTokenAmount, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + orderAddresses: string[], + orderValues: BigNumber[], + cancelTakerTokenAmount: BigNumber, + txData: TxData = {}, + ): string { + const self = this as ExchangeContract; + const abiEncodedTransactionData = self.web3ContractInstance.cancelOrder.getData(); + return abiEncodedTransactionData; + }, + }; + public ZRX_TOKEN_CONTRACT = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.ZRX_TOKEN_CONTRACT.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public batchFillOrKillOrders = { + async sendTransactionAsync( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmounts: BigNumber[], + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.batchFillOrKillOrders.estimateGasAsync.bind( + self, + orderAddresses, + orderValues, + fillTakerTokenAmounts, + v, + r, + s, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.batchFillOrKillOrders, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmounts, + v, + r, + s, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmounts: BigNumber[], + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.batchFillOrKillOrders.estimateGas, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmounts, + v, + r, + s, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmounts: BigNumber[], + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): string { + const self = this as ExchangeContract; + const abiEncodedTransactionData = self.web3ContractInstance.batchFillOrKillOrders.getData(); + return abiEncodedTransactionData; + }, + }; + public fillOrKillOrder = { + async sendTransactionAsync( + orderAddresses: string[], + orderValues: BigNumber[], + fillTakerTokenAmount: BigNumber, + v: number|BigNumber, + r: string, + s: string, + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.fillOrKillOrder.estimateGasAsync.bind( + self, + orderAddresses, + orderValues, + fillTakerTokenAmount, + v, + r, + s, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.fillOrKillOrder, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmount, + v, + r, + s, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + orderAddresses: string[], + orderValues: BigNumber[], + fillTakerTokenAmount: BigNumber, + v: number|BigNumber, + r: string, + s: string, + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.fillOrKillOrder.estimateGas, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmount, + v, + r, + s, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + orderAddresses: string[], + orderValues: BigNumber[], + fillTakerTokenAmount: BigNumber, + v: number|BigNumber, + r: string, + s: string, + txData: TxData = {}, + ): string { + const self = this as ExchangeContract; + const abiEncodedTransactionData = self.web3ContractInstance.fillOrKillOrder.getData(); + return abiEncodedTransactionData; + }, + }; + public getUnavailableTakerTokenAmount = { + async callAsync( + orderHash: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.getUnavailableTakerTokenAmount.call, + self.web3ContractInstance, + )( + orderHash, + ); + return result; + }, + }; + public isValidSignature = { + async callAsync( + signer: string, + hash: string, + v: number|BigNumber, + r: string, + s: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.isValidSignature.call, + self.web3ContractInstance, + )( + signer, + hash, + v, + r, + s, + ); + return result; + }, + }; + public getPartialAmount = { + async callAsync( + numerator: BigNumber, + denominator: BigNumber, + target: BigNumber, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.getPartialAmount.call, + self.web3ContractInstance, + )( + numerator, + denominator, + target, + ); + return result; + }, + }; + public TOKEN_TRANSFER_PROXY_CONTRACT = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.TOKEN_TRANSFER_PROXY_CONTRACT.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public batchFillOrders = { + async sendTransactionAsync( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmounts: BigNumber[], + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.batchFillOrders.estimateGasAsync.bind( + self, + orderAddresses, + orderValues, + fillTakerTokenAmounts, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.batchFillOrders, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmounts, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmounts: BigNumber[], + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.batchFillOrders.estimateGas, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmounts, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + orderAddresses: string[][], + orderValues: BigNumber[][], + fillTakerTokenAmounts: BigNumber[], + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber[], + r: string[], + s: string[], + txData: TxData = {}, + ): string { + const self = this as ExchangeContract; + const abiEncodedTransactionData = self.web3ContractInstance.batchFillOrders.getData(); + return abiEncodedTransactionData; + }, + }; + public batchCancelOrders = { + async sendTransactionAsync( + orderAddresses: string[][], + orderValues: BigNumber[][], + cancelTakerTokenAmounts: BigNumber[], + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.batchCancelOrders.estimateGasAsync.bind( + self, + orderAddresses, + orderValues, + cancelTakerTokenAmounts, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.batchCancelOrders, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + cancelTakerTokenAmounts, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + orderAddresses: string[][], + orderValues: BigNumber[][], + cancelTakerTokenAmounts: BigNumber[], + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.batchCancelOrders.estimateGas, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + cancelTakerTokenAmounts, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + orderAddresses: string[][], + orderValues: BigNumber[][], + cancelTakerTokenAmounts: BigNumber[], + txData: TxData = {}, + ): string { + const self = this as ExchangeContract; + const abiEncodedTransactionData = self.web3ContractInstance.batchCancelOrders.getData(); + return abiEncodedTransactionData; + }, + }; + public fillOrder = { + async sendTransactionAsync( + orderAddresses: string[], + orderValues: BigNumber[], + fillTakerTokenAmount: BigNumber, + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber, + r: string, + s: string, + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.fillOrder.estimateGasAsync.bind( + self, + orderAddresses, + orderValues, + fillTakerTokenAmount, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.fillOrder, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmount, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + orderAddresses: string[], + orderValues: BigNumber[], + fillTakerTokenAmount: BigNumber, + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber, + r: string, + s: string, + txData: TxData = {}, + ): Promise { + const self = this as ExchangeContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.fillOrder.estimateGas, self.web3ContractInstance, + )( + orderAddresses, + orderValues, + fillTakerTokenAmount, + shouldThrowOnInsufficientBalanceOrAllowance, + v, + r, + s, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + orderAddresses: string[], + orderValues: BigNumber[], + fillTakerTokenAmount: BigNumber, + shouldThrowOnInsufficientBalanceOrAllowance: boolean, + v: number|BigNumber, + r: string, + s: string, + txData: TxData = {}, + ): string { + const self = this as ExchangeContract; + const abiEncodedTransactionData = self.web3ContractInstance.fillOrder.getData(); + return abiEncodedTransactionData; + }, + }; + public getOrderHash = { + async callAsync( + orderAddresses: string[], + orderValues: BigNumber[], + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.getOrderHash.call, + self.web3ContractInstance, + )( + orderAddresses, + orderValues, + ); + return result; + }, + }; + public EXTERNAL_QUERY_GAS_LIMIT = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.EXTERNAL_QUERY_GAS_LIMIT.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public VERSION = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as ExchangeContract; + const result = await promisify( + self.web3ContractInstance.VERSION.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { + super(web3ContractInstance, defaults); + classUtils.bindAll(this, ['web3ContractInstance', 'defaults']); + } +} // tslint:disable:max-file-line-count diff --git a/packages/0x.js/src/contract_wrappers/generated/token.ts b/packages/0x.js/src/contract_wrappers/generated/token.ts new file mode 100644 index 000000000..1248f53a3 --- /dev/null +++ b/packages/0x.js/src/contract_wrappers/generated/token.ts @@ -0,0 +1,228 @@ +import {BigNumber} from 'bignumber.js'; +import * as Web3 from 'web3'; + +import {TxData, TxDataPayable} from '../../types'; +import {classUtils} from '../../utils/class_utils'; +import {promisify} from '../../utils/promisify'; + +import {BaseContract} from './base_contract'; + +export class TokenContract extends BaseContract { + public approve = { + async sendTransactionAsync( + _spender: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.approve.estimateGasAsync.bind( + self, + _spender, + _value, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.approve, self.web3ContractInstance, + )( + _spender, + _value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _spender: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.approve.estimateGas, self.web3ContractInstance, + )( + _spender, + _value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _spender: string, + _value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as TokenContract; + const abiEncodedTransactionData = self.web3ContractInstance.approve.getData(); + return abiEncodedTransactionData; + }, + }; + public totalSupply = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenContract; + const result = await promisify( + self.web3ContractInstance.totalSupply.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public transferFrom = { + async sendTransactionAsync( + _from: string, + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.transferFrom.estimateGasAsync.bind( + self, + _from, + _to, + _value, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.transferFrom, self.web3ContractInstance, + )( + _from, + _to, + _value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _from: string, + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.transferFrom.estimateGas, self.web3ContractInstance, + )( + _from, + _to, + _value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _from: string, + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as TokenContract; + const abiEncodedTransactionData = self.web3ContractInstance.transferFrom.getData(); + return abiEncodedTransactionData; + }, + }; + public balanceOf = { + async callAsync( + _owner: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenContract; + const result = await promisify( + self.web3ContractInstance.balanceOf.call, + self.web3ContractInstance, + )( + _owner, + ); + return result; + }, + }; + public transfer = { + async sendTransactionAsync( + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.transfer.estimateGasAsync.bind( + self, + _to, + _value, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.transfer, self.web3ContractInstance, + )( + _to, + _value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.transfer.estimateGas, self.web3ContractInstance, + )( + _to, + _value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as TokenContract; + const abiEncodedTransactionData = self.web3ContractInstance.transfer.getData(); + return abiEncodedTransactionData; + }, + }; + public allowance = { + async callAsync( + _owner: string, + _spender: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenContract; + const result = await promisify( + self.web3ContractInstance.allowance.call, + self.web3ContractInstance, + )( + _owner, + _spender, + ); + return result; + }, + }; + constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { + super(web3ContractInstance, defaults); + classUtils.bindAll(this, ['web3ContractInstance', 'defaults']); + } +} // tslint:disable:max-file-line-count diff --git a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts new file mode 100644 index 000000000..ec2158bb8 --- /dev/null +++ b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts @@ -0,0 +1,546 @@ +import {BigNumber} from 'bignumber.js'; +import * as Web3 from 'web3'; + +import {TxData, TxDataPayable} from '../../types'; +import {classUtils} from '../../utils/class_utils'; +import {promisify} from '../../utils/promisify'; + +import {BaseContract} from './base_contract'; + +export class TokenRegistryContract extends BaseContract { + public removeToken = { + async sendTransactionAsync( + _token: string, + _index: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.removeToken.estimateGasAsync.bind( + self, + _token, + _index, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.removeToken, self.web3ContractInstance, + )( + _token, + _index, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _token: string, + _index: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.removeToken.estimateGas, self.web3ContractInstance, + )( + _token, + _index, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _token: string, + _index: BigNumber, + txData: TxData = {}, + ): string { + const self = this as TokenRegistryContract; + const abiEncodedTransactionData = self.web3ContractInstance.removeToken.getData(); + return abiEncodedTransactionData; + }, + }; + public getTokenAddressByName = { + async callAsync( + _name: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenRegistryContract; + const result = await promisify( + self.web3ContractInstance.getTokenAddressByName.call, + self.web3ContractInstance, + )( + _name, + ); + return result; + }, + }; + public getTokenAddressBySymbol = { + async callAsync( + _symbol: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenRegistryContract; + const result = await promisify( + self.web3ContractInstance.getTokenAddressBySymbol.call, + self.web3ContractInstance, + )( + _symbol, + ); + return result; + }, + }; + public setTokenSwarmHash = { + async sendTransactionAsync( + _token: string, + _swarmHash: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.setTokenSwarmHash.estimateGasAsync.bind( + self, + _token, + _swarmHash, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.setTokenSwarmHash, self.web3ContractInstance, + )( + _token, + _swarmHash, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _token: string, + _swarmHash: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.setTokenSwarmHash.estimateGas, self.web3ContractInstance, + )( + _token, + _swarmHash, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _token: string, + _swarmHash: string, + txData: TxData = {}, + ): string { + const self = this as TokenRegistryContract; + const abiEncodedTransactionData = self.web3ContractInstance.setTokenSwarmHash.getData(); + return abiEncodedTransactionData; + }, + }; + public getTokenMetaData = { + async callAsync( + _token: string, + defaultBlock?: Web3.BlockParam, + ): Promise<[string, string, string, BigNumber, string, string] + > { + const self = this as TokenRegistryContract; + const result = await promisify<[string, string, string, BigNumber, string, string] + >( + self.web3ContractInstance.getTokenMetaData.call, + self.web3ContractInstance, + )( + _token, + ); + return result; + }, + }; + public owner = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenRegistryContract; + const result = await promisify( + self.web3ContractInstance.owner.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public addToken = { + async sendTransactionAsync( + _token: string, + _name: string, + _symbol: string, + _decimals: number|BigNumber, + _ipfsHash: string, + _swarmHash: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.addToken.estimateGasAsync.bind( + self, + _token, + _name, + _symbol, + _decimals, + _ipfsHash, + _swarmHash, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.addToken, self.web3ContractInstance, + )( + _token, + _name, + _symbol, + _decimals, + _ipfsHash, + _swarmHash, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _token: string, + _name: string, + _symbol: string, + _decimals: number|BigNumber, + _ipfsHash: string, + _swarmHash: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.addToken.estimateGas, self.web3ContractInstance, + )( + _token, + _name, + _symbol, + _decimals, + _ipfsHash, + _swarmHash, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _token: string, + _name: string, + _symbol: string, + _decimals: number|BigNumber, + _ipfsHash: string, + _swarmHash: string, + txData: TxData = {}, + ): string { + const self = this as TokenRegistryContract; + const abiEncodedTransactionData = self.web3ContractInstance.addToken.getData(); + return abiEncodedTransactionData; + }, + }; + public setTokenName = { + async sendTransactionAsync( + _token: string, + _name: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.setTokenName.estimateGasAsync.bind( + self, + _token, + _name, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.setTokenName, self.web3ContractInstance, + )( + _token, + _name, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _token: string, + _name: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.setTokenName.estimateGas, self.web3ContractInstance, + )( + _token, + _name, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _token: string, + _name: string, + txData: TxData = {}, + ): string { + const self = this as TokenRegistryContract; + const abiEncodedTransactionData = self.web3ContractInstance.setTokenName.getData(); + return abiEncodedTransactionData; + }, + }; + public tokens = { + async callAsync( + index: string, + defaultBlock?: Web3.BlockParam, + ): Promise<[string, string, string, BigNumber, string, string] + > { + const self = this as TokenRegistryContract; + const result = await promisify<[string, string, string, BigNumber, string, string] + >( + self.web3ContractInstance.tokens.call, + self.web3ContractInstance, + )( + index, + ); + return result; + }, + }; + public tokenAddresses = { + async callAsync( + index: BigNumber, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenRegistryContract; + const result = await promisify( + self.web3ContractInstance.tokenAddresses.call, + self.web3ContractInstance, + )( + index, + ); + return result; + }, + }; + public getTokenByName = { + async callAsync( + _name: string, + defaultBlock?: Web3.BlockParam, + ): Promise<[string, string, string, BigNumber, string, string] + > { + const self = this as TokenRegistryContract; + const result = await promisify<[string, string, string, BigNumber, string, string] + >( + self.web3ContractInstance.getTokenByName.call, + self.web3ContractInstance, + )( + _name, + ); + return result; + }, + }; + public getTokenAddresses = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenRegistryContract; + const result = await promisify( + self.web3ContractInstance.getTokenAddresses.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public setTokenIpfsHash = { + async sendTransactionAsync( + _token: string, + _ipfsHash: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.setTokenIpfsHash.estimateGasAsync.bind( + self, + _token, + _ipfsHash, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.setTokenIpfsHash, self.web3ContractInstance, + )( + _token, + _ipfsHash, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _token: string, + _ipfsHash: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.setTokenIpfsHash.estimateGas, self.web3ContractInstance, + )( + _token, + _ipfsHash, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _token: string, + _ipfsHash: string, + txData: TxData = {}, + ): string { + const self = this as TokenRegistryContract; + const abiEncodedTransactionData = self.web3ContractInstance.setTokenIpfsHash.getData(); + return abiEncodedTransactionData; + }, + }; + public getTokenBySymbol = { + async callAsync( + _symbol: string, + defaultBlock?: Web3.BlockParam, + ): Promise<[string, string, string, BigNumber, string, string] + > { + const self = this as TokenRegistryContract; + const result = await promisify<[string, string, string, BigNumber, string, string] + >( + self.web3ContractInstance.getTokenBySymbol.call, + self.web3ContractInstance, + )( + _symbol, + ); + return result; + }, + }; + public setTokenSymbol = { + async sendTransactionAsync( + _token: string, + _symbol: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.setTokenSymbol.estimateGasAsync.bind( + self, + _token, + _symbol, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.setTokenSymbol, self.web3ContractInstance, + )( + _token, + _symbol, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _token: string, + _symbol: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.setTokenSymbol.estimateGas, self.web3ContractInstance, + )( + _token, + _symbol, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _token: string, + _symbol: string, + txData: TxData = {}, + ): string { + const self = this as TokenRegistryContract; + const abiEncodedTransactionData = self.web3ContractInstance.setTokenSymbol.getData(); + return abiEncodedTransactionData; + }, + }; + public transferOwnership = { + async sendTransactionAsync( + newOwner: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.transferOwnership.estimateGasAsync.bind( + self, + newOwner, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.transferOwnership, self.web3ContractInstance, + )( + newOwner, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + newOwner: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenRegistryContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.transferOwnership.estimateGas, self.web3ContractInstance, + )( + newOwner, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + newOwner: string, + txData: TxData = {}, + ): string { + const self = this as TokenRegistryContract; + const abiEncodedTransactionData = self.web3ContractInstance.transferOwnership.getData(); + return abiEncodedTransactionData; + }, + }; + constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { + super(web3ContractInstance, defaults); + classUtils.bindAll(this, ['web3ContractInstance', 'defaults']); + } +} // tslint:disable:max-file-line-count diff --git a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts new file mode 100644 index 000000000..2e0c294ab --- /dev/null +++ b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts @@ -0,0 +1,281 @@ +import {BigNumber} from 'bignumber.js'; +import * as Web3 from 'web3'; + +import {TxData, TxDataPayable} from '../../types'; +import {classUtils} from '../../utils/class_utils'; +import {promisify} from '../../utils/promisify'; + +import {BaseContract} from './base_contract'; + +export class TokenTransferProxyContract extends BaseContract { + public transferFrom = { + async sendTransactionAsync( + token: string, + from: string, + to: string, + value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenTransferProxyContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.transferFrom.estimateGasAsync.bind( + self, + token, + from, + to, + value, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.transferFrom, self.web3ContractInstance, + )( + token, + from, + to, + value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + token: string, + from: string, + to: string, + value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as TokenTransferProxyContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.transferFrom.estimateGas, self.web3ContractInstance, + )( + token, + from, + to, + value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + token: string, + from: string, + to: string, + value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as TokenTransferProxyContract; + const abiEncodedTransactionData = self.web3ContractInstance.transferFrom.getData(); + return abiEncodedTransactionData; + }, + }; + public addAuthorizedAddress = { + async sendTransactionAsync( + target: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenTransferProxyContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.addAuthorizedAddress.estimateGasAsync.bind( + self, + target, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.addAuthorizedAddress, self.web3ContractInstance, + )( + target, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + target: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenTransferProxyContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.addAuthorizedAddress.estimateGas, self.web3ContractInstance, + )( + target, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + target: string, + txData: TxData = {}, + ): string { + const self = this as TokenTransferProxyContract; + const abiEncodedTransactionData = self.web3ContractInstance.addAuthorizedAddress.getData(); + return abiEncodedTransactionData; + }, + }; + public authorities = { + async callAsync( + index: BigNumber, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenTransferProxyContract; + const result = await promisify( + self.web3ContractInstance.authorities.call, + self.web3ContractInstance, + )( + index, + ); + return result; + }, + }; + public removeAuthorizedAddress = { + async sendTransactionAsync( + target: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenTransferProxyContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.removeAuthorizedAddress.estimateGasAsync.bind( + self, + target, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.removeAuthorizedAddress, self.web3ContractInstance, + )( + target, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + target: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenTransferProxyContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.removeAuthorizedAddress.estimateGas, self.web3ContractInstance, + )( + target, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + target: string, + txData: TxData = {}, + ): string { + const self = this as TokenTransferProxyContract; + const abiEncodedTransactionData = self.web3ContractInstance.removeAuthorizedAddress.getData(); + return abiEncodedTransactionData; + }, + }; + public owner = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenTransferProxyContract; + const result = await promisify( + self.web3ContractInstance.owner.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public authorized = { + async callAsync( + index: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenTransferProxyContract; + const result = await promisify( + self.web3ContractInstance.authorized.call, + self.web3ContractInstance, + )( + index, + ); + return result; + }, + }; + public getAuthorizedAddresses = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as TokenTransferProxyContract; + const result = await promisify( + self.web3ContractInstance.getAuthorizedAddresses.call, + self.web3ContractInstance, + )( + ); + return result; + }, + }; + public transferOwnership = { + async sendTransactionAsync( + newOwner: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenTransferProxyContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + self.transferOwnership.estimateGasAsync.bind( + self, + newOwner, + ), + ); + const txHash = await promisify( + self.web3ContractInstance.transferOwnership, self.web3ContractInstance, + )( + newOwner, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + newOwner: string, + txData: TxData = {}, + ): Promise { + const self = this as TokenTransferProxyContract; + const txDataWithDefaults = await self.applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self.web3ContractInstance.transferOwnership.estimateGas, self.web3ContractInstance, + )( + newOwner, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + newOwner: string, + txData: TxData = {}, + ): string { + const self = this as TokenTransferProxyContract; + const abiEncodedTransactionData = self.web3ContractInstance.transferOwnership.getData(); + return abiEncodedTransactionData; + }, + }; + constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { + super(web3ContractInstance, defaults); + classUtils.bindAll(this, ['web3ContractInstance', 'defaults']); + } +} // tslint:disable:max-file-line-count -- cgit v1.2.3 From 865ee090c8c23376b018bf0d109912ac20eaafc4 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 22:44:06 -0600 Subject: Add class utils --- packages/0x.js/src/utils/class_utils.ts | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 packages/0x.js/src/utils/class_utils.ts (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/utils/class_utils.ts b/packages/0x.js/src/utils/class_utils.ts new file mode 100644 index 000000000..de7e99cd9 --- /dev/null +++ b/packages/0x.js/src/utils/class_utils.ts @@ -0,0 +1,17 @@ +import * as _ from 'lodash'; + +export const classUtils = { + bindAll(self: any, exclude: string[] = ['contructor'], thisArg?: any): void { + for (const key of Object.getOwnPropertyNames(self)) { + const val = self[key]; + if (!_.includes(exclude, key)) { + if (_.isFunction(val)) { + self[key] = val.bind(thisArg || self); + } else if (_.isObject(val)) { + classUtils.bindAll(val, exclude, self); + } + } + } + return self; + }, +}; -- cgit v1.2.3 From 9485e4f4f38133141c32af3545a33c267222b851 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 22:44:18 -0600 Subject: Add promisify --- packages/0x.js/src/utils/promisify.ts | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 packages/0x.js/src/utils/promisify.ts (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/utils/promisify.ts b/packages/0x.js/src/utils/promisify.ts new file mode 100644 index 000000000..8021a3c9f --- /dev/null +++ b/packages/0x.js/src/utils/promisify.ts @@ -0,0 +1,24 @@ +import * as _ from 'lodash'; + +/** + * Transforms callback-based function -- func(arg1, arg2 .. argN, callback) -- into + * an ES6-compatible Promise. Promisify provides a default callback of the form (error, result) + * and rejects when `error` is not null. You can also supply settings object as the second argument. + */ +export function promisify( + originalFn: ( + ...args: any[], + // HACK: This can't be properly typed without variadic kinds https://github.com/Microsoft/TypeScript/issues/5453 + ) => void, + target: any, +): (...callArgs: any[]) => Promise { + const promisifiedFunction = (...callArgs: any[]): Promise => { + return new Promise((resolve, reject) => { + const callback = (err: Error|null, data?: T) => { + _.isNull(err) ? resolve(data) : reject(err); + }; + originalFn.apply(target, [...callArgs, callback]); + }); + }; + return promisifiedFunction; +} -- cgit v1.2.3 From 11bf2a0e060a358476f35f4d0d4a081df0dc7f71 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 22:45:02 -0600 Subject: Add depencies and a command to generate contract wrappers --- packages/0x.js/package.json | 3 +++ 1 file changed, 3 insertions(+) (limited to 'packages/0x.js') diff --git a/packages/0x.js/package.json b/packages/0x.js/package.json index 97aff0581..1089e1a91 100644 --- a/packages/0x.js/package.json +++ b/packages/0x.js/package.json @@ -16,6 +16,7 @@ "build": "run-p build:umd:prod build:commonjs; exit 0;", "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --json $JSON_FILE_PATH $PROJECT_DIR", "upload_docs_json": "aws s3 cp generated_docs/index.json $S3_URL --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type application/json", + "generate_contract_wrappers": "typed-contracts --abiGlob 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry).json' --templates ../typed-contracts-templates/ --output src/contract_wrappers/generated", "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'", "test:circleci": "run-s test:coverage report_test_coverage && if [ $CIRCLE_BRANCH = \"development\" ]; then yarn test:umd; fi", "test": "run-s clean test:commonjs", @@ -45,6 +46,8 @@ }, "devDependencies": { "@0xproject/tslint-config": "^0.2.0", + "@0xproject/typed-contracts": "^0.0.0", + "@0xproject/typed-contracts-templates": "^0.0.0", "@types/bintrees": "^1.0.2", "@types/jsonschema": "^1.1.1", "@types/lodash": "^4.14.64", -- cgit v1.2.3 From 6cbd0d4537be3e51866c407dc01fb0efca0b50c2 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 22:46:21 -0600 Subject: Remove old contract typings --- packages/0x.js/src/types.ts | 165 +++----------------------------------------- 1 file changed, 11 insertions(+), 154 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/types.ts b/packages/0x.js/src/types.ts index 5363b02ff..3586919cb 100644 --- a/packages/0x.js/src/types.ts +++ b/packages/0x.js/src/types.ts @@ -52,156 +52,6 @@ export interface DecodedLogEvent { export type EventCallback = (err: null|Error, log?: DecodedLogEvent) => void; export type EventWatcherCallback = (log: LogEvent) => void; -export interface ExchangeContract extends Web3.ContractInstance { - isValidSignature: { - callAsync: (signerAddressHex: string, dataHex: string, v: number, r: string, s: string, - txOpts?: TxOpts) => Promise; - }; - ZRX_TOKEN_CONTRACT: { - callAsync: () => Promise; - }; - TOKEN_TRANSFER_PROXY_CONTRACT: { - callAsync: () => Promise; - }; - getUnavailableTakerTokenAmount: { - callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise; - }; - isRoundingError: { - callAsync: (takerTokenFillAmount: BigNumber, takerTokenAmount: BigNumber, - makerTokenAmount: BigNumber, txOpts?: TxOpts) => Promise; - }; - fillOrder: { - sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues, - fillTakerTokenAmount: BigNumber, - shouldThrowOnInsufficientBalanceOrAllowance: boolean, - v: number, r: string, s: string, txOpts?: TxOpts) => Promise; - estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues, - fillTakerTokenAmount: BigNumber, - shouldThrowOnInsufficientBalanceOrAllowance: boolean, - v: number, r: string, s: string, txOpts?: TxOpts) => Promise; - }; - batchFillOrders: { - sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], - fillTakerTokenAmounts: BigNumber[], - shouldThrowOnInsufficientBalanceOrAllowance: boolean, - v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise; - estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], - fillTakerTokenAmounts: BigNumber[], - shouldThrowOnInsufficientBalanceOrAllowance: boolean, - v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise; - }; - fillOrdersUpTo: { - sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], - fillTakerTokenAmount: BigNumber, - shouldThrowOnInsufficientBalanceOrAllowance: boolean, - v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise; - estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], - fillTakerTokenAmount: BigNumber, - shouldThrowOnInsufficientBalanceOrAllowance: boolean, - v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise; - }; - cancelOrder: { - sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues, - cancelTakerTokenAmount: BigNumber, txOpts?: TxOpts) => Promise; - estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues, - cancelTakerTokenAmount: BigNumber, - txOpts?: TxOpts) => Promise; - }; - batchCancelOrders: { - sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], - cancelTakerTokenAmounts: BigNumber[], txOpts?: TxOpts) => Promise; - estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], - cancelTakerTokenAmounts: BigNumber[], - txOpts?: TxOpts) => Promise; - }; - fillOrKillOrder: { - sendTransactionAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues, - fillTakerTokenAmount: BigNumber, - v: number, r: string, s: string, txOpts?: TxOpts) => Promise; - estimateGasAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues, - fillTakerTokenAmount: BigNumber, - v: number, r: string, s: string, txOpts?: TxOpts) => Promise; - }; - batchFillOrKillOrders: { - sendTransactionAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], - fillTakerTokenAmounts: BigNumber[], - v: number[], r: string[], s: string[], txOpts: TxOpts) => Promise; - estimateGasAsync: (orderAddresses: OrderAddresses[], orderValues: OrderValues[], - fillTakerTokenAmounts: BigNumber[], - v: number[], r: string[], s: string[], txOpts?: TxOpts) => Promise; - }; - filled: { - callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise; - }; - cancelled: { - callAsync: (orderHash: string, defaultBlock?: Web3.BlockParam) => Promise; - }; - getOrderHash: { - callAsync: (orderAddresses: OrderAddresses, orderValues: OrderValues) => Promise; - }; -} - -export interface TokenContract extends Web3.ContractInstance { - balanceOf: { - callAsync: (address: string, defaultBlock?: Web3.BlockParam) => Promise; - }; - allowance: { - callAsync: (ownerAddress: string, allowedAddress: string, - defaultBlock?: Web3.BlockParam) => Promise; - }; - transfer: { - sendTransactionAsync: (toAddress: string, amountInBaseUnits: BigNumber, - txOpts?: TxOpts) => Promise; - }; - transferFrom: { - sendTransactionAsync: (fromAddress: string, toAddress: string, amountInBaseUnits: BigNumber, - txOpts?: TxOpts) => Promise; - }; - approve: { - sendTransactionAsync: (proxyAddress: string, amountInBaseUnits: BigNumber, - txOpts?: TxOpts) => Promise; - }; -} - -export interface TokenRegistryContract extends Web3.ContractInstance { - getTokenMetaData: { - callAsync: (address: string) => Promise; - }; - getTokenAddresses: { - callAsync: () => Promise; - }; - getTokenAddressBySymbol: { - callAsync: (symbol: string) => Promise; - }; - getTokenAddressByName: { - callAsync: (name: string) => Promise; - }; - getTokenBySymbol: { - callAsync: (symbol: string) => Promise; - }; - getTokenByName: { - callAsync: (name: string) => Promise; - }; -} - -export interface EtherTokenContract extends Web3.ContractInstance { - deposit: { - sendTransactionAsync: (txOpts: TxOpts) => Promise; - }; - withdraw: { - sendTransactionAsync: (amount: BigNumber, txOpts: TxOpts) => Promise; - }; -} - -export interface TokenTransferProxyContract extends Web3.ContractInstance { - getAuthorizedAddresses: { - callAsync: () => Promise; - }; - authorized: { - callAsync: (address: string) => Promise; - }; -} - export enum SolidityTypes { Address = 'address', Uint256 = 'uint256', @@ -393,10 +243,6 @@ export type AsyncMethod = (...args: any[]) => Promise; */ export type Web3Provider = Web3.Provider; -export interface ExchangeContractByAddress { - [address: string]: ExchangeContract; -} - export interface JSONRPCPayload { params: any[]; method: string; @@ -540,6 +386,17 @@ export type OrderState = OrderStateValid|OrderStateInvalid; export type OnOrderStateChangeCallback = (orderState: OrderState) => void; +export interface TxData { + from?: string; + gas?: number; + gasPrice?: BigNumber; + nonce?: number; +} + +export interface TxDataPayable extends TxData { + value?: BigNumber; +} + export interface TransactionReceipt { blockHash: string; blockNumber: number; -- cgit v1.2.3 From eb667f653c4ee87132390844afaecf409c7575c8 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 22:47:05 -0600 Subject: Adjust 0x.js to use generated wrappers --- .../0x.js/src/contract_wrappers/contract_wrapper.ts | 12 +++++++----- .../src/contract_wrappers/ether_token_wrapper.ts | 6 ++++-- .../0x.js/src/contract_wrappers/exchange_wrapper.ts | 5 +++-- .../src/contract_wrappers/token_registry_wrapper.ts | 8 ++++++-- .../token_transfer_proxy_wrapper.ts | 8 ++++++-- .../0x.js/src/contract_wrappers/token_wrapper.ts | 7 +++++-- packages/0x.js/src/web3_wrapper.ts | 21 ++++++++++++--------- 7 files changed, 43 insertions(+), 24 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/contract_wrappers/contract_wrapper.ts b/packages/0x.js/src/contract_wrappers/contract_wrapper.ts index 8c92931b4..5e5a38f8c 100644 --- a/packages/0x.js/src/contract_wrappers/contract_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/contract_wrapper.ts @@ -90,11 +90,13 @@ export class ContractWrapper { const logWithDecodedArgs = this._abiDecoder.tryToDecodeLogOrNoop(log); return logWithDecodedArgs; } - protected async _instantiateContractIfExistsAsync( - artifact: Artifact, addressIfExists?: string): Promise { - const contractInstance = - await this._web3Wrapper.getContractInstanceFromArtifactAsync(artifact, addressIfExists); - return contractInstance; + protected async _instantiateContractIfExistsAsync( + artifact: Artifact, addressIfExists?: string, + ): Promise { + const web3ContractInstance = await this._web3Wrapper.getContractInstanceFromArtifactAsync( + artifact, addressIfExists, + ); + return web3ContractInstance; } protected _getContractAddress(artifact: Artifact, addressIfExists?: string): string { if (_.isUndefined(addressIfExists)) { diff --git a/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts b/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts index ede0460bd..26025f6f9 100644 --- a/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts @@ -2,11 +2,12 @@ import BigNumber from 'bignumber.js'; import * as _ from 'lodash'; import {artifacts} from '../artifacts'; -import {EtherTokenContract, TransactionOpts, ZeroExError} from '../types'; +import {TransactionOpts, ZeroExError} from '../types'; import {assert} from '../utils/assert'; import {Web3Wrapper} from '../web3_wrapper'; import {ContractWrapper} from './contract_wrapper'; +import {EtherTokenContract} from './generated/ether_token'; import {TokenWrapper} from './token_wrapper'; /** @@ -92,9 +93,10 @@ export class EtherTokenWrapper extends ContractWrapper { if (!_.isUndefined(this._etherTokenContractIfExists)) { return this._etherTokenContractIfExists; } - const contractInstance = await this._instantiateContractIfExistsAsync( + const web3ContractInstance = await this._instantiateContractIfExistsAsync( artifacts.EtherTokenArtifact, this._contractAddressIfExists, ); + const contractInstance = new EtherTokenContract(web3ContractInstance, this._web3Wrapper.getContractDefaults()); this._etherTokenContractIfExists = contractInstance; return this._etherTokenContractIfExists; } diff --git a/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts b/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts index 273b348ff..aaf6256a3 100644 --- a/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts @@ -9,7 +9,6 @@ import { DecodedLogArgs, ECSignature, EventCallback, - ExchangeContract, ExchangeContractErrCodes, ExchangeContractErrs, ExchangeContractEventArgs, @@ -40,6 +39,7 @@ import {utils} from '../utils/utils'; import {Web3Wrapper} from '../web3_wrapper'; import {ContractWrapper} from './contract_wrapper'; +import {ExchangeContract} from './generated/exchange'; import {TokenWrapper} from './token_wrapper'; const SHOULD_VALIDATE_BY_DEFAULT = true; @@ -789,9 +789,10 @@ export class ExchangeWrapper extends ContractWrapper { if (!_.isUndefined(this._exchangeContractIfExists)) { return this._exchangeContractIfExists; } - const contractInstance = await this._instantiateContractIfExistsAsync( + const web3ContractInstance = await this._instantiateContractIfExistsAsync( artifacts.ExchangeArtifact, this._contractAddressIfExists, ); + const contractInstance = new ExchangeContract(web3ContractInstance, this._web3Wrapper.getContractDefaults()); this._exchangeContractIfExists = contractInstance; return this._exchangeContractIfExists; } diff --git a/packages/0x.js/src/contract_wrappers/token_registry_wrapper.ts b/packages/0x.js/src/contract_wrappers/token_registry_wrapper.ts index 35337fa35..27ecb8bde 100644 --- a/packages/0x.js/src/contract_wrappers/token_registry_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/token_registry_wrapper.ts @@ -1,12 +1,13 @@ import * as _ from 'lodash'; import {artifacts} from '../artifacts'; -import {Token, TokenMetadata, TokenRegistryContract, ZeroExError} from '../types'; +import {Token, TokenMetadata, ZeroExError} from '../types'; import {assert} from '../utils/assert'; import {constants} from '../utils/constants'; import {Web3Wrapper} from '../web3_wrapper'; 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. @@ -116,9 +117,12 @@ export class TokenRegistryWrapper extends ContractWrapper { if (!_.isUndefined(this._tokenRegistryContractIfExists)) { return this._tokenRegistryContractIfExists; } - const contractInstance = await this._instantiateContractIfExistsAsync( + const web3ContractInstance = await this._instantiateContractIfExistsAsync( artifacts.TokenRegistryArtifact, this._contractAddressIfExists, ); + const contractInstance = new TokenRegistryContract( + web3ContractInstance, this._web3Wrapper.getContractDefaults(), + ); this._tokenRegistryContractIfExists = contractInstance; return this._tokenRegistryContractIfExists; } diff --git a/packages/0x.js/src/contract_wrappers/token_transfer_proxy_wrapper.ts b/packages/0x.js/src/contract_wrappers/token_transfer_proxy_wrapper.ts index c3df7d3eb..edc702672 100644 --- a/packages/0x.js/src/contract_wrappers/token_transfer_proxy_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/token_transfer_proxy_wrapper.ts @@ -1,10 +1,11 @@ import * as _ from 'lodash'; import {artifacts} from '../artifacts'; -import {TokenTransferProxyContract, ZeroExError} from '../types'; +import {ZeroExError} from '../types'; import {Web3Wrapper} from '../web3_wrapper'; import {ContractWrapper} from './contract_wrapper'; +import {TokenTransferProxyContract} from './generated/token_transfer_proxy'; /** * This class includes the functionality related to interacting with the TokenTransferProxy contract. @@ -53,9 +54,12 @@ export class TokenTransferProxyWrapper extends ContractWrapper { if (!_.isUndefined(this._tokenTransferProxyContractIfExists)) { return this._tokenTransferProxyContractIfExists; } - const contractInstance = await this._instantiateContractIfExistsAsync( + const web3ContractInstance = await this._instantiateContractIfExistsAsync( artifacts.TokenTransferProxyArtifact, this._contractAddressIfExists, ); + const contractInstance = new TokenTransferProxyContract( + web3ContractInstance, this._web3Wrapper.getContractDefaults(), + ); this._tokenTransferProxyContractIfExists = contractInstance; return this._tokenTransferProxyContractIfExists; } diff --git a/packages/0x.js/src/contract_wrappers/token_wrapper.ts b/packages/0x.js/src/contract_wrappers/token_wrapper.ts index 4a1dfcf8d..630ab6e3b 100644 --- a/packages/0x.js/src/contract_wrappers/token_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/token_wrapper.ts @@ -9,7 +9,6 @@ import { LogWithDecodedArgs, MethodOpts, SubscriptionOpts, - TokenContract, TokenContractEventArgs, TokenEvents, TransactionOpts, @@ -21,6 +20,7 @@ import {constants} from '../utils/constants'; import {Web3Wrapper} from '../web3_wrapper'; import {ContractWrapper} from './contract_wrapper'; +import {TokenContract} from './generated/token'; import {TokenTransferProxyWrapper} from './token_transfer_proxy_wrapper'; const ALLOWANCE_TO_ZERO_GAS_AMOUNT = 47275; @@ -313,9 +313,12 @@ export class TokenWrapper extends ContractWrapper { if (!_.isUndefined(tokenContract)) { return tokenContract; } - const contractInstance = await this._instantiateContractIfExistsAsync( + const web3ContractInstance = await this._instantiateContractIfExistsAsync( artifacts.TokenArtifact, tokenAddress, ); + const contractInstance = new TokenContract( + web3ContractInstance, this._web3Wrapper.getContractDefaults(), + ); tokenContract = contractInstance; this._tokenContractsByAddress[tokenAddress] = tokenContract; return tokenContract; diff --git a/packages/0x.js/src/web3_wrapper.ts b/packages/0x.js/src/web3_wrapper.ts index a031de486..0f23272a7 100644 --- a/packages/0x.js/src/web3_wrapper.ts +++ b/packages/0x.js/src/web3_wrapper.ts @@ -4,7 +4,7 @@ import * as _ from 'lodash'; import * as Web3 from 'web3'; import {Contract} from './contract'; -import {Artifact, ArtifactContractName, TransactionReceipt, ZeroExError} from './types'; +import {Artifact, ArtifactContractName, TransactionReceipt, TxData, ZeroExError} from './types'; interface RawLogEntry { logIndex: string|null; @@ -29,9 +29,9 @@ const CONTRACT_NAME_TO_NOT_FOUND_ERROR: {[contractName: string]: ZeroExError} = export class Web3Wrapper { private web3: Web3; private networkId: number; - private defaults: Partial; + private defaults: Partial; private jsonRpcRequestId: number; - constructor(provider: Web3.Provider, networkId: number, defaults?: Partial) { + constructor(provider: Web3.Provider, networkId: number, defaults?: Partial) { if (_.isUndefined((provider as any).sendAsync)) { // Web3@1.0 provider doesn't support synchronous http requests, // so it only has an async `send` method, instead of a `send` and `sendAsync` in web3@0.x.x` @@ -44,6 +44,9 @@ export class Web3Wrapper { this.defaults = defaults || {}; this.jsonRpcRequestId = 0; } + public getContractDefaults(): Partial { + return this.defaults; + } public setProvider(provider: Web3.Provider, networkId: number) { this.networkId = networkId; this.web3.setProvider(provider); @@ -72,8 +75,9 @@ export class Web3Wrapper { public getNetworkId(): number { return this.networkId; } - public async getContractInstanceFromArtifactAsync(artifact: Artifact, - address?: string): Promise { + public async getContractInstanceFromArtifactAsync( + artifact: Artifact, address?: string, + ): Promise { let contractAddress: string; if (_.isUndefined(address)) { const networkId = this.getNetworkId(); @@ -88,7 +92,7 @@ export class Web3Wrapper { if (!doesContractExist) { throw new Error(CONTRACT_NAME_TO_NOT_FOUND_ERROR[artifact.contract_name]); } - const contractInstance = this.getContractInstance( + const contractInstance = this.getContractInstance( artifact.abi, contractAddress, ); return contractInstance; @@ -152,10 +156,9 @@ export class Web3Wrapper { const formattedLogs = _.map(rawLogs, this.formatLog.bind(this)); return formattedLogs; } - private getContractInstance(abi: Web3.ContractAbi, address: string): A { + private getContractInstance(abi: Web3.ContractAbi, address: string): Web3.ContractInstance { const web3ContractInstance = this.web3.eth.contract(abi).at(address); - const contractInstance = new Contract(web3ContractInstance, this.defaults) as any as A; - return contractInstance; + return web3ContractInstance; } private async getNetworkAsync(): Promise { const networkId = await promisify(this.web3.version.getNetwork)(); -- cgit v1.2.3 From 042caa3363b15ed298486afe4236d665fc254065 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 22:55:36 -0600 Subject: Add async prefix --- packages/0x.js/src/utils/promisify.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/utils/promisify.ts b/packages/0x.js/src/utils/promisify.ts index 8021a3c9f..1eb1bf29f 100644 --- a/packages/0x.js/src/utils/promisify.ts +++ b/packages/0x.js/src/utils/promisify.ts @@ -12,7 +12,7 @@ export function promisify( ) => void, target: any, ): (...callArgs: any[]) => Promise { - const promisifiedFunction = (...callArgs: any[]): Promise => { + const promisifiedFunction = async (...callArgs: any[]): Promise => { return new Promise((resolve, reject) => { const callback = (err: Error|null, data?: T) => { _.isNull(err) ? resolve(data) : reject(err); -- cgit v1.2.3 From ee15143dd7caccacdfe33118692d3a77bbd19429 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 23:10:44 -0600 Subject: Remove all contract wrapper --- packages/0x.js/src/contract.ts | 98 ------------------------------------------ 1 file changed, 98 deletions(-) delete mode 100644 packages/0x.js/src/contract.ts (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/contract.ts b/packages/0x.js/src/contract.ts deleted file mode 100644 index a4ee03910..000000000 --- a/packages/0x.js/src/contract.ts +++ /dev/null @@ -1,98 +0,0 @@ -import {schemas, SchemaValidator} from '@0xproject/json-schemas'; -import promisify = require('es6-promisify'); -import * as _ from 'lodash'; -import * as Web3 from 'web3'; - -import {AbiType} from './types'; - -// HACK: Gas estimates on testrpc don't take into account gas refunds. -// Our calls can trigger max 8 gas refunds for SSTORE per transaction for 15k gas each which gives 120k. -const GAS_MARGIN = 120000; - -export class Contract implements Web3.ContractInstance { - public address: string; - public abi: Web3.ContractAbi; - private contract: Web3.ContractInstance; - private defaults: Partial; - private validator: SchemaValidator; - // This class instance is going to be populated with functions and events depending on the ABI - // and we don't know their types in advance - [name: string]: any; - constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { - this.contract = web3ContractInstance; - this.address = web3ContractInstance.address; - this.abi = web3ContractInstance.abi; - this.defaults = defaults; - this.populateEvents(); - this.populateFunctions(); - this.validator = new SchemaValidator(); - } - private populateFunctions(): void { - const functionsAbi = _.filter(this.abi, abiPart => abiPart.type === AbiType.Function); - _.forEach(functionsAbi, (functionAbi: Web3.MethodAbi) => { - if (functionAbi.constant) { - const cbStyleCallFunction = this.contract[functionAbi.name].call; - this[functionAbi.name] = { - callAsync: promisify(cbStyleCallFunction, this.contract), - }; - } else { - const cbStyleFunction = this.contract[functionAbi.name]; - const cbStyleEstimateGasFunction = this.contract[functionAbi.name].estimateGas; - const estimateGasAsync = promisify(cbStyleEstimateGasFunction, this.contract); - this[functionAbi.name] = { - estimateGasAsync, - sendTransactionAsync: this.promisifyWithDefaultParams(cbStyleFunction, estimateGasAsync), - }; - } - }); - } - private populateEvents(): void { - const eventsAbi = _.filter(this.abi, abiPart => abiPart.type === AbiType.Event); - _.forEach(eventsAbi, (eventAbi: Web3.EventAbi) => { - this[eventAbi.name] = this.contract[eventAbi.name]; - }); - } - private promisifyWithDefaultParams( - web3CbStyleFunction: (...args: any[]) => void, - estimateGasAsync: (...args: any[]) => Promise, - ): (...args: any[]) => Promise { - const promisifiedWithDefaultParams = async (...args: any[]) => { - const promise = new Promise(async (resolve, reject) => { - const lastArg = args[args.length - 1]; - let txData: Partial = {}; - if (!_.isUndefined(lastArg) && this.isTxData(lastArg)) { - txData = args.pop(); - } - // Gas amount sourced with the following priorities: - // 1. Optional param passed in to public method call - // 2. Global config passed in at library instantiation - // 3. Gas estimate calculation + safety margin - const removeUndefinedProperties = _.pickBy; - txData = { - ...removeUndefinedProperties(this.defaults), - ...removeUndefinedProperties(txData), - }; - if (_.isUndefined(txData.gas)) { - try { - const estimatedGas = await estimateGasAsync.apply(this.contract, [...args, txData]); - const gas = estimatedGas + GAS_MARGIN; - txData.gas = gas; - } catch (err) { - reject(err); - return; - } - } - const callback = (err: Error, data: any) => _.isNull(err) ? resolve(data) : reject(err); - args.push(txData); - args.push(callback); - web3CbStyleFunction.apply(this.contract, args); - }); - return promise; - }; - return promisifiedWithDefaultParams; - } - private isTxData(lastArg: any): boolean { - const isValid = this.validator.isValid(lastArg, schemas.txDataSchema); - return isValid; - } -} -- cgit v1.2.3 From 438c8ff807aa83ca8a2526a4a398d744554b76fd Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 23:11:31 -0600 Subject: Remove es6-promisify --- packages/0x.js/package.json | 1 - packages/0x.js/src/globals.d.ts | 6 ------ 2 files changed, 7 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/package.json b/packages/0x.js/package.json index 1089e1a91..b91f23ecb 100644 --- a/packages/0x.js/package.json +++ b/packages/0x.js/package.json @@ -92,7 +92,6 @@ "bintrees": "^1.0.2", "bn.js": "4.11.8", "compare-versions": "^3.0.1", - "es6-promisify": "^5.0.0", "ethereumjs-abi": "^0.6.4", "ethereumjs-blockstream": "^2.0.6", "ethereumjs-util": "^5.1.1", diff --git a/packages/0x.js/src/globals.d.ts b/packages/0x.js/src/globals.d.ts index cb3800056..4fa1cfd9c 100644 --- a/packages/0x.js/src/globals.d.ts +++ b/packages/0x.js/src/globals.d.ts @@ -39,12 +39,6 @@ declare module 'compare-versions' { export = compareVersions; } -// es6-promisify declarations -declare function promisify(original: any, settings?: any): ((...arg: any[]) => Promise); -declare module 'es6-promisify' { - export = promisify; -} - declare module 'ethereumjs-abi' { const soliditySHA3: (argTypes: string[], args: any[]) => Buffer; } -- cgit v1.2.3 From 5673b42ec47342a1e4be2dd77a5676407a60e401 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 23:11:55 -0600 Subject: Make target optional --- packages/0x.js/src/utils/promisify.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/utils/promisify.ts b/packages/0x.js/src/utils/promisify.ts index 1eb1bf29f..49024c0e9 100644 --- a/packages/0x.js/src/utils/promisify.ts +++ b/packages/0x.js/src/utils/promisify.ts @@ -10,7 +10,7 @@ export function promisify( ...args: any[], // HACK: This can't be properly typed without variadic kinds https://github.com/Microsoft/TypeScript/issues/5453 ) => void, - target: any, + target?: any, ): (...callArgs: any[]) => Promise { const promisifiedFunction = async (...callArgs: any[]): Promise => { return new Promise((resolve, reject) => { -- cgit v1.2.3 From 78fb8d2bdcc8a8d41dc23dfc29b6858c7658c6b0 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 23:12:19 -0600 Subject: Use our promisify --- packages/0x.js/src/web3_wrapper.ts | 23 +++++++++++------------ packages/0x.js/test/subscription_test.ts | 1 - packages/0x.js/test/token_wrapper_test.ts | 17 ++++++++++++----- 3 files changed, 23 insertions(+), 18 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/web3_wrapper.ts b/packages/0x.js/src/web3_wrapper.ts index 0f23272a7..6a6b4e760 100644 --- a/packages/0x.js/src/web3_wrapper.ts +++ b/packages/0x.js/src/web3_wrapper.ts @@ -1,10 +1,9 @@ import BigNumber from 'bignumber.js'; -import promisify = require('es6-promisify'); import * as _ from 'lodash'; import * as Web3 from 'web3'; -import {Contract} from './contract'; import {Artifact, ArtifactContractName, TransactionReceipt, TxData, ZeroExError} from './types'; +import {promisify} from './utils/promisify'; interface RawLogEntry { logIndex: string|null; @@ -59,11 +58,11 @@ export class Web3Wrapper { return _.includes(addresses, senderAddress); } public async getNodeVersionAsync(): Promise { - const nodeVersion = await promisify(this.web3.version.getNode)(); + const nodeVersion = await promisify(this.web3.version.getNode)(); return nodeVersion; } public async getTransactionReceiptAsync(txHash: string): Promise { - const transactionReceipt = await promisify(this.web3.eth.getTransactionReceipt)(txHash); + const transactionReceipt = await promisify(this.web3.eth.getTransactionReceipt)(txHash); if (!_.isNull(transactionReceipt)) { transactionReceipt.status = this.normalizeTxReceiptStatus(transactionReceipt.status); } @@ -102,26 +101,26 @@ export class Web3Wrapper { return balanceWei; } public async getBalanceInWeiAsync(owner: string): Promise { - let balanceInWei = await promisify(this.web3.eth.getBalance)(owner); + let balanceInWei = await promisify(this.web3.eth.getBalance)(owner); balanceInWei = new BigNumber(balanceInWei); return balanceInWei; } public async doesContractExistAtAddressAsync(address: string): Promise { - const code = await promisify(this.web3.eth.getCode)(address); + const code = await promisify(this.web3.eth.getCode)(address); // Regex matches 0x0, 0x00, 0x in order to accommodate poorly implemented clients const codeIsEmpty = /^0x0{0,40}$/i.test(code); return !codeIsEmpty; } public async signTransactionAsync(address: string, message: string): Promise { - const signData = await promisify(this.web3.eth.sign)(address, message); + const signData = await promisify(this.web3.eth.sign)(address, message); return signData; } public async getBlockNumberAsync(): Promise { - const blockNumber = await promisify(this.web3.eth.getBlockNumber)(); + const blockNumber = await promisify(this.web3.eth.getBlockNumber)(); return blockNumber; } public async getBlockAsync(blockParam: string|Web3.BlockParam): Promise { - const block = await promisify(this.web3.eth.getBlock)(blockParam); + const block = await promisify(this.web3.eth.getBlock)(blockParam); return block; } public async getBlockTimestampAsync(blockParam: string|Web3.BlockParam): Promise { @@ -129,7 +128,7 @@ export class Web3Wrapper { return timestamp; } public async getAvailableAddressesAsync(): Promise { - const addresses: string[] = await promisify(this.web3.eth.getAccounts)(); + const addresses = await promisify(this.web3.eth.getAccounts)(); return addresses; } public async getLogsAsync(filter: Web3.FilterObject): Promise { @@ -161,12 +160,12 @@ export class Web3Wrapper { return web3ContractInstance; } private async getNetworkAsync(): Promise { - const networkId = await promisify(this.web3.version.getNetwork)(); + const networkId = await promisify(this.web3.version.getNetwork)(); return networkId; } private async sendRawPayloadAsync(payload: Web3.JSONRPCRequestPayload): Promise { const sendAsync = this.web3.currentProvider.sendAsync.bind(this.web3.currentProvider); - const response = await promisify(sendAsync)(payload); + const response = await promisify(sendAsync)(payload); const result = response.result; return result; } diff --git a/packages/0x.js/test/subscription_test.ts b/packages/0x.js/test/subscription_test.ts index e3b15808b..3aeeaa109 100644 --- a/packages/0x.js/test/subscription_test.ts +++ b/packages/0x.js/test/subscription_test.ts @@ -1,6 +1,5 @@ import BigNumber from 'bignumber.js'; import * as chai from 'chai'; -import promisify = require('es6-promisify'); import * as _ from 'lodash'; import 'mocha'; import * as Sinon from 'sinon'; diff --git a/packages/0x.js/test/token_wrapper_test.ts b/packages/0x.js/test/token_wrapper_test.ts index c853fe0c2..421bd0a8c 100644 --- a/packages/0x.js/test/token_wrapper_test.ts +++ b/packages/0x.js/test/token_wrapper_test.ts @@ -1,6 +1,5 @@ import BigNumber from 'bignumber.js'; import * as chai from 'chai'; -import promisify = require('es6-promisify'); import 'mocha'; import * as Web3 from 'web3'; @@ -19,6 +18,8 @@ import { ZeroExError, } from '../src'; import {BlockParamLiteral, DoneCallback} from '../src/types'; +import {promisify} from '../src/utils/promisify'; +import {Web3Wrapper} from '../src/web3_wrapper'; import {BlockchainLifecycle} from './utils/blockchain_lifecycle'; import {chaiSetup} from './utils/chai_setup'; @@ -38,12 +39,14 @@ describe('TokenWrapper', () => { let tokenUtils: TokenUtils; let coinbase: string; let addressWithoutFunds: string; + let web3Wrapper: Web3Wrapper; const config = { networkId: constants.TESTRPC_NETWORK_ID, }; before(async () => { web3 = web3Factory.create(); zeroEx = new ZeroEx(web3.currentProvider, config); + web3Wrapper = new Web3Wrapper(web3.currentProvider, config.networkId); userAddresses = await zeroEx.getAvailableAddressesAsync(); tokens = await zeroEx.tokenRegistry.getTokensAsync(); tokenUtils = new TokenUtils(tokens); @@ -237,8 +240,10 @@ describe('TokenWrapper', () => { await zeroEx.token.setAllowanceAsync(zrx.address, coinbase, userWithNormalAllowance, transferAmount); await zeroEx.token.setUnlimitedAllowanceAsync(zrx.address, coinbase, userWithUnlimitedAllowance); - const initBalanceWithNormalAllowance = await promisify(web3.eth.getBalance)(userWithNormalAllowance); - const initBalanceWithUnlimitedAllowance = await promisify(web3.eth.getBalance)(userWithUnlimitedAllowance); + const initBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance); + const initBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync( + userWithUnlimitedAllowance, + ); await zeroEx.token.transferFromAsync( zrx.address, coinbase, userWithNormalAllowance, userWithNormalAllowance, transferAmount, @@ -247,8 +252,10 @@ describe('TokenWrapper', () => { zrx.address, coinbase, userWithUnlimitedAllowance, userWithUnlimitedAllowance, transferAmount, ); - const finalBalanceWithNormalAllowance = await promisify(web3.eth.getBalance)(userWithNormalAllowance); - const finalBalanceWithUnlimitedAllowance = await promisify(web3.eth.getBalance)(userWithUnlimitedAllowance); + const finalBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance); + const finalBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync( + userWithUnlimitedAllowance, + ); const normalGasCost = initBalanceWithNormalAllowance.minus(finalBalanceWithNormalAllowance); const unlimitedGasCost = initBalanceWithUnlimitedAllowance.minus(finalBalanceWithUnlimitedAllowance); -- cgit v1.2.3 From 518d0eba84f8708e2e49da796a2aa62087751ee7 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 23:12:58 -0600 Subject: Add comments before generated contracts --- packages/0x.js/src/contract_wrappers/generated/ether_token.ts | 4 ++++ packages/0x.js/src/contract_wrappers/generated/exchange.ts | 4 ++++ packages/0x.js/src/contract_wrappers/generated/token.ts | 4 ++++ packages/0x.js/src/contract_wrappers/generated/token_registry.ts | 4 ++++ .../0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts | 4 ++++ 5 files changed, 20 insertions(+) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts index e613f453f..fc3e93269 100644 --- a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts +++ b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts @@ -1,3 +1,7 @@ +/** + * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; diff --git a/packages/0x.js/src/contract_wrappers/generated/exchange.ts b/packages/0x.js/src/contract_wrappers/generated/exchange.ts index 8bb2a24a3..bad873582 100644 --- a/packages/0x.js/src/contract_wrappers/generated/exchange.ts +++ b/packages/0x.js/src/contract_wrappers/generated/exchange.ts @@ -1,3 +1,7 @@ +/** + * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token.ts b/packages/0x.js/src/contract_wrappers/generated/token.ts index 1248f53a3..ed877ad2b 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token.ts @@ -1,3 +1,7 @@ +/** + * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts index ec2158bb8..884cef0f1 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts @@ -1,3 +1,7 @@ +/** + * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts index 2e0c294ab..f77e60815 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts @@ -1,3 +1,7 @@ +/** + * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; -- cgit v1.2.3 From 355514ca388937f9e0c7326e31f96ae5a7fea5b0 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Fri, 1 Dec 2017 23:18:36 -0600 Subject: Update comment --- packages/0x.js/src/contract_wrappers/generated/ether_token.ts | 2 +- packages/0x.js/src/contract_wrappers/generated/exchange.ts | 2 +- packages/0x.js/src/contract_wrappers/generated/token.ts | 2 +- packages/0x.js/src/contract_wrappers/generated/token_registry.ts | 2 +- packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts index fc3e93269..aae6230c9 100644 --- a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts +++ b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. */ import {BigNumber} from 'bignumber.js'; diff --git a/packages/0x.js/src/contract_wrappers/generated/exchange.ts b/packages/0x.js/src/contract_wrappers/generated/exchange.ts index bad873582..512cc80d7 100644 --- a/packages/0x.js/src/contract_wrappers/generated/exchange.ts +++ b/packages/0x.js/src/contract_wrappers/generated/exchange.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. */ import {BigNumber} from 'bignumber.js'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token.ts b/packages/0x.js/src/contract_wrappers/generated/token.ts index ed877ad2b..f8f578dd9 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. */ import {BigNumber} from 'bignumber.js'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts index 884cef0f1..5638a92d6 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. */ import {BigNumber} from 'bignumber.js'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts index f77e60815..33e244d8d 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts. Don't edit directly. + * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. */ import {BigNumber} from 'bignumber.js'; -- cgit v1.2.3 From e1127dc2e850490e78a6a14366a7421ffc3a9fc9 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 16:56:50 +0300 Subject: Fix a typo --- packages/0x.js/src/contract_wrappers/generated/base_contract.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/contract_wrappers/generated/base_contract.ts b/packages/0x.js/src/contract_wrappers/generated/base_contract.ts index e5f536448..9abba14cd 100644 --- a/packages/0x.js/src/contract_wrappers/generated/base_contract.ts +++ b/packages/0x.js/src/contract_wrappers/generated/base_contract.ts @@ -20,7 +20,7 @@ export class BaseContract { const txDataWithDefaults = { ...removeUndefinedProperties(this.defaults), ...removeUndefinedProperties(txData as any), - // HACK: TS can't prove that T is speadable. + // HACK: TS can't prove that T is spreadable. // Awaiting https://github.com/Microsoft/TypeScript/pull/13288 to be merged }; if (_.isUndefined(txDataWithDefaults.gas) && !_.isUndefined(estimateGasAsync)) { -- cgit v1.2.3 From c0cf47138ec2efe4c0a27de9a503bb0d74d99d5f Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 16:59:36 +0300 Subject: Add a comment --- packages/0x.js/src/utils/class_utils.ts | 1 + 1 file changed, 1 insertion(+) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/utils/class_utils.ts b/packages/0x.js/src/utils/class_utils.ts index de7e99cd9..b89d3ba32 100644 --- a/packages/0x.js/src/utils/class_utils.ts +++ b/packages/0x.js/src/utils/class_utils.ts @@ -1,6 +1,7 @@ import * as _ from 'lodash'; export const classUtils = { + // This is usefull for classes that have nested methods. Nested methods don't get binded out of the box. bindAll(self: any, exclude: string[] = ['contructor'], thisArg?: any): void { for (const key of Object.getOwnPropertyNames(self)) { const val = self[key]; -- cgit v1.2.3 From f88ecaa035352a511fbee1ff1846cdacd03ca169 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 17:01:24 +0300 Subject: Fix a comment --- packages/0x.js/src/utils/promisify.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/utils/promisify.ts b/packages/0x.js/src/utils/promisify.ts index 49024c0e9..c114cf32f 100644 --- a/packages/0x.js/src/utils/promisify.ts +++ b/packages/0x.js/src/utils/promisify.ts @@ -1,23 +1,23 @@ import * as _ from 'lodash'; /** - * Transforms callback-based function -- func(arg1, arg2 .. argN, callback) -- into - * an ES6-compatible Promise. Promisify provides a default callback of the form (error, result) - * and rejects when `error` is not null. You can also supply settings object as the second argument. + * Transforms callback-based function -- func(arg1, arg2 .. argN, callback) -- into an ES6-compatible Promise. + * Promisify provides a default callback of the form (error, result) and rejects when `error` is not null. You can also + * supply thisArg object as the second argument which will be passed to `apply`. */ export function promisify( originalFn: ( ...args: any[], // HACK: This can't be properly typed without variadic kinds https://github.com/Microsoft/TypeScript/issues/5453 ) => void, - target?: any, + thisArg?: any, ): (...callArgs: any[]) => Promise { const promisifiedFunction = async (...callArgs: any[]): Promise => { return new Promise((resolve, reject) => { const callback = (err: Error|null, data?: T) => { _.isNull(err) ? resolve(data) : reject(err); }; - originalFn.apply(target, [...callArgs, callback]); + originalFn.apply(thisArg, [...callArgs, callback]); }); }; return promisifiedFunction; -- cgit v1.2.3 From e2ef7a74dbca24cc18b0c331497812cdc3c221fd Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 18:07:39 +0300 Subject: Remove TODOs --- packages/0x.js/src/contract_wrappers/generated/base_contract.ts | 2 -- 1 file changed, 2 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/contract_wrappers/generated/base_contract.ts b/packages/0x.js/src/contract_wrappers/generated/base_contract.ts index 9abba14cd..396a4d593 100644 --- a/packages/0x.js/src/contract_wrappers/generated/base_contract.ts +++ b/packages/0x.js/src/contract_wrappers/generated/base_contract.ts @@ -3,8 +3,6 @@ import * as Web3 from 'web3'; import {TxData, TxDataPayable} from '../../types'; -// TODO: Gas Margin -// TODO: Abi check export class BaseContract { protected web3ContractInstance: Web3.ContractInstance; protected defaults: Partial; -- cgit v1.2.3 From 1ce66b4a81b736f5288463be609a902af64cbe77 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 19:53:59 +0300 Subject: Rename abi-gen to typed-contracts --- packages/0x.js/package.json | 6 +++--- packages/0x.js/src/contract_wrappers/generated/ether_token.ts | 4 ++-- packages/0x.js/src/contract_wrappers/generated/exchange.ts | 4 ++-- packages/0x.js/src/contract_wrappers/generated/token.ts | 4 ++-- packages/0x.js/src/contract_wrappers/generated/token_registry.ts | 4 ++-- .../0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts | 4 ++-- 6 files changed, 13 insertions(+), 13 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/package.json b/packages/0x.js/package.json index b91f23ecb..b09aadd7e 100644 --- a/packages/0x.js/package.json +++ b/packages/0x.js/package.json @@ -16,7 +16,7 @@ "build": "run-p build:umd:prod build:commonjs; exit 0;", "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --json $JSON_FILE_PATH $PROJECT_DIR", "upload_docs_json": "aws s3 cp generated_docs/index.json $S3_URL --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type application/json", - "generate_contract_wrappers": "typed-contracts --abiGlob 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry).json' --templates ../typed-contracts-templates/ --output src/contract_wrappers/generated", + "generate_contract_wrappers": "abi-gen --abiGlob 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry).json' --templates ../abi-gen-templates/ --output src/contract_wrappers/generated", "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'", "test:circleci": "run-s test:coverage report_test_coverage && if [ $CIRCLE_BRANCH = \"development\" ]; then yarn test:umd; fi", "test": "run-s clean test:commonjs", @@ -46,8 +46,8 @@ }, "devDependencies": { "@0xproject/tslint-config": "^0.2.0", - "@0xproject/typed-contracts": "^0.0.0", - "@0xproject/typed-contracts-templates": "^0.0.0", + "abi-gen": "^0.0.0", + "abi-gen-templates": "^0.0.0", "@types/bintrees": "^1.0.2", "@types/jsonschema": "^1.1.1", "@types/lodash": "^4.14.64", diff --git a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts index aae6230c9..1e4230788 100644 --- a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts +++ b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts @@ -1,6 +1,6 @@ /** - * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. - * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; diff --git a/packages/0x.js/src/contract_wrappers/generated/exchange.ts b/packages/0x.js/src/contract_wrappers/generated/exchange.ts index 512cc80d7..e6bc74c65 100644 --- a/packages/0x.js/src/contract_wrappers/generated/exchange.ts +++ b/packages/0x.js/src/contract_wrappers/generated/exchange.ts @@ -1,6 +1,6 @@ /** - * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. - * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token.ts b/packages/0x.js/src/contract_wrappers/generated/token.ts index f8f578dd9..7762a29e5 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token.ts @@ -1,6 +1,6 @@ /** - * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. - * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts index 5638a92d6..ce03449d8 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts @@ -1,6 +1,6 @@ /** - * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. - * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts index 33e244d8d..41c9669e3 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts @@ -1,6 +1,6 @@ /** - * This file is auto-generated using @0xproject/typed-contracts. Don't edit directly. - * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/typed-contracts-templates. + * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; import * as Web3 from 'web3'; -- cgit v1.2.3 From 9891d7aaa6ce0148b87c49b534b0baa678b813d0 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 19:59:13 +0300 Subject: Make fileExtension configurable --- packages/0x.js/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/package.json b/packages/0x.js/package.json index b09aadd7e..341b12188 100644 --- a/packages/0x.js/package.json +++ b/packages/0x.js/package.json @@ -16,7 +16,7 @@ "build": "run-p build:umd:prod build:commonjs; exit 0;", "docs:json": "typedoc --excludePrivate --excludeExternals --target ES5 --json $JSON_FILE_PATH $PROJECT_DIR", "upload_docs_json": "aws s3 cp generated_docs/index.json $S3_URL --profile 0xproject --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers --content-type application/json", - "generate_contract_wrappers": "abi-gen --abiGlob 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry).json' --templates ../abi-gen-templates/ --output src/contract_wrappers/generated", + "generate_contract_wrappers": "abi-gen --abiGlob 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry).json' --templates ../abi-gen-templates/ --output src/contract_wrappers/generated --fileExtension ts", "lint": "tslint --project . 'src/**/*.ts' 'test/**/*.ts'", "test:circleci": "run-s test:coverage report_test_coverage && if [ $CIRCLE_BRANCH = \"development\" ]; then yarn test:umd; fi", "test": "run-s clean test:commonjs", -- cgit v1.2.3 From 293847053ac061137fdf286dfa51c6d95feb319d Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 20:34:39 +0300 Subject: Regenerate files --- packages/0x.js/src/contract_wrappers/generated/ether_token.ts | 2 +- packages/0x.js/src/contract_wrappers/generated/exchange.ts | 2 +- packages/0x.js/src/contract_wrappers/generated/token.ts | 2 +- packages/0x.js/src/contract_wrappers/generated/token_registry.ts | 2 +- packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts index 1e4230788..eed5e4686 100644 --- a/packages/0x.js/src/contract_wrappers/generated/ether_token.ts +++ b/packages/0x.js/src/contract_wrappers/generated/ether_token.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * This file is auto-generated using abi-gen. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; diff --git a/packages/0x.js/src/contract_wrappers/generated/exchange.ts b/packages/0x.js/src/contract_wrappers/generated/exchange.ts index e6bc74c65..8c25ca014 100644 --- a/packages/0x.js/src/contract_wrappers/generated/exchange.ts +++ b/packages/0x.js/src/contract_wrappers/generated/exchange.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * This file is auto-generated using abi-gen. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token.ts b/packages/0x.js/src/contract_wrappers/generated/token.ts index 7762a29e5..30b06292f 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * This file is auto-generated using abi-gen. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts index ce03449d8..6aacc4336 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token_registry.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token_registry.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * This file is auto-generated using abi-gen. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; diff --git a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts index 41c9669e3..50f1c8f25 100644 --- a/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts +++ b/packages/0x.js/src/contract_wrappers/generated/token_transfer_proxy.ts @@ -1,5 +1,5 @@ /** - * This file is auto-generated using @0xproject/abi-gen. Don't edit directly. + * This file is auto-generated using abi-gen. Don't edit directly. * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/abi-gen-templates. */ import {BigNumber} from 'bignumber.js'; -- cgit v1.2.3 From c64ec92fb23fd130d0c54a4d42147bb468e434d9 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 5 Dec 2017 22:02:27 +0300 Subject: Address feedback --- packages/0x.js/src/utils/class_utils.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'packages/0x.js') diff --git a/packages/0x.js/src/utils/class_utils.ts b/packages/0x.js/src/utils/class_utils.ts index b89d3ba32..04e60ee57 100644 --- a/packages/0x.js/src/utils/class_utils.ts +++ b/packages/0x.js/src/utils/class_utils.ts @@ -1,7 +1,7 @@ import * as _ from 'lodash'; export const classUtils = { - // This is usefull for classes that have nested methods. Nested methods don't get binded out of the box. + // This is useful for classes that have nested methods. Nested methods don't get bound out of the box. bindAll(self: any, exclude: string[] = ['contructor'], thisArg?: any): void { for (const key of Object.getOwnPropertyNames(self)) { const val = self[key]; -- cgit v1.2.3