From 897515c00207a11f7a45932d3c526a5eaf961635 Mon Sep 17 00:00:00 2001 From: Amir Bandeali Date: Mon, 5 Feb 2018 13:02:48 -0800 Subject: [PATCH 01/21] Add CLI option for networkId, add abi-gen to contracts package --- packages/abi-gen/CHANGELOG.md | 1 + packages/abi-gen/src/index.ts | 18 +- .../contract_templates/contract.handlebars | 25 + .../partials/call.handlebars | 15 + .../partials/params.handlebars | 3 + .../partials/return_type.handlebars | 6 + .../contract_templates/partials/tx.handlebars | 51 ++ .../partials/typed_params.handlebars | 3 + packages/contracts/package.json | 1 + .../{ => src}/artifacts/DummyToken.json | 0 .../{ => src}/artifacts/ERC20Token.json | 0 .../{ => src}/artifacts/ERC20Token_v1.json | 0 .../{ => src}/artifacts/Exchange.json | 0 .../{ => src}/artifacts/MaliciousToken.json | 0 .../{ => src}/artifacts/Mintable.json | 0 .../{ => src}/artifacts/MultiSigWallet.json | 0 .../artifacts/MultiSigWalletWithTimeLock.json | 0 ...TimeLockExceptRemoveAuthorizedAddress.json | 0 .../{ => src}/artifacts/Ownable.json | 0 .../{ => src}/artifacts/Ownable_v1.json | 0 .../{ => src}/artifacts/SafeMath.json | 0 .../{ => src}/artifacts/SafeMath_v1.json | 0 .../contracts/{ => src}/artifacts/Token.json | 0 .../{ => src}/artifacts/TokenRegistry.json | 0 .../artifacts/TokenTransferProxy.json | 0 .../{ => src}/artifacts/Token_v1.json | 0 .../artifacts/UnlimitedAllowanceToken.json | 0 .../artifacts/UnlimitedAllowanceToken_v1.json | 0 .../contracts/{ => src}/artifacts/WETH9.json | 0 .../{ => src}/artifacts/ZRXToken.json | 0 .../generated/dummy_token.ts | 434 +++++++++++ .../contract_wrappers/generated/exchange.ts | 728 ++++++++++++++++++ .../src/contract_wrappers/generated/token.ts | 215 ++++++ .../generated/token_registry.ts | 548 +++++++++++++ .../generated/token_transfer_proxy.ts | 283 +++++++ .../MultiSigWallet/MultiSigWallet.sol | 0 .../MultiSigWalletWithTimeLock.sol | 0 ...hTimeLockExceptRemoveAuthorizedAddress.sol | 0 .../current/protocol/Exchange/Exchange.sol | 0 .../protocol/TokenRegistry/TokenRegistry.sol | 0 .../TokenTransferProxy/TokenTransferProxy.sol | 0 .../current/test/DummyToken/DummyToken.sol | 0 .../test/MaliciousToken/MaliciousToken.sol | 0 .../current/test/Mintable/Mintable.sol | 0 .../current/tokens/ERC20Token/ERC20Token.sol | 0 .../current/tokens/Token/Token.sol | 0 .../UnlimitedAllowanceToken.sol | 0 .../current/tokens/WETH9/WETH9.sol | 0 .../current/tokens/ZRXToken/ZRXToken.sol | 0 .../current/utils/Ownable/Ownable.sol | 0 .../current/utils/SafeMath/SafeMath.sol | 0 .../previous/ERC20Token/ERC20Token_v1.sol | 0 .../previous/Ownable/Ownable_v1.sol | 0 .../previous/SafeMath/SafeMath_v1.sol | 0 .../previous/Token/Token_v1.sol | 0 .../UnlimitedAllowanceToken_v1.sol | 0 56 files changed, 2328 insertions(+), 3 deletions(-) create mode 100644 packages/contracts/contract_templates/contract.handlebars create mode 100644 packages/contracts/contract_templates/partials/call.handlebars create mode 100644 packages/contracts/contract_templates/partials/params.handlebars create mode 100644 packages/contracts/contract_templates/partials/return_type.handlebars create mode 100644 packages/contracts/contract_templates/partials/tx.handlebars create mode 100644 packages/contracts/contract_templates/partials/typed_params.handlebars rename packages/contracts/{ => src}/artifacts/DummyToken.json (100%) rename packages/contracts/{ => src}/artifacts/ERC20Token.json (100%) rename packages/contracts/{ => src}/artifacts/ERC20Token_v1.json (100%) rename packages/contracts/{ => src}/artifacts/Exchange.json (100%) rename packages/contracts/{ => src}/artifacts/MaliciousToken.json (100%) rename packages/contracts/{ => src}/artifacts/Mintable.json (100%) rename packages/contracts/{ => src}/artifacts/MultiSigWallet.json (100%) rename packages/contracts/{ => src}/artifacts/MultiSigWalletWithTimeLock.json (100%) rename packages/contracts/{ => src}/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json (100%) rename packages/contracts/{ => src}/artifacts/Ownable.json (100%) rename packages/contracts/{ => src}/artifacts/Ownable_v1.json (100%) rename packages/contracts/{ => src}/artifacts/SafeMath.json (100%) rename packages/contracts/{ => src}/artifacts/SafeMath_v1.json (100%) rename packages/contracts/{ => src}/artifacts/Token.json (100%) rename packages/contracts/{ => src}/artifacts/TokenRegistry.json (100%) rename packages/contracts/{ => src}/artifacts/TokenTransferProxy.json (100%) rename packages/contracts/{ => src}/artifacts/Token_v1.json (100%) rename packages/contracts/{ => src}/artifacts/UnlimitedAllowanceToken.json (100%) rename packages/contracts/{ => src}/artifacts/UnlimitedAllowanceToken_v1.json (100%) rename packages/contracts/{ => src}/artifacts/WETH9.json (100%) rename packages/contracts/{ => src}/artifacts/ZRXToken.json (100%) create mode 100644 packages/contracts/src/contract_wrappers/generated/dummy_token.ts create mode 100644 packages/contracts/src/contract_wrappers/generated/exchange.ts create mode 100644 packages/contracts/src/contract_wrappers/generated/token.ts create mode 100644 packages/contracts/src/contract_wrappers/generated/token_registry.ts create mode 100644 packages/contracts/src/contract_wrappers/generated/token_transfer_proxy.ts rename packages/contracts/src/{ => contracts}/current/multisig/MultiSigWallet/MultiSigWallet.sol (100%) rename packages/contracts/src/{ => contracts}/current/multisig/MultiSigWalletWithTimeLock/MultiSigWalletWithTimeLock.sol (100%) rename packages/contracts/src/{ => contracts}/current/multisig/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.sol (100%) rename packages/contracts/src/{ => contracts}/current/protocol/Exchange/Exchange.sol (100%) rename packages/contracts/src/{ => contracts}/current/protocol/TokenRegistry/TokenRegistry.sol (100%) rename packages/contracts/src/{ => contracts}/current/protocol/TokenTransferProxy/TokenTransferProxy.sol (100%) rename packages/contracts/src/{ => contracts}/current/test/DummyToken/DummyToken.sol (100%) rename packages/contracts/src/{ => contracts}/current/test/MaliciousToken/MaliciousToken.sol (100%) rename packages/contracts/src/{ => contracts}/current/test/Mintable/Mintable.sol (100%) rename packages/contracts/src/{ => contracts}/current/tokens/ERC20Token/ERC20Token.sol (100%) rename packages/contracts/src/{ => contracts}/current/tokens/Token/Token.sol (100%) rename packages/contracts/src/{ => contracts}/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol (100%) rename packages/contracts/src/{ => contracts}/current/tokens/WETH9/WETH9.sol (100%) rename packages/contracts/src/{ => contracts}/current/tokens/ZRXToken/ZRXToken.sol (100%) rename packages/contracts/src/{ => contracts}/current/utils/Ownable/Ownable.sol (100%) rename packages/contracts/src/{ => contracts}/current/utils/SafeMath/SafeMath.sol (100%) rename packages/contracts/src/{ => contracts}/previous/ERC20Token/ERC20Token_v1.sol (100%) rename packages/contracts/src/{ => contracts}/previous/Ownable/Ownable_v1.sol (100%) rename packages/contracts/src/{ => contracts}/previous/SafeMath/SafeMath_v1.sol (100%) rename packages/contracts/src/{ => contracts}/previous/Token/Token_v1.sol (100%) rename packages/contracts/src/{ => contracts}/previous/UnlimitedAllowanceToken/UnlimitedAllowanceToken_v1.sol (100%) diff --git a/packages/abi-gen/CHANGELOG.md b/packages/abi-gen/CHANGELOG.md index ffa8a7a350..570c76bdd1 100644 --- a/packages/abi-gen/CHANGELOG.md +++ b/packages/abi-gen/CHANGELOG.md @@ -3,6 +3,7 @@ ## v0.2.0 - _???_ * Added CLI options for explicit specifying location of partials and main template (#346) +* Added CLI option to specify networkId, adding support for the JSON artifact format found in @0xproject/contracts ## v0.1.0 - _January 11, 2018_ diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts index fe2b56524f..85cc67daf6 100644 --- a/packages/abi-gen/src/index.ts +++ b/packages/abi-gen/src/index.ts @@ -17,6 +17,7 @@ import { utils } from './utils'; const ABI_TYPE_CONSTRUCTOR = 'constructor'; const ABI_TYPE_METHOD = 'function'; const ABI_TYPE_EVENT = 'event'; +const DEFAULT_NETWORK_ID = 50; const args = yargs .option('abis', { @@ -42,6 +43,12 @@ const args = yargs demandOption: true, normalize: true, }) + .option('network-id', { + describe: 'ID of the network where contract ABIs are nested in artifacts', + type: 'number', + default: DEFAULT_NETWORK_ID, + + }) .example( "$0 --abis 'src/artifacts/**/*.json' --out 'src/contracts/generated/' --partials 'src/templates/partials/**/*.handlebars' --template 'src/templates/contract.handlebars'", 'Full usage example', @@ -87,9 +94,14 @@ for (const abiFileName of abiFileNames) { const namedContent = utils.getNamedContent(abiFileName); utils.log(`Processing: ${chalk.bold(namedContent.name)}...`); const parsedContent = JSON.parse(namedContent.content); - const ABI = _.isArray(parsedContent) - ? parsedContent // ABI file - : parsedContent.abi; // Truffle contracts file + let ABI; + if (_.isArray(parsedContent)) { + ABI = parsedContent; // ABI file + } else if (!_.isUndefined(parsedContent.abi)) { + ABI = parsedContent.abi; // Truffle artifact + } else if (!_.isUndefined(parsedContent.networks) && !_.isUndefined(parsedContent.networks[args.networkId])) { + ABI = parsedContent.networks[args.networkId]; // 0x contracts package artifact + } if (_.isUndefined(ABI)) { utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`); utils.log(`Please make sure your ABI file is either an array with ABI entries or an object with the abi key`); diff --git a/packages/contracts/contract_templates/contract.handlebars b/packages/contracts/contract_templates/contract.handlebars new file mode 100644 index 0000000000..d3fe1b8cc4 --- /dev/null +++ b/packages/contracts/contract_templates/contract.handlebars @@ -0,0 +1,25 @@ +/** + * 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. + */ +// tslint:disable-next-line:no-unused-variable +import { TxData, TxDataPayable } from '@0xproject/types'; +import { BigNumber, classUtils, promisify } from '@0xproject/utils'; +import * as Web3 from 'web3'; + +import {BaseContract} from './base_contract'; + +export class {{contractName}}Contract extends BaseContract { +{{#each methods}} + {{#this.constant}} + {{> call contractName=../contractName}} + {{/this.constant}} + {{^this.constant}} + {{> tx contractName=../contractName}} + {{/this.constant}} +{{/each}} + constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { + super(web3ContractInstance, defaults); + classUtils.bindAll(this, ['_web3ContractInstance', '_defaults']); + } +} // tslint:disable:max-file-line-count diff --git a/packages/contracts/contract_templates/partials/call.handlebars b/packages/contracts/contract_templates/partials/call.handlebars new file mode 100644 index 0000000000..0475136f0c --- /dev/null +++ b/packages/contracts/contract_templates/partials/call.handlebars @@ -0,0 +1,15 @@ +public {{this.name}} = { + async callAsync( + {{> typed_params inputs=inputs}} + defaultBlock?: Web3.BlockParam, + ): Promise<{{> return_type outputs=outputs}}> { + const self = this as {{contractName}}Contract; + const result = await promisify<{{> return_type outputs=outputs}}>( + self._web3ContractInstance.{{this.name}}.call, + self._web3ContractInstance, + )( + {{> params inputs=inputs}} + ); + return result; + }, +}; diff --git a/packages/contracts/contract_templates/partials/params.handlebars b/packages/contracts/contract_templates/partials/params.handlebars new file mode 100644 index 0000000000..ac5d4ae85e --- /dev/null +++ b/packages/contracts/contract_templates/partials/params.handlebars @@ -0,0 +1,3 @@ +{{#each inputs}} +{{name}}, +{{/each}} diff --git a/packages/contracts/contract_templates/partials/return_type.handlebars b/packages/contracts/contract_templates/partials/return_type.handlebars new file mode 100644 index 0000000000..383961a40f --- /dev/null +++ b/packages/contracts/contract_templates/partials/return_type.handlebars @@ -0,0 +1,6 @@ +{{#singleReturnValue}} +{{#returnType outputs.0.type}}{{/returnType}} +{{/singleReturnValue}} +{{^singleReturnValue}} +[{{#each outputs}}{{#returnType type}}{{/returnType}}{{#unless @last}}, {{/unless}}{{/each}}] +{{/singleReturnValue}} diff --git a/packages/contracts/contract_templates/partials/tx.handlebars b/packages/contracts/contract_templates/partials/tx.handlebars new file mode 100644 index 0000000000..9df83266a0 --- /dev/null +++ b/packages/contracts/contract_templates/partials/tx.handlebars @@ -0,0 +1,51 @@ +public {{this.name}} = { + async sendTransactionAsync( + {{> typed_params inputs=inputs}} + {{#this.payable}} + txData: TxDataPayable = {}, + {{/this.payable}} + {{^this.payable}} + txData: TxData = {}, + {{/this.payable}} + ): Promise { + const self = this as {{contractName}}Contract; + const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( + txData, + self.{{this.name}}.estimateGasAsync.bind( + self, + {{> params inputs=inputs}} + ), + ); + const txHash = await promisify( + self._web3ContractInstance.{{this.name}}, self._web3ContractInstance, + )( + {{> params inputs=inputs}} + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + {{> typed_params inputs=inputs}} + txData: TxData = {}, + ): Promise { + const self = this as {{contractName}}Contract; + const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self._web3ContractInstance.{{this.name}}.estimateGas, self._web3ContractInstance, + )( + {{> params inputs=inputs}} + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + {{> typed_params inputs=inputs}} + txData: TxData = {}, + ): string { + const self = this as {{contractName}}Contract; + const abiEncodedTransactionData = self._web3ContractInstance.{{this.name}}.getData(); + return abiEncodedTransactionData; + }, +}; diff --git a/packages/contracts/contract_templates/partials/typed_params.handlebars b/packages/contracts/contract_templates/partials/typed_params.handlebars new file mode 100644 index 0000000000..3ea4b2e955 --- /dev/null +++ b/packages/contracts/contract_templates/partials/typed_params.handlebars @@ -0,0 +1,3 @@ +{{#each inputs}} + {{name}}: {{#parameterType type}}{{/parameterType}}, +{{/each}} diff --git a/packages/contracts/package.json b/packages/contracts/package.json index b4074193dd..712b220ec2 100644 --- a/packages/contracts/package.json +++ b/packages/contracts/package.json @@ -17,6 +17,7 @@ "compile:comment": "Yarn workspaces do not link binaries correctly so we need to reference them directly https://github.com/yarnpkg/yarn/issues/3846", "compile": "node ../deployer/lib/src/cli.js compile", "clean": "rm -rf ./lib", + "generate_contract_wrappers": "node ../abi-gen/lib/index.js --abis 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry|DummyToken).json' --template contract_templates/contract.handlebars --partials 'contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated", "migrate": "node ../deployer/lib/src/cli.js migrate", "lint": "tslint --project . 'migrations/**/*.ts' 'test/**/*.ts' 'util/**/*.ts' 'deploy/**/*.ts'", "test:circleci": "yarn test" diff --git a/packages/contracts/artifacts/DummyToken.json b/packages/contracts/src/artifacts/DummyToken.json similarity index 100% rename from packages/contracts/artifacts/DummyToken.json rename to packages/contracts/src/artifacts/DummyToken.json diff --git a/packages/contracts/artifacts/ERC20Token.json b/packages/contracts/src/artifacts/ERC20Token.json similarity index 100% rename from packages/contracts/artifacts/ERC20Token.json rename to packages/contracts/src/artifacts/ERC20Token.json diff --git a/packages/contracts/artifacts/ERC20Token_v1.json b/packages/contracts/src/artifacts/ERC20Token_v1.json similarity index 100% rename from packages/contracts/artifacts/ERC20Token_v1.json rename to packages/contracts/src/artifacts/ERC20Token_v1.json diff --git a/packages/contracts/artifacts/Exchange.json b/packages/contracts/src/artifacts/Exchange.json similarity index 100% rename from packages/contracts/artifacts/Exchange.json rename to packages/contracts/src/artifacts/Exchange.json diff --git a/packages/contracts/artifacts/MaliciousToken.json b/packages/contracts/src/artifacts/MaliciousToken.json similarity index 100% rename from packages/contracts/artifacts/MaliciousToken.json rename to packages/contracts/src/artifacts/MaliciousToken.json diff --git a/packages/contracts/artifacts/Mintable.json b/packages/contracts/src/artifacts/Mintable.json similarity index 100% rename from packages/contracts/artifacts/Mintable.json rename to packages/contracts/src/artifacts/Mintable.json diff --git a/packages/contracts/artifacts/MultiSigWallet.json b/packages/contracts/src/artifacts/MultiSigWallet.json similarity index 100% rename from packages/contracts/artifacts/MultiSigWallet.json rename to packages/contracts/src/artifacts/MultiSigWallet.json diff --git a/packages/contracts/artifacts/MultiSigWalletWithTimeLock.json b/packages/contracts/src/artifacts/MultiSigWalletWithTimeLock.json similarity index 100% rename from packages/contracts/artifacts/MultiSigWalletWithTimeLock.json rename to packages/contracts/src/artifacts/MultiSigWalletWithTimeLock.json diff --git a/packages/contracts/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json b/packages/contracts/src/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json similarity index 100% rename from packages/contracts/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json rename to packages/contracts/src/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json diff --git a/packages/contracts/artifacts/Ownable.json b/packages/contracts/src/artifacts/Ownable.json similarity index 100% rename from packages/contracts/artifacts/Ownable.json rename to packages/contracts/src/artifacts/Ownable.json diff --git a/packages/contracts/artifacts/Ownable_v1.json b/packages/contracts/src/artifacts/Ownable_v1.json similarity index 100% rename from packages/contracts/artifacts/Ownable_v1.json rename to packages/contracts/src/artifacts/Ownable_v1.json diff --git a/packages/contracts/artifacts/SafeMath.json b/packages/contracts/src/artifacts/SafeMath.json similarity index 100% rename from packages/contracts/artifacts/SafeMath.json rename to packages/contracts/src/artifacts/SafeMath.json diff --git a/packages/contracts/artifacts/SafeMath_v1.json b/packages/contracts/src/artifacts/SafeMath_v1.json similarity index 100% rename from packages/contracts/artifacts/SafeMath_v1.json rename to packages/contracts/src/artifacts/SafeMath_v1.json diff --git a/packages/contracts/artifacts/Token.json b/packages/contracts/src/artifacts/Token.json similarity index 100% rename from packages/contracts/artifacts/Token.json rename to packages/contracts/src/artifacts/Token.json diff --git a/packages/contracts/artifacts/TokenRegistry.json b/packages/contracts/src/artifacts/TokenRegistry.json similarity index 100% rename from packages/contracts/artifacts/TokenRegistry.json rename to packages/contracts/src/artifacts/TokenRegistry.json diff --git a/packages/contracts/artifacts/TokenTransferProxy.json b/packages/contracts/src/artifacts/TokenTransferProxy.json similarity index 100% rename from packages/contracts/artifacts/TokenTransferProxy.json rename to packages/contracts/src/artifacts/TokenTransferProxy.json diff --git a/packages/contracts/artifacts/Token_v1.json b/packages/contracts/src/artifacts/Token_v1.json similarity index 100% rename from packages/contracts/artifacts/Token_v1.json rename to packages/contracts/src/artifacts/Token_v1.json diff --git a/packages/contracts/artifacts/UnlimitedAllowanceToken.json b/packages/contracts/src/artifacts/UnlimitedAllowanceToken.json similarity index 100% rename from packages/contracts/artifacts/UnlimitedAllowanceToken.json rename to packages/contracts/src/artifacts/UnlimitedAllowanceToken.json diff --git a/packages/contracts/artifacts/UnlimitedAllowanceToken_v1.json b/packages/contracts/src/artifacts/UnlimitedAllowanceToken_v1.json similarity index 100% rename from packages/contracts/artifacts/UnlimitedAllowanceToken_v1.json rename to packages/contracts/src/artifacts/UnlimitedAllowanceToken_v1.json diff --git a/packages/contracts/artifacts/WETH9.json b/packages/contracts/src/artifacts/WETH9.json similarity index 100% rename from packages/contracts/artifacts/WETH9.json rename to packages/contracts/src/artifacts/WETH9.json diff --git a/packages/contracts/artifacts/ZRXToken.json b/packages/contracts/src/artifacts/ZRXToken.json similarity index 100% rename from packages/contracts/artifacts/ZRXToken.json rename to packages/contracts/src/artifacts/ZRXToken.json diff --git a/packages/contracts/src/contract_wrappers/generated/dummy_token.ts b/packages/contracts/src/contract_wrappers/generated/dummy_token.ts new file mode 100644 index 0000000000..788cbfe3f0 --- /dev/null +++ b/packages/contracts/src/contract_wrappers/generated/dummy_token.ts @@ -0,0 +1,434 @@ +/** + * 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. + */ +// tslint:disable-next-line:no-unused-variable +import { TxData, TxDataPayable } from '@0xproject/types'; +import { BigNumber, classUtils, promisify } from '@0xproject/utils'; +import * as Web3 from 'web3'; + +import {BaseContract} from './base_contract'; + +export class DummyTokenContract extends BaseContract { + public name = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as DummyTokenContract; + 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 DummyTokenContract; + 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 DummyTokenContract; + 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 DummyTokenContract; + const abiEncodedTransactionData = self._web3ContractInstance.approve.getData(); + return abiEncodedTransactionData; + }, + }; + public totalSupply = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as DummyTokenContract; + 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 DummyTokenContract; + 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 DummyTokenContract; + 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 DummyTokenContract; + const abiEncodedTransactionData = self._web3ContractInstance.transferFrom.getData(); + return abiEncodedTransactionData; + }, + }; + public decimals = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as DummyTokenContract; + 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 DummyTokenContract; + const result = await promisify( + self._web3ContractInstance.balanceOf.call, + self._web3ContractInstance, + )( + _owner, + ); + return result; + }, + }; + public owner = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as DummyTokenContract; + const result = await promisify( + self._web3ContractInstance.owner.call, + self._web3ContractInstance, + )( + ); + return result; + }, + }; + public symbol = { + async callAsync( + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as DummyTokenContract; + const result = await promisify( + self._web3ContractInstance.symbol.call, + self._web3ContractInstance, + )( + ); + return result; + }, + }; + public mint = { + async sendTransactionAsync( + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as DummyTokenContract; + const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( + txData, + self.mint.estimateGasAsync.bind( + self, + _value, + ), + ); + const txHash = await promisify( + self._web3ContractInstance.mint, self._web3ContractInstance, + )( + _value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as DummyTokenContract; + const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self._web3ContractInstance.mint.estimateGas, self._web3ContractInstance, + )( + _value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as DummyTokenContract; + const abiEncodedTransactionData = self._web3ContractInstance.mint.getData(); + return abiEncodedTransactionData; + }, + }; + public transfer = { + async sendTransactionAsync( + _to: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as DummyTokenContract; + 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 DummyTokenContract; + 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 DummyTokenContract; + const abiEncodedTransactionData = self._web3ContractInstance.transfer.getData(); + return abiEncodedTransactionData; + }, + }; + public allowance = { + async callAsync( + _owner: string, + _spender: string, + defaultBlock?: Web3.BlockParam, + ): Promise { + const self = this as DummyTokenContract; + const result = await promisify( + self._web3ContractInstance.allowance.call, + self._web3ContractInstance, + )( + _owner, + _spender, + ); + return result; + }, + }; + public setBalance = { + async sendTransactionAsync( + _target: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as DummyTokenContract; + const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( + txData, + self.setBalance.estimateGasAsync.bind( + self, + _target, + _value, + ), + ); + const txHash = await promisify( + self._web3ContractInstance.setBalance, self._web3ContractInstance, + )( + _target, + _value, + txDataWithDefaults, + ); + return txHash; + }, + async estimateGasAsync( + _target: string, + _value: BigNumber, + txData: TxData = {}, + ): Promise { + const self = this as DummyTokenContract; + const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( + txData, + ); + const gas = await promisify( + self._web3ContractInstance.setBalance.estimateGas, self._web3ContractInstance, + )( + _target, + _value, + txDataWithDefaults, + ); + return gas; + }, + getABIEncodedTransactionData( + _target: string, + _value: BigNumber, + txData: TxData = {}, + ): string { + const self = this as DummyTokenContract; + const abiEncodedTransactionData = self._web3ContractInstance.setBalance.getData(); + return abiEncodedTransactionData; + }, + }; + public transferOwnership = { + async sendTransactionAsync( + newOwner: string, + txData: TxData = {}, + ): Promise { + const self = this as DummyTokenContract; + 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 DummyTokenContract; + 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 DummyTokenContract; + 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/contracts/src/contract_wrappers/generated/exchange.ts b/packages/contracts/src/contract_wrappers/generated/exchange.ts new file mode 100644 index 0000000000..c328ec7251 --- /dev/null +++ b/packages/contracts/src/contract_wrappers/generated/exchange.ts @@ -0,0 +1,728 @@ +/** + * 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. + */ +// tslint:disable-next-line:no-unused-variable +import { TxData, TxDataPayable } from '@0xproject/types'; +import { BigNumber, classUtils, promisify } from '@0xproject/utils'; +import * as Web3 from 'web3'; + +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: Array, + 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: Array, + 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: Array, + 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: Array, + 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: Array, + 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: Array, + 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: Array, + 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: Array, + 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: Array, + 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/contracts/src/contract_wrappers/generated/token.ts b/packages/contracts/src/contract_wrappers/generated/token.ts new file mode 100644 index 0000000000..5ad96da1e2 --- /dev/null +++ b/packages/contracts/src/contract_wrappers/generated/token.ts @@ -0,0 +1,215 @@ +/** + * 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. + */ +// tslint:disable-next-line:no-unused-variable +import { TxData, TxDataPayable } from '@0xproject/types'; +import { BigNumber, classUtils, promisify } from '@0xproject/utils'; +import * as Web3 from 'web3'; + +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 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/contracts/src/contract_wrappers/generated/token_registry.ts b/packages/contracts/src/contract_wrappers/generated/token_registry.ts new file mode 100644 index 0000000000..635f9f214f --- /dev/null +++ b/packages/contracts/src/contract_wrappers/generated/token_registry.ts @@ -0,0 +1,548 @@ +/** + * 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. + */ +// tslint:disable-next-line:no-unused-variable +import { TxData, TxDataPayable } from '@0xproject/types'; +import { BigNumber, classUtils, promisify } from '@0xproject/utils'; +import * as Web3 from 'web3'; + +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/contracts/src/contract_wrappers/generated/token_transfer_proxy.ts b/packages/contracts/src/contract_wrappers/generated/token_transfer_proxy.ts new file mode 100644 index 0000000000..a5a40d47f4 --- /dev/null +++ b/packages/contracts/src/contract_wrappers/generated/token_transfer_proxy.ts @@ -0,0 +1,283 @@ +/** + * 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. + */ +// tslint:disable-next-line:no-unused-variable +import { TxData, TxDataPayable } from '@0xproject/types'; +import { BigNumber, classUtils, promisify } from '@0xproject/utils'; +import * as Web3 from 'web3'; + +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 diff --git a/packages/contracts/src/current/multisig/MultiSigWallet/MultiSigWallet.sol b/packages/contracts/src/contracts/current/multisig/MultiSigWallet/MultiSigWallet.sol similarity index 100% rename from packages/contracts/src/current/multisig/MultiSigWallet/MultiSigWallet.sol rename to packages/contracts/src/contracts/current/multisig/MultiSigWallet/MultiSigWallet.sol diff --git a/packages/contracts/src/current/multisig/MultiSigWalletWithTimeLock/MultiSigWalletWithTimeLock.sol b/packages/contracts/src/contracts/current/multisig/MultiSigWalletWithTimeLock/MultiSigWalletWithTimeLock.sol similarity index 100% rename from packages/contracts/src/current/multisig/MultiSigWalletWithTimeLock/MultiSigWalletWithTimeLock.sol rename to packages/contracts/src/contracts/current/multisig/MultiSigWalletWithTimeLock/MultiSigWalletWithTimeLock.sol diff --git a/packages/contracts/src/current/multisig/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.sol b/packages/contracts/src/contracts/current/multisig/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.sol similarity index 100% rename from packages/contracts/src/current/multisig/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.sol rename to packages/contracts/src/contracts/current/multisig/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.sol diff --git a/packages/contracts/src/current/protocol/Exchange/Exchange.sol b/packages/contracts/src/contracts/current/protocol/Exchange/Exchange.sol similarity index 100% rename from packages/contracts/src/current/protocol/Exchange/Exchange.sol rename to packages/contracts/src/contracts/current/protocol/Exchange/Exchange.sol diff --git a/packages/contracts/src/current/protocol/TokenRegistry/TokenRegistry.sol b/packages/contracts/src/contracts/current/protocol/TokenRegistry/TokenRegistry.sol similarity index 100% rename from packages/contracts/src/current/protocol/TokenRegistry/TokenRegistry.sol rename to packages/contracts/src/contracts/current/protocol/TokenRegistry/TokenRegistry.sol diff --git a/packages/contracts/src/current/protocol/TokenTransferProxy/TokenTransferProxy.sol b/packages/contracts/src/contracts/current/protocol/TokenTransferProxy/TokenTransferProxy.sol similarity index 100% rename from packages/contracts/src/current/protocol/TokenTransferProxy/TokenTransferProxy.sol rename to packages/contracts/src/contracts/current/protocol/TokenTransferProxy/TokenTransferProxy.sol diff --git a/packages/contracts/src/current/test/DummyToken/DummyToken.sol b/packages/contracts/src/contracts/current/test/DummyToken/DummyToken.sol similarity index 100% rename from packages/contracts/src/current/test/DummyToken/DummyToken.sol rename to packages/contracts/src/contracts/current/test/DummyToken/DummyToken.sol diff --git a/packages/contracts/src/current/test/MaliciousToken/MaliciousToken.sol b/packages/contracts/src/contracts/current/test/MaliciousToken/MaliciousToken.sol similarity index 100% rename from packages/contracts/src/current/test/MaliciousToken/MaliciousToken.sol rename to packages/contracts/src/contracts/current/test/MaliciousToken/MaliciousToken.sol diff --git a/packages/contracts/src/current/test/Mintable/Mintable.sol b/packages/contracts/src/contracts/current/test/Mintable/Mintable.sol similarity index 100% rename from packages/contracts/src/current/test/Mintable/Mintable.sol rename to packages/contracts/src/contracts/current/test/Mintable/Mintable.sol diff --git a/packages/contracts/src/current/tokens/ERC20Token/ERC20Token.sol b/packages/contracts/src/contracts/current/tokens/ERC20Token/ERC20Token.sol similarity index 100% rename from packages/contracts/src/current/tokens/ERC20Token/ERC20Token.sol rename to packages/contracts/src/contracts/current/tokens/ERC20Token/ERC20Token.sol diff --git a/packages/contracts/src/current/tokens/Token/Token.sol b/packages/contracts/src/contracts/current/tokens/Token/Token.sol similarity index 100% rename from packages/contracts/src/current/tokens/Token/Token.sol rename to packages/contracts/src/contracts/current/tokens/Token/Token.sol diff --git a/packages/contracts/src/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol b/packages/contracts/src/contracts/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol similarity index 100% rename from packages/contracts/src/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol rename to packages/contracts/src/contracts/current/tokens/UnlimitedAllowanceToken/UnlimitedAllowanceToken.sol diff --git a/packages/contracts/src/current/tokens/WETH9/WETH9.sol b/packages/contracts/src/contracts/current/tokens/WETH9/WETH9.sol similarity index 100% rename from packages/contracts/src/current/tokens/WETH9/WETH9.sol rename to packages/contracts/src/contracts/current/tokens/WETH9/WETH9.sol diff --git a/packages/contracts/src/current/tokens/ZRXToken/ZRXToken.sol b/packages/contracts/src/contracts/current/tokens/ZRXToken/ZRXToken.sol similarity index 100% rename from packages/contracts/src/current/tokens/ZRXToken/ZRXToken.sol rename to packages/contracts/src/contracts/current/tokens/ZRXToken/ZRXToken.sol diff --git a/packages/contracts/src/current/utils/Ownable/Ownable.sol b/packages/contracts/src/contracts/current/utils/Ownable/Ownable.sol similarity index 100% rename from packages/contracts/src/current/utils/Ownable/Ownable.sol rename to packages/contracts/src/contracts/current/utils/Ownable/Ownable.sol diff --git a/packages/contracts/src/current/utils/SafeMath/SafeMath.sol b/packages/contracts/src/contracts/current/utils/SafeMath/SafeMath.sol similarity index 100% rename from packages/contracts/src/current/utils/SafeMath/SafeMath.sol rename to packages/contracts/src/contracts/current/utils/SafeMath/SafeMath.sol diff --git a/packages/contracts/src/previous/ERC20Token/ERC20Token_v1.sol b/packages/contracts/src/contracts/previous/ERC20Token/ERC20Token_v1.sol similarity index 100% rename from packages/contracts/src/previous/ERC20Token/ERC20Token_v1.sol rename to packages/contracts/src/contracts/previous/ERC20Token/ERC20Token_v1.sol diff --git a/packages/contracts/src/previous/Ownable/Ownable_v1.sol b/packages/contracts/src/contracts/previous/Ownable/Ownable_v1.sol similarity index 100% rename from packages/contracts/src/previous/Ownable/Ownable_v1.sol rename to packages/contracts/src/contracts/previous/Ownable/Ownable_v1.sol diff --git a/packages/contracts/src/previous/SafeMath/SafeMath_v1.sol b/packages/contracts/src/contracts/previous/SafeMath/SafeMath_v1.sol similarity index 100% rename from packages/contracts/src/previous/SafeMath/SafeMath_v1.sol rename to packages/contracts/src/contracts/previous/SafeMath/SafeMath_v1.sol diff --git a/packages/contracts/src/previous/Token/Token_v1.sol b/packages/contracts/src/contracts/previous/Token/Token_v1.sol similarity index 100% rename from packages/contracts/src/previous/Token/Token_v1.sol rename to packages/contracts/src/contracts/previous/Token/Token_v1.sol diff --git a/packages/contracts/src/previous/UnlimitedAllowanceToken/UnlimitedAllowanceToken_v1.sol b/packages/contracts/src/contracts/previous/UnlimitedAllowanceToken/UnlimitedAllowanceToken_v1.sol similarity index 100% rename from packages/contracts/src/previous/UnlimitedAllowanceToken/UnlimitedAllowanceToken_v1.sol rename to packages/contracts/src/contracts/previous/UnlimitedAllowanceToken/UnlimitedAllowanceToken_v1.sol From 6cda67df101feab64abf43eeb4c6263ed103528c Mon Sep 17 00:00:00 2001 From: Amir Bandeali Date: Mon, 5 Feb 2018 15:37:02 -0800 Subject: [PATCH 02/21] Update compile command and run prettier --- packages/abi-gen/src/index.ts | 7 +++---- packages/contracts/package.json | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts index 85cc67daf6..b6aaa03ca4 100644 --- a/packages/abi-gen/src/index.ts +++ b/packages/abi-gen/src/index.ts @@ -47,7 +47,6 @@ const args = yargs describe: 'ID of the network where contract ABIs are nested in artifacts', type: 'number', default: DEFAULT_NETWORK_ID, - }) .example( "$0 --abis 'src/artifacts/**/*.json' --out 'src/contracts/generated/' --partials 'src/templates/partials/**/*.handlebars' --template 'src/templates/contract.handlebars'", @@ -96,11 +95,11 @@ for (const abiFileName of abiFileNames) { const parsedContent = JSON.parse(namedContent.content); let ABI; if (_.isArray(parsedContent)) { - ABI = parsedContent; // ABI file + ABI = parsedContent; // ABI file } else if (!_.isUndefined(parsedContent.abi)) { - ABI = parsedContent.abi; // Truffle artifact + ABI = parsedContent.abi; // Truffle artifact } else if (!_.isUndefined(parsedContent.networks) && !_.isUndefined(parsedContent.networks[args.networkId])) { - ABI = parsedContent.networks[args.networkId]; // 0x contracts package artifact + ABI = parsedContent.networks[args.networkId]; // 0x contracts package artifact } if (_.isUndefined(ABI)) { utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`); diff --git a/packages/contracts/package.json b/packages/contracts/package.json index 712b220ec2..4bdbf3f412 100644 --- a/packages/contracts/package.json +++ b/packages/contracts/package.json @@ -15,7 +15,7 @@ "test": "run-s compile build run_mocha", "run_mocha": "mocha 'lib/test/**/*.js' --timeout 10000 --bail --exit", "compile:comment": "Yarn workspaces do not link binaries correctly so we need to reference them directly https://github.com/yarnpkg/yarn/issues/3846", - "compile": "node ../deployer/lib/src/cli.js compile", + "compile": "node ../deployer/lib/src/cli.js compile --contracts-dir src/contracts --artifacts-dir src/artifacts", "clean": "rm -rf ./lib", "generate_contract_wrappers": "node ../abi-gen/lib/index.js --abis 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry|DummyToken).json' --template contract_templates/contract.handlebars --partials 'contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated", "migrate": "node ../deployer/lib/src/cli.js migrate", From 218876ac196a1b1bf7eba096a7bc6a2b3b8556bf Mon Sep 17 00:00:00 2001 From: Amir Bandeali Date: Mon, 5 Feb 2018 16:25:52 -0800 Subject: [PATCH 03/21] Fix artifacts path --- packages/abi-gen/src/index.ts | 2 +- packages/contracts/package.json | 2 +- packages/contracts/test/utils/deployer.ts | 2 +- packages/contracts/util/artifacts.ts | 20 ++++++++++---------- 4 files changed, 13 insertions(+), 13 deletions(-) diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts index b6aaa03ca4..6b5119ca4a 100644 --- a/packages/abi-gen/src/index.ts +++ b/packages/abi-gen/src/index.ts @@ -99,7 +99,7 @@ for (const abiFileName of abiFileNames) { } else if (!_.isUndefined(parsedContent.abi)) { ABI = parsedContent.abi; // Truffle artifact } else if (!_.isUndefined(parsedContent.networks) && !_.isUndefined(parsedContent.networks[args.networkId])) { - ABI = parsedContent.networks[args.networkId]; // 0x contracts package artifact + ABI = parsedContent.networks[args.networkId].abi; // 0x contracts package artifact } if (_.isUndefined(ABI)) { utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`); diff --git a/packages/contracts/package.json b/packages/contracts/package.json index 4bdbf3f412..4b5d647426 100644 --- a/packages/contracts/package.json +++ b/packages/contracts/package.json @@ -10,7 +10,7 @@ "scripts": { "build:watch": "tsc -w", "prebuild": "run-s clean copy_artifacts", - "copy_artifacts": "copyfiles './artifacts/**/*' ./lib", + "copy_artifacts": "copyfiles './src/artifacts/**/*' ./lib", "build": "tsc", "test": "run-s compile build run_mocha", "run_mocha": "mocha 'lib/test/**/*.js' --timeout 10000 --bail --exit", diff --git a/packages/contracts/test/utils/deployer.ts b/packages/contracts/test/utils/deployer.ts index dc41e41e27..4e7f35c722 100644 --- a/packages/contracts/test/utils/deployer.ts +++ b/packages/contracts/test/utils/deployer.ts @@ -5,7 +5,7 @@ import * as path from 'path'; import { constants } from '../../util/constants'; const deployerOpts = { - artifactsDir: path.resolve('artifacts'), + artifactsDir: path.resolve('src', 'artifacts'), jsonrpcPort: devConstants.RPC_PORT, networkId: constants.TESTRPC_NETWORK_ID, defaults: { diff --git a/packages/contracts/util/artifacts.ts b/packages/contracts/util/artifacts.ts index fd9380d1d0..7c375c1b75 100644 --- a/packages/contracts/util/artifacts.ts +++ b/packages/contracts/util/artifacts.ts @@ -1,13 +1,13 @@ -import * as DummyTokenArtifact from '../artifacts/DummyToken.json'; -import * as ExchangeArtifact from '../artifacts/Exchange.json'; -import * as MaliciousTokenArtifact from '../artifacts/MaliciousToken.json'; -import * as MultiSigWalletWithTimeLockArtifact from '../artifacts/MultiSigWalletWithTimeLock.json'; -import * as MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressArtifact from '../artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json'; -import * as TokenArtifact from '../artifacts/Token.json'; -import * as TokenRegistryArtifact from '../artifacts/TokenRegistry.json'; -import * as TokenTransferProxyArtifact from '../artifacts/TokenTransferProxy.json'; -import * as EtherTokenArtifact from '../artifacts/WETH9.json'; -import * as ZRXArtifact from '../artifacts/ZRXToken.json'; +import * as DummyTokenArtifact from '../src/artifacts/DummyToken.json'; +import * as ExchangeArtifact from '../src/artifacts/Exchange.json'; +import * as MaliciousTokenArtifact from '../src/artifacts/MaliciousToken.json'; +import * as MultiSigWalletWithTimeLockArtifact from '../src/artifacts/MultiSigWalletWithTimeLock.json'; +import * as MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressArtifact from '../src/artifacts/MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress.json'; +import * as TokenArtifact from '../src/artifacts/Token.json'; +import * as TokenRegistryArtifact from '../src/artifacts/TokenRegistry.json'; +import * as TokenTransferProxyArtifact from '../src/artifacts/TokenTransferProxy.json'; +import * as EtherTokenArtifact from '../src/artifacts/WETH9.json'; +import * as ZRXArtifact from '../src/artifacts/ZRXToken.json'; import { Artifact } from './types'; From a7c51593e4e6bc514f4f975fdc6fb9207c52ac8e Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 12:07:19 +0100 Subject: [PATCH 04/21] Use abi-gen for events in 0x.js --- .../contract_templates/contract.handlebars | 20 ++++- .../partials/event.handlebars | 5 ++ .../contract_wrappers/ether_token_wrapper.ts | 12 +-- .../src/contract_wrappers/exchange_wrapper.ts | 10 ++- .../src/contract_wrappers/token_wrapper.ts | 13 +--- packages/0x.js/src/index.ts | 35 +++++---- .../src/order_watcher/order_state_watcher.ts | 25 +++--- packages/0x.js/src/types.ts | 76 +------------------ .../testnet-faucets/src/ts/request_queue.ts | 5 -- 9 files changed, 76 insertions(+), 125 deletions(-) create mode 100644 packages/0x.js/contract_templates/partials/event.handlebars diff --git a/packages/0x.js/contract_templates/contract.handlebars b/packages/0x.js/contract_templates/contract.handlebars index d3fe1b8cc4..227cfcc5a7 100644 --- a/packages/0x.js/contract_templates/contract.handlebars +++ b/packages/0x.js/contract_templates/contract.handlebars @@ -1,6 +1,6 @@ /** * 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. + * Templates can be found at https://github.com/0xProject/0x.js/tree/development/packages/0x.js/contract_templates. */ // tslint:disable-next-line:no-unused-variable import { TxData, TxDataPayable } from '@0xproject/types'; @@ -9,6 +9,24 @@ import * as Web3 from 'web3'; import {BaseContract} from './base_contract'; +{{#if events}} +export type {{contractName}}ContractEventArgs = +{{#each events}} + | {{name}}ContractEventArgs{{#if @last}};{{/if}} +{{/each}} + +export enum {{contractName}}Events { + {{#each events}} + {{name}} = '{{name}}', + {{/each}} +} + +{{#each events}} +{{> event}} + +{{/each}} +{{/if}} + export class {{contractName}}Contract extends BaseContract { {{#each methods}} {{#this.constant}} diff --git a/packages/0x.js/contract_templates/partials/event.handlebars b/packages/0x.js/contract_templates/partials/event.handlebars new file mode 100644 index 0000000000..8f8676a4ff --- /dev/null +++ b/packages/0x.js/contract_templates/partials/event.handlebars @@ -0,0 +1,5 @@ +export interface {{name}}ContractEventArgs { + {{#each inputs}} + {{name}}: {{#returnType type}}{{/returnType}}, + {{/each}} +}; 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 32c9ae6a9a..db7cdee436 100644 --- a/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/ether_token_wrapper.ts @@ -5,19 +5,11 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as _ from 'lodash'; import { artifacts } from '../artifacts'; -import { - BlockRange, - EtherTokenContractEventArgs, - EtherTokenEvents, - EventCallback, - IndexedFilterValues, - TransactionOpts, - ZeroExError, -} from '../types'; +import { BlockRange, EventCallback, IndexedFilterValues, TransactionOpts, ZeroExError } from '../types'; import { assert } from '../utils/assert'; import { ContractWrapper } from './contract_wrapper'; -import { EtherTokenContract } from './generated/ether_token'; +import { EtherTokenContract, EtherTokenContractEventArgs, EtherTokenEvents } from './generated/ether_token'; import { TokenWrapper } from './token_wrapper'; /** diff --git a/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts b/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts index e0c85505cf..c82b7ecf59 100644 --- a/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/exchange_wrapper.ts @@ -12,10 +12,7 @@ import { EventCallback, ExchangeContractErrCodes, ExchangeContractErrs, - ExchangeContractEventArgs, - ExchangeEvents, IndexedFilterValues, - LogErrorContractEventArgs, MethodOpts, Order, OrderAddresses, @@ -33,7 +30,12 @@ import { OrderValidationUtils } from '../utils/order_validation_utils'; import { utils } from '../utils/utils'; import { ContractWrapper } from './contract_wrapper'; -import { ExchangeContract } from './generated/exchange'; +import { + ExchangeContract, + ExchangeContractEventArgs, + ExchangeEvents, + LogErrorContractEventArgs, +} from './generated/exchange'; import { TokenWrapper } from './token_wrapper'; const SHOULD_VALIDATE_BY_DEFAULT = true; diff --git a/packages/0x.js/src/contract_wrappers/token_wrapper.ts b/packages/0x.js/src/contract_wrappers/token_wrapper.ts index 98c24d0591..a018006b8c 100644 --- a/packages/0x.js/src/contract_wrappers/token_wrapper.ts +++ b/packages/0x.js/src/contract_wrappers/token_wrapper.ts @@ -5,21 +5,12 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as _ from 'lodash'; import { artifacts } from '../artifacts'; -import { - BlockRange, - EventCallback, - IndexedFilterValues, - MethodOpts, - TokenContractEventArgs, - TokenEvents, - TransactionOpts, - ZeroExError, -} from '../types'; +import { BlockRange, EventCallback, IndexedFilterValues, MethodOpts, TransactionOpts, ZeroExError } from '../types'; import { assert } from '../utils/assert'; import { constants } from '../utils/constants'; import { ContractWrapper } from './contract_wrapper'; -import { TokenContract } from './generated/token'; +import { TokenContract, TokenContractEventArgs, TokenEvents } from './generated/token'; import { TokenTransferProxyWrapper } from './token_transfer_proxy_wrapper'; /** diff --git a/packages/0x.js/src/index.ts b/packages/0x.js/src/index.ts index c3c8854daa..1619454436 100644 --- a/packages/0x.js/src/index.ts +++ b/packages/0x.js/src/index.ts @@ -9,26 +9,13 @@ export { ExchangeContractErrs, ContractEvent, Token, - ExchangeEvents, - TokenEvents, IndexedFilterValues, BlockRange, OrderCancellationRequest, OrderFillRequest, - LogErrorContractEventArgs, - LogCancelContractEventArgs, - LogFillContractEventArgs, - ExchangeContractEventArgs, - TransferContractEventArgs, - ApprovalContractEventArgs, - TokenContractEventArgs, - EtherTokenContractEventArgs, - WithdrawalContractEventArgs, - DepositContractEventArgs, ContractEventArgs, Web3Provider, ZeroExConfig, - EtherTokenEvents, MethodOpts, OrderTransactionOpts, TransactionOpts, @@ -50,4 +37,26 @@ export { TransactionReceiptWithDecodedLogs, } from '@0xproject/types'; +export { + EtherTokenContractEventArgs, + WithdrawalContractEventArgs, + DepositContractEventArgs, + EtherTokenEvents, +} from './contract_wrappers/generated/ether_token'; + +export { + TransferContractEventArgs, + ApprovalContractEventArgs, + TokenContractEventArgs, + TokenEvents, +} from './contract_wrappers/generated/token'; + +export { + LogErrorContractEventArgs, + LogCancelContractEventArgs, + LogFillContractEventArgs, + ExchangeContractEventArgs, + ExchangeEvents, +} from './contract_wrappers/generated/exchange'; + export { TransactionReceipt } from '@0xproject/types'; diff --git a/packages/0x.js/src/order_watcher/order_state_watcher.ts b/packages/0x.js/src/order_watcher/order_state_watcher.ts index a9b3eba680..9ff07b38d9 100644 --- a/packages/0x.js/src/order_watcher/order_state_watcher.ts +++ b/packages/0x.js/src/order_watcher/order_state_watcher.ts @@ -6,26 +6,33 @@ import * as _ from 'lodash'; import { ZeroEx } from '../0x'; import { ExchangeWrapper } from '../contract_wrappers/exchange_wrapper'; +import { + DepositContractEventArgs, + EtherTokenEvents, + WithdrawalContractEventArgs, +} from '../contract_wrappers/generated/ether_token'; +import { + ExchangeEvents, + LogCancelContractEventArgs, + LogFillContractEventArgs, +} from '../contract_wrappers/generated/exchange'; +import { + ApprovalContractEventArgs, + TokenEvents, + TransferContractEventArgs, +} from '../contract_wrappers/generated/token'; import { TokenWrapper } from '../contract_wrappers/token_wrapper'; import { BalanceAndProxyAllowanceLazyStore } from '../stores/balance_proxy_allowance_lazy_store'; import { OrderFilledCancelledLazyStore } from '../stores/order_filled_cancelled_lazy_store'; import { - ApprovalContractEventArgs, + BlockParamLiteral, ContractEventArgs, - DepositContractEventArgs, - EtherTokenEvents, ExchangeContractErrs, - ExchangeEvents, - LogCancelContractEventArgs, LogEvent, - LogFillContractEventArgs, OnOrderStateChangeCallback, OrderState, OrderStateWatcherConfig, SignedOrder, - TokenEvents, - TransferContractEventArgs, - WithdrawalContractEventArgs, ZeroExError, } from '../types'; import { assert } from '../utils/assert'; diff --git a/packages/0x.js/src/types.ts b/packages/0x.js/src/types.ts index a2d1b9eb4b..ab97f7775c 100644 --- a/packages/0x.js/src/types.ts +++ b/packages/0x.js/src/types.ts @@ -4,6 +4,10 @@ import { BlockParam, BlockParamLiteral, ContractEventArg, LogWithDecodedArgs } f import * as Web3 from 'web3'; +import { EtherTokenContractEventArgs, EtherTokenEvents } from './contract_wrappers/generated/ether_token'; +import { ExchangeContractEventArgs, ExchangeEvents } from './contract_wrappers/generated/exchange'; +import { TokenContractEventArgs, TokenEvents } from './contract_wrappers/generated/token'; + export enum ZeroExError { ExchangeContractDoesNotExist = 'EXCHANGE_CONTRACT_DOES_NOT_EXIST', ZRXContractDoesNotExist = 'ZRX_CONTRACT_DOES_NOT_EXIST', @@ -101,60 +105,6 @@ export interface ContractEvent { args: ContractEventArgs; } -export interface LogFillContractEventArgs { - maker: string; - taker: string; - feeRecipient: string; - makerToken: string; - takerToken: string; - filledMakerTokenAmount: BigNumber; - filledTakerTokenAmount: BigNumber; - paidMakerFee: BigNumber; - paidTakerFee: BigNumber; - tokens: string; - orderHash: string; -} -export interface LogCancelContractEventArgs { - maker: string; - feeRecipient: string; - makerToken: string; - takerToken: string; - cancelledMakerTokenAmount: BigNumber; - cancelledTakerTokenAmount: BigNumber; - tokens: string; - orderHash: string; -} -export interface LogErrorContractEventArgs { - errorId: BigNumber; - orderHash: string; -} -export type ExchangeContractEventArgs = - | LogFillContractEventArgs - | LogCancelContractEventArgs - | LogErrorContractEventArgs; -export interface TransferContractEventArgs { - _from: string; - _to: string; - _value: BigNumber; -} -export interface ApprovalContractEventArgs { - _owner: string; - _spender: string; - _value: BigNumber; -} -export interface DepositContractEventArgs { - _owner: string; - _value: BigNumber; -} -export interface WithdrawalContractEventArgs { - _owner: string; - _value: BigNumber; -} -export type TokenContractEventArgs = TransferContractEventArgs | ApprovalContractEventArgs; -export type EtherTokenContractEventArgs = - | TokenContractEventArgs - | DepositContractEventArgs - | WithdrawalContractEventArgs; export type ContractEventArgs = ExchangeContractEventArgs | TokenContractEventArgs | EtherTokenContractEventArgs; export interface Order { @@ -197,24 +147,6 @@ export interface TokenAddressBySymbol { [symbol: string]: string; } -export enum ExchangeEvents { - LogFill = 'LogFill', - LogCancel = 'LogCancel', - LogError = 'LogError', -} - -export enum TokenEvents { - Transfer = 'Transfer', - Approval = 'Approval', -} - -export enum EtherTokenEvents { - Transfer = 'Transfer', - Approval = 'Approval', - Deposit = 'Deposit', - Withdrawal = 'Withdrawal', -} - export type ContractEvents = TokenEvents | ExchangeEvents | EtherTokenEvents; export interface IndexedFilterValues { diff --git a/packages/testnet-faucets/src/ts/request_queue.ts b/packages/testnet-faucets/src/ts/request_queue.ts index 718f8be0ca..f128528a5e 100644 --- a/packages/testnet-faucets/src/ts/request_queue.ts +++ b/packages/testnet-faucets/src/ts/request_queue.ts @@ -44,11 +44,6 @@ export class RequestQueue { this._processNextRequestFireAndForgetAsync(recipientAddress); }, this._queueIntervalMs); } - protected _stop() { - if (!_.isUndefined(this._queueIntervalId)) { - clearInterval(this._queueIntervalId); - } - } // tslint:disable-next-line:prefer-function-over-method protected async _processNextRequestFireAndForgetAsync(recipientAddress: string) { throw new Error('Expected processNextRequestFireAndForgetAsync to be implemented by a subclass'); From 600a2b40af0430d4037f86f6ffe21d6edf3fb166 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:37:07 +0100 Subject: [PATCH 05/21] Add indices for index parameters so that their names don't collide --- packages/abi-gen/src/index.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts index 6b5119ca4a..46d41861dd 100644 --- a/packages/abi-gen/src/index.ts +++ b/packages/abi-gen/src/index.ts @@ -114,10 +114,10 @@ for (const abiFileName of abiFileNames) { const methodAbis = ABI.filter((abi: Web3.AbiDefinition) => abi.type === ABI_TYPE_METHOD) as Web3.MethodAbi[]; const methodsData = _.map(methodAbis, methodAbi => { - _.map(methodAbi.inputs, input => { + _.map(methodAbi.inputs, (input, i: number) => { if (_.isEmpty(input.name)) { // Auto-generated getters don't have parameter names - input.name = 'index'; + input.name = `index_${i}`; } }); // This will make templates simpler From eea8b15180d3e6616a908a8eb4c537df7d87a6ab Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:37:42 +0100 Subject: [PATCH 06/21] Change contract templates --- .../contract_templates/contract.handlebars | 3 +- .../partials/call.handlebars | 25 +++++------- .../partials/return_type.handlebars | 4 ++ .../contract_templates/partials/tx.handlebars | 39 ++++++------------- 4 files changed, 28 insertions(+), 43 deletions(-) diff --git a/packages/contracts/contract_templates/contract.handlebars b/packages/contracts/contract_templates/contract.handlebars index d3fe1b8cc4..f9ffb730c4 100644 --- a/packages/contracts/contract_templates/contract.handlebars +++ b/packages/contracts/contract_templates/contract.handlebars @@ -2,6 +2,7 @@ * 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. */ +// tslint:disable:async-suffix member-ordering // tslint:disable-next-line:no-unused-variable import { TxData, TxDataPayable } from '@0xproject/types'; import { BigNumber, classUtils, promisify } from '@0xproject/utils'; @@ -18,7 +19,7 @@ export class {{contractName}}Contract extends BaseContract { {{> tx contractName=../contractName}} {{/this.constant}} {{/each}} - constructor(web3ContractInstance: Web3.ContractInstance, defaults: Partial) { + constructor(web3ContractInstance: Web3.ContractInstance, defaults?: Partial) { super(web3ContractInstance, defaults); classUtils.bindAll(this, ['_web3ContractInstance', '_defaults']); } diff --git a/packages/contracts/contract_templates/partials/call.handlebars b/packages/contracts/contract_templates/partials/call.handlebars index 0475136f0c..82a45b40ee 100644 --- a/packages/contracts/contract_templates/partials/call.handlebars +++ b/packages/contracts/contract_templates/partials/call.handlebars @@ -1,15 +1,10 @@ -public {{this.name}} = { - async callAsync( - {{> typed_params inputs=inputs}} - defaultBlock?: Web3.BlockParam, - ): Promise<{{> return_type outputs=outputs}}> { - const self = this as {{contractName}}Contract; - const result = await promisify<{{> return_type outputs=outputs}}>( - self._web3ContractInstance.{{this.name}}.call, - self._web3ContractInstance, - )( - {{> params inputs=inputs}} - ); - return result; - }, -}; +public async {{this.name}}( +{{> typed_params inputs=inputs}} + defaultBlock?: Web3.BlockParam, +): Promise<{{> return_type outputs=outputs}}> { + const self = this as {{contractName}}Contract; + const result = await self._web3ContractInstance.{{this.name}}.call( + {{> params inputs=inputs}} + ); + return result; +} diff --git a/packages/contracts/contract_templates/partials/return_type.handlebars b/packages/contracts/contract_templates/partials/return_type.handlebars index 383961a40f..40a5dd8b09 100644 --- a/packages/contracts/contract_templates/partials/return_type.handlebars +++ b/packages/contracts/contract_templates/partials/return_type.handlebars @@ -1,6 +1,10 @@ +{{#if outputs.length}} {{#singleReturnValue}} {{#returnType outputs.0.type}}{{/returnType}} {{/singleReturnValue}} {{^singleReturnValue}} [{{#each outputs}}{{#returnType type}}{{/returnType}}{{#unless @last}}, {{/unless}}{{/each}}] {{/singleReturnValue}} +{{else}} +void +{{/if}} diff --git a/packages/contracts/contract_templates/partials/tx.handlebars b/packages/contracts/contract_templates/partials/tx.handlebars index 9df83266a0..69ae982d6d 100644 --- a/packages/contracts/contract_templates/partials/tx.handlebars +++ b/packages/contracts/contract_templates/partials/tx.handlebars @@ -9,43 +9,28 @@ public {{this.name}} = { {{/this.payable}} ): Promise { const self = this as {{contractName}}Contract; - const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( - txData, - self.{{this.name}}.estimateGasAsync.bind( - self, - {{> params inputs=inputs}} - ), - ); - const txHash = await promisify( - self._web3ContractInstance.{{this.name}}, self._web3ContractInstance, - )( + const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(txData); + const txHash = await self._web3ContractInstance.{{this.name}}( {{> params inputs=inputs}} txDataWithDefaults, ); return txHash; }, - async estimateGasAsync( + async callAsync( {{> typed_params inputs=inputs}} + {{#this.payable}} + txData: TxDataPayable = {}, + {{/this.payable}} + {{^this.payable}} txData: TxData = {}, - ): Promise { + {{/this.payable}} + ): Promise<{{> return_type outputs=outputs}}> { const self = this as {{contractName}}Contract; - const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( - txData, - ); - const gas = await promisify( - self._web3ContractInstance.{{this.name}}.estimateGas, self._web3ContractInstance, - )( + const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(txData); + const returnValue = await self._web3ContractInstance.{{this.name}}.call( {{> params inputs=inputs}} txDataWithDefaults, ); - return gas; - }, - getABIEncodedTransactionData( - {{> typed_params inputs=inputs}} - txData: TxData = {}, - ): string { - const self = this as {{contractName}}Contract; - const abiEncodedTransactionData = self._web3ContractInstance.{{this.name}}.getData(); - return abiEncodedTransactionData; + return returnValue; }, }; From 2287597712fa916e1ab61c1ea6a0ec36f432f6b9 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:37:58 +0100 Subject: [PATCH 07/21] Change the list of generated wrappers --- packages/contracts/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/contracts/package.json b/packages/contracts/package.json index 4b5d647426..61cda2622a 100644 --- a/packages/contracts/package.json +++ b/packages/contracts/package.json @@ -17,7 +17,7 @@ "compile:comment": "Yarn workspaces do not link binaries correctly so we need to reference them directly https://github.com/yarnpkg/yarn/issues/3846", "compile": "node ../deployer/lib/src/cli.js compile --contracts-dir src/contracts --artifacts-dir src/artifacts", "clean": "rm -rf ./lib", - "generate_contract_wrappers": "node ../abi-gen/lib/index.js --abis 'src/artifacts/@(Exchange|Token|TokenTransferProxy|EtherToken|TokenRegistry|DummyToken).json' --template contract_templates/contract.handlebars --partials 'contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated", + "generate_contract_wrappers": "node ../abi-gen/lib/index.js --abis 'src/artifacts/@(DummyToken|TokenTransferProxy|Exchange|TokenRegistry|MultiSigWallet|MultiSigWalletWithTimeLock|MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress|TokenRegistry|ZRXToken).json' --template contract_templates/contract.handlebars --partials 'contract_templates/partials/**/*.handlebars' --output src/contract_wrappers/generated", "migrate": "node ../deployer/lib/src/cli.js migrate", "lint": "tslint --project . 'migrations/**/*.ts' 'test/**/*.ts' 'util/**/*.ts' 'deploy/**/*.ts'", "test:circleci": "yarn test" From 745f209f7e59bc604c22114d92dcff6eec670abb Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:38:30 +0100 Subject: [PATCH 08/21] .gitignore gemerated files --- .../contracts/src/contract_wrappers/generated/.gitignore | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 packages/contracts/src/contract_wrappers/generated/.gitignore diff --git a/packages/contracts/src/contract_wrappers/generated/.gitignore b/packages/contracts/src/contract_wrappers/generated/.gitignore new file mode 100644 index 0000000000..c9bba195a3 --- /dev/null +++ b/packages/contracts/src/contract_wrappers/generated/.gitignore @@ -0,0 +1,8 @@ +dummy_token.ts +exchange.ts +multi_sig_wallet_with_time_lock_except_remove_authorized_address.ts +multi_sig_wallet_with_time_lock.ts +multi_sig_wallet.ts +token_registry.ts +token_transfer_proxy.ts +z_r_x_token.ts From 47adad5122cea7c2bac54c6e6b83be55a2b6609a Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:39:32 +0100 Subject: [PATCH 09/21] Remove generated files --- .../generated/dummy_token.ts | 434 ----------- .../contract_wrappers/generated/exchange.ts | 728 ------------------ .../src/contract_wrappers/generated/token.ts | 215 ------ .../generated/token_registry.ts | 548 ------------- .../generated/token_transfer_proxy.ts | 283 ------- 5 files changed, 2208 deletions(-) delete mode 100644 packages/contracts/src/contract_wrappers/generated/dummy_token.ts delete mode 100644 packages/contracts/src/contract_wrappers/generated/exchange.ts delete mode 100644 packages/contracts/src/contract_wrappers/generated/token.ts delete mode 100644 packages/contracts/src/contract_wrappers/generated/token_registry.ts delete mode 100644 packages/contracts/src/contract_wrappers/generated/token_transfer_proxy.ts diff --git a/packages/contracts/src/contract_wrappers/generated/dummy_token.ts b/packages/contracts/src/contract_wrappers/generated/dummy_token.ts deleted file mode 100644 index 788cbfe3f0..0000000000 --- a/packages/contracts/src/contract_wrappers/generated/dummy_token.ts +++ /dev/null @@ -1,434 +0,0 @@ -/** - * 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. - */ -// tslint:disable-next-line:no-unused-variable -import { TxData, TxDataPayable } from '@0xproject/types'; -import { BigNumber, classUtils, promisify } from '@0xproject/utils'; -import * as Web3 from 'web3'; - -import {BaseContract} from './base_contract'; - -export class DummyTokenContract extends BaseContract { - public name = { - async callAsync( - defaultBlock?: Web3.BlockParam, - ): Promise { - const self = this as DummyTokenContract; - 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 DummyTokenContract; - 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 DummyTokenContract; - 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 DummyTokenContract; - const abiEncodedTransactionData = self._web3ContractInstance.approve.getData(); - return abiEncodedTransactionData; - }, - }; - public totalSupply = { - async callAsync( - defaultBlock?: Web3.BlockParam, - ): Promise { - const self = this as DummyTokenContract; - 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 DummyTokenContract; - 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 DummyTokenContract; - 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 DummyTokenContract; - const abiEncodedTransactionData = self._web3ContractInstance.transferFrom.getData(); - return abiEncodedTransactionData; - }, - }; - public decimals = { - async callAsync( - defaultBlock?: Web3.BlockParam, - ): Promise { - const self = this as DummyTokenContract; - 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 DummyTokenContract; - const result = await promisify( - self._web3ContractInstance.balanceOf.call, - self._web3ContractInstance, - )( - _owner, - ); - return result; - }, - }; - public owner = { - async callAsync( - defaultBlock?: Web3.BlockParam, - ): Promise { - const self = this as DummyTokenContract; - const result = await promisify( - self._web3ContractInstance.owner.call, - self._web3ContractInstance, - )( - ); - return result; - }, - }; - public symbol = { - async callAsync( - defaultBlock?: Web3.BlockParam, - ): Promise { - const self = this as DummyTokenContract; - const result = await promisify( - self._web3ContractInstance.symbol.call, - self._web3ContractInstance, - )( - ); - return result; - }, - }; - public mint = { - async sendTransactionAsync( - _value: BigNumber, - txData: TxData = {}, - ): Promise { - const self = this as DummyTokenContract; - const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( - txData, - self.mint.estimateGasAsync.bind( - self, - _value, - ), - ); - const txHash = await promisify( - self._web3ContractInstance.mint, self._web3ContractInstance, - )( - _value, - txDataWithDefaults, - ); - return txHash; - }, - async estimateGasAsync( - _value: BigNumber, - txData: TxData = {}, - ): Promise { - const self = this as DummyTokenContract; - const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( - txData, - ); - const gas = await promisify( - self._web3ContractInstance.mint.estimateGas, self._web3ContractInstance, - )( - _value, - txDataWithDefaults, - ); - return gas; - }, - getABIEncodedTransactionData( - _value: BigNumber, - txData: TxData = {}, - ): string { - const self = this as DummyTokenContract; - const abiEncodedTransactionData = self._web3ContractInstance.mint.getData(); - return abiEncodedTransactionData; - }, - }; - public transfer = { - async sendTransactionAsync( - _to: string, - _value: BigNumber, - txData: TxData = {}, - ): Promise { - const self = this as DummyTokenContract; - 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 DummyTokenContract; - 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 DummyTokenContract; - const abiEncodedTransactionData = self._web3ContractInstance.transfer.getData(); - return abiEncodedTransactionData; - }, - }; - public allowance = { - async callAsync( - _owner: string, - _spender: string, - defaultBlock?: Web3.BlockParam, - ): Promise { - const self = this as DummyTokenContract; - const result = await promisify( - self._web3ContractInstance.allowance.call, - self._web3ContractInstance, - )( - _owner, - _spender, - ); - return result; - }, - }; - public setBalance = { - async sendTransactionAsync( - _target: string, - _value: BigNumber, - txData: TxData = {}, - ): Promise { - const self = this as DummyTokenContract; - const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( - txData, - self.setBalance.estimateGasAsync.bind( - self, - _target, - _value, - ), - ); - const txHash = await promisify( - self._web3ContractInstance.setBalance, self._web3ContractInstance, - )( - _target, - _value, - txDataWithDefaults, - ); - return txHash; - }, - async estimateGasAsync( - _target: string, - _value: BigNumber, - txData: TxData = {}, - ): Promise { - const self = this as DummyTokenContract; - const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( - txData, - ); - const gas = await promisify( - self._web3ContractInstance.setBalance.estimateGas, self._web3ContractInstance, - )( - _target, - _value, - txDataWithDefaults, - ); - return gas; - }, - getABIEncodedTransactionData( - _target: string, - _value: BigNumber, - txData: TxData = {}, - ): string { - const self = this as DummyTokenContract; - const abiEncodedTransactionData = self._web3ContractInstance.setBalance.getData(); - return abiEncodedTransactionData; - }, - }; - public transferOwnership = { - async sendTransactionAsync( - newOwner: string, - txData: TxData = {}, - ): Promise { - const self = this as DummyTokenContract; - 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 DummyTokenContract; - 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 DummyTokenContract; - 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/contracts/src/contract_wrappers/generated/exchange.ts b/packages/contracts/src/contract_wrappers/generated/exchange.ts deleted file mode 100644 index c328ec7251..0000000000 --- a/packages/contracts/src/contract_wrappers/generated/exchange.ts +++ /dev/null @@ -1,728 +0,0 @@ -/** - * 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. - */ -// tslint:disable-next-line:no-unused-variable -import { TxData, TxDataPayable } from '@0xproject/types'; -import { BigNumber, classUtils, promisify } from '@0xproject/utils'; -import * as Web3 from 'web3'; - -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: Array, - 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: Array, - 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: Array, - 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: Array, - 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: Array, - 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: Array, - 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: Array, - 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: Array, - 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: Array, - 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/contracts/src/contract_wrappers/generated/token.ts b/packages/contracts/src/contract_wrappers/generated/token.ts deleted file mode 100644 index 5ad96da1e2..0000000000 --- a/packages/contracts/src/contract_wrappers/generated/token.ts +++ /dev/null @@ -1,215 +0,0 @@ -/** - * 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. - */ -// tslint:disable-next-line:no-unused-variable -import { TxData, TxDataPayable } from '@0xproject/types'; -import { BigNumber, classUtils, promisify } from '@0xproject/utils'; -import * as Web3 from 'web3'; - -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 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/contracts/src/contract_wrappers/generated/token_registry.ts b/packages/contracts/src/contract_wrappers/generated/token_registry.ts deleted file mode 100644 index 635f9f214f..0000000000 --- a/packages/contracts/src/contract_wrappers/generated/token_registry.ts +++ /dev/null @@ -1,548 +0,0 @@ -/** - * 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. - */ -// tslint:disable-next-line:no-unused-variable -import { TxData, TxDataPayable } from '@0xproject/types'; -import { BigNumber, classUtils, promisify } from '@0xproject/utils'; -import * as Web3 from 'web3'; - -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/contracts/src/contract_wrappers/generated/token_transfer_proxy.ts b/packages/contracts/src/contract_wrappers/generated/token_transfer_proxy.ts deleted file mode 100644 index a5a40d47f4..0000000000 --- a/packages/contracts/src/contract_wrappers/generated/token_transfer_proxy.ts +++ /dev/null @@ -1,283 +0,0 @@ -/** - * 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. - */ -// tslint:disable-next-line:no-unused-variable -import { TxData, TxDataPayable } from '@0xproject/types'; -import { BigNumber, classUtils, promisify } from '@0xproject/utils'; -import * as Web3 from 'web3'; - -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 From 0c2ab2265624eb0dc18244b263fed3c8788b5c09 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:39:45 +0100 Subject: [PATCH 10/21] Add base_contract.ts --- .../generated/base_contract.ts | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 packages/contracts/src/contract_wrappers/generated/base_contract.ts diff --git a/packages/contracts/src/contract_wrappers/generated/base_contract.ts b/packages/contracts/src/contract_wrappers/generated/base_contract.ts new file mode 100644 index 0000000000..2d77b3ab13 --- /dev/null +++ b/packages/contracts/src/contract_wrappers/generated/base_contract.ts @@ -0,0 +1,35 @@ +import {TxData, TxDataPayable} from '@0xproject/types'; +import * as _ from 'lodash'; +import * as Web3 from 'web3'; + +export class BaseContract { + public address: string; + 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 spreadable. + // 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.address = web3ContractInstance.address; + this._web3ContractInstance = web3ContractInstance; + this._defaults = defaults || {}; + } +} From a264c36a48d224a55c2ef883f207692752ca74c7 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:40:03 +0100 Subject: [PATCH 11/21] Change tests --- packages/contracts/test/exchange/core.ts | 81 ++++++++++-------- packages/contracts/test/exchange/helpers.ts | 7 +- packages/contracts/test/exchange/wrapper.ts | 59 ++++++++----- .../test/multi_sig_with_time_lock.ts | 70 ++++++++------- ..._with_time_lock_except_remove_auth_addr.ts | 85 ++++++++++--------- packages/contracts/test/token_registry.ts | 55 ++++++------ .../test/token_transfer_proxy/auth.ts | 36 ++++---- .../token_transfer_proxy/transfer_from.ts | 51 +++++++---- .../test/unlimited_allowance_token.ts | 22 +++-- packages/contracts/test/zrx_token.ts | 16 ++-- 10 files changed, 275 insertions(+), 207 deletions(-) diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts index 10816d2d6f..5cedaddc93 100644 --- a/packages/contracts/test/exchange/core.ts +++ b/packages/contracts/test/exchange/core.ts @@ -13,6 +13,9 @@ import * as chai from 'chai'; import ethUtil = require('ethereumjs-util'); import * as Web3 from 'web3'; +import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token'; +import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange'; +import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy'; import { Balances } from '../../util/balances'; import { constants } from '../../util/constants'; import { crypto } from '../../util/crypto'; @@ -37,11 +40,11 @@ describe('Exchange', () => { const INITIAL_BALANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18); const INITIAL_ALLOWANCE = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18); - let rep: Web3.ContractInstance; - let dgd: Web3.ContractInstance; - let zrx: Web3.ContractInstance; - let exchange: Web3.ContractInstance; - let tokenTransferProxy: Web3.ContractInstance; + let rep: DummyTokenContract; + let dgd: DummyTokenContract; + let zrx: DummyTokenContract; + let exchange: ExchangeContract; + let tokenTransferProxy: TokenTransferProxyContract; let order: Order; let balances: BalancesByOwner; @@ -55,14 +58,22 @@ describe('Exchange', () => { const accounts = await web3Wrapper.getAvailableAddressesAsync(); maker = accounts[0]; [tokenOwner, taker, feeRecipient] = accounts; - [rep, dgd, zrx] = await Promise.all([ + const [repInstance, dgdInstance, zrxInstance] = await Promise.all([ deployer.deployAsync(ContractName.DummyToken), deployer.deployAsync(ContractName.DummyToken), deployer.deployAsync(ContractName.DummyToken), ]); - tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy); - exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]); - await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] }); + rep = new DummyTokenContract(repInstance); + dgd = new DummyTokenContract(dgdInstance); + zrx = new DummyTokenContract(zrxInstance); + const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy); + tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance); + const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [ + zrx.address, + tokenTransferProxy.address, + ]); + exchange = new ExchangeContract(exchangeInstance); + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] }); zeroEx = new ZeroEx(web3.currentProvider, { exchangeContractAddress: exchange.address, networkId: constants.TESTRPC_NETWORK_ID, @@ -83,30 +94,30 @@ describe('Exchange', () => { orderFactory = new OrderFactory(web3Wrapper, defaultOrderParams); dmyBalances = new Balances([rep, dgd, zrx], [maker, taker, feeRecipient]); await Promise.all([ - rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: maker, }), - rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: taker, }), - rep.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }), - rep.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }), - dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + rep.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }), + rep.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }), + dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: maker, }), - dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: taker, }), - dgd.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }), - dgd.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }), - zrx.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + dgd.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }), + dgd.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }), + zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: maker, }), - zrx.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: taker, }), - zrx.setBalance(maker, INITIAL_BALANCE, { from: tokenOwner }), - zrx.setBalance(taker, INITIAL_BALANCE, { from: tokenOwner }), + zrx.setBalance.sendTransactionAsync(maker, INITIAL_BALANCE, { from: tokenOwner }), + zrx.setBalance.sendTransactionAsync(taker, INITIAL_BALANCE, { from: tokenOwner }), ]); }); beforeEach(async () => { @@ -117,19 +128,19 @@ describe('Exchange', () => { }); describe('internal functions', () => { it('should include transferViaTokenTransferProxy', () => { - expect(exchange.transferViaTokenTransferProxy).to.be.undefined(); + expect((exchange as any).transferViaTokenTransferProxy).to.be.undefined(); }); it('should include isTransferable', () => { - expect(exchange.isTransferable).to.be.undefined(); + expect((exchange as any).isTransferable).to.be.undefined(); }); it('should include getBalance', () => { - expect(exchange.getBalance).to.be.undefined(); + expect((exchange as any).getBalance).to.be.undefined(); }); it('should include getAllowance', () => { - expect(exchange.getAllowance).to.be.undefined(); + expect((exchange as any).getAllowance).to.be.undefined(); }); }); @@ -565,9 +576,9 @@ describe('Exchange', () => { it('should not change balances if maker allowances are too low to fill order and \ shouldThrowOnInsufficientBalanceOrAllowance = false', async () => { - await rep.approve(tokenTransferProxy.address, 0, { from: maker }); + await rep.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: maker }); await exWrapper.fillOrderAsync(order, taker); - await rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + await rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: maker, }); @@ -577,22 +588,22 @@ describe('Exchange', () => { it('should throw if maker allowances are too low to fill order and \ shouldThrowOnInsufficientBalanceOrAllowance = true', async () => { - await rep.approve(tokenTransferProxy.address, 0, { from: maker }); + await rep.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: maker }); expect( exWrapper.fillOrderAsync(order, taker, { shouldThrowOnInsufficientBalanceOrAllowance: true, }), ).to.be.rejectedWith(constants.REVERT); - await rep.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + await rep.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: maker, }); }); it('should not change balances if taker allowances are too low to fill order and \ shouldThrowOnInsufficientBalanceOrAllowance = false', async () => { - await dgd.approve(tokenTransferProxy.address, 0, { from: taker }); + await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: taker }); await exWrapper.fillOrderAsync(order, taker); - await dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: taker, }); @@ -602,13 +613,13 @@ describe('Exchange', () => { it('should throw if taker allowances are too low to fill order and \ shouldThrowOnInsufficientBalanceOrAllowance = true', async () => { - await dgd.approve(tokenTransferProxy.address, 0, { from: taker }); + await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, new BigNumber(0), { from: taker }); expect( exWrapper.fillOrderAsync(order, taker, { shouldThrowOnInsufficientBalanceOrAllowance: true, }), ).to.be.rejectedWith(constants.REVERT); - await dgd.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + await dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: taker, }); }); @@ -668,7 +679,9 @@ describe('Exchange', () => { it('should throw if getBalance or getAllowance attempts to change state and \ shouldThrowOnInsufficientBalanceOrAllowance = false', async () => { const maliciousToken = await deployer.deployAsync(ContractName.MaliciousToken); - await maliciousToken.approve(tokenTransferProxy.address, INITIAL_ALLOWANCE, { from: taker }); + await maliciousToken.approve.sendTransactionAsync(tokenTransferProxy.address, INITIAL_ALLOWANCE, { + from: taker, + }); order = await orderFactory.newSignedOrderAsync({ takerToken: maliciousToken.address, diff --git a/packages/contracts/test/exchange/helpers.ts b/packages/contracts/test/exchange/helpers.ts index 5efce41a4c..33bf8b8032 100644 --- a/packages/contracts/test/exchange/helpers.ts +++ b/packages/contracts/test/exchange/helpers.ts @@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as chai from 'chai'; import ethUtil = require('ethereumjs-util'); +import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange'; import { constants } from '../../util/constants'; import { ExchangeWrapper } from '../../util/exchange_wrapper'; import { Order } from '../../util/order'; @@ -38,7 +39,11 @@ describe('Exchange', () => { deployer.deployAsync(ContractName.DummyToken), deployer.deployAsync(ContractName.DummyToken), ]); - const exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]); + const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [ + zrx.address, + tokenTransferProxy.address, + ]); + const exchange = new ExchangeContract(exchangeInstance); await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] }); const zeroEx = new ZeroEx(web3.currentProvider, { networkId: constants.TESTRPC_NETWORK_ID }); exchangeWrapper = new ExchangeWrapper(exchange, zeroEx); diff --git a/packages/contracts/test/exchange/wrapper.ts b/packages/contracts/test/exchange/wrapper.ts index acdf481a98..b1851a55ca 100644 --- a/packages/contracts/test/exchange/wrapper.ts +++ b/packages/contracts/test/exchange/wrapper.ts @@ -6,6 +6,10 @@ import * as chai from 'chai'; import * as _ from 'lodash'; import * as Web3 from 'web3'; +import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token'; +import { ExchangeContract } from '../../src/contract_wrappers/generated/exchange'; +import { TokenRegistryContract } from '../../src/contract_wrappers/generated/token_registry'; +import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy'; import { Balances } from '../../util/balances'; import { constants } from '../../util/constants'; import { ExchangeWrapper } from '../../util/exchange_wrapper'; @@ -30,12 +34,12 @@ describe('Exchange', () => { const INIT_BAL = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18); const INIT_ALLOW = ZeroEx.toBaseUnitAmount(new BigNumber(10000), 18); - let rep: Web3.ContractInstance; - let dgd: Web3.ContractInstance; - let zrx: Web3.ContractInstance; - let exchange: Web3.ContractInstance; - let tokenRegistry: Web3.ContractInstance; - let tokenTransferProxy: Web3.ContractInstance; + let rep: DummyTokenContract; + let dgd: DummyTokenContract; + let zrx: DummyTokenContract; + let exchange: ExchangeContract; + let tokenRegistry: TokenRegistryContract; + let tokenTransferProxy: TokenTransferProxyContract; let balances: BalancesByOwner; @@ -47,15 +51,24 @@ describe('Exchange', () => { const accounts = await web3Wrapper.getAvailableAddressesAsync(); tokenOwner = accounts[0]; [maker, taker, feeRecipient] = accounts; - [rep, dgd, zrx] = await Promise.all([ + const [repInstance, dgdInstance, zrxInstance] = await Promise.all([ deployer.deployAsync(ContractName.DummyToken), deployer.deployAsync(ContractName.DummyToken), deployer.deployAsync(ContractName.DummyToken), ]); - tokenRegistry = await deployer.deployAsync(ContractName.TokenRegistry); - tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy); - exchange = await deployer.deployAsync(ContractName.Exchange, [zrx.address, tokenTransferProxy.address]); - await tokenTransferProxy.addAuthorizedAddress(exchange.address, { from: accounts[0] }); + rep = new DummyTokenContract(repInstance); + dgd = new DummyTokenContract(dgdInstance); + zrx = new DummyTokenContract(zrxInstance); + const tokenRegistryInstance = await deployer.deployAsync(ContractName.TokenRegistry); + tokenRegistry = new TokenRegistryContract(tokenRegistryInstance); + const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy); + tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance); + const exchangeInstance = await deployer.deployAsync(ContractName.Exchange, [ + zrx.address, + tokenTransferProxy.address, + ]); + exchange = new ExchangeContract(exchangeInstance); + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(exchange.address, { from: accounts[0] }); const zeroEx = new ZeroEx(web3.currentProvider, { networkId: constants.TESTRPC_NETWORK_ID }); exWrapper = new ExchangeWrapper(exchange, zeroEx); @@ -74,18 +87,18 @@ describe('Exchange', () => { orderFactory = new OrderFactory(web3Wrapper, defaultOrderParams); dmyBalances = new Balances([rep, dgd, zrx], [maker, taker, feeRecipient]); await Promise.all([ - rep.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }), - rep.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }), - rep.setBalance(maker, INIT_BAL, { from: tokenOwner }), - rep.setBalance(taker, INIT_BAL, { from: tokenOwner }), - dgd.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }), - dgd.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }), - dgd.setBalance(maker, INIT_BAL, { from: tokenOwner }), - dgd.setBalance(taker, INIT_BAL, { from: tokenOwner }), - zrx.approve(tokenTransferProxy.address, INIT_ALLOW, { from: maker }), - zrx.approve(tokenTransferProxy.address, INIT_ALLOW, { from: taker }), - zrx.setBalance(maker, INIT_BAL, { from: tokenOwner }), - zrx.setBalance(taker, INIT_BAL, { from: tokenOwner }), + rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }), + rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }), + rep.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }), + rep.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }), + dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }), + dgd.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }), + dgd.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }), + dgd.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }), + zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: maker }), + zrx.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: taker }), + zrx.setBalance.sendTransactionAsync(maker, INIT_BAL, { from: tokenOwner }), + zrx.setBalance.sendTransactionAsync(taker, INIT_BAL, { from: tokenOwner }), ]); }); beforeEach(async () => { diff --git a/packages/contracts/test/multi_sig_with_time_lock.ts b/packages/contracts/test/multi_sig_with_time_lock.ts index bd64be1ba1..6812cb09f6 100644 --- a/packages/contracts/test/multi_sig_with_time_lock.ts +++ b/packages/contracts/test/multi_sig_with_time_lock.ts @@ -6,6 +6,8 @@ import * as chai from 'chai'; import * as Web3 from 'web3'; import * as multiSigWalletJSON from '../../build/contracts/MultiSigWalletWithTimeLock.json'; +import { MultiSigWalletContract } from '../src/contract_wrappers/generated/multi_sig_wallet'; +import { MultiSigWalletWithTimeLockContract } from '../src/contract_wrappers/generated/multi_sig_wallet_with_time_lock'; import { artifacts } from '../util/artifacts'; import { constants } from '../util/constants'; import { MultiSigWrapper } from '../util/multi_sig_wrapper'; @@ -30,12 +32,12 @@ describe('MultiSigWalletWithTimeLock', () => { const accounts = await web3Wrapper.getAvailableAddressesAsync(); owners = [accounts[0], accounts[1]]; }); - const SIGNATURES_REQUIRED = 2; - const SECONDS_TIME_LOCKED = 10000; + const SIGNATURES_REQUIRED = new BigNumber(2); + const SECONDS_TIME_LOCKED = new BigNumber(10000); - let multiSig: Web3.ContractInstance; + let multiSig: MultiSigWalletWithTimeLockContract; let multiSigWrapper: MultiSigWrapper; - let txId: number; + let txId: BigNumber; let initialSecondsTimeLocked: number; let rpc: RPC; @@ -52,20 +54,21 @@ describe('MultiSigWalletWithTimeLock', () => { describe('changeTimeLock', () => { describe('initially non-time-locked', async () => { before('deploy a walet', async () => { - multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [ + const multiSigInstance = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [ owners, SIGNATURES_REQUIRED, 0, ]); - multiSigWrapper = new MultiSigWrapper(multiSig); + multiSig = new MultiSigWalletWithTimeLockContract(multiSigInstance); + multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract); const secondsTimeLocked = await multiSig.secondsTimeLocked(); initialSecondsTimeLocked = secondsTimeLocked.toNumber(); }); it('should throw when not called by wallet', async () => { - return expect(multiSig.changeTimeLock(SECONDS_TIME_LOCKED, { from: owners[0] })).to.be.rejectedWith( - constants.REVERT, - ); + return expect( + multiSig.changeTimeLock.sendTransactionAsync(SECONDS_TIME_LOCKED, { from: owners[0] }), + ).to.be.rejectedWith(constants.REVERT); }); it('should throw without enough confirmations', async () => { @@ -74,7 +77,7 @@ describe('MultiSigWalletWithTimeLock', () => { const dataParams = { name: 'changeTimeLock', abi: MULTI_SIG_ABI, - args: [SECONDS_TIME_LOCKED], + args: [SECONDS_TIME_LOCKED.toNumber()], }; const txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams); const subRes = await zeroEx.awaitTransactionMinedAsync(txHash); @@ -82,10 +85,10 @@ describe('MultiSigWalletWithTimeLock', () => { SubmissionContractEventArgs >; - txId = log.args.transactionId.toNumber(); - return expect(multiSig.executeTransaction(txId, { from: owners[0] })).to.be.rejectedWith( - constants.REVERT, - ); + txId = log.args.transactionId; + return expect( + multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }), + ).to.be.rejectedWith(constants.REVERT); }); it('should set confirmation time with enough confirmations', async () => { @@ -94,7 +97,7 @@ describe('MultiSigWalletWithTimeLock', () => { const dataParams = { name: 'changeTimeLock', abi: MULTI_SIG_ABI, - args: [SECONDS_TIME_LOCKED], + args: [SECONDS_TIME_LOCKED.toNumber()], }; let txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams); const subRes = await zeroEx.awaitTransactionMinedAsync(txHash); @@ -102,15 +105,15 @@ describe('MultiSigWalletWithTimeLock', () => { SubmissionContractEventArgs >; - txId = log.args.transactionId.toNumber(); - txHash = await multiSig.confirmTransaction(txId, { from: owners[1] }); + txId = log.args.transactionId; + txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] }); const res = await zeroEx.awaitTransactionMinedAsync(txHash); expect(res.logs).to.have.length(2); const blockNum = await web3Wrapper.getBlockNumberAsync(); const blockInfo = await web3Wrapper.getBlockAsync(blockNum); const timestamp = new BigNumber(blockInfo.timestamp); - const confirmationTimeBigNum = new BigNumber(await multiSig.confirmationTimes.call(txId)); + const confirmationTimeBigNum = new BigNumber(await multiSig.confirmationTimes(txId)); expect(timestamp).to.be.bignumber.equal(confirmationTimeBigNum); }); @@ -121,7 +124,7 @@ describe('MultiSigWalletWithTimeLock', () => { const dataParams = { name: 'changeTimeLock', abi: MULTI_SIG_ABI, - args: [SECONDS_TIME_LOCKED], + args: [SECONDS_TIME_LOCKED.toNumber()], }; let txHash = await multiSigWrapper.submitTransactionAsync(destination, from, dataParams); const subRes = await zeroEx.awaitTransactionMinedAsync(txHash); @@ -129,27 +132,28 @@ describe('MultiSigWalletWithTimeLock', () => { SubmissionContractEventArgs >; - txId = log.args.transactionId.toNumber(); - txHash = await multiSig.confirmTransaction(txId, { from: owners[1] }); + txId = log.args.transactionId; + txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] }); expect(initialSecondsTimeLocked).to.be.equal(0); - txHash = await multiSig.executeTransaction(txId, { from: owners[0] }); + txHash = await multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }); const res = await zeroEx.awaitTransactionMinedAsync(txHash); expect(res.logs).to.have.length(2); - const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked.call()); + const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked()); expect(secondsTimeLocked).to.be.bignumber.equal(SECONDS_TIME_LOCKED); }); }); describe('initially time-locked', async () => { before('deploy a walet', async () => { - multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [ + const multiSigInstance = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLock, [ owners, SIGNATURES_REQUIRED, SECONDS_TIME_LOCKED, ]); - multiSigWrapper = new MultiSigWrapper(multiSig); + multiSig = new MultiSigWalletWithTimeLockContract(multiSigInstance); + multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract); const secondsTimeLocked = await multiSig.secondsTimeLocked(); initialSecondsTimeLocked = secondsTimeLocked.toNumber(); @@ -165,8 +169,8 @@ describe('MultiSigWalletWithTimeLock', () => { const log = abiDecoder.tryToDecodeLogOrNoop(subRes.logs[0]) as LogWithDecodedArgs< SubmissionContractEventArgs >; - txId = log.args.transactionId.toNumber(); - txHash = await multiSig.confirmTransaction(txId, { + txId = log.args.transactionId; + txHash = await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1], }); const confRes = await zeroEx.awaitTransactionMinedAsync(txHash); @@ -174,16 +178,16 @@ describe('MultiSigWalletWithTimeLock', () => { }); const newSecondsTimeLocked = 0; it('should throw if it has enough confirmations but is not past the time lock', async () => { - return expect(multiSig.executeTransaction(txId, { from: owners[0] })).to.be.rejectedWith( - constants.REVERT, - ); + return expect( + multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }), + ).to.be.rejectedWith(constants.REVERT); }); it('should execute if it has enough confirmations and is past the time lock', async () => { - await rpc.increaseTimeAsync(SECONDS_TIME_LOCKED); - await multiSig.executeTransaction(txId, { from: owners[0] }); + await rpc.increaseTimeAsync(SECONDS_TIME_LOCKED.toNumber()); + await multiSig.executeTransaction.sendTransactionAsync(txId, { from: owners[0] }); - const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked.call()); + const secondsTimeLocked = new BigNumber(await multiSig.secondsTimeLocked()); expect(secondsTimeLocked).to.be.bignumber.equal(newSecondsTimeLocked); }); }); diff --git a/packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts b/packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts index f6b7c1d535..7e9d447302 100644 --- a/packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts +++ b/packages/contracts/test/multi_sig_with_time_lock_except_remove_auth_addr.ts @@ -5,6 +5,9 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as chai from 'chai'; import * as Web3 from 'web3'; +import { MultiSigWalletContract } from '../src/contract_wrappers/generated/multi_sig_wallet'; +import { MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract } from '../src/contract_wrappers/generated/multi_sig_wallet_with_time_lock_except_remove_authorized_address'; +import { TokenTransferProxyContract } from '../src/contract_wrappers/generated/token_transfer_proxy'; import { artifacts } from '../util/artifacts'; import { constants } from '../util/constants'; import { crypto } from '../util/crypto'; @@ -35,8 +38,8 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => { let authorizedAddress: string; let unauthorizedAddress: string; - let tokenTransferProxy: Web3.ContractInstance; - let multiSig: Web3.ContractInstance; + let tokenTransferProxy: TokenTransferProxyContract; + let multiSig: MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract; let multiSigWrapper: MultiSigWrapper; let validDestination: string; @@ -45,20 +48,20 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => { owners = [accounts[0], accounts[1]]; [authorizedAddress, unauthorizedAddress] = accounts; const initialOwner = accounts[0]; - tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy); - await tokenTransferProxy.addAuthorizedAddress(authorizedAddress, { + const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy); + tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance); + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(authorizedAddress, { from: initialOwner, }); - multiSig = await deployer.deployAsync(ContractName.MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress, [ - owners, - requiredApprovals, - SECONDS_TIME_LOCKED, - tokenTransferProxy.address, - ]); - await tokenTransferProxy.transferOwnership(multiSig.address, { + const multiSigInstance = await deployer.deployAsync( + ContractName.MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress, + [owners, requiredApprovals, SECONDS_TIME_LOCKED, tokenTransferProxy.address], + ); + multiSig = new MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddressContract(multiSigInstance); + await tokenTransferProxy.transferOwnership.sendTransactionAsync(multiSig.address, { from: initialOwner, }); - multiSigWrapper = new MultiSigWrapper(multiSig); + multiSigWrapper = new MultiSigWrapper((multiSig as any) as MultiSigWalletContract); validDestination = tokenTransferProxy.address; }); beforeEach(async () => { @@ -71,12 +74,12 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => { describe('isFunctionRemoveAuthorizedAddress', () => { it('should throw if data is not for removeAuthorizedAddress', async () => { const data = MultiSigWrapper.encodeFnArgs('addAuthorizedAddress', PROXY_ABI, [owners[0]]); - return expect(multiSig.isFunctionRemoveAuthorizedAddress.call(data)).to.be.rejectedWith(constants.REVERT); + return expect(multiSig.isFunctionRemoveAuthorizedAddress(data)).to.be.rejectedWith(constants.REVERT); }); it('should return true if data is for removeAuthorizedAddress', async () => { const data = MultiSigWrapper.encodeFnArgs('removeAuthorizedAddress', PROXY_ABI, [owners[0]]); - const isFunctionRemoveAuthorizedAddress = await multiSig.isFunctionRemoveAuthorizedAddress.call(data); + const isFunctionRemoveAuthorizedAddress = await multiSig.isFunctionRemoveAuthorizedAddress(data); expect(isFunctionRemoveAuthorizedAddress).to.be.true(); }); }); @@ -91,11 +94,11 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => { const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams); const res = await zeroEx.awaitTransactionMinedAsync(txHash); const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs; - const txId = log.args.transactionId.toString(); + const txId = log.args.transactionId; - return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith( - constants.REVERT, - ); + return expect( + multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }), + ).to.be.rejectedWith(constants.REVERT); }); it('should throw if tx destination is not the tokenTransferProxy', async () => { @@ -109,14 +112,14 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => { const txHash = await multiSigWrapper.submitTransactionAsync(invalidDestination, owners[0], dataParams); const res = await zeroEx.awaitTransactionMinedAsync(txHash); const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs; - const txId = log.args.transactionId.toString(); - await multiSig.confirmTransaction(txId, { from: owners[1] }); - const isConfirmed = await multiSig.isConfirmed.call(txId); + const txId = log.args.transactionId; + await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] }); + const isConfirmed = await multiSig.isConfirmed(txId); expect(isConfirmed).to.be.true(); - return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith( - constants.REVERT, - ); + return expect( + multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }), + ).to.be.rejectedWith(constants.REVERT); }); it('should throw if tx data is not for removeAuthorizedAddress', async () => { @@ -128,14 +131,14 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => { const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams); const res = await zeroEx.awaitTransactionMinedAsync(txHash); const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs; - const txId = log.args.transactionId.toString(); - await multiSig.confirmTransaction(txId, { from: owners[1] }); - const isConfirmed = await multiSig.isConfirmed.call(txId); + const txId = log.args.transactionId; + await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] }); + const isConfirmed = await multiSig.isConfirmed(txId); expect(isConfirmed).to.be.true(); - return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith( - constants.REVERT, - ); + return expect( + multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }), + ).to.be.rejectedWith(constants.REVERT); }); it('should execute removeAuthorizedAddress for valid tokenTransferProxy if fully confirmed', async () => { @@ -147,12 +150,12 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => { const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams); const res = await zeroEx.awaitTransactionMinedAsync(txHash); const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs; - const txId = log.args.transactionId.toString(); - await multiSig.confirmTransaction(txId, { from: owners[1] }); - const isConfirmed = await multiSig.isConfirmed.call(txId); + const txId = log.args.transactionId; + await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] }); + const isConfirmed = await multiSig.isConfirmed(txId); expect(isConfirmed).to.be.true(); - await multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] }); - const isAuthorized = await tokenTransferProxy.authorized.call(authorizedAddress); + await multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }); + const isAuthorized = await tokenTransferProxy.authorized(authorizedAddress); expect(isAuthorized).to.be.false(); }); @@ -165,17 +168,17 @@ describe('MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress', () => { const txHash = await multiSigWrapper.submitTransactionAsync(validDestination, owners[0], dataParams); const res = await zeroEx.awaitTransactionMinedAsync(txHash); const log = abiDecoder.tryToDecodeLogOrNoop(res.logs[0]) as LogWithDecodedArgs; - const txId = log.args.transactionId.toString(); - await multiSig.confirmTransaction(txId, { from: owners[1] }); + const txId = log.args.transactionId; + await multiSig.confirmTransaction.sendTransactionAsync(txId, { from: owners[1] }); const isConfirmed = await multiSig.isConfirmed(txId); expect(isConfirmed).to.be.true(); - await multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] }); + await multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }); const tx = await multiSig.transactions(txId); const isExecuted = tx[3]; expect(isExecuted).to.be.true(); - return expect(multiSig.executeRemoveAuthorizedAddress(txId, { from: owners[1] })).to.be.rejectedWith( - constants.REVERT, - ); + return expect( + multiSig.executeRemoveAuthorizedAddress.sendTransactionAsync(txId, { from: owners[1] }), + ).to.be.rejectedWith(constants.REVERT); }); }); }); diff --git a/packages/contracts/test/token_registry.ts b/packages/contracts/test/token_registry.ts index 2a270dc2fb..867282d2cc 100644 --- a/packages/contracts/test/token_registry.ts +++ b/packages/contracts/test/token_registry.ts @@ -1,11 +1,13 @@ import { ZeroEx } from '0x.js'; import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils'; +import { BigNumber } from '@0xproject/utils'; import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as chai from 'chai'; import ethUtil = require('ethereumjs-util'); import * as _ from 'lodash'; import * as Web3 from 'web3'; +import { TokenRegistryContract } from '../src/contract_wrappers/generated/token_registry'; import { constants } from '../util/constants'; import { TokenRegWrapper } from '../util/token_registry_wrapper'; import { ContractName } from '../util/types'; @@ -22,13 +24,14 @@ const blockchainLifecycle = new BlockchainLifecycle(); describe('TokenRegistry', () => { let owner: string; let notOwner: string; - let tokenReg: Web3.ContractInstance; + let tokenReg: TokenRegistryContract; let tokenRegWrapper: TokenRegWrapper; before(async () => { const accounts = await web3Wrapper.getAvailableAddressesAsync(); owner = accounts[0]; notOwner = accounts[1]; - tokenReg = await deployer.deployAsync(ContractName.TokenRegistry); + const tokenRegInstance = await deployer.deployAsync(ContractName.TokenRegistry); + tokenReg = new TokenRegistryContract(tokenRegInstance); tokenRegWrapper = new TokenRegWrapper(tokenReg); }); beforeEach(async () => { @@ -132,12 +135,12 @@ describe('TokenRegistry', () => { describe('setTokenName', () => { it('should throw when not called by owner', async () => { return expect( - tokenReg.setTokenName(token1.address, token2.name, { from: notOwner }), + tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, { from: notOwner }), ).to.be.rejectedWith(constants.REVERT); }); it('should change the token name when called by owner', async () => { - await tokenReg.setTokenName(token1.address, token2.name, { + await tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, { from: owner, }); const [newData, oldData] = await Promise.all([ @@ -154,14 +157,14 @@ describe('TokenRegistry', () => { it('should throw if the name already exists', async () => { await tokenRegWrapper.addTokenAsync(token2, owner); - return expect(tokenReg.setTokenName(token1.address, token2.name, { from: owner })).to.be.rejectedWith( - constants.REVERT, - ); + return expect( + tokenReg.setTokenName.sendTransactionAsync(token1.address, token2.name, { from: owner }), + ).to.be.rejectedWith(constants.REVERT); }); it('should throw if token does not exist', async () => { return expect( - tokenReg.setTokenName(nullToken.address, token2.name, { from: owner }), + tokenReg.setTokenName.sendTransactionAsync(nullToken.address, token2.name, { from: owner }), ).to.be.rejectedWith(constants.REVERT); }); }); @@ -169,14 +172,14 @@ describe('TokenRegistry', () => { describe('setTokenSymbol', () => { it('should throw when not called by owner', async () => { return expect( - tokenReg.setTokenSymbol(token1.address, token2.symbol, { + tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, { from: notOwner, }), ).to.be.rejectedWith(constants.REVERT); }); it('should change the token symbol when called by owner', async () => { - await tokenReg.setTokenSymbol(token1.address, token2.symbol, { from: owner }); + await tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, { from: owner }); const [newData, oldData] = await Promise.all([ tokenRegWrapper.getTokenBySymbolAsync(token2.symbol), tokenRegWrapper.getTokenBySymbolAsync(token1.symbol), @@ -192,7 +195,7 @@ describe('TokenRegistry', () => { await tokenRegWrapper.addTokenAsync(token2, owner); return expect( - tokenReg.setTokenSymbol(token1.address, token2.symbol, { + tokenReg.setTokenSymbol.sendTransactionAsync(token1.address, token2.symbol, { from: owner, }), ).to.be.rejectedWith(constants.REVERT); @@ -200,7 +203,7 @@ describe('TokenRegistry', () => { it('should throw if token does not exist', async () => { return expect( - tokenReg.setTokenSymbol(nullToken.address, token2.symbol, { + tokenReg.setTokenSymbol.sendTransactionAsync(nullToken.address, token2.symbol, { from: owner, }), ).to.be.rejectedWith(constants.REVERT); @@ -209,15 +212,15 @@ describe('TokenRegistry', () => { describe('removeToken', () => { it('should throw if not called by owner', async () => { - const index = 0; - return expect(tokenReg.removeToken(token1.address, index, { from: notOwner })).to.be.rejectedWith( - constants.REVERT, - ); + const index = new BigNumber(0); + return expect( + tokenReg.removeToken.sendTransactionAsync(token1.address, index, { from: notOwner }), + ).to.be.rejectedWith(constants.REVERT); }); it('should remove token metadata when called by owner', async () => { - const index = 0; - await tokenReg.removeToken(token1.address, index, { + const index = new BigNumber(0); + await tokenReg.removeToken.sendTransactionAsync(token1.address, index, { from: owner, }); const tokenData = await tokenRegWrapper.getTokenMetaDataAsync(token1.address); @@ -225,18 +228,18 @@ describe('TokenRegistry', () => { }); it('should throw if token does not exist', async () => { - const index = 0; - return expect(tokenReg.removeToken(nullToken.address, index, { from: owner })).to.be.rejectedWith( - constants.REVERT, - ); + const index = new BigNumber(0); + return expect( + tokenReg.removeToken.sendTransactionAsync(nullToken.address, index, { from: owner }), + ).to.be.rejectedWith(constants.REVERT); }); it('should throw if token at given index does not match address', async () => { await tokenRegWrapper.addTokenAsync(token2, owner); - const incorrectIndex = 0; - return expect(tokenReg.removeToken(token2.address, incorrectIndex, { from: owner })).to.be.rejectedWith( - constants.REVERT, - ); + const incorrectIndex = new BigNumber(0); + return expect( + tokenReg.removeToken.sendTransactionAsync(token2.address, incorrectIndex, { from: owner }), + ).to.be.rejectedWith(constants.REVERT); }); }); }); diff --git a/packages/contracts/test/token_transfer_proxy/auth.ts b/packages/contracts/test/token_transfer_proxy/auth.ts index b2bfc6b65f..9d453b0794 100644 --- a/packages/contracts/test/token_transfer_proxy/auth.ts +++ b/packages/contracts/test/token_transfer_proxy/auth.ts @@ -3,6 +3,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as chai from 'chai'; import * as Web3 from 'web3'; +import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy'; import { constants } from '../../util/constants'; import { ContractName } from '../../util/types'; import { chaiSetup } from '../utils/chai_setup'; @@ -18,12 +19,13 @@ describe('TokenTransferProxy', () => { let owner: string; let notOwner: string; let address: string; - let tokenTransferProxy: Web3.ContractInstance; + let tokenTransferProxy: TokenTransferProxyContract; before(async () => { const accounts = await web3Wrapper.getAvailableAddressesAsync(); owner = address = accounts[0]; notOwner = accounts[1]; - tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy); + const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy); + tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance); }); beforeEach(async () => { await blockchainLifecycle.startAsync(); @@ -33,36 +35,36 @@ describe('TokenTransferProxy', () => { }); describe('addAuthorizedAddress', () => { it('should throw if not called by owner', async () => { - return expect(tokenTransferProxy.addAuthorizedAddress(notOwner, { from: notOwner })).to.be.rejectedWith( - constants.REVERT, - ); + return expect( + tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(notOwner, { from: notOwner }), + ).to.be.rejectedWith(constants.REVERT); }); it('should allow owner to add an authorized address', async () => { - await tokenTransferProxy.addAuthorizedAddress(address, { from: owner }); + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }); const isAuthorized = await tokenTransferProxy.authorized(address); expect(isAuthorized).to.be.true(); }); it('should throw if owner attempts to authorize a duplicate address', async () => { - await tokenTransferProxy.addAuthorizedAddress(address, { from: owner }); - return expect(tokenTransferProxy.addAuthorizedAddress(address, { from: owner })).to.be.rejectedWith( - constants.REVERT, - ); + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }); + return expect( + tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }), + ).to.be.rejectedWith(constants.REVERT); }); }); describe('removeAuthorizedAddress', () => { it('should throw if not called by owner', async () => { - await tokenTransferProxy.addAuthorizedAddress(address, { from: owner }); + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }); return expect( - tokenTransferProxy.removeAuthorizedAddress(address, { + tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, { from: notOwner, }), ).to.be.rejectedWith(constants.REVERT); }); it('should allow owner to remove an authorized address', async () => { - await tokenTransferProxy.addAuthorizedAddress(address, { from: owner }); - await tokenTransferProxy.removeAuthorizedAddress(address, { + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner }); + await tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, { from: owner, }); const isAuthorized = await tokenTransferProxy.authorized(address); @@ -71,7 +73,7 @@ describe('TokenTransferProxy', () => { it('should throw if owner attempts to remove an address that is not authorized', async () => { return expect( - tokenTransferProxy.removeAuthorizedAddress(address, { + tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, { from: owner, }), ).to.be.rejectedWith(constants.REVERT); @@ -82,14 +84,14 @@ describe('TokenTransferProxy', () => { it('should return all authorized addresses', async () => { const initial = await tokenTransferProxy.getAuthorizedAddresses(); expect(initial).to.have.length(0); - await tokenTransferProxy.addAuthorizedAddress(address, { + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(address, { from: owner, }); const afterAdd = await tokenTransferProxy.getAuthorizedAddresses(); expect(afterAdd).to.have.length(1); expect(afterAdd).to.include(address); - await tokenTransferProxy.removeAuthorizedAddress(address, { + await tokenTransferProxy.removeAuthorizedAddress.sendTransactionAsync(address, { from: owner, }); const afterRemove = await tokenTransferProxy.getAuthorizedAddresses(); diff --git a/packages/contracts/test/token_transfer_proxy/transfer_from.ts b/packages/contracts/test/token_transfer_proxy/transfer_from.ts index bd7adcfae8..c35a7276ac 100644 --- a/packages/contracts/test/token_transfer_proxy/transfer_from.ts +++ b/packages/contracts/test/token_transfer_proxy/transfer_from.ts @@ -1,8 +1,11 @@ import { BlockchainLifecycle, devConstants, web3Factory } from '@0xproject/dev-utils'; +import { BigNumber } from '@0xproject/utils'; import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as chai from 'chai'; import * as Web3 from 'web3'; +import { DummyTokenContract } from '../../src/contract_wrappers/generated/dummy_token'; +import { TokenTransferProxyContract } from '../../src/contract_wrappers/generated/token_transfer_proxy'; import { Balances } from '../../util/balances'; import { constants } from '../../util/constants'; import { ContractName } from '../../util/types'; @@ -19,29 +22,31 @@ describe('TokenTransferProxy', () => { let accounts: string[]; let owner: string; let notAuthorized: string; - const INIT_BAL = 100000000; - const INIT_ALLOW = 100000000; + const INIT_BAL = new BigNumber(100000000); + const INIT_ALLOW = new BigNumber(100000000); - let tokenTransferProxy: Web3.ContractInstance; - let rep: Web3.ContractInstance; + let tokenTransferProxy: TokenTransferProxyContract; + let rep: DummyTokenContract; let dmyBalances: Balances; before(async () => { accounts = await web3Wrapper.getAvailableAddressesAsync(); owner = notAuthorized = accounts[0]; - tokenTransferProxy = await deployer.deployAsync(ContractName.TokenTransferProxy); - rep = await deployer.deployAsync(ContractName.DummyToken); + const tokenTransferProxyInstance = await deployer.deployAsync(ContractName.TokenTransferProxy); + tokenTransferProxy = new TokenTransferProxyContract(tokenTransferProxyInstance); + const repInstance = await deployer.deployAsync(ContractName.DummyToken); + rep = new DummyTokenContract(repInstance); dmyBalances = new Balances([rep], [accounts[0], accounts[1]]); await Promise.all([ - rep.approve(tokenTransferProxy.address, INIT_ALLOW, { + rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: accounts[0], }), - rep.setBalance(accounts[0], INIT_BAL, { from: owner }), - rep.approve(tokenTransferProxy.address, INIT_ALLOW, { + rep.setBalance.sendTransactionAsync(accounts[0], INIT_BAL, { from: owner }), + rep.approve.sendTransactionAsync(tokenTransferProxy.address, INIT_ALLOW, { from: accounts[1], }), - rep.setBalance(accounts[1], INIT_BAL, { from: owner }), + rep.setBalance.sendTransactionAsync(accounts[1], INIT_BAL, { from: owner }), ]); }); beforeEach(async () => { @@ -54,20 +59,34 @@ describe('TokenTransferProxy', () => { describe('transferFrom', () => { it('should throw when called by an unauthorized address', async () => { expect( - tokenTransferProxy.transferFrom(rep.address, accounts[0], accounts[1], 1000, { from: notAuthorized }), + tokenTransferProxy.transferFrom.sendTransactionAsync( + rep.address, + accounts[0], + accounts[1], + new BigNumber(1000), + { + from: notAuthorized, + }, + ), ).to.be.rejectedWith(constants.REVERT); }); it('should allow an authorized address to transfer', async () => { const balances = await dmyBalances.getAsync(); - await tokenTransferProxy.addAuthorizedAddress(notAuthorized, { + await tokenTransferProxy.addAuthorizedAddress.sendTransactionAsync(notAuthorized, { from: owner, }); - const transferAmt = 10000; - await tokenTransferProxy.transferFrom(rep.address, accounts[0], accounts[1], transferAmt, { - from: notAuthorized, - }); + const transferAmt = new BigNumber(10000); + await tokenTransferProxy.transferFrom.sendTransactionAsync( + rep.address, + accounts[0], + accounts[1], + transferAmt, + { + from: notAuthorized, + }, + ); const newBalances = await dmyBalances.getAsync(); expect(newBalances[accounts[0]][rep.address]).to.be.bignumber.equal( diff --git a/packages/contracts/test/unlimited_allowance_token.ts b/packages/contracts/test/unlimited_allowance_token.ts index 34d2ba33b1..f0a66e76b7 100644 --- a/packages/contracts/test/unlimited_allowance_token.ts +++ b/packages/contracts/test/unlimited_allowance_token.ts @@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as chai from 'chai'; import * as Web3 from 'web3'; +import { DummyTokenContract } from '../src/contract_wrappers/generated/dummy_token'; import { constants } from '../util/constants'; import { ContractName } from '../util/types'; @@ -27,14 +28,15 @@ describe('UnlimitedAllowanceToken', () => { const MAX_MINT_VALUE = new BigNumber(100000000000000000000); let tokenAddress: string; - let token: Web3.ContractInstance; + let token: DummyTokenContract; before(async () => { const accounts = await web3Wrapper.getAvailableAddressesAsync(); owner = accounts[0]; spender = accounts[1]; - token = await deployer.deployAsync(ContractName.DummyToken); - await token.mint(MAX_MINT_VALUE, { from: owner }); + const tokenInstance = await deployer.deployAsync(ContractName.DummyToken); + token = new DummyTokenContract(tokenInstance); + await token.mint.sendTransactionAsync(MAX_MINT_VALUE, { from: owner }); tokenAddress = token.address; }); beforeEach(async () => { @@ -47,7 +49,7 @@ describe('UnlimitedAllowanceToken', () => { it('should throw if owner has insufficient balance', async () => { const ownerBalance = await zeroEx.token.getBalanceAsync(tokenAddress, owner); const amountToTransfer = ownerBalance.plus(1); - return expect(token.transfer.call(spender, amountToTransfer, { from: owner })).to.be.rejectedWith( + return expect(token.transfer.callAsync(spender, amountToTransfer, { from: owner })).to.be.rejectedWith( constants.REVERT, ); }); @@ -67,7 +69,7 @@ describe('UnlimitedAllowanceToken', () => { }); it('should return true on a 0 value transfer', async () => { - const didReturnTrue = await token.transfer.call(spender, 0, { + const didReturnTrue = await token.transfer.callAsync(spender, new BigNumber(0), { from: owner, }); expect(didReturnTrue).to.be.true(); @@ -80,7 +82,7 @@ describe('UnlimitedAllowanceToken', () => { const amountToTransfer = ownerBalance.plus(1); await zeroEx.token.setAllowanceAsync(tokenAddress, owner, spender, amountToTransfer); return expect( - token.transferFrom.call(owner, spender, amountToTransfer, { + token.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender, }), ).to.be.rejectedWith(constants.REVERT); @@ -95,15 +97,17 @@ describe('UnlimitedAllowanceToken', () => { expect(spenderAllowanceIsInsufficient).to.be.true(); return expect( - token.transferFrom.call(owner, spender, amountToTransfer, { + token.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender, }), ).to.be.rejectedWith(constants.REVERT); }); it('should return true on a 0 value transfer', async () => { - const amountToTransfer = 0; - const didReturnTrue = await token.transferFrom.call(owner, spender, amountToTransfer, { from: spender }); + const amountToTransfer = new BigNumber(0); + const didReturnTrue = await token.transferFrom.callAsync(owner, spender, amountToTransfer, { + from: spender, + }); expect(didReturnTrue).to.be.true(); }); diff --git a/packages/contracts/test/zrx_token.ts b/packages/contracts/test/zrx_token.ts index 1844a67aff..5e4bfed37a 100644 --- a/packages/contracts/test/zrx_token.ts +++ b/packages/contracts/test/zrx_token.ts @@ -5,6 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as chai from 'chai'; import * as Web3 from 'web3'; +import { ZRXTokenContract } from '../src/contract_wrappers/generated/z_r_x_token'; import { constants } from '../util/constants'; import { ContractName } from '../util/types'; @@ -24,7 +25,7 @@ describe('ZRXToken', () => { let MAX_UINT: BigNumber; - let zrx: Web3.ContractInstance; + let zrx: ZRXTokenContract; let zrxAddress: string; before(async () => { @@ -34,7 +35,8 @@ describe('ZRXToken', () => { zeroEx = new ZeroEx(web3.currentProvider, { networkId: constants.TESTRPC_NETWORK_ID, }); - zrx = await deployer.deployAsync(ContractName.ZRXToken); + const zrxInstance = await deployer.deployAsync(ContractName.ZRXToken); + zrx = new ZRXTokenContract(zrxInstance); zrxAddress = zrx.address; MAX_UINT = zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS; }); @@ -94,7 +96,7 @@ describe('ZRXToken', () => { }); it('should return true on a 0 value transfer', async () => { - const didReturnTrue = await zrx.transfer.call(spender, 0, { + const didReturnTrue = await zrx.transfer.callAsync(spender, new BigNumber(0), { from: owner, }); expect(didReturnTrue).to.be.true(); @@ -108,7 +110,7 @@ describe('ZRXToken', () => { await zeroEx.token.setAllowanceAsync(zrxAddress, owner, spender, amountToTransfer, { gasLimit: constants.MAX_TOKEN_APPROVE_GAS, }); - const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender }); + const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender }); expect(didReturnTrue).to.be.false(); }); @@ -120,13 +122,13 @@ describe('ZRXToken', () => { const spenderAllowanceIsInsufficient = spenderAllowance.cmp(amountToTransfer) < 0; expect(spenderAllowanceIsInsufficient).to.be.true(); - const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender }); + const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender }); expect(didReturnTrue).to.be.false(); }); it('should return true on a 0 value transfer', async () => { - const amountToTransfer = 0; - const didReturnTrue = await zrx.transferFrom.call(owner, spender, amountToTransfer, { from: spender }); + const amountToTransfer = new BigNumber(0); + const didReturnTrue = await zrx.transferFrom.callAsync(owner, spender, amountToTransfer, { from: spender }); expect(didReturnTrue).to.be.true(); }); From 4cc5bbaf19d2388b0be0669a6249bf92f60c712c Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:40:25 +0100 Subject: [PATCH 12/21] Change utils --- packages/contracts/util/balances.ts | 6 ++- packages/contracts/util/exchange_wrapper.ts | 42 ++++++++++--------- packages/contracts/util/multi_sig_wrapper.ts | 13 +++--- .../contracts/util/token_registry_wrapper.ts | 12 +++--- 4 files changed, 41 insertions(+), 32 deletions(-) diff --git a/packages/contracts/util/balances.ts b/packages/contracts/util/balances.ts index 5bcb5145f9..0abc305d81 100644 --- a/packages/contracts/util/balances.ts +++ b/packages/contracts/util/balances.ts @@ -2,12 +2,14 @@ import { BigNumber } from '@0xproject/utils'; import * as _ from 'lodash'; import * as Web3 from 'web3'; +import { DummyTokenContract } from '../src/contract_wrappers/generated/dummy_token'; + import { BalancesByOwner } from './types'; export class Balances { - private _tokenContractInstances: Web3.ContractInstance[]; + private _tokenContractInstances: DummyTokenContract[]; private _ownerAddresses: string[]; - constructor(tokenContractInstances: Web3.ContractInstance[], ownerAddresses: string[]) { + constructor(tokenContractInstances: DummyTokenContract[], ownerAddresses: string[]) { this._tokenContractInstances = tokenContractInstances; this._ownerAddresses = ownerAddresses; } diff --git a/packages/contracts/util/exchange_wrapper.ts b/packages/contracts/util/exchange_wrapper.ts index 7a07239f58..b749cd72ee 100644 --- a/packages/contracts/util/exchange_wrapper.ts +++ b/packages/contracts/util/exchange_wrapper.ts @@ -3,14 +3,16 @@ import { BigNumber } from '@0xproject/utils'; import * as _ from 'lodash'; import * as Web3 from 'web3'; +import { ExchangeContract } from '../src/contract_wrappers/generated/exchange'; + import { formatters } from './formatters'; import { Order } from './order'; export class ExchangeWrapper { - private _exchange: Web3.ContractInstance; + private _exchange: ExchangeContract; private _zeroEx: ZeroEx; - constructor(exchangeContractInstance: Web3.ContractInstance, zeroEx: ZeroEx) { - this._exchange = exchangeContractInstance; + constructor(exchangeContract: ExchangeContract, zeroEx: ZeroEx) { + this._exchange = exchangeContract; this._zeroEx = zeroEx; } public async fillOrderAsync( @@ -23,14 +25,14 @@ export class ExchangeWrapper { ): Promise { const shouldThrowOnInsufficientBalanceOrAllowance = !!opts.shouldThrowOnInsufficientBalanceOrAllowance; const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount); - const txHash = await this._exchange.fillOrder( + const txHash = await this._exchange.fillOrder.sendTransactionAsync( params.orderAddresses, params.orderValues, params.fillTakerTokenAmount, params.shouldThrowOnInsufficientBalanceOrAllowance, - params.v, - params.r, - params.s, + params.v as number, + params.r as string, + params.s as string, { from }, ); const tx = await this._zeroEx.awaitTransactionMinedAsync(txHash); @@ -44,7 +46,7 @@ export class ExchangeWrapper { opts: { cancelTakerTokenAmount?: BigNumber } = {}, ): Promise { const params = order.createCancel(opts.cancelTakerTokenAmount); - const txHash = await this._exchange.cancelOrder( + const txHash = await this._exchange.cancelOrder.sendTransactionAsync( params.orderAddresses, params.orderValues, params.cancelTakerTokenAmount, @@ -62,13 +64,13 @@ export class ExchangeWrapper { ): Promise { const shouldThrowOnInsufficientBalanceOrAllowance = true; const params = order.createFill(shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount); - const txHash = await this._exchange.fillOrKillOrder( + const txHash = await this._exchange.fillOrKillOrder.sendTransactionAsync( params.orderAddresses, params.orderValues, params.fillTakerTokenAmount, - params.v, - params.r, - params.s, + params.v as number, + params.r as string, + params.s as string, { from }, ); const tx = await this._zeroEx.awaitTransactionMinedAsync(txHash); @@ -90,7 +92,7 @@ export class ExchangeWrapper { shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmounts, ); - const txHash = await this._exchange.batchFillOrders( + const txHash = await this._exchange.batchFillOrders.sendTransactionAsync( params.orderAddresses, params.orderValues, params.fillTakerTokenAmounts, @@ -116,7 +118,7 @@ export class ExchangeWrapper { shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmounts, ); - const txHash = await this._exchange.batchFillOrKillOrders( + const txHash = await this._exchange.batchFillOrKillOrders.sendTransactionAsync( params.orderAddresses, params.orderValues, params.fillTakerTokenAmounts, @@ -141,7 +143,7 @@ export class ExchangeWrapper { shouldThrowOnInsufficientBalanceOrAllowance, opts.fillTakerTokenAmount, ); - const txHash = await this._exchange.fillOrdersUpTo( + const txHash = await this._exchange.fillOrdersUpTo.sendTransactionAsync( params.orderAddresses, params.orderValues, params.fillTakerTokenAmount, @@ -162,7 +164,7 @@ export class ExchangeWrapper { opts: { cancelTakerTokenAmounts?: BigNumber[] } = {}, ): Promise { const params = formatters.createBatchCancel(orders, opts.cancelTakerTokenAmounts); - const txHash = await this._exchange.batchCancelOrders( + const txHash = await this._exchange.batchCancelOrders.sendTransactionAsync( params.orderAddresses, params.orderValues, params.cancelTakerTokenAmounts, @@ -182,10 +184,10 @@ export class ExchangeWrapper { public async isValidSignatureAsync(order: Order): Promise { const isValidSignature = await this._exchange.isValidSignature( order.params.maker, - order.params.orderHashHex, - order.params.v, - order.params.r, - order.params.s, + order.params.orderHashHex as string, + order.params.v as number, + order.params.r as string, + order.params.s as string, ); return isValidSignature; } diff --git a/packages/contracts/util/multi_sig_wrapper.ts b/packages/contracts/util/multi_sig_wrapper.ts index 0a066df536..3b83ccb7b1 100644 --- a/packages/contracts/util/multi_sig_wrapper.ts +++ b/packages/contracts/util/multi_sig_wrapper.ts @@ -1,12 +1,15 @@ +import { BigNumber } from '@0xproject/utils'; import ABI = require('ethereumjs-abi'); import ethUtil = require('ethereumjs-util'); import * as _ from 'lodash'; import * as Web3 from 'web3'; +import { MultiSigWalletContract } from '../src/contract_wrappers/generated/multi_sig_wallet'; + import { TransactionDataParams } from './types'; export class MultiSigWrapper { - private _multiSig: Web3.ContractInstance; + private _multiSig: MultiSigWalletContract; public static encodeFnArgs(name: string, abi: Web3.AbiDefinition[], args: any[]) { const abiEntity = _.find(abi, { name }) as Web3.MethodAbi; if (_.isUndefined(abiEntity)) { @@ -21,18 +24,18 @@ export class MultiSigWrapper { }); return funcSig + argsData.join(''); } - constructor(multiSigContractInstance: Web3.ContractInstance) { - this._multiSig = multiSigContractInstance; + constructor(multiSigContract: MultiSigWalletContract) { + this._multiSig = multiSigContract; } public async submitTransactionAsync( destination: string, from: string, dataParams: TransactionDataParams, - value: number = 0, + value: BigNumber = new BigNumber(0), ) { const { name, abi, args = [] } = dataParams; const encoded = MultiSigWrapper.encodeFnArgs(name, abi, args); - return this._multiSig.submitTransaction(destination, value, encoded, { + return this._multiSig.submitTransaction.sendTransactionAsync(destination, value, encoded, { from, }); } diff --git a/packages/contracts/util/token_registry_wrapper.ts b/packages/contracts/util/token_registry_wrapper.ts index 033b72d10d..6539a6da87 100644 --- a/packages/contracts/util/token_registry_wrapper.ts +++ b/packages/contracts/util/token_registry_wrapper.ts @@ -1,15 +1,17 @@ import * as Web3 from 'web3'; +import { TokenRegistryContract } from '../src/contract_wrappers/generated/token_registry'; + import { Token } from './types'; export class TokenRegWrapper { - private _tokenReg: Web3.ContractInstance; - constructor(tokenRegContractInstance: Web3.ContractInstance) { - this._tokenReg = tokenRegContractInstance; + private _tokenReg: TokenRegistryContract; + constructor(tokenRegContract: TokenRegistryContract) { + this._tokenReg = tokenRegContract; } public addTokenAsync(token: Token, from: string) { - const tx = this._tokenReg.addToken( - token.address, + const tx = this._tokenReg.addToken.sendTransactionAsync( + token.address as string, token.name, token.symbol, token.decimals, From 071b1c47d10c7a750246e35c7849478e29ff2901 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:40:52 +0100 Subject: [PATCH 13/21] Change compiled sources in contracts --- packages/contracts/tsconfig.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/contracts/tsconfig.json b/packages/contracts/tsconfig.json index 0c1b3bc163..d3e1aed9c5 100644 --- a/packages/contracts/tsconfig.json +++ b/packages/contracts/tsconfig.json @@ -14,10 +14,10 @@ "../../node_modules/types-ethereumjs-util/index.d.ts", "../../node_modules/types-bn/index.d.ts", "./globals.d.ts", + "./src/**/*", "./util/**/*", "./test/**/*", - "./migrations/**/*", - "./deploy/**/*" + "./migrations/**/*" ], "exclude": ["./deploy/solc/solc_bin"] } From ae775f96644c0a4d936287b49f6ff4fad0981c01 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:48:51 +0100 Subject: [PATCH 14/21] Tslint disable no-consecutive-blank-lines in generated files --- packages/contracts/contract_templates/contract.handlebars | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/contracts/contract_templates/contract.handlebars b/packages/contracts/contract_templates/contract.handlebars index f9ffb730c4..afb9708e97 100644 --- a/packages/contracts/contract_templates/contract.handlebars +++ b/packages/contracts/contract_templates/contract.handlebars @@ -2,7 +2,7 @@ * 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. */ -// tslint:disable:async-suffix member-ordering +// tslint:disable:async-suffix member-ordering no-consecutive-blank-lines // tslint:disable-next-line:no-unused-variable import { TxData, TxDataPayable } from '@0xproject/types'; import { BigNumber, classUtils, promisify } from '@0xproject/utils'; From e35519b50fc4efd6f23b035ad4d5cd691e644553 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:49:10 +0100 Subject: [PATCH 15/21] Remove noImplicitThis --- packages/contracts/tsconfig.json | 1 + 1 file changed, 1 insertion(+) diff --git a/packages/contracts/tsconfig.json b/packages/contracts/tsconfig.json index d3e1aed9c5..b618ca4e70 100644 --- a/packages/contracts/tsconfig.json +++ b/packages/contracts/tsconfig.json @@ -4,6 +4,7 @@ "outDir": "lib", "baseUrl": ".", "declaration": false, + "noImplicitThis": false, "allowJs": true }, "include": [ From a96e3f3222e5c5b26d4241ba8fdc84bdc0220047 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:49:17 +0100 Subject: [PATCH 16/21] Add missing async --- packages/contracts/util/token_registry_wrapper.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/contracts/util/token_registry_wrapper.ts b/packages/contracts/util/token_registry_wrapper.ts index 6539a6da87..d0af171033 100644 --- a/packages/contracts/util/token_registry_wrapper.ts +++ b/packages/contracts/util/token_registry_wrapper.ts @@ -9,7 +9,7 @@ export class TokenRegWrapper { constructor(tokenRegContract: TokenRegistryContract) { this._tokenReg = tokenRegContract; } - public addTokenAsync(token: Token, from: string) { + public async addTokenAsync(token: Token, from: string) { const tx = this._tokenReg.addToken.sendTransactionAsync( token.address as string, token.name, From 55312d00ef7ee9a71204d55e339bc143d6586339 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 16:58:13 +0100 Subject: [PATCH 17/21] Generate contract wrappers on pre-build --- packages/contracts/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/contracts/package.json b/packages/contracts/package.json index 61cda2622a..af7441d855 100644 --- a/packages/contracts/package.json +++ b/packages/contracts/package.json @@ -9,7 +9,7 @@ }, "scripts": { "build:watch": "tsc -w", - "prebuild": "run-s clean copy_artifacts", + "prebuild": "run-s clean copy_artifacts generate_contract_wrappers", "copy_artifacts": "copyfiles './src/artifacts/**/*' ./lib", "build": "tsc", "test": "run-s compile build run_mocha", From fcbe24a1263e189aad8f2698043217e6ed6488b3 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 17:15:20 +0100 Subject: [PATCH 18/21] Fix linter errors --- packages/0x.js/contract_templates/contract.handlebars | 1 + packages/0x.js/contract_templates/partials/event.handlebars | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/packages/0x.js/contract_templates/contract.handlebars b/packages/0x.js/contract_templates/contract.handlebars index 227cfcc5a7..33699b8a79 100644 --- a/packages/0x.js/contract_templates/contract.handlebars +++ b/packages/0x.js/contract_templates/contract.handlebars @@ -2,6 +2,7 @@ * 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/0x.js/contract_templates. */ +// tslint:disable:no-consecutive-blank-lines // tslint:disable-next-line:no-unused-variable import { TxData, TxDataPayable } from '@0xproject/types'; import { BigNumber, classUtils, promisify } from '@0xproject/utils'; diff --git a/packages/0x.js/contract_templates/partials/event.handlebars b/packages/0x.js/contract_templates/partials/event.handlebars index 8f8676a4ff..6d68d4c0f5 100644 --- a/packages/0x.js/contract_templates/partials/event.handlebars +++ b/packages/0x.js/contract_templates/partials/event.handlebars @@ -1,5 +1,5 @@ export interface {{name}}ContractEventArgs { {{#each inputs}} - {{name}}: {{#returnType type}}{{/returnType}}, + {{name}}: {{#returnType type}}{{/returnType}}; {{/each}} -}; +} From b61852b1f5501efd357e61c5478f25b68455dc38 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 22:40:14 +0100 Subject: [PATCH 19/21] Special-case ZRXToken snake case conversion --- packages/abi-gen/src/index.ts | 5 ++++- .../contracts/src/contract_wrappers/generated/.gitignore | 2 +- packages/contracts/test/zrx_token.ts | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts index 46d41861dd..68beb2352f 100644 --- a/packages/abi-gen/src/index.ts +++ b/packages/abi-gen/src/index.ts @@ -64,7 +64,10 @@ function registerPartials(partialsGlob: string) { } function writeOutputFile(name: string, renderedTsCode: string): void { - const fileName = toSnakeCase(name); + let fileName = toSnakeCase(name); + if (fileName === 'z_r_x_token') { + fileName = 'zrx_token'; + } const filePath = `${args.output}/${fileName}.ts`; fs.writeFileSync(filePath, renderedTsCode); utils.log(`Created: ${chalk.bold(filePath)}`); diff --git a/packages/contracts/src/contract_wrappers/generated/.gitignore b/packages/contracts/src/contract_wrappers/generated/.gitignore index c9bba195a3..b976a8737e 100644 --- a/packages/contracts/src/contract_wrappers/generated/.gitignore +++ b/packages/contracts/src/contract_wrappers/generated/.gitignore @@ -5,4 +5,4 @@ multi_sig_wallet_with_time_lock.ts multi_sig_wallet.ts token_registry.ts token_transfer_proxy.ts -z_r_x_token.ts +zrx_token.ts diff --git a/packages/contracts/test/zrx_token.ts b/packages/contracts/test/zrx_token.ts index 5e4bfed37a..1610ada120 100644 --- a/packages/contracts/test/zrx_token.ts +++ b/packages/contracts/test/zrx_token.ts @@ -5,7 +5,7 @@ import { Web3Wrapper } from '@0xproject/web3-wrapper'; import * as chai from 'chai'; import * as Web3 from 'web3'; -import { ZRXTokenContract } from '../src/contract_wrappers/generated/z_r_x_token'; +import { ZRXTokenContract } from '../src/contract_wrappers/generated/zrx_token'; import { constants } from '../util/constants'; import { ContractName } from '../util/types'; From 6e87c9e7133d9250a861151545deb50122b16f30 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Tue, 6 Feb 2018 23:33:29 +0100 Subject: [PATCH 20/21] Stop using definite assignment assertion cause prettier doesn't handle that --- packages/testnet-faucets/tsconfig.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/testnet-faucets/tsconfig.json b/packages/testnet-faucets/tsconfig.json index 79f9e2413e..5deaaebe63 100644 --- a/packages/testnet-faucets/tsconfig.json +++ b/packages/testnet-faucets/tsconfig.json @@ -1,7 +1,8 @@ { "extends": "../../tsconfig", "compilerOptions": { - "outDir": "lib" + "outDir": "lib", + "strictPropertyInitialization": false }, "include": [ "./src/ts/**/*", From 0bad911a16dd2924e5be693710a422383aba4871 Mon Sep 17 00:00:00 2001 From: Leonid Logvinov Date: Wed, 7 Feb 2018 00:03:44 +0100 Subject: [PATCH 21/21] Fix ABI error message --- packages/0x.js/src/order_watcher/order_state_watcher.ts | 1 - packages/abi-gen/src/index.ts | 4 +++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/packages/0x.js/src/order_watcher/order_state_watcher.ts b/packages/0x.js/src/order_watcher/order_state_watcher.ts index 9ff07b38d9..e489dd5cc2 100644 --- a/packages/0x.js/src/order_watcher/order_state_watcher.ts +++ b/packages/0x.js/src/order_watcher/order_state_watcher.ts @@ -25,7 +25,6 @@ import { TokenWrapper } from '../contract_wrappers/token_wrapper'; import { BalanceAndProxyAllowanceLazyStore } from '../stores/balance_proxy_allowance_lazy_store'; import { OrderFilledCancelledLazyStore } from '../stores/order_filled_cancelled_lazy_store'; import { - BlockParamLiteral, ContractEventArgs, ExchangeContractErrs, LogEvent, diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts index 68beb2352f..bc5a974a98 100644 --- a/packages/abi-gen/src/index.ts +++ b/packages/abi-gen/src/index.ts @@ -106,7 +106,9 @@ for (const abiFileName of abiFileNames) { } if (_.isUndefined(ABI)) { utils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`); - utils.log(`Please make sure your ABI file is either an array with ABI entries or an object with the abi key`); + utils.log( + `Please make sure your ABI file is either an array with ABI entries or a truffle artifact or 0x deployer artifact`, + ); process.exit(1); }