diff --git a/.circleci/config.yml b/.circleci/config.yml index 9c1046dc0b..a387f40e6d 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -29,6 +29,10 @@ jobs: key: repo-{{ .Environment.CIRCLE_SHA1 }} paths: - ~/repo + - save_cache: + key: python-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }} + paths: + - ~/repo/packages/python-contract-wrappers/generated build-website: resource_class: medium+ docker: @@ -210,14 +214,17 @@ jobs: - run: sudo chown -R circleci:circleci /usr/local/bin - run: sudo chown -R circleci:circleci /usr/local/lib/python3.7 - restore_cache: - key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} + key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} + - restore_cache: + key: python-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }} - run: command: | cd python-packages python -m ensurepip + ./pre_install ./install - save_cache: - key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} + key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} paths: - '/usr/local/bin' - '/usr/local/lib/python3.7/site-packages' @@ -258,14 +265,14 @@ jobs: - run: sudo chown -R circleci:circleci /usr/local/bin - run: sudo chown -R circleci:circleci /usr/local/lib/python3.7 - restore_cache: - key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} + key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} - run: command: | cd python-packages/order_utils python -m ensurepip python -m pip install . - save_cache: - key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} + key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} paths: - '/usr/local/bin' - '/usr/local/lib/python3.7/site-packages' @@ -286,11 +293,14 @@ jobs: - run: sudo chown -R circleci:circleci /usr/local/bin - run: sudo chown -R circleci:circleci /usr/local/lib/python3.7 - restore_cache: - key: deps9-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} + key: installed-py-{{ .Branch }}-{{ .Environment.CIRCLE_SHA1 }} + - restore_cache: + key: python-contract-wrappers-{{ .Environment.CIRCLE_SHA1 }} - run: command: | python -m ensurepip cd python-packages + ./pre_install ./install ./lint static-tests: @@ -419,6 +429,8 @@ workflows: - static-tests-python: requires: - test-python - - test-python + - test-python: + requires: + - build # skip python tox run for now, as we don't yet have multiple test environments to support. #- test-rest-python diff --git a/.gitignore b/.gitignore index 3ed656cbdf..6a958afc41 100644 --- a/.gitignore +++ b/.gitignore @@ -96,11 +96,14 @@ contracts/extensions/generated-artifacts/ contracts/exchange-forwarder/generated-artifacts/ contracts/dev-utils/generated-artifacts/ /packages/abi-gen/test/generated-test/generated-artifacts +/packages/abi-gen/test/generated-test/output packages/sol-tracing-utils/test/fixtures/artifacts/ packages/metacoin/artifacts/ +python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ # generated contract wrappers -packages/abi-gen-wrappers/wrappers +packages/abi-gen-wrappers/src/generated-wrappers/ +packages/python-contract-wrappers/generated/ contracts/coordinator/generated-wrappers/ contracts/exchange/generated-wrappers/ contracts/asset-proxy/generated-wrappers/ diff --git a/.prettierignore b/.prettierignore index 27f17a48d8..5a4ab213ff 100644 --- a/.prettierignore +++ b/.prettierignore @@ -25,7 +25,7 @@ lib /contracts/dev-utils/generated-wrappers /contracts/dev-utils/generated-artifacts /packages/abi-gen/test/generated-test/generated-artifacts -/packages/abi-gen/test/generated-test/generated-wrappers +/packages/abi-gen/test/generated-test/known-good /packages/abi-gen-wrappers/src/generated-wrappers /packages/contract-artifacts/artifacts /python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts diff --git a/CODEOWNERS b/CODEOWNERS index 6ce54ef1fd..e47c2c742b 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -11,10 +11,10 @@ packages/website/ @BMillman19 @fragosti @fabioberger @steveklebanoff # Dev tools & setup .circleci/ @LogvinovLeon -packages/abi-gen/ @LogvinovLeon -packages/base-contract/ @LogvinovLeon +packages/abi-gen/ @feuGeneA +packages/base-contract/ @xianny packages/connect/ @fragosti -packages/abi-gen-templates/ @LogvinovLeon +packages/abi-gen-templates/ @feuGeneA @xianny packages/contract-addresses/ @albrow packages/contract-artifacts/ @albrow packages/dev-utils/ @LogvinovLeon @fabioberger @@ -23,6 +23,7 @@ packages/ethereum-types/ @LogvinovLeon packages/metacoin/ @LogvinovLeon packages/monorepo-scripts/ @fabioberger packages/order-utils/ @fabioberger @LogvinovLeon +packages/python-contract-wrappers/ @feuGeneA packages/sol-compiler/ @LogvinovLeon packages/sol-coverage/ @LogvinovLeon packages/sol-profiler/ @LogvinovLeon diff --git a/packages/abi-gen-templates/CHANGELOG.json b/packages/abi-gen-templates/CHANGELOG.json index 873c3c54b6..15f8790d43 100644 --- a/packages/abi-gen-templates/CHANGELOG.json +++ b/packages/abi-gen-templates/CHANGELOG.json @@ -9,6 +9,10 @@ { "note": "Move `getABITransactionData` to `callAsync` template", "pr": 1863 + }, + { + "note": "Initial support for Python", + "pr": 1878 } ] }, diff --git a/packages/abi-gen-templates/Python/contract.handlebars b/packages/abi-gen-templates/Python/contract.handlebars new file mode 100644 index 0000000000..63d9ed412c --- /dev/null +++ b/packages/abi-gen-templates/Python/contract.handlebars @@ -0,0 +1,57 @@ +"""Generated wrapper for {{contractName}} Solidity contract.""" + +import json +from typing import Optional, Tuple, Union + +from hexbytes import HexBytes +from web3.datastructures import AttributeDict +from web3.providers.base import BaseProvider + +from zero_ex.contract_wrappers._base_contract_wrapper import BaseContractWrapper +from zero_ex.contract_wrappers.tx_params import TxParams + + +class {{contractName}}(BaseContractWrapper): + """Wrapper class for {{contractName}} Solidity contract.""" + + def __init__( + self, + provider: BaseProvider, + contract_address: str, + private_key: str = None, + ): + """Get an instance of wrapper for smart contract. + + :param provider: instance of :class:`web3.providers.base.BaseProvider` + :param contract_address: where the contract has been deployed + :param private_key: If specified, transactions will be signed locally, + via Web3.py's `eth.account.signTransaction()`:code:, before being + sent via `eth.sendRawTransaction()`:code:. + """ + super().__init__( + provider=provider, + contract_address=contract_address, + private_key=private_key, + ) + + def _get_contract_instance(self, token_address): + """Get an instance of the smart contract at a specific address. + + :returns: contract object + """ + return self._contract_instance( + address=token_address, abi={{contractName}}.abi() + ) +{{#each methods}} +{{> call contractName=../contractName}} +{{/each}} +{{#each events}} +{{> event}} +{{/each}} + + @staticmethod + def abi(): + """Return the ABI to the underlying contract.""" + return json.loads( + '{{{ABI}}}' # noqa: E501 (line-too-long) + ) diff --git a/packages/abi-gen-templates/Python/partials/call.handlebars b/packages/abi-gen-templates/Python/partials/call.handlebars new file mode 100644 index 0000000000..334b1d21ac --- /dev/null +++ b/packages/abi-gen-templates/Python/partials/call.handlebars @@ -0,0 +1,41 @@ + + def {{this.languageSpecificName}}( + self, + {{> typed_params inputs=inputs}} + tx_params: Optional[TxParams] = None, + {{^this.constant}} + view_only: bool = False, + {{/this.constant}} + ) ->{{#if outputs}}{{~> return_type outputs=outputs~}}{{else}} None{{/if}}: + """Execute underlying, same-named contract method. +{{sanitizeDevdocDetails this.name this.devdoc.details 8}} + {{#each this.devdoc.params}} + :param {{@key}}: {{this}} + {{/each}} + {{#if this.constant}} + {{#if this.devdoc.return}}:returns: {{this.devdoc.return}}{{/if}} + {{else}} + :param tx_params: transaction parameters + :param view_only: whether to use transact() or call() + + :returns: transaction hash + {{/if}} + """ + {{#each this.inputs}} + {{#if (equal type 'address')}} + {{this.name}} = self._validate_and_checksum_address({{this.name}}) + {{else if (equal type 'uint256')}} + # safeguard against fractional inputs + {{this.name}} = int({{this.name}}) +{{/if}} +{{/each}} + func = self._get_contract_instance( + self._contract_address + ).functions.{{this.name}}( + {{> params}} + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only={{#if this.constant}}True{{else}}view_only{{/if}} + ) diff --git a/packages/abi-gen-templates/Python/partials/event.handlebars b/packages/abi-gen-templates/Python/partials/event.handlebars new file mode 100644 index 0000000000..eb3725612e --- /dev/null +++ b/packages/abi-gen-templates/Python/partials/event.handlebars @@ -0,0 +1,14 @@ + def get_{{languageSpecificName}}_event( + self, token_address: str, tx_hash: Union[HexBytes, bytes] + ) -> Tuple[AttributeDict]: + """Get log entry for {{name}} event. + + :param tx_hash: hash of transaction emitting {{name}} event. + """ + tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash) + token_address = self._validate_and_checksum_address(token_address) + return ( + self._get_contract_instance(token_address) + .events.{{name}}() + .processReceipt(tx_receipt) + ) diff --git a/packages/abi-gen-templates/Python/partials/params.handlebars b/packages/abi-gen-templates/Python/partials/params.handlebars new file mode 100644 index 0000000000..2d9bb8ed96 --- /dev/null +++ b/packages/abi-gen-templates/Python/partials/params.handlebars @@ -0,0 +1,3 @@ +{{#each inputs}} +{{name}}{{#if @last}}{{else}},{{/if}} +{{/each}} diff --git a/packages/abi-gen-templates/Python/partials/return_type.handlebars b/packages/abi-gen-templates/Python/partials/return_type.handlebars new file mode 100644 index 0000000000..7ff7b83696 --- /dev/null +++ b/packages/abi-gen-templates/Python/partials/return_type.handlebars @@ -0,0 +1,13 @@ +{{#if this.constant}} +{{#if outputs.length}} +{{#singleReturnValue}} + {{#returnType outputs.0.type outputs.0.components}}{{~/returnType~}} +{{/singleReturnValue}} +{{^singleReturnValue}} +[{{#each outputs}}{{#returnType type components}}{{/returnType}}{{#unless @last}}, {{/unless}}{{/each}}] +{{/singleReturnValue}} +{{/if}} +{{/if}} +{{^if this.constant}} + Union[HexBytes, bytes] +{{~/if~}} diff --git a/packages/abi-gen-templates/Python/partials/typed_params.handlebars b/packages/abi-gen-templates/Python/partials/typed_params.handlebars new file mode 100644 index 0000000000..bbbdef29b4 --- /dev/null +++ b/packages/abi-gen-templates/Python/partials/typed_params.handlebars @@ -0,0 +1,3 @@ +{{#each inputs}} +{{name}}: {{#parameterType type components}}{{/parameterType}}, +{{/each}} diff --git a/packages/abi-gen-templates/partials/call.handlebars b/packages/abi-gen-templates/partials/call.handlebars index 7c9c934c31..702f747d60 100644 --- a/packages/abi-gen-templates/partials/call.handlebars +++ b/packages/abi-gen-templates/partials/call.handlebars @@ -1,3 +1,3 @@ -public {{this.tsName}} = { +public {{languageSpecificName}} = { {{> callAsync}} }; diff --git a/packages/abi-gen-templates/partials/tx.handlebars b/packages/abi-gen-templates/partials/tx.handlebars index ab00fbcd5d..ad6092fb4d 100644 --- a/packages/abi-gen-templates/partials/tx.handlebars +++ b/packages/abi-gen-templates/partials/tx.handlebars @@ -1,4 +1,4 @@ -public {{this.tsName}} = { +public {{languageSpecificName}} = { async sendTransactionAsync( {{> typed_params inputs=inputs}} txData?: Partial | undefined, @@ -15,7 +15,7 @@ public {{this.tsName}} = { data: encodedData, }, self._web3Wrapper.getContractDefaults(), - self.{{this.tsName}}.estimateGasAsync.bind( + self.{{languageSpecificName}}.estimateGasAsync.bind( self, {{> params inputs=inputs}} ), @@ -34,9 +34,9 @@ public {{this.tsName}} = { {{/each}} const self = this as any as {{contractName}}Contract; {{#if inputs}} - const txHashPromise = self.{{this.tsName}}.sendTransactionAsync({{> params input=inputs}}, txData); + const txHashPromise = self.{{languageSpecificName}}.sendTransactionAsync({{> params input=inputs}}, txData); {{else}} - const txHashPromise = self.{{this.tsName}}.sendTransactionAsync(txData); + const txHashPromise = self.{{languageSpecificName}}.sendTransactionAsync(txData); {{/if}} return new PromiseWithTransactionHash( txHashPromise, diff --git a/packages/abi-gen-wrappers/package.json b/packages/abi-gen-wrappers/package.json index 6423395fa1..3254d3b047 100644 --- a/packages/abi-gen-wrappers/package.json +++ b/packages/abi-gen-wrappers/package.json @@ -15,7 +15,7 @@ "lint": "tslint --format stylish --project .", "fix": "tslint --fix --format stylish --project .", "pre_build": "yarn generate_contract_wrappers", - "clean": "shx rm -rf lib wrappers", + "clean": "shx rm -rf lib src/generated-wrappers", "generate_contract_wrappers": "abi-gen --abis ${npm_package_config_abis} --template ../../node_modules/@0x/abi-gen-templates/contract.handlebars --partials '../../node_modules/@0x/abi-gen-templates/partials/**/*.handlebars' --output src/generated-wrappers --backend ethers" }, "config": { diff --git a/packages/abi-gen-wrappers/src/generated-wrappers/eth_balance_checker.ts b/packages/abi-gen-wrappers/src/generated-wrappers/eth_balance_checker.ts index 94c5d1ad45..3c55f24afd 100644 --- a/packages/abi-gen-wrappers/src/generated-wrappers/eth_balance_checker.ts +++ b/packages/abi-gen-wrappers/src/generated-wrappers/eth_balance_checker.ts @@ -64,6 +64,15 @@ export class EthBalanceCheckerContract extends BaseContract { // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + addresses: string[], + ): string { + assert.isArray('addresses', addresses); + const self = this as any as EthBalanceCheckerContract; + const abiEncodedTransactionData = self._strictEncodeArguments('getEthBalances(address[])', [addresses + ]); + return abiEncodedTransactionData; + }, }; public static async deployFrom0xArtifactAsync( artifact: ContractArtifact | SimpleContractArtifact, diff --git a/packages/abi-gen/CHANGELOG.json b/packages/abi-gen/CHANGELOG.json index 8ed7e92309..f51f908b2d 100644 --- a/packages/abi-gen/CHANGELOG.json +++ b/packages/abi-gen/CHANGELOG.json @@ -1,4 +1,13 @@ [ + { + "version": "2.1.0", + "changes": [ + { + "note": "Initial support for Python", + "pr": 1878 + } + ] + }, { "version": "2.0.11", "changes": [ diff --git a/packages/abi-gen/diff.sh b/packages/abi-gen/diff.sh index 5f6c89709c..04369f9da3 100755 --- a/packages/abi-gen/diff.sh +++ b/packages/abi-gen/diff.sh @@ -1,5 +1,5 @@ diff $1 $2 if [ $? -ne 0 ]; then - echo "ERROR: Run 'yarn generate_contract_wrappers' to update ./test/generated_test/generated-wrappers" + echo "ERROR: Freshly generated code does not match known-good, commited output. If you're confident that the freshly generated code should be considered known-good, then copy it into there and commit it." exit 1 fi diff --git a/packages/abi-gen/package.json b/packages/abi-gen/package.json index 4b3f7030ec..697ce2f36e 100644 --- a/packages/abi-gen/package.json +++ b/packages/abi-gen/package.json @@ -11,13 +11,14 @@ "lint": "tslint --format stylish --project . && yarn lint-contracts", "lint-contracts": "solhint -c ../../contracts/.solhint.json contracts/**/**/**/**/*.sol", "fix": "tslint --fix --format stylish --project . && yarn lint-contracts", - "clean": "shx rm -rf lib test/generated-test/lib", - "build": "tsc -b && yarn build:test", - "prebuild:test": "run-s compile:sol generate_contract_wrappers", - "build:test": "tsc --project test/generated-test/tsconfig.json", + "clean": "shx rm -rf lib test/generated-test/output", + "build": "tsc -b", + "build_contracts_to_wrap": "run-s compile:sol", + "build_contract_wrappers": "tsc --project test/generated-test/tsconfig.json", "build:ci": "yarn build", - "test": "run-s run_mocha tmp_generate_contract_wrappers diff_contract_wrappers tmp_remove_contract_wrappers", - "run_mocha": "mocha --require source-map-support/register --require make-promises-safe lib/test/**/*_test.js test/generated-test/lib/**/*_test.js --timeout 100000 --bail --exit", + "test": "run-s run_mocha build_contracts_to_wrap generate_contract_wrappers diff_contract_wrappers # build_contract_wrappers run_contract_wrapper_tests HACK: note this is commented out. building those contract wrappers is broken on development right now", + "run_mocha": "mocha --require source-map-support/register --require make-promises-safe lib/test/*_test.js --timeout 100000 --bail --exit", + "run_contract_wrapper_tests": "mocha --require source-map-support/register --require make-promises-safe test/generated-test/output/TypeScript/lib/**/*_test.js --timeout 100000 --bail --exit", "test:circleci": "yarn test:coverage", "test:coverage": "nyc npm run test --all && yarn coverage:report:lcov", "coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info", @@ -27,10 +28,12 @@ "clean:sol": "rm -rf test/generated-test/generated-artifacts", "compile:sol": "sol-compiler", "watch:sol": "sol-compiler -w", - "generate_contract_wrappers": "abi-gen --abis ${npm_package_config_abis} --template ../../node_modules/@0x/abi-gen-templates/contract.handlebars --partials '../../node_modules/@0x/abi-gen-templates/partials/**/*.handlebars' --output ./test/generated-test/generated-wrappers --backend ethers", - "tmp_generate_contract_wrappers": "abi-gen --abis ${npm_package_config_abis} --template ../../node_modules/@0x/abi-gen-templates/contract.handlebars --partials '../../node_modules/@0x/abi-gen-templates/partials/**/*.handlebars' --output ./tmp/generated-wrappers --backend ethers", - "tmp_remove_contract_wrappers": "rm -rf ./tmp/generated-wrappers", - "diff_contract_wrappers": "./diff.sh ./tmp/generated-wrappers ./test/generated-test/generated-wrappers", + "generate_contract_wrappers": "run-p gen_typescript gen_python", + "gen_typescript": "abi-gen --abis ${npm_package_config_abis} --template ../../node_modules/@0x/abi-gen-templates/contract.handlebars --partials '../../node_modules/@0x/abi-gen-templates/partials/**/*.handlebars' --output ./test/generated-test/output/TypeScript/src --backend ethers", + "gen_python": "abi-gen --abis ${npm_package_config_abis} --template ../../node_modules/@0x/abi-gen-templates/Python/contract.handlebars --partials '../../node_modules/@0x/abi-gen-templates/Python/partials/**/*.handlebars' --output ./test/generated-test/output/Python --language Python", + "diff_contract_wrappers": "run-p diff_typescript diff_python", + "diff_typescript": "./diff.sh ./test/generated-test/known-good/TypeScript ./test/generated-test/output/TypeScript/src", + "diff_python": "./diff.sh ./test/generated-test/known-good/Python ./test/generated-test/output/Python", "coverage:report:text": "istanbul report text", "coverage:report:html": "istanbul report html && open coverage/index.html", "profiler:report:html": "istanbul report html && open coverage/index.html", @@ -57,6 +60,8 @@ "@0x/typescript-typings": "^4.2.2", "@0x/utils": "^4.3.3", "chalk": "^2.3.0", + "change-case": "^3.0.2", + "cli-format": "^3.0.9", "ethereum-types": "^2.1.2", "glob": "^7.1.2", "handlebars": "^4.0.11", diff --git a/packages/abi-gen/src/index.ts b/packages/abi-gen/src/index.ts index 347ed6bd75..49bc3338f2 100644 --- a/packages/abi-gen/src/index.ts +++ b/packages/abi-gen/src/index.ts @@ -2,7 +2,9 @@ import { AbiEncoder, abiUtils, logUtils } from '@0x/utils'; import chalk from 'chalk'; -import { AbiDefinition, ConstructorAbi, EventAbi, MethodAbi } from 'ethereum-types'; +import * as changeCase from 'change-case'; +import * as cliFormat from 'cli-format'; +import { AbiDefinition, ConstructorAbi, DevdocOutput, EventAbi, MethodAbi } from 'ethereum-types'; import { sync as globSync } from 'glob'; import * as Handlebars from 'handlebars'; import * as _ from 'lodash'; @@ -43,7 +45,7 @@ const args = yargs normalize: true, }) .option('backend', { - describe: `The backing Ethereum library your app uses. Either 'web3' or 'ethers'. Ethers auto-converts small ints to numbers whereas Web3 doesn't.`, + describe: `The backing Ethereum library your app uses. For TypeScript, either 'web3' or 'ethers'. Ethers auto-converts small ints to numbers whereas Web3 doesn't. For Python, the only possibility is Web3.py`, type: 'string', choices: [ContractsBackend.Web3, ContractsBackend.Ethers], default: DEFAULT_BACKEND, @@ -53,6 +55,12 @@ const args = yargs type: 'number', default: DEFAULT_NETWORK_ID, }) + .option('language', { + describe: 'Language of output file to generate', + type: 'string', + choices: ['TypeScript', 'Python'], + default: 'TypeScript', + }) .example( "$0 --abis 'src/artifacts/**/*.json' --out 'src/contracts/generated/' --partials 'src/templates/partials/**/*.handlebars' --template 'src/templates/contract.handlebars'", 'Full usage example', @@ -71,11 +79,42 @@ function registerPartials(): void { } } -Handlebars.registerHelper('parameterType', utils.solTypeToTsType.bind(utils, ParamKind.Input, args.backend)); -Handlebars.registerHelper('assertionType', utils.solTypeToAssertion.bind(utils)); -Handlebars.registerHelper('returnType', utils.solTypeToTsType.bind(utils, ParamKind.Output, args.backend)); +if (args.language === 'TypeScript') { + Handlebars.registerHelper('parameterType', utils.solTypeToTsType.bind(utils, ParamKind.Input, args.backend)); + Handlebars.registerHelper('assertionType', utils.solTypeToAssertion.bind(utils)); + Handlebars.registerHelper('returnType', utils.solTypeToTsType.bind(utils, ParamKind.Output, args.backend)); +} else if (args.language === 'Python') { + Handlebars.registerHelper('equal', (lhs, rhs, options) => { + return lhs === rhs; + }); + Handlebars.registerHelper('safeString', (str, options) => new Handlebars.SafeString(str)); + Handlebars.registerHelper('parameterType', utils.solTypeToPyType.bind(utils, ParamKind.Input, args.backend)); + Handlebars.registerHelper('returnType', utils.solTypeToPyType.bind(utils, ParamKind.Output, args.backend)); + Handlebars.registerHelper( + 'sanitizeDevdocDetails', + (methodName: string, devdocDetails: string, indent: number, options) => { + // wrap to 80 columns, assuming given indent, so that generated + // docstrings can pass pycodestyle checks. + if (devdocDetails === undefined || devdocDetails.length === 0) { + return ''; + } + const columnsPerRow = 80; + return new Handlebars.SafeString( + `\n${cliFormat.wrap(devdocDetails || '', { + paddingLeft: ' '.repeat(indent), + width: columnsPerRow - indent, + ansi: false, + })}\n`, + ); + }, + ); +} registerPartials(); +function makeLanguageSpecificName(methodName: string): string { + return args.language === 'Python' ? changeCase.snake(methodName) : methodName; +} + if (_.isEmpty(abiFileNames)) { logUtils.log(`${chalk.red(`No ABI files found.`)}`); logUtils.log(`Please make sure you've passed the correct folder name and that the files have @@ -90,12 +129,16 @@ for (const abiFileName of abiFileNames) { logUtils.log(`Processing: ${chalk.bold(namedContent.name)}...`); const parsedContent = JSON.parse(namedContent.content); let ABI; + let devdoc: DevdocOutput; if (_.isArray(parsedContent)) { ABI = parsedContent; // ABI file } else if (parsedContent.abi !== undefined) { ABI = parsedContent.abi; // Truffle artifact } else if (parsedContent.compilerOutput.abi !== undefined) { ABI = parsedContent.compilerOutput.abi; // 0x artifact + if (parsedContent.compilerOutput.devdoc !== undefined) { + devdoc = parsedContent.compilerOutput.devdoc; + } } if (ABI === undefined) { logUtils.log(`${chalk.red(`ABI not found in ${abiFileName}.`)}`); @@ -106,7 +149,16 @@ for (const abiFileName of abiFileNames) { } const outFileName = utils.makeOutputFileName(namedContent.name); - const outFilePath = `${args.output}/${outFileName}.ts`; + const outFileExtension = (() => { + if (args.language === 'TypeScript') { + return 'ts'; + } else if (args.language === 'Python') { + return 'py'; + } else { + throw new Error(`Unexpected language '${args.language}'`); + } + })(); + const outFilePath = `${args.output}/${outFileName}.${outFileExtension}`; if (utils.isOutputFileUpToDate(outFilePath, [abiFileName, args.template, ...partialTemplateFileNames])) { logUtils.log(`Already up to date: ${chalk.bold(outFilePath)}`); @@ -127,26 +179,39 @@ for (const abiFileName of abiFileNames) { input.name = `index_${inputIndex}`; } }); + const functionSignature = new AbiEncoder.Method(methodAbi).getSignature(); + const languageSpecificName: string = makeLanguageSpecificName(sanitizedMethodAbis[methodAbiIndex].name); // This will make templates simpler const methodData = { ...methodAbi, singleReturnValue: methodAbi.outputs.length === 1, hasReturnValue: methodAbi.outputs.length !== 0, - tsName: sanitizedMethodAbis[methodAbiIndex].name, - functionSignature: new AbiEncoder.Method(methodAbi).getSignature(), + languageSpecificName, + functionSignature, + devdoc: devdoc ? devdoc.methods[functionSignature] : undefined, }; return methodData; }); const eventAbis = ABI.filter((abi: AbiDefinition) => abi.type === ABI_TYPE_EVENT) as EventAbi[]; + const eventsData = _.map(eventAbis, (eventAbi, eventAbiIndex: number) => { + const languageSpecificName = makeLanguageSpecificName(eventAbi.name); + + const eventData = { + ...eventAbi, + languageSpecificName, + }; + return eventData; + }); const contextData = { contractName: namedContent.name, ctor, + ABI: JSON.stringify(ABI), methods: methodsData, - events: eventAbis, + events: eventsData, }; - const renderedTsCode = template(contextData); - utils.writeOutputFile(outFilePath, renderedTsCode); + const renderedCode = template(contextData); + utils.writeOutputFile(outFilePath, renderedCode); logUtils.log(`Created: ${chalk.bold(outFilePath)}`); } diff --git a/packages/abi-gen/src/types.ts b/packages/abi-gen/src/types.ts index 68765b04d2..f8d27004e9 100644 --- a/packages/abi-gen/src/types.ts +++ b/packages/abi-gen/src/types.ts @@ -13,7 +13,7 @@ export enum ContractsBackend { export interface Method extends MethodAbi { singleReturnValue: boolean; hasReturnValue: boolean; - tsName: string; + languageSpecificName: string; functionSignature: string; } diff --git a/packages/abi-gen/src/utils.ts b/packages/abi-gen/src/utils.ts index b2f642f5bd..dfa102f2db 100644 --- a/packages/abi-gen/src/utils.ts +++ b/packages/abi-gen/src/utils.ts @@ -98,6 +98,45 @@ export const utils = { throw new Error(`Unknown Solidity type found: ${solType}`); } }, + solTypeToPyType(paramKind: ParamKind, backend: ContractsBackend, solType: string, components?: DataItem[]): string { + const trailingArrayRegex = /\[\d*\]$/; + if (solType.match(trailingArrayRegex)) { + const arrayItemSolType = solType.replace(trailingArrayRegex, ''); + const arrayItemPyType = utils.solTypeToPyType(paramKind, backend, arrayItemSolType, components); + const arrayPyType = `Array[${arrayItemPyType}]`; + return arrayPyType; + } else { + const solTypeRegexToPyType = [ + { regex: '^string$', pyType: 'str' }, + { regex: '^address$', pyType: 'str' }, + { regex: '^bool$', pyType: 'bool' }, + { regex: '^u?int\\d*$', pyType: 'int' }, + { regex: '^bytes\\d*$', pyType: 'bytes' }, + ]; + for (const regexAndTxType of solTypeRegexToPyType) { + const { regex, pyType } = regexAndTxType; + if (solType.match(regex)) { + return pyType; + } + } + const TUPLE_TYPE_REGEX = '^tuple$'; + if (solType.match(TUPLE_TYPE_REGEX)) { + const componentsType = _.map(components, component => { + const componentValueType = utils.solTypeToPyType( + paramKind, + backend, + component.type, + component.components, + ); + const componentType = `'${component.name}': ${componentValueType}`; + return componentType; + }); + const pyType = `TypedDict('${solType}(${components})', {${componentsType.join(',')}}`; + return pyType; + } + throw new Error(`Unknown Solidity type found: ${solType}`); + } + }, isUnionType(tsType: string): boolean { return tsType === 'number|BigNumber'; }, diff --git a/packages/abi-gen/test/generated-test/known-good/Python/abi_gen_dummy.py b/packages/abi-gen/test/generated-test/known-good/Python/abi_gen_dummy.py new file mode 100644 index 0000000000..db6219b8c6 --- /dev/null +++ b/packages/abi-gen/test/generated-test/known-good/Python/abi_gen_dummy.py @@ -0,0 +1,207 @@ +"""Generated wrapper for AbiGenDummy Solidity contract.""" + +import json +from typing import Optional, Tuple, Union + +from hexbytes import HexBytes +from web3.datastructures import AttributeDict +from web3.providers.base import BaseProvider + +from zero_ex.contract_wrappers._base_contract_wrapper import BaseContractWrapper +from zero_ex.contract_wrappers.tx_params import TxParams + + +class AbiGenDummy(BaseContractWrapper): + """Wrapper class for AbiGenDummy Solidity contract.""" + + def __init__( + self, + provider: BaseProvider, + contract_address: str, + private_key: str = None, + ): + """Get an instance of wrapper for smart contract. + + :param provider: instance of :class:`web3.providers.base.BaseProvider` + :param contract_address: where the contract has been deployed + :param private_key: If specified, transactions will be signed locally, + via Web3.py's `eth.account.signTransaction()`:code:, before being + sent via `eth.sendRawTransaction()`:code:. + """ + super().__init__( + provider=provider, + contract_address=contract_address, + private_key=private_key, + ) + + def _get_contract_instance(self, token_address): + """Get an instance of the smart contract at a specific address. + + :returns: contract object + """ + return self._contract_instance( + address=token_address, abi=AbiGenDummy.abi() + ) + + def simple_require( + self, + tx_params: Optional[TxParams] = None, + ) -> None: + """Execute underlying, same-named contract method. + + + """ + func = self._get_contract_instance( + self._contract_address + ).functions.simpleRequire( + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + def ecrecover_fn( + self, + hash: bytes, + v: int, + r: bytes, + s: bytes, + tx_params: Optional[TxParams] = None, + ) -> str: + """Execute underlying, same-named contract method. + + + """ + func = self._get_contract_instance( + self._contract_address + ).functions.ecrecoverFn( + hash, + v, + r, + s + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + def revert_with_constant( + self, + tx_params: Optional[TxParams] = None, + ) -> None: + """Execute underlying, same-named contract method. + + + """ + func = self._get_contract_instance( + self._contract_address + ).functions.revertWithConstant( + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + def simple_revert( + self, + tx_params: Optional[TxParams] = None, + ) -> None: + """Execute underlying, same-named contract method. + + + """ + func = self._get_contract_instance( + self._contract_address + ).functions.simpleRevert( + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + def require_with_constant( + self, + tx_params: Optional[TxParams] = None, + ) -> None: + """Execute underlying, same-named contract method. + + + """ + func = self._get_contract_instance( + self._contract_address + ).functions.requireWithConstant( + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + def simple_pure_function_with_input( + self, + x: int, + tx_params: Optional[TxParams] = None, + ) -> int: + """Execute underlying, same-named contract method. + + + """ + # safeguard against fractional inputs + x = int(x) + func = self._get_contract_instance( + self._contract_address + ).functions.simplePureFunctionWithInput( + x + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + def simple_pure_function( + self, + tx_params: Optional[TxParams] = None, + ) -> int: + """Execute underlying, same-named contract method. + + + """ + func = self._get_contract_instance( + self._contract_address + ).functions.simplePureFunction( + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + def pure_function_with_constant( + self, + tx_params: Optional[TxParams] = None, + ) -> int: + """Execute underlying, same-named contract method. + + + """ + func = self._get_contract_instance( + self._contract_address + ).functions.pureFunctionWithConstant( + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + @staticmethod + def abi(): + """Return the ABI to the underlying contract.""" + return json.loads( + '[{"constant":true,"inputs":[],"name":"simpleRequire","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"hash","type":"bytes32"},{"name":"v","type":"uint8"},{"name":"r","type":"bytes32"},{"name":"s","type":"bytes32"}],"name":"ecrecoverFn","outputs":[{"name":"signerAddress","type":"address"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"revertWithConstant","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"simpleRevert","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"requireWithConstant","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"x","type":"uint256"}],"name":"simplePureFunctionWithInput","outputs":[{"name":"sum","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"simplePureFunction","outputs":[{"name":"result","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"pureFunctionWithConstant","outputs":[{"name":"someConstant","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"}]' # noqa: E501 (line-too-long) + ) diff --git a/packages/abi-gen/test/generated-test/known-good/Python/lib_dummy.py b/packages/abi-gen/test/generated-test/known-good/Python/lib_dummy.py new file mode 100644 index 0000000000..cd9a9103df --- /dev/null +++ b/packages/abi-gen/test/generated-test/known-good/Python/lib_dummy.py @@ -0,0 +1,51 @@ +"""Generated wrapper for LibDummy Solidity contract.""" + +import json +from typing import Optional, Tuple, Union + +from hexbytes import HexBytes +from web3.datastructures import AttributeDict +from web3.providers.base import BaseProvider + +from zero_ex.contract_wrappers._base_contract_wrapper import BaseContractWrapper +from zero_ex.contract_wrappers.tx_params import TxParams + + +class LibDummy(BaseContractWrapper): + """Wrapper class for LibDummy Solidity contract.""" + + def __init__( + self, + provider: BaseProvider, + contract_address: str, + private_key: str = None, + ): + """Get an instance of wrapper for smart contract. + + :param provider: instance of :class:`web3.providers.base.BaseProvider` + :param contract_address: where the contract has been deployed + :param private_key: If specified, transactions will be signed locally, + via Web3.py's `eth.account.signTransaction()`:code:, before being + sent via `eth.sendRawTransaction()`:code:. + """ + super().__init__( + provider=provider, + contract_address=contract_address, + private_key=private_key, + ) + + def _get_contract_instance(self, token_address): + """Get an instance of the smart contract at a specific address. + + :returns: contract object + """ + return self._contract_instance( + address=token_address, abi=LibDummy.abi() + ) + + @staticmethod + def abi(): + """Return the ABI to the underlying contract.""" + return json.loads( + '[]' # noqa: E501 (line-too-long) + ) diff --git a/packages/abi-gen/test/generated-test/known-good/Python/test_lib_dummy.py b/packages/abi-gen/test/generated-test/known-good/Python/test_lib_dummy.py new file mode 100644 index 0000000000..98b33bd621 --- /dev/null +++ b/packages/abi-gen/test/generated-test/known-good/Python/test_lib_dummy.py @@ -0,0 +1,95 @@ +"""Generated wrapper for TestLibDummy Solidity contract.""" + +import json +from typing import Optional, Tuple, Union + +from hexbytes import HexBytes +from web3.datastructures import AttributeDict +from web3.providers.base import BaseProvider + +from zero_ex.contract_wrappers._base_contract_wrapper import BaseContractWrapper +from zero_ex.contract_wrappers.tx_params import TxParams + + +class TestLibDummy(BaseContractWrapper): + """Wrapper class for TestLibDummy Solidity contract.""" + + def __init__( + self, + provider: BaseProvider, + contract_address: str, + private_key: str = None, + ): + """Get an instance of wrapper for smart contract. + + :param provider: instance of :class:`web3.providers.base.BaseProvider` + :param contract_address: where the contract has been deployed + :param private_key: If specified, transactions will be signed locally, + via Web3.py's `eth.account.signTransaction()`:code:, before being + sent via `eth.sendRawTransaction()`:code:. + """ + super().__init__( + provider=provider, + contract_address=contract_address, + private_key=private_key, + ) + + def _get_contract_instance(self, token_address): + """Get an instance of the smart contract at a specific address. + + :returns: contract object + """ + return self._contract_instance( + address=token_address, abi=TestLibDummy.abi() + ) + + def public_add_constant( + self, + x: int, + tx_params: Optional[TxParams] = None, + ) -> int: + """Execute underlying, same-named contract method. + + + """ + # safeguard against fractional inputs + x = int(x) + func = self._get_contract_instance( + self._contract_address + ).functions.publicAddConstant( + x + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + def public_add_one( + self, + x: int, + tx_params: Optional[TxParams] = None, + ) -> int: + """Execute underlying, same-named contract method. + + + """ + # safeguard against fractional inputs + x = int(x) + func = self._get_contract_instance( + self._contract_address + ).functions.publicAddOne( + x + ) + return self._invoke_function_call( + func=func, + tx_params=tx_params, + view_only=True + ) + + @staticmethod + def abi(): + """Return the ABI to the underlying contract.""" + return json.loads( + '[{"constant":true,"inputs":[{"name":"x","type":"uint256"}],"name":"publicAddConstant","outputs":[{"name":"result","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"x","type":"uint256"}],"name":"publicAddOne","outputs":[{"name":"result","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"}]' # noqa: E501 (line-too-long) + ) diff --git a/packages/abi-gen/test/generated-test/generated-wrappers/abi_gen_dummy.ts b/packages/abi-gen/test/generated-test/known-good/TypeScript/abi_gen_dummy.ts similarity index 73% rename from packages/abi-gen/test/generated-test/generated-wrappers/abi_gen_dummy.ts rename to packages/abi-gen/test/generated-test/known-good/TypeScript/abi_gen_dummy.ts index 57a449e373..8c5713875a 100644 --- a/packages/abi-gen/test/generated-test/generated-wrappers/abi_gen_dummy.ts +++ b/packages/abi-gen/test/generated-test/known-good/TypeScript/abi_gen_dummy.ts @@ -23,12 +23,17 @@ import { assert } from '@0x/assert'; import * as ethers from 'ethers'; // tslint:enable:no-unused-variable + /* istanbul ignore next */ // tslint:disable:no-parameter-reassignment // tslint:disable-next-line:class-name export class AbiGenDummyContract extends BaseContract { public simpleRequire = { - async callAsync(callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, schemas.numberSchema, @@ -37,7 +42,7 @@ export class AbiGenDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as AbiGenDummyContract; + const self = this as any as AbiGenDummyContract; const encodedData = self._strictEncodeArguments('simpleRequire()', []); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { @@ -51,20 +56,28 @@ export class AbiGenDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('simpleRequire()'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + ): string { + const self = this as any as AbiGenDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('simpleRequire()', []); + return abiEncodedTransactionData; + }, }; public ecrecoverFn = { async callAsync( hash: string, - v: number | BigNumber, + v: number|BigNumber, r: string, s: string, callData: Partial = {}, defaultBlock?: BlockParam, - ): Promise { + ): Promise { assert.isString('hash', hash); assert.isNumberOrBigNumber('v', v); assert.isString('r', r); @@ -77,13 +90,12 @@ export class AbiGenDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as AbiGenDummyContract; - const encodedData = self._strictEncodeArguments('ecrecoverFn(bytes32,uint8,bytes32,bytes32)', [ - hash, - v, - r, - s, - ]); + const self = this as any as AbiGenDummyContract; + const encodedData = self._strictEncodeArguments('ecrecoverFn(bytes32,uint8,bytes32,bytes32)', [hash, + v, + r, + s + ]); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { to: self.address, @@ -96,13 +108,36 @@ export class AbiGenDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('ecrecoverFn(bytes32,uint8,bytes32,bytes32)'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + hash: string, + v: number|BigNumber, + r: string, + s: string, + ): string { + assert.isString('hash', hash); + assert.isNumberOrBigNumber('v', v); + assert.isString('r', r); + assert.isString('s', s); + const self = this as any as AbiGenDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('ecrecoverFn(bytes32,uint8,bytes32,bytes32)', [hash, + v, + r, + s + ]); + return abiEncodedTransactionData; + }, }; public revertWithConstant = { - async callAsync(callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, schemas.numberSchema, @@ -111,7 +146,7 @@ export class AbiGenDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as AbiGenDummyContract; + const self = this as any as AbiGenDummyContract; const encodedData = self._strictEncodeArguments('revertWithConstant()', []); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { @@ -125,13 +160,24 @@ export class AbiGenDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('revertWithConstant()'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + ): string { + const self = this as any as AbiGenDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('revertWithConstant()', []); + return abiEncodedTransactionData; + }, }; public simpleRevert = { - async callAsync(callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, schemas.numberSchema, @@ -140,7 +186,7 @@ export class AbiGenDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as AbiGenDummyContract; + const self = this as any as AbiGenDummyContract; const encodedData = self._strictEncodeArguments('simpleRevert()', []); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { @@ -154,13 +200,24 @@ export class AbiGenDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('simpleRevert()'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + ): string { + const self = this as any as AbiGenDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('simpleRevert()', []); + return abiEncodedTransactionData; + }, }; public requireWithConstant = { - async callAsync(callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, schemas.numberSchema, @@ -169,7 +226,7 @@ export class AbiGenDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as AbiGenDummyContract; + const self = this as any as AbiGenDummyContract; const encodedData = self._strictEncodeArguments('requireWithConstant()', []); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { @@ -183,13 +240,25 @@ export class AbiGenDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('requireWithConstant()'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + ): string { + const self = this as any as AbiGenDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('requireWithConstant()', []); + return abiEncodedTransactionData; + }, }; public simplePureFunctionWithInput = { - async callAsync(x: BigNumber, callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + x: BigNumber, + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.isBigNumber('x', x); assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, @@ -199,8 +268,9 @@ export class AbiGenDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as AbiGenDummyContract; - const encodedData = self._strictEncodeArguments('simplePureFunctionWithInput(uint256)', [x]); + const self = this as any as AbiGenDummyContract; + const encodedData = self._strictEncodeArguments('simplePureFunctionWithInput(uint256)', [x + ]); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { to: self.address, @@ -213,13 +283,27 @@ export class AbiGenDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('simplePureFunctionWithInput(uint256)'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + x: BigNumber, + ): string { + assert.isBigNumber('x', x); + const self = this as any as AbiGenDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('simplePureFunctionWithInput(uint256)', [x + ]); + return abiEncodedTransactionData; + }, }; public simplePureFunction = { - async callAsync(callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, schemas.numberSchema, @@ -228,7 +312,7 @@ export class AbiGenDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as AbiGenDummyContract; + const self = this as any as AbiGenDummyContract; const encodedData = self._strictEncodeArguments('simplePureFunction()', []); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { @@ -242,13 +326,24 @@ export class AbiGenDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('simplePureFunction()'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + ): string { + const self = this as any as AbiGenDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('simplePureFunction()', []); + return abiEncodedTransactionData; + }, }; public pureFunctionWithConstant = { - async callAsync(callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, schemas.numberSchema, @@ -257,7 +352,7 @@ export class AbiGenDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as AbiGenDummyContract; + const self = this as any as AbiGenDummyContract; const encodedData = self._strictEncodeArguments('pureFunctionWithConstant()', []); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { @@ -271,10 +366,17 @@ export class AbiGenDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('pureFunctionWithConstant()'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + ): string { + const self = this as any as AbiGenDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('pureFunctionWithConstant()', []); + return abiEncodedTransactionData; + }, }; public static async deployFrom0xArtifactAsync( artifact: ContractArtifact | SimpleContractArtifact, @@ -292,7 +394,7 @@ export class AbiGenDummyContract extends BaseContract { const provider = providerUtils.standardizeOrThrow(supportedProvider); const bytecode = artifact.compilerOutput.evm.bytecode.object; const abi = artifact.compilerOutput.abi; - return AbiGenDummyContract.deployAsync(bytecode, abi, provider, txDefaults); + return AbiGenDummyContract.deployAsync(bytecode, abi, provider, txDefaults, ); } public static async deployAsync( bytecode: string, @@ -308,13 +410,17 @@ export class AbiGenDummyContract extends BaseContract { ]); const provider = providerUtils.standardizeOrThrow(supportedProvider); const constructorAbi = BaseContract._lookupConstructorAbi(abi); - [] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString); + [] = BaseContract._formatABIDataItemList( + constructorAbi.inputs, + [], + BaseContract._bigNumberToString, + ); const iface = new ethers.utils.Interface(abi); const deployInfo = iface.deployFunction; const txData = deployInfo.encode(bytecode, []); const web3Wrapper = new Web3Wrapper(provider); const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( - { data: txData }, + {data: txData}, txDefaults, web3Wrapper.estimateGasAsync.bind(web3Wrapper), ); @@ -322,12 +428,7 @@ export class AbiGenDummyContract extends BaseContract { logUtils.log(`transactionHash: ${txHash}`); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); logUtils.log(`AbiGenDummy successfully deployed at ${txReceipt.contractAddress}`); - const contractInstance = new AbiGenDummyContract( - abi, - txReceipt.contractAddress as string, - provider, - txDefaults, - ); + const contractInstance = new AbiGenDummyContract(abi, txReceipt.contractAddress as string, provider, txDefaults); contractInstance.constructorArgs = []; return contractInstance; } diff --git a/packages/abi-gen/test/generated-test/generated-wrappers/lib_dummy.ts b/packages/abi-gen/test/generated-test/known-good/TypeScript/lib_dummy.ts similarity index 94% rename from packages/abi-gen/test/generated-test/generated-wrappers/lib_dummy.ts rename to packages/abi-gen/test/generated-test/known-good/TypeScript/lib_dummy.ts index 4411c07ce9..3bfd80dd25 100644 --- a/packages/abi-gen/test/generated-test/generated-wrappers/lib_dummy.ts +++ b/packages/abi-gen/test/generated-test/known-good/TypeScript/lib_dummy.ts @@ -23,6 +23,7 @@ import { assert } from '@0x/assert'; import * as ethers from 'ethers'; // tslint:enable:no-unused-variable + /* istanbul ignore next */ // tslint:disable:no-parameter-reassignment // tslint:disable-next-line:class-name @@ -43,7 +44,7 @@ export class LibDummyContract extends BaseContract { const provider = providerUtils.standardizeOrThrow(supportedProvider); const bytecode = artifact.compilerOutput.evm.bytecode.object; const abi = artifact.compilerOutput.abi; - return LibDummyContract.deployAsync(bytecode, abi, provider, txDefaults); + return LibDummyContract.deployAsync(bytecode, abi, provider, txDefaults, ); } public static async deployAsync( bytecode: string, @@ -59,13 +60,17 @@ export class LibDummyContract extends BaseContract { ]); const provider = providerUtils.standardizeOrThrow(supportedProvider); const constructorAbi = BaseContract._lookupConstructorAbi(abi); - [] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString); + [] = BaseContract._formatABIDataItemList( + constructorAbi.inputs, + [], + BaseContract._bigNumberToString, + ); const iface = new ethers.utils.Interface(abi); const deployInfo = iface.deployFunction; const txData = deployInfo.encode(bytecode, []); const web3Wrapper = new Web3Wrapper(provider); const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( - { data: txData }, + {data: txData}, txDefaults, web3Wrapper.estimateGasAsync.bind(web3Wrapper), ); diff --git a/packages/abi-gen/test/generated-test/generated-wrappers/test_lib_dummy.ts b/packages/abi-gen/test/generated-test/known-good/TypeScript/test_lib_dummy.ts similarity index 78% rename from packages/abi-gen/test/generated-test/generated-wrappers/test_lib_dummy.ts rename to packages/abi-gen/test/generated-test/known-good/TypeScript/test_lib_dummy.ts index bf36180bd4..64f18023f2 100644 --- a/packages/abi-gen/test/generated-test/generated-wrappers/test_lib_dummy.ts +++ b/packages/abi-gen/test/generated-test/known-good/TypeScript/test_lib_dummy.ts @@ -23,12 +23,18 @@ import { assert } from '@0x/assert'; import * as ethers from 'ethers'; // tslint:enable:no-unused-variable + /* istanbul ignore next */ // tslint:disable:no-parameter-reassignment // tslint:disable-next-line:class-name export class TestLibDummyContract extends BaseContract { public publicAddConstant = { - async callAsync(x: BigNumber, callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + x: BigNumber, + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.isBigNumber('x', x); assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, @@ -38,8 +44,9 @@ export class TestLibDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as TestLibDummyContract; - const encodedData = self._strictEncodeArguments('publicAddConstant(uint256)', [x]); + const self = this as any as TestLibDummyContract; + const encodedData = self._strictEncodeArguments('publicAddConstant(uint256)', [x + ]); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { to: self.address, @@ -52,13 +59,28 @@ export class TestLibDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('publicAddConstant(uint256)'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + x: BigNumber, + ): string { + assert.isBigNumber('x', x); + const self = this as any as TestLibDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('publicAddConstant(uint256)', [x + ]); + return abiEncodedTransactionData; + }, }; public publicAddOne = { - async callAsync(x: BigNumber, callData: Partial = {}, defaultBlock?: BlockParam): Promise { + async callAsync( + x: BigNumber, + callData: Partial = {}, + defaultBlock?: BlockParam, + ): Promise { assert.isBigNumber('x', x); assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ schemas.addressSchema, @@ -68,8 +90,9 @@ export class TestLibDummyContract extends BaseContract { if (defaultBlock !== undefined) { assert.isBlockParam('defaultBlock', defaultBlock); } - const self = (this as any) as TestLibDummyContract; - const encodedData = self._strictEncodeArguments('publicAddOne(uint256)', [x]); + const self = this as any as TestLibDummyContract; + const encodedData = self._strictEncodeArguments('publicAddOne(uint256)', [x + ]); const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( { to: self.address, @@ -82,10 +105,20 @@ export class TestLibDummyContract extends BaseContract { BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); const abiEncoder = self._lookupAbiEncoder('publicAddOne(uint256)'); // tslint:disable boolean-naming - const result = abiEncoder.strictDecodeReturnValue(rawCallResult); + const result = abiEncoder.strictDecodeReturnValue(rawCallResult); // tslint:enable boolean-naming return result; }, + getABIEncodedTransactionData( + x: BigNumber, + ): string { + assert.isBigNumber('x', x); + const self = this as any as TestLibDummyContract; + const abiEncodedTransactionData = self._strictEncodeArguments('publicAddOne(uint256)', [x + ]); + return abiEncodedTransactionData; + }, }; public static async deployFrom0xArtifactAsync( artifact: ContractArtifact | SimpleContractArtifact, @@ -103,7 +136,7 @@ export class TestLibDummyContract extends BaseContract { const provider = providerUtils.standardizeOrThrow(supportedProvider); const bytecode = artifact.compilerOutput.evm.bytecode.object; const abi = artifact.compilerOutput.abi; - return TestLibDummyContract.deployAsync(bytecode, abi, provider, txDefaults); + return TestLibDummyContract.deployAsync(bytecode, abi, provider, txDefaults, ); } public static async deployAsync( bytecode: string, @@ -119,13 +152,17 @@ export class TestLibDummyContract extends BaseContract { ]); const provider = providerUtils.standardizeOrThrow(supportedProvider); const constructorAbi = BaseContract._lookupConstructorAbi(abi); - [] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString); + [] = BaseContract._formatABIDataItemList( + constructorAbi.inputs, + [], + BaseContract._bigNumberToString, + ); const iface = new ethers.utils.Interface(abi); const deployInfo = iface.deployFunction; const txData = deployInfo.encode(bytecode, []); const web3Wrapper = new Web3Wrapper(provider); const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( - { data: txData }, + {data: txData}, txDefaults, web3Wrapper.estimateGasAsync.bind(web3Wrapper), ); @@ -133,12 +170,7 @@ export class TestLibDummyContract extends BaseContract { logUtils.log(`transactionHash: ${txHash}`); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); logUtils.log(`TestLibDummy successfully deployed at ${txReceipt.contractAddress}`); - const contractInstance = new TestLibDummyContract( - abi, - txReceipt.contractAddress as string, - provider, - txDefaults, - ); + const contractInstance = new TestLibDummyContract(abi, txReceipt.contractAddress as string, provider, txDefaults); contractInstance.constructorArgs = []; return contractInstance; } diff --git a/packages/abi-gen/test/generated-test/tsconfig.json b/packages/abi-gen/test/generated-test/tsconfig.json index c4cf1171c7..37cf4bd60e 100644 --- a/packages/abi-gen/test/generated-test/tsconfig.json +++ b/packages/abi-gen/test/generated-test/tsconfig.json @@ -1,14 +1,16 @@ { - "extends": "../../tsconfig.json", + "extends": "../../../../tsconfig.json", "compilerOptions": { "resolveJsonModule": true, - "outDir": "lib", + "outDir": "./output/lib", "rootDir": "." }, - "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*"], "files": [ "./generated-artifacts/AbiGenDummy.json", "./generated-artifacts/LibDummy.json", - "./generated-artifacts/TestLibDummy.json" + "./generated-artifacts/TestLibDummy.json", + "./output/src/abi_gen_dummy.ts", + "./output/src/lib_dummy.ts", + "./output/src/test_lib_dummy.ts" ] } diff --git a/packages/abi-gen/tsconfig.json b/packages/abi-gen/tsconfig.json index c8f4fab52a..7081de5abe 100644 --- a/packages/abi-gen/tsconfig.json +++ b/packages/abi-gen/tsconfig.json @@ -4,6 +4,11 @@ "outDir": "lib", "rootDir": "." }, - "exclude": ["./test/generated-test/**/*"], + "exclude": [ + "./test/generated-test/**/*", + "./src/artifacts.ts", + "./src/wrappers.ts", + "prior two elements refer to code generated by contracts-gen for test fixture contracts" + ], "include": ["./src/**/*", "./test/*"] } diff --git a/packages/ethereum-types/CHANGELOG.json b/packages/ethereum-types/CHANGELOG.json index 2d5e6a8f3f..eac1823d00 100644 --- a/packages/ethereum-types/CHANGELOG.json +++ b/packages/ethereum-types/CHANGELOG.json @@ -1,4 +1,13 @@ [ + { + "version": "2.1.3", + "changes": [ + { + "note": "Made most fields in DevdocOutput optional, as they may not all be present just because devdoc is", + "pr": 1878 + } + ] + }, { "version": "2.1.2", "changes": [ diff --git a/packages/pipeline/pipeline.env.gpg b/packages/pipeline/pipeline.env.gpg new file mode 100644 index 0000000000..d5e3f22ca5 Binary files /dev/null and b/packages/pipeline/pipeline.env.gpg differ diff --git a/packages/python-contract-wrappers/CHANGELOG.json b/packages/python-contract-wrappers/CHANGELOG.json new file mode 100644 index 0000000000..0e8561487e --- /dev/null +++ b/packages/python-contract-wrappers/CHANGELOG.json @@ -0,0 +1,11 @@ +[ + { + "version": "1.0.0", + "changes": [ + { + "note": "Initial commit. Functionality tested for ERC20Token wrapper", + "pr": 1878 + } + ] + } +] diff --git a/packages/python-contract-wrappers/README.md b/packages/python-contract-wrappers/README.md new file mode 100644 index 0000000000..d1a2f65045 --- /dev/null +++ b/packages/python-contract-wrappers/README.md @@ -0,0 +1,41 @@ +## @0x/python-contract-wrappers + +Python wrappers around the 0x smart contracts, generated using @0x/abi-gen. + +The code generated by this package's `build` script is consumed by +`../../python-packages/contract_wrappers/setup.py`'s `pre_install` command. +The code generated by this package should not be used directly. + +## Contributing + +We welcome improvements and fixes from the wider community! To report bugs within this package, please create an issue in this repository. + +Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started. + +### Install dependencies + +If you don't have yarn workspaces enabled (Yarn < v1.0) - enable them: + +```bash +yarn config set workspaces-experimental true +``` + +Then install dependencies + +```bash +yarn install +``` + +### Build + +To build this package and all other monorepo packages that it depends on, run the following from the monorepo root directory: + +```bash +PKG=@0x/python-contract-wrappers yarn build +``` + +### Clean + +```bash +yarn clean +``` diff --git a/packages/python-contract-wrappers/package.json b/packages/python-contract-wrappers/package.json new file mode 100644 index 0000000000..87d07c3666 --- /dev/null +++ b/packages/python-contract-wrappers/package.json @@ -0,0 +1,34 @@ +{ + "name": "@0x/python-contract-wrappers", + "version": "1.0.0", + "engines": { + "node": ">=6.12" + }, + "private": true, + "description": "Python wrappers for 0x smart contracts, generated via abi-gen", + "scripts": { + "generate": "abi-gen --abis ${npm_package_config_abis} --template ../abi-gen-templates/Python/contract.handlebars --partials '../abi-gen-templates/Python/partials/**/*.handlebars' --output generated --language Python", + "build": "yarn generate", + "build:ci": "yarn build", + "clean": "shx rm -rf generated" + }, + "config": { + "abis": "../contract-artifacts/artifacts/ERC20Token.json" + }, + "repository": { + "type": "git", + "url": "https://github.com/0xProject/0x-monorepo.git" + }, + "license": "Apache-2.0", + "bugs": { + "url": "https://github.com/0xProject/0x-monorepo/issues" + }, + "homepage": "https://github.com/0xProject/0x-monorepo/packages/python-contract-wrappers/README.md", + "devDependencies": { + "@0x/abi-gen": "^2.0.10", + "shx": "^0.2.2" + }, + "publishConfig": { + "access": "restricted" + } +} diff --git a/packages/sol-doc/CHANGELOG.json b/packages/sol-doc/CHANGELOG.json index 45768da3d0..0af25523ad 100644 --- a/packages/sol-doc/CHANGELOG.json +++ b/packages/sol-doc/CHANGELOG.json @@ -1,4 +1,13 @@ [ + { + "version": "2.0.13", + "changes": [ + { + "note": "Confirm devdoc components exist before using them", + "pr": 1878 + } + ] + }, { "timestamp": 1558712885, "version": "2.0.12", diff --git a/packages/typescript-typings/types/cli-format/index.d.ts b/packages/typescript-typings/types/cli-format/index.d.ts new file mode 100644 index 0000000000..5590df022a --- /dev/null +++ b/packages/typescript-typings/types/cli-format/index.d.ts @@ -0,0 +1 @@ +declare module 'cli-format'; diff --git a/python-packages/contract_artifacts/README.md b/python-packages/contract_artifacts/README.md index caa6b5df4a..e29af2ba35 100644 --- a/python-packages/contract_artifacts/README.md +++ b/python-packages/contract_artifacts/README.md @@ -16,6 +16,12 @@ We welcome improvements and fixes from the wider community! To report bugs withi Please read our [contribution guidelines](../../CONTRIBUTING.md) before getting started. +### Pull in artifacts from TypeScript build environment + +```bash +./setup.py pre_install +``` + ### Install Code and Dependencies ```bash diff --git a/python-packages/contract_artifacts/setup.py b/python-packages/contract_artifacts/setup.py index 02d2bda98a..f3a88cd483 100755 --- a/python-packages/contract_artifacts/setup.py +++ b/python-packages/contract_artifacts/setup.py @@ -3,7 +3,7 @@ """setuptools module for contract_artifacts package.""" import subprocess # nosec -from shutil import rmtree +from shutil import copytree, rmtree from os import environ, path from sys import argv @@ -13,6 +13,35 @@ from setuptools import find_packages, setup from setuptools.command.test import test as TestCommand +class PreInstallCommand(distutils.command.build_py.build_py): + """Custom setuptools command class for pulling in artifacts.""" + + description = "Pull in the artifacts that live in the TypeScript package." + + def run(self): + """Copy files from TS build area to local src, & `black` them.""" + pkgdir = path.dirname(path.realpath(argv[0])) + rmtree( + path.join( + pkgdir, "src", "zero_ex", "contract_artifacts", "artifacts" + ), + ignore_errors=True, + ) + copytree( + path.join( + pkgdir, + "..", + "..", + "packages", + "contract-artifacts", + "artifacts", + ), + path.join( + pkgdir, "src", "zero_ex", "contract_artifacts", "artifacts" + ), + ) + + class LintCommand(distutils.command.build_py.build_py): """Custom setuptools command class for running linters.""" @@ -138,6 +167,7 @@ setup( author="F. Eugene Aumson", author_email="feuGeneA@users.noreply.github.com", cmdclass={ + "pre_install": PreInstallCommand, "clean": CleanCommandExtension, "lint": LintCommand, "test": TestCommandExtension, diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/AssetProxyOwner.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/AssetProxyOwner.json deleted file mode 100644 index b7fdf9a8b2..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/AssetProxyOwner.json +++ /dev/null @@ -1,465 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "AssetProxyOwner", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [{ "name": "", "type": "uint256" }], - "name": "owners", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "owner", "type": "address" }], - "name": "removeOwner", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "transactionId", "type": "uint256" }], - "name": "revokeConfirmation", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }], - "name": "isOwner", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "uint256" }, { "name": "", "type": "address" }], - "name": "confirmations", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "transactionId", "type": "uint256" }], - "name": "executeRemoveAuthorizedAddressAtIndex", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "secondsTimeLocked", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "pending", "type": "bool" }, { "name": "executed", "type": "bool" }], - "name": "getTransactionCount", - "outputs": [{ "name": "count", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "assetProxyContract", "type": "address" }, - { "name": "isRegistered", "type": "bool" } - ], - "name": "registerAssetProxy", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "owner", "type": "address" }], - "name": "addOwner", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "transactionId", "type": "uint256" }], - "name": "isConfirmed", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_secondsTimeLocked", "type": "uint256" }], - "name": "changeTimeLock", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }], - "name": "isAssetProxyRegistered", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "transactionId", "type": "uint256" }], - "name": "getConfirmationCount", - "outputs": [{ "name": "count", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "uint256" }], - "name": "transactions", - "outputs": [ - { "name": "destination", "type": "address" }, - { "name": "value", "type": "uint256" }, - { "name": "data", "type": "bytes" }, - { "name": "executed", "type": "bool" } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getOwners", - "outputs": [{ "name": "", "type": "address[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { "name": "from", "type": "uint256" }, - { "name": "to", "type": "uint256" }, - { "name": "pending", "type": "bool" }, - { "name": "executed", "type": "bool" } - ], - "name": "getTransactionIds", - "outputs": [{ "name": "_transactionIds", "type": "uint256[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "transactionId", "type": "uint256" }], - "name": "getConfirmations", - "outputs": [{ "name": "_confirmations", "type": "address[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "transactionCount", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_required", "type": "uint256" }], - "name": "changeRequirement", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "transactionId", "type": "uint256" }], - "name": "confirmTransaction", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "destination", "type": "address" }, - { "name": "value", "type": "uint256" }, - { "name": "data", "type": "bytes" } - ], - "name": "submitTransaction", - "outputs": [{ "name": "transactionId", "type": "uint256" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "uint256" }], - "name": "confirmationTimes", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "MAX_OWNER_COUNT", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "required", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "owner", "type": "address" }, { "name": "newOwner", "type": "address" }], - "name": "replaceOwner", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "transactionId", "type": "uint256" }], - "name": "executeTransaction", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { "name": "_owners", "type": "address[]" }, - { "name": "_assetProxyContracts", "type": "address[]" }, - { "name": "_required", "type": "uint256" }, - { "name": "_secondsTimeLocked", "type": "uint256" } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - }, - { "payable": true, "stateMutability": "payable", "type": "fallback" }, - { - "anonymous": false, - "inputs": [ - { "indexed": false, "name": "assetProxyContract", "type": "address" }, - { "indexed": false, "name": "isRegistered", "type": "bool" } - ], - "name": "AssetProxyRegistration", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "transactionId", "type": "uint256" }, - { "indexed": false, "name": "confirmationTime", "type": "uint256" } - ], - "name": "ConfirmationTimeSet", - "type": "event" - }, - { - "anonymous": false, - "inputs": [{ "indexed": false, "name": "secondsTimeLocked", "type": "uint256" }], - "name": "TimeLockChange", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "sender", "type": "address" }, - { "indexed": true, "name": "transactionId", "type": "uint256" } - ], - "name": "Confirmation", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "sender", "type": "address" }, - { "indexed": true, "name": "transactionId", "type": "uint256" } - ], - "name": "Revocation", - "type": "event" - }, - { - "anonymous": false, - "inputs": [{ "indexed": true, "name": "transactionId", "type": "uint256" }], - "name": "Submission", - "type": "event" - }, - { - "anonymous": false, - "inputs": [{ "indexed": true, "name": "transactionId", "type": "uint256" }], - "name": "Execution", - "type": "event" - }, - { - "anonymous": false, - "inputs": [{ "indexed": true, "name": "transactionId", "type": "uint256" }], - "name": "ExecutionFailure", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "sender", "type": "address" }, - { "indexed": false, "name": "value", "type": "uint256" } - ], - "name": "Deposit", - "type": "event" - }, - { - "anonymous": false, - "inputs": [{ "indexed": true, "name": "owner", "type": "address" }], - "name": "OwnerAddition", - "type": "event" - }, - { - "anonymous": false, - "inputs": [{ "indexed": true, "name": "owner", "type": "address" }], - "name": "OwnerRemoval", - "type": "event" - }, - { - "anonymous": false, - "inputs": [{ "indexed": false, "name": "required", "type": "uint256" }], - "name": "RequirementChange", - "type": "event" - } - ], - "devdoc": { - "methods": { - "addOwner(address)": { - "details": "Allows to add a new owner. Transaction has to be sent by wallet.", - "params": { "owner": "Address of new owner." } - }, - "changeRequirement(uint256)": { - "details": "Allows to change the number of required confirmations. Transaction has to be sent by wallet.", - "params": { "_required": "Number of required confirmations." } - }, - "changeTimeLock(uint256)": { - "details": "Changes the duration of the time lock for transactions.", - "params": { - "_secondsTimeLocked": "Duration needed after a transaction is confirmed and before it becomes executable, in seconds." - } - }, - "confirmTransaction(uint256)": { - "details": "Allows an owner to confirm a transaction.", - "params": { "transactionId": "Transaction ID." } - }, - "executeRemoveAuthorizedAddressAtIndex(uint256)": { - "details": "Allows execution of `removeAuthorizedAddressAtIndex` without time lock.", - "params": { "transactionId": "Transaction ID." } - }, - "executeTransaction(uint256)": { - "details": "Allows anyone to execute a confirmed transaction.", - "params": { "transactionId": "Transaction ID." } - }, - "getConfirmationCount(uint256)": { - "details": "Returns number of confirmations of a transaction.", - "params": { "transactionId": "Transaction ID." }, - "return": "Number of confirmations." - }, - "getConfirmations(uint256)": { - "details": "Returns array with owner addresses, which confirmed transaction.", - "params": { "transactionId": "Transaction ID." }, - "return": "Returns array of owner addresses." - }, - "getOwners()": { "details": "Returns list of owners.", "return": "List of owner addresses." }, - "getTransactionCount(bool,bool)": { - "details": "Returns total number of transactions after filers are applied.", - "params": { - "executed": "Include executed transactions.", - "pending": "Include pending transactions." - }, - "return": "Total number of transactions after filters are applied." - }, - "getTransactionIds(uint256,uint256,bool,bool)": { - "details": "Returns list of transaction IDs in defined range.", - "params": { - "executed": "Include executed transactions.", - "from": "Index start position of transaction array.", - "pending": "Include pending transactions.", - "to": "Index end position of transaction array." - }, - "return": "Returns array of transaction IDs." - }, - "isConfirmed(uint256)": { - "details": "Returns the confirmation status of a transaction.", - "params": { "transactionId": "Transaction ID." }, - "return": "Confirmation status." - }, - "registerAssetProxy(address,bool)": { - "details": "Registers or deregisters an AssetProxy to be able to execute `removeAuthorizedAddressAtIndex` without a timelock.", - "params": { - "assetProxyContract": "Address of AssetProxy contract.", - "isRegistered": "Status of approval for AssetProxy contract." - } - }, - "removeOwner(address)": { - "details": "Allows to remove an owner. Transaction has to be sent by wallet.", - "params": { "owner": "Address of owner." } - }, - "replaceOwner(address,address)": { - "details": "Allows to replace an owner with a new owner. Transaction has to be sent by wallet.", - "params": { "newOwner": "Address of new owner.", "owner": "Address of owner to be replaced." } - }, - "revokeConfirmation(uint256)": { - "details": "Allows an owner to revoke a confirmation for a transaction.", - "params": { "transactionId": "Transaction ID." } - }, - "submitTransaction(address,uint256,bytes)": { - "details": "Allows an owner to submit and confirm a transaction.", - "params": { - "data": "Transaction data payload.", - "destination": "Transaction target address.", - "value": "Transaction ether value." - }, - "return": "Returns transaction ID." - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Coordinator.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Coordinator.json deleted file mode 100644 index b65fe37e45..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Coordinator.json +++ /dev/null @@ -1,208 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "Coordinator", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [{ "name": "hash", "type": "bytes32" }, { "name": "signature", "type": "bytes" }], - "name": "getSignerAddress", - "outputs": [{ "name": "signerAddress", "type": "address" }], - "payable": false, - "stateMutability": "pure", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "salt", "type": "uint256" }, - { "name": "signerAddress", "type": "address" }, - { "name": "data", "type": "bytes" } - ], - "name": "transaction", - "type": "tuple" - } - ], - "name": "getTransactionHash", - "outputs": [{ "name": "transactionHash", "type": "bytes32" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "txOrigin", "type": "address" }, - { "name": "transactionHash", "type": "bytes32" }, - { "name": "transactionSignature", "type": "bytes" }, - { "name": "approvalExpirationTimeSeconds", "type": "uint256" } - ], - "name": "approval", - "type": "tuple" - } - ], - "name": "getCoordinatorApprovalHash", - "outputs": [{ "name": "approvalHash", "type": "bytes32" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "salt", "type": "uint256" }, - { "name": "signerAddress", "type": "address" }, - { "name": "data", "type": "bytes" } - ], - "name": "transaction", - "type": "tuple" - }, - { "name": "txOrigin", "type": "address" }, - { "name": "transactionSignature", "type": "bytes" }, - { "name": "approvalExpirationTimeSeconds", "type": "uint256[]" }, - { "name": "approvalSignatures", "type": "bytes[]" } - ], - "name": "executeTransaction", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "EIP712_EXCHANGE_DOMAIN_HASH", - "outputs": [{ "name": "", "type": "bytes32" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "salt", "type": "uint256" }, - { "name": "signerAddress", "type": "address" }, - { "name": "data", "type": "bytes" } - ], - "name": "transaction", - "type": "tuple" - }, - { "name": "txOrigin", "type": "address" }, - { "name": "transactionSignature", "type": "bytes" }, - { "name": "approvalExpirationTimeSeconds", "type": "uint256[]" }, - { "name": "approvalSignatures", "type": "bytes[]" } - ], - "name": "assertValidCoordinatorApprovals", - "outputs": [], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "data", "type": "bytes" }], - "name": "decodeOrdersFromFillData", - "outputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - } - ], - "payable": false, - "stateMutability": "pure", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "EIP712_COORDINATOR_DOMAIN_HASH", - "outputs": [{ "name": "", "type": "bytes32" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [{ "name": "_exchange", "type": "address" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - } - ], - "devdoc": { - "methods": { - "assertValidCoordinatorApprovals((uint256,address,bytes),address,bytes,uint256[],bytes[])": { - "details": "Validates that the 0x transaction has been approved by all of the feeRecipients that correspond to each order in the transaction's Exchange calldata.", - "params": { - "approvalExpirationTimeSeconds": "Array of expiration times in seconds for which each corresponding approval signature expires.", - "approvalSignatures": "Array of signatures that correspond to the feeRecipients of each order in the transaction's Exchange calldata.", - "transaction": "0x transaction containing salt, signerAddress, and data.", - "transactionSignature": "Proof that the transaction has been signed by the signer.", - "txOrigin": "Required signer of Ethereum transaction calling this function." - } - }, - "decodeOrdersFromFillData(bytes)": { - "details": "Decodes the orders from Exchange calldata representing any fill method.", - "params": { "data": "Exchange calldata representing a fill method." }, - "return": "The orders from the Exchange calldata." - }, - "executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])": { - "details": "Executes a 0x transaction that has been signed by the feeRecipients that correspond to each order in the transaction's Exchange calldata.", - "params": { - "approvalExpirationTimeSeconds": "Array of expiration times in seconds for which each corresponding approval signature expires.", - "approvalSignatures": "Array of signatures that correspond to the feeRecipients of each order in the transaction's Exchange calldata.", - "transaction": "0x transaction containing salt, signerAddress, and data.", - "transactionSignature": "Proof that the transaction has been signed by the signer.", - "txOrigin": "Required signer of Ethereum transaction calling this function." - } - }, - "getCoordinatorApprovalHash((address,bytes32,bytes,uint256))": { - "details": "Calculated the EIP712 hash of the Coordinator approval mesasage using the domain separator of this contract.", - "params": { - "approval": "Coordinator approval message containing the transaction hash, transaction signature, and expiration of the approval." - }, - "return": "EIP712 hash of the Coordinator approval message with the domain separator of this contract." - }, - "getSignerAddress(bytes32,bytes)": { - "details": "Recovers the address of a signer given a hash and signature.", - "params": { - "hash": "Any 32 byte hash.", - "signature": "Proof that the hash has been signed by signer." - } - }, - "getTransactionHash((uint256,address,bytes))": { - "details": "Calculates the EIP712 hash of a 0x transaction using the domain separator of the Exchange contract.", - "params": { "transaction": "0x transaction containing salt, signerAddress, and data." }, - "return": "EIP712 hash of the transaction with the domain separator of this contract." - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/CoordinatorRegistry.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/CoordinatorRegistry.json deleted file mode 100644 index a1ce8b525a..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/CoordinatorRegistry.json +++ /dev/null @@ -1,54 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "CoordinatorRegistry", - "compilerOutput": { - "abi": [ - { - "constant": false, - "inputs": [{ "name": "coordinatorEndpoint", "type": "string" }], - "name": "setCoordinatorEndpoint", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "coordinatorOperator", "type": "address" }], - "name": "getCoordinatorEndpoint", - "outputs": [{ "name": "coordinatorEndpoint", "type": "string" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { "inputs": [], "payable": false, "stateMutability": "nonpayable", "type": "constructor" }, - { - "anonymous": false, - "inputs": [ - { "indexed": false, "name": "coordinatorOperator", "type": "address" }, - { "indexed": false, "name": "coordinatorEndpoint", "type": "string" } - ], - "name": "CoordinatorEndpointSet", - "type": "event" - } - ], - "devdoc": { - "methods": { - "getCoordinatorEndpoint(address)": { - "details": "Gets the endpoint for a Coordinator.", - "params": { "coordinatorOperator": "operator of the Coordinator endpoint." } - }, - "setCoordinatorEndpoint(string)": { - "details": "Called by a Coordinator operator to set the endpoint of their Coordinator.", - "params": { "coordinatorEndpoint": "endpoint of the Coordinator." } - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DummyERC20Token.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DummyERC20Token.json deleted file mode 100644 index a058f26a24..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DummyERC20Token.json +++ /dev/null @@ -1,228 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "DummyERC20Token", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [], - "name": "name", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_spender", "type": "address" }, { "name": "_value", "type": "uint256" }], - "name": "approve", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "totalSupply", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_value", "type": "uint256" } - ], - "name": "transferFrom", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "decimals", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }], - "name": "balanceOf", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "owner", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "symbol", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_value", "type": "uint256" }], - "name": "mint", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_to", "type": "address" }, { "name": "_value", "type": "uint256" }], - "name": "transfer", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }, { "name": "_spender", "type": "address" }], - "name": "allowance", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_target", "type": "address" }, { "name": "_value", "type": "uint256" }], - "name": "setBalance", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "newOwner", "type": "address" }], - "name": "transferOwnership", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "MAX_MINT_AMOUNT", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { "name": "_name", "type": "string" }, - { "name": "_symbol", "type": "string" }, - { "name": "_decimals", "type": "uint256" }, - { "name": "_totalSupply", "type": "uint256" } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_from", "type": "address" }, - { "indexed": true, "name": "_to", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Transfer", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": true, "name": "_spender", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Approval", - "type": "event" - } - ], - "devdoc": { - "methods": { - "allowance(address,address)": { - "params": { - "_owner": "The address of the account owning tokens", - "_spender": "The address of the account able to transfer the tokens" - }, - "return": "Amount of remaining tokens allowed to spent" - }, - "approve(address,uint256)": { - "details": "`msg.sender` approves `_spender` to spend `_value` tokens", - "params": { - "_spender": "The address of the account able to transfer the tokens", - "_value": "The amount of wei to be approved for transfer" - }, - "return": "Always true if the call has enough gas to complete execution" - }, - "balanceOf(address)": { - "details": "Query the balance of owner", - "params": { "_owner": "The address from which the balance will be retrieved" }, - "return": "Balance of owner" - }, - "mint(uint256)": { - "details": "Mints new tokens for sender", - "params": { "_value": "Amount of tokens to mint" } - }, - "setBalance(address,uint256)": { - "details": "Sets the balance of target address", - "params": { - "_target": "Address or which balance will be updated", - "_value": "New balance of target address" - } - }, - "totalSupply()": { "details": "Query total supply of token", "return": "Total supply of token" }, - "transfer(address,uint256)": { - "details": "send `value` token to `to` from `msg.sender`", - "params": { - "_to": "The address of the recipient", - "_value": "The amount of token to be transferred" - }, - "return": "True if transfer was successful" - }, - "transferFrom(address,address,uint256)": { - "details": "ERC20 transferFrom, modified such that an allowance of MAX_UINT represents an unlimited allowance. See https://github.com/ethereum/EIPs/issues/717", - "params": { - "_from": "Address to transfer from.", - "_to": "Address to transfer to.", - "_value": "Amount to transfer." - }, - "return": "Success of transfer." - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DummyERC721Token.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DummyERC721Token.json deleted file mode 100644 index b401d9ad29..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DummyERC721Token.json +++ /dev/null @@ -1,274 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "DummyERC721Token", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [], - "name": "name", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_tokenId", "type": "uint256" }], - "name": "getApproved", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_approved", "type": "address" }, { "name": "_tokenId", "type": "uint256" }], - "name": "approve", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_tokenId", "type": "uint256" } - ], - "name": "transferFrom", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_to", "type": "address" }, { "name": "_tokenId", "type": "uint256" }], - "name": "mint", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_tokenId", "type": "uint256" } - ], - "name": "safeTransferFrom", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_tokenId", "type": "uint256" }], - "name": "ownerOf", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }], - "name": "balanceOf", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "owner", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "symbol", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_owner", "type": "address" }, { "name": "_tokenId", "type": "uint256" }], - "name": "burn", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_operator", "type": "address" }, { "name": "_approved", "type": "bool" }], - "name": "setApprovalForAll", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_tokenId", "type": "uint256" }, - { "name": "_data", "type": "bytes" } - ], - "name": "safeTransferFrom", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }, { "name": "_operator", "type": "address" }], - "name": "isApprovedForAll", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "newOwner", "type": "address" }], - "name": "transferOwnership", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [{ "name": "_name", "type": "string" }, { "name": "_symbol", "type": "string" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_from", "type": "address" }, - { "indexed": true, "name": "_to", "type": "address" }, - { "indexed": true, "name": "_tokenId", "type": "uint256" } - ], - "name": "Transfer", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": true, "name": "_approved", "type": "address" }, - { "indexed": true, "name": "_tokenId", "type": "uint256" } - ], - "name": "Approval", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": true, "name": "_operator", "type": "address" }, - { "indexed": false, "name": "_approved", "type": "bool" } - ], - "name": "ApprovalForAll", - "type": "event" - } - ], - "devdoc": { - "methods": { - "approve(address,uint256)": { - "details": "The zero address indicates there is no approved address. Throws unless `msg.sender` is the current NFT owner, or an authorized operator of the current owner.", - "params": { "_approved": "The new approved NFT controller", "_tokenId": "The NFT to approve" } - }, - "balanceOf(address)": { - "details": "NFTs assigned to the zero address are considered invalid, and this function throws for queries about the zero address.", - "params": { "_owner": "An address for whom to query the balance" }, - "return": "The number of NFTs owned by `_owner`, possibly zero" - }, - "burn(address,uint256)": { - "details": "Function to burn a token Reverts if the given token ID doesn't exist or not called by contract owner", - "params": { - "_owner": "Owner of token with given token ID", - "_tokenId": "ID of the token to be burned by the msg.sender" - } - }, - "getApproved(uint256)": { - "details": "Throws if `_tokenId` is not a valid NFT.", - "params": { "_tokenId": "The NFT to find the approved address for" }, - "return": "The approved address for this NFT, or the zero address if there is none" - }, - "isApprovedForAll(address,address)": { - "params": { - "_operator": "The address that acts on behalf of the owner", - "_owner": "The address that owns the NFTs" - }, - "return": "True if `_operator` is an approved operator for `_owner`, false otherwise" - }, - "mint(address,uint256)": { - "details": "Function to mint a new token Reverts if the given token ID already exists", - "params": { - "_to": "Address of the beneficiary that will own the minted token", - "_tokenId": "ID of the token to be minted by the msg.sender " - } - }, - "ownerOf(uint256)": { - "details": "NFTs assigned to zero address are considered invalid, and queries about them do throw.", - "params": { "_tokenId": "The identifier for an NFT" }, - "return": "The address of the owner of the NFT" - }, - "safeTransferFrom(address,address,uint256)": { - "details": "This works identically to the other function with an extra data parameter, except this function just sets data to \"\".", - "params": { - "_from": "The current owner of the NFT", - "_to": "The new owner", - "_tokenId": "The NFT to transfer" - } - }, - "safeTransferFrom(address,address,uint256,bytes)": { - "details": "Throws unless `msg.sender` is the current owner, an authorized operator, or the approved address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is the zero address. Throws if `_tokenId` is not a valid NFT. When transfer is complete, this function checks if `_to` is a smart contract (code size > 0). If so, it calls `onERC721Received` on `_to` and throws if the return value is not `bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`.", - "params": { - "_data": "Additional data with no specified format, sent in call to `_to`", - "_from": "The current owner of the NFT", - "_to": "The new owner", - "_tokenId": "The NFT to transfer" - } - }, - "setApprovalForAll(address,bool)": { - "details": "Emits the ApprovalForAll event. The contract MUST allow multiple operators per owner.", - "params": { - "_approved": "True if the operator is approved, false to revoke approval", - "_operator": "Address to add to the set of authorized operators" - } - }, - "transferFrom(address,address,uint256)": { - "details": "Throws unless `msg.sender` is the current owner, an authorized operator, or the approved address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is the zero address. Throws if `_tokenId` is not a valid NFT.", - "params": { - "_from": "The current owner of the NFT", - "_to": "The new owner", - "_tokenId": "The NFT to transfer" - } - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DutchAuction.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DutchAuction.json deleted file mode 100644 index 2ad9d54c1b..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/DutchAuction.json +++ /dev/null @@ -1,156 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "DutchAuction", - "compilerOutput": { - "abi": [ - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "order", - "type": "tuple" - } - ], - "name": "getAuctionDetails", - "outputs": [ - { - "components": [ - { "name": "beginTimeSeconds", "type": "uint256" }, - { "name": "endTimeSeconds", "type": "uint256" }, - { "name": "beginAmount", "type": "uint256" }, - { "name": "endAmount", "type": "uint256" }, - { "name": "currentAmount", "type": "uint256" }, - { "name": "currentTimeSeconds", "type": "uint256" } - ], - "name": "auctionDetails", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "buyOrder", - "type": "tuple" - }, - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "sellOrder", - "type": "tuple" - }, - { "name": "buySignature", "type": "bytes" }, - { "name": "sellSignature", "type": "bytes" } - ], - "name": "matchOrders", - "outputs": [ - { - "components": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "left", - "type": "tuple" - }, - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "right", - "type": "tuple" - }, - { "name": "leftMakerAssetSpreadAmount", "type": "uint256" } - ], - "name": "matchedFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [{ "name": "_exchange", "type": "address" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - } - ], - "devdoc": { - "methods": { - "getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))": { - "details": "Calculates the Auction Details for the given order", - "params": { "order": "The sell order" }, - "return": "AuctionDetails" - }, - "matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)": { - "details": "Matches the buy and sell orders at an amount given the following: the current block time, the auction start time and the auction begin amount. The sell order is a an order at the lowest amount at the end of the auction. Excess from the match is transferred to the seller. Over time the price moves from beginAmount to endAmount given the current block.timestamp. sellOrder.expiryTimeSeconds is the end time of the auction. sellOrder.takerAssetAmount is the end amount of the auction (lowest possible amount). sellOrder.makerAssetData is the ABI encoded Asset Proxy data with the following data appended buyOrder.makerAssetData is the buyers bid on the auction, must meet the amount for the current block timestamp (uint256 beginTimeSeconds, uint256 beginAmount). This function reverts in the following scenarios: * Auction has not started (auctionDetails.currentTimeSeconds < auctionDetails.beginTimeSeconds) * Auction has expired (auctionDetails.endTimeSeconds < auctionDetails.currentTimeSeconds) * Amount is invalid: Buy order amount is too low (buyOrder.makerAssetAmount < auctionDetails.currentAmount) * Amount is invalid: Invalid begin amount (auctionDetails.beginAmount > auctionDetails.endAmount) * Any failure in the 0x Match Orders", - "params": { - "buyOrder": "The Buyer's order. This order is for the current expected price of the auction.", - "buySignature": "Proof that order was created by the buyer.", - "sellOrder": "The Seller's order. This order is for the lowest amount (at the end of the auction).", - "sellSignature": "Proof that order was created by the seller." - }, - "return": "matchedFillResults amounts filled and fees paid by maker and taker of matched orders." - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC20Proxy.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC20Proxy.json deleted file mode 100644 index c57f29d9ef..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC20Proxy.json +++ /dev/null @@ -1,141 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "ERC20Proxy", - "compilerOutput": { - "abi": [ - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }], - "name": "addAuthorizedAddress", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "uint256" }], - "name": "authorities", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }], - "name": "removeAuthorizedAddress", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "owner", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }, { "name": "index", "type": "uint256" }], - "name": "removeAuthorizedAddressAtIndex", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getProxyId", - "outputs": [{ "name": "", "type": "bytes4" }], - "payable": false, - "stateMutability": "pure", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }], - "name": "authorized", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getAuthorizedAddresses", - "outputs": [{ "name": "", "type": "address[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "newOwner", "type": "address" }], - "name": "transferOwnership", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { "payable": false, "stateMutability": "nonpayable", "type": "fallback" }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "target", "type": "address" }, - { "indexed": true, "name": "caller", "type": "address" } - ], - "name": "AuthorizedAddressAdded", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "target", "type": "address" }, - { "indexed": true, "name": "caller", "type": "address" } - ], - "name": "AuthorizedAddressRemoved", - "type": "event" - } - ], - "devdoc": { - "methods": { - "addAuthorizedAddress(address)": { - "details": "Authorizes an address.", - "params": { "target": "Address to authorize." } - }, - "getAuthorizedAddresses()": { - "details": "Gets all authorized addresses.", - "return": "Array of authorized addresses." - }, - "getProxyId()": { - "details": "Gets the proxy id associated with the proxy address.", - "return": "Proxy id." - }, - "removeAuthorizedAddress(address)": { - "details": "Removes authorizion of an address.", - "params": { "target": "Address to remove authorization from." } - }, - "removeAuthorizedAddressAtIndex(address,uint256)": { - "details": "Removes authorizion of an address.", - "params": { - "index": "Index of target in authorities array.", - "target": "Address to remove authorization from." - } - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC20Token.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC20Token.json deleted file mode 100644 index 5f21d7ed0d..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC20Token.json +++ /dev/null @@ -1,134 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "ERC20Token", - "compilerOutput": { - "abi": [ - { - "constant": false, - "inputs": [{ "name": "_spender", "type": "address" }, { "name": "_value", "type": "uint256" }], - "name": "approve", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "totalSupply", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_value", "type": "uint256" } - ], - "name": "transferFrom", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }], - "name": "balanceOf", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_to", "type": "address" }, { "name": "_value", "type": "uint256" }], - "name": "transfer", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }, { "name": "_spender", "type": "address" }], - "name": "allowance", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_from", "type": "address" }, - { "indexed": true, "name": "_to", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Transfer", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": true, "name": "_spender", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Approval", - "type": "event" - } - ], - "devdoc": { - "methods": { - "allowance(address,address)": { - "params": { - "_owner": "The address of the account owning tokens", - "_spender": "The address of the account able to transfer the tokens" - }, - "return": "Amount of remaining tokens allowed to spent" - }, - "approve(address,uint256)": { - "details": "`msg.sender` approves `_spender` to spend `_value` tokens", - "params": { - "_spender": "The address of the account able to transfer the tokens", - "_value": "The amount of wei to be approved for transfer" - }, - "return": "Always true if the call has enough gas to complete execution" - }, - "balanceOf(address)": { - "details": "Query the balance of owner", - "params": { "_owner": "The address from which the balance will be retrieved" }, - "return": "Balance of owner" - }, - "totalSupply()": { "details": "Query total supply of token", "return": "Total supply of token" }, - "transfer(address,uint256)": { - "details": "send `value` token to `to` from `msg.sender`", - "params": { - "_to": "The address of the recipient", - "_value": "The amount of token to be transferred" - }, - "return": "True if transfer was successful" - }, - "transferFrom(address,address,uint256)": { - "details": "send `value` token to `to` from `from` on the condition it is approved by `from`", - "params": { - "_from": "The address of the sender", - "_to": "The address of the recipient", - "_value": "The amount of token to be transferred" - }, - "return": "True if transfer was successful" - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC721Proxy.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC721Proxy.json deleted file mode 100644 index 18aee4bbdb..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC721Proxy.json +++ /dev/null @@ -1,141 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "ERC721Proxy", - "compilerOutput": { - "abi": [ - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }], - "name": "addAuthorizedAddress", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "uint256" }], - "name": "authorities", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }], - "name": "removeAuthorizedAddress", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "owner", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }, { "name": "index", "type": "uint256" }], - "name": "removeAuthorizedAddressAtIndex", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getProxyId", - "outputs": [{ "name": "", "type": "bytes4" }], - "payable": false, - "stateMutability": "pure", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }], - "name": "authorized", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getAuthorizedAddresses", - "outputs": [{ "name": "", "type": "address[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "newOwner", "type": "address" }], - "name": "transferOwnership", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { "payable": false, "stateMutability": "nonpayable", "type": "fallback" }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "target", "type": "address" }, - { "indexed": true, "name": "caller", "type": "address" } - ], - "name": "AuthorizedAddressAdded", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "target", "type": "address" }, - { "indexed": true, "name": "caller", "type": "address" } - ], - "name": "AuthorizedAddressRemoved", - "type": "event" - } - ], - "devdoc": { - "methods": { - "addAuthorizedAddress(address)": { - "details": "Authorizes an address.", - "params": { "target": "Address to authorize." } - }, - "getAuthorizedAddresses()": { - "details": "Gets all authorized addresses.", - "return": "Array of authorized addresses." - }, - "getProxyId()": { - "details": "Gets the proxy id associated with the proxy address.", - "return": "Proxy id." - }, - "removeAuthorizedAddress(address)": { - "details": "Removes authorizion of an address.", - "params": { "target": "Address to remove authorization from." } - }, - "removeAuthorizedAddressAtIndex(address,uint256)": { - "details": "Removes authorizion of an address.", - "params": { - "index": "Index of target in authorities array.", - "target": "Address to remove authorization from." - } - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC721Token.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC721Token.json deleted file mode 100644 index 8a77605782..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ERC721Token.json +++ /dev/null @@ -1,200 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "ERC721Token", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [{ "name": "_tokenId", "type": "uint256" }], - "name": "getApproved", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_approved", "type": "address" }, { "name": "_tokenId", "type": "uint256" }], - "name": "approve", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_tokenId", "type": "uint256" } - ], - "name": "transferFrom", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_tokenId", "type": "uint256" } - ], - "name": "safeTransferFrom", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_tokenId", "type": "uint256" }], - "name": "ownerOf", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }], - "name": "balanceOf", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_operator", "type": "address" }, { "name": "_approved", "type": "bool" }], - "name": "setApprovalForAll", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_tokenId", "type": "uint256" }, - { "name": "_data", "type": "bytes" } - ], - "name": "safeTransferFrom", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }, { "name": "_operator", "type": "address" }], - "name": "isApprovedForAll", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_from", "type": "address" }, - { "indexed": true, "name": "_to", "type": "address" }, - { "indexed": true, "name": "_tokenId", "type": "uint256" } - ], - "name": "Transfer", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": true, "name": "_approved", "type": "address" }, - { "indexed": true, "name": "_tokenId", "type": "uint256" } - ], - "name": "Approval", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": true, "name": "_operator", "type": "address" }, - { "indexed": false, "name": "_approved", "type": "bool" } - ], - "name": "ApprovalForAll", - "type": "event" - } - ], - "devdoc": { - "methods": { - "approve(address,uint256)": { - "details": "The zero address indicates there is no approved address. Throws unless `msg.sender` is the current NFT owner, or an authorized operator of the current owner.", - "params": { "_approved": "The new approved NFT controller", "_tokenId": "The NFT to approve" } - }, - "balanceOf(address)": { - "details": "NFTs assigned to the zero address are considered invalid, and this function throws for queries about the zero address.", - "params": { "_owner": "An address for whom to query the balance" }, - "return": "The number of NFTs owned by `_owner`, possibly zero" - }, - "getApproved(uint256)": { - "details": "Throws if `_tokenId` is not a valid NFT.", - "params": { "_tokenId": "The NFT to find the approved address for" }, - "return": "The approved address for this NFT, or the zero address if there is none" - }, - "isApprovedForAll(address,address)": { - "params": { - "_operator": "The address that acts on behalf of the owner", - "_owner": "The address that owns the NFTs" - }, - "return": "True if `_operator` is an approved operator for `_owner`, false otherwise" - }, - "ownerOf(uint256)": { - "details": "NFTs assigned to zero address are considered invalid, and queries about them do throw.", - "params": { "_tokenId": "The identifier for an NFT" }, - "return": "The address of the owner of the NFT" - }, - "safeTransferFrom(address,address,uint256)": { - "details": "This works identically to the other function with an extra data parameter, except this function just sets data to \"\".", - "params": { - "_from": "The current owner of the NFT", - "_to": "The new owner", - "_tokenId": "The NFT to transfer" - } - }, - "safeTransferFrom(address,address,uint256,bytes)": { - "details": "Throws unless `msg.sender` is the current owner, an authorized operator, or the approved address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is the zero address. Throws if `_tokenId` is not a valid NFT. When transfer is complete, this function checks if `_to` is a smart contract (code size > 0). If so, it calls `onERC721Received` on `_to` and throws if the return value is not `bytes4(keccak256(\"onERC721Received(address,address,uint256,bytes)\"))`.", - "params": { - "_data": "Additional data with no specified format, sent in call to `_to`", - "_from": "The current owner of the NFT", - "_to": "The new owner", - "_tokenId": "The NFT to transfer" - } - }, - "setApprovalForAll(address,bool)": { - "details": "Emits the ApprovalForAll event. The contract MUST allow multiple operators per owner.", - "params": { - "_approved": "True if the operator is approved, false to revoke approval", - "_operator": "Address to add to the set of authorized operators" - } - }, - "transferFrom(address,address,uint256)": { - "details": "Throws unless `msg.sender` is the current owner, an authorized operator, or the approved address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is the zero address. Throws if `_tokenId` is not a valid NFT.", - "params": { - "_from": "The current owner of the NFT", - "_to": "The new owner", - "_tokenId": "The NFT to transfer" - } - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/EthBalanceChecker.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/EthBalanceChecker.json deleted file mode 100644 index 2d0b679c6f..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/EthBalanceChecker.json +++ /dev/null @@ -1,32 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "EthBalanceChecker", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [{ "name": "addresses", "type": "address[]" }], - "name": "getEthBalances", - "outputs": [{ "name": "", "type": "uint256[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - } - ], - "devdoc": { - "methods": { - "getEthBalances(address[])": { - "details": "Batch fetches ETH balances", - "params": { "addresses": "Array of addresses." }, - "return": "Array of ETH balances." - } - } - }, - "evm": { - "bytecode": { - "object": "0x608060405234801561001057600080fd5b506101e5806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c8063a0901e5114610030575b600080fd5b6100d36004803603602081101561004657600080fd5b81019060208101813564010000000081111561006157600080fd5b82018360208201111561007357600080fd5b8035906020019184602083028401116401000000008311171561009557600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250929550610123945050505050565b60408051602080825283518183015283519192839290830191858101910280838360005b8381101561010f5781810151838201526020016100f7565b505050509050019250505060405180910390f35b6060808251604051908082528060200260200182016040528015610151578160200160208202803883390190505b50905060005b835181146101a95783818151811061016b57fe5b602002602001015173ffffffffffffffffffffffffffffffffffffffff163182828151811061019657fe5b6020908102919091010152600101610157565b509291505056fea265627a7a72305820c934dc478ccdc0f8a6d0fb6135610c21efcb23a2fd5075c6d2c4891b449b70f964736f6c63430005090032" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Exchange.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Exchange.json deleted file mode 100644 index ab2b62747d..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Exchange.json +++ /dev/null @@ -1,1059 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "Exchange", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [{ "name": "", "type": "bytes32" }], - "name": "filled", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "takerAssetFillAmounts", "type": "uint256[]" }, - { "name": "signatures", "type": "bytes[]" } - ], - "name": "batchFillOrders", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "totalFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "bytes32" }], - "name": "cancelled", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "hash", "type": "bytes32" }, - { "name": "signerAddress", "type": "address" }, - { "name": "signature", "type": "bytes" } - ], - "name": "preSign", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "leftOrder", - "type": "tuple" - }, - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "rightOrder", - "type": "tuple" - }, - { "name": "leftSignature", "type": "bytes" }, - { "name": "rightSignature", "type": "bytes" } - ], - "name": "matchOrders", - "outputs": [ - { - "components": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "left", - "type": "tuple" - }, - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "right", - "type": "tuple" - }, - { "name": "leftMakerAssetSpreadAmount", "type": "uint256" } - ], - "name": "matchedFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "order", - "type": "tuple" - }, - { "name": "takerAssetFillAmount", "type": "uint256" }, - { "name": "signature", "type": "bytes" } - ], - "name": "fillOrderNoThrow", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "fillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "bytes4" }], - "name": "assetProxies", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - } - ], - "name": "batchCancelOrders", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "takerAssetFillAmounts", "type": "uint256[]" }, - { "name": "signatures", "type": "bytes[]" } - ], - "name": "batchFillOrKillOrders", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "totalFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "targetOrderEpoch", "type": "uint256" }], - "name": "cancelOrdersUpTo", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "takerAssetFillAmounts", "type": "uint256[]" }, - { "name": "signatures", "type": "bytes[]" } - ], - "name": "batchFillOrdersNoThrow", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "totalFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "assetProxyId", "type": "bytes4" }], - "name": "getAssetProxy", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "bytes32" }], - "name": "transactions", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "order", - "type": "tuple" - }, - { "name": "takerAssetFillAmount", "type": "uint256" }, - { "name": "signature", "type": "bytes" } - ], - "name": "fillOrKillOrder", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "fillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "validatorAddress", "type": "address" }, { "name": "approval", "type": "bool" }], - "name": "setSignatureValidatorApproval", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }, { "name": "", "type": "address" }], - "name": "allowedValidators", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "takerAssetFillAmount", "type": "uint256" }, - { "name": "signatures", "type": "bytes[]" } - ], - "name": "marketSellOrders", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "totalFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - } - ], - "name": "getOrdersInfo", - "outputs": [ - { - "components": [ - { "name": "orderStatus", "type": "uint8" }, - { "name": "orderHash", "type": "bytes32" }, - { "name": "orderTakerAssetFilledAmount", "type": "uint256" } - ], - "name": "", - "type": "tuple[]" - } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "bytes32" }, { "name": "", "type": "address" }], - "name": "preSigned", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "owner", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { "name": "hash", "type": "bytes32" }, - { "name": "signerAddress", "type": "address" }, - { "name": "signature", "type": "bytes" } - ], - "name": "isValidSignature", - "outputs": [{ "name": "isValid", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "makerAssetFillAmount", "type": "uint256" }, - { "name": "signatures", "type": "bytes[]" } - ], - "name": "marketBuyOrdersNoThrow", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "totalFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "order", - "type": "tuple" - }, - { "name": "takerAssetFillAmount", "type": "uint256" }, - { "name": "signature", "type": "bytes" } - ], - "name": "fillOrder", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "fillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "salt", "type": "uint256" }, - { "name": "signerAddress", "type": "address" }, - { "name": "data", "type": "bytes" }, - { "name": "signature", "type": "bytes" } - ], - "name": "executeTransaction", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "assetProxy", "type": "address" }], - "name": "registerAssetProxy", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "order", - "type": "tuple" - } - ], - "name": "getOrderInfo", - "outputs": [ - { - "components": [ - { "name": "orderStatus", "type": "uint8" }, - { "name": "orderHash", "type": "bytes32" }, - { "name": "orderTakerAssetFilledAmount", "type": "uint256" } - ], - "name": "orderInfo", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "order", - "type": "tuple" - } - ], - "name": "cancelOrder", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }, { "name": "", "type": "address" }], - "name": "orderEpoch", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "ZRX_ASSET_DATA", - "outputs": [{ "name": "", "type": "bytes" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "takerAssetFillAmount", "type": "uint256" }, - { "name": "signatures", "type": "bytes[]" } - ], - "name": "marketSellOrdersNoThrow", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "totalFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "EIP712_DOMAIN_HASH", - "outputs": [{ "name": "", "type": "bytes32" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "makerAssetFillAmount", "type": "uint256" }, - { "name": "signatures", "type": "bytes[]" } - ], - "name": "marketBuyOrders", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "totalFillResults", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "currentContextAddress", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "newOwner", "type": "address" }], - "name": "transferOwnership", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "VERSION", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [{ "name": "_zrxAssetData", "type": "bytes" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "signerAddress", "type": "address" }, - { "indexed": true, "name": "validatorAddress", "type": "address" }, - { "indexed": false, "name": "approved", "type": "bool" } - ], - "name": "SignatureValidatorApproval", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "makerAddress", "type": "address" }, - { "indexed": true, "name": "feeRecipientAddress", "type": "address" }, - { "indexed": false, "name": "takerAddress", "type": "address" }, - { "indexed": false, "name": "senderAddress", "type": "address" }, - { "indexed": false, "name": "makerAssetFilledAmount", "type": "uint256" }, - { "indexed": false, "name": "takerAssetFilledAmount", "type": "uint256" }, - { "indexed": false, "name": "makerFeePaid", "type": "uint256" }, - { "indexed": false, "name": "takerFeePaid", "type": "uint256" }, - { "indexed": true, "name": "orderHash", "type": "bytes32" }, - { "indexed": false, "name": "makerAssetData", "type": "bytes" }, - { "indexed": false, "name": "takerAssetData", "type": "bytes" } - ], - "name": "Fill", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "makerAddress", "type": "address" }, - { "indexed": true, "name": "feeRecipientAddress", "type": "address" }, - { "indexed": false, "name": "senderAddress", "type": "address" }, - { "indexed": true, "name": "orderHash", "type": "bytes32" }, - { "indexed": false, "name": "makerAssetData", "type": "bytes" }, - { "indexed": false, "name": "takerAssetData", "type": "bytes" } - ], - "name": "Cancel", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "makerAddress", "type": "address" }, - { "indexed": true, "name": "senderAddress", "type": "address" }, - { "indexed": false, "name": "orderEpoch", "type": "uint256" } - ], - "name": "CancelUpTo", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": false, "name": "id", "type": "bytes4" }, - { "indexed": false, "name": "assetProxy", "type": "address" } - ], - "name": "AssetProxyRegistered", - "type": "event" - } - ], - "devdoc": { - "methods": { - "batchCancelOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[])": { - "details": "Synchronously cancels multiple orders in a single transaction.", - "params": { "orders": "Array of order specifications." } - }, - "batchFillOrKillOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256[],bytes[])": { - "details": "Synchronously executes multiple calls of fillOrKill.", - "params": { - "orders": "Array of order specifications.", - "signatures": "Proofs that orders have been created by makers.", - "takerAssetFillAmounts": "Array of desired amounts of takerAsset to sell in orders." - }, - "return": "Amounts filled and fees paid by makers and taker. NOTE: makerAssetFilledAmount and takerAssetFilledAmount may include amounts filled of different assets." - }, - "batchFillOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256[],bytes[])": { - "details": "Synchronously executes multiple calls of fillOrder.", - "params": { - "orders": "Array of order specifications.", - "signatures": "Proofs that orders have been created by makers.", - "takerAssetFillAmounts": "Array of desired amounts of takerAsset to sell in orders." - }, - "return": "Amounts filled and fees paid by makers and taker. NOTE: makerAssetFilledAmount and takerAssetFilledAmount may include amounts filled of different assets." - }, - "batchFillOrdersNoThrow((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256[],bytes[])": { - "details": "Fills an order with specified parameters and ECDSA signature. Returns false if the transaction would otherwise revert.", - "params": { - "orders": "Array of order specifications.", - "signatures": "Proofs that orders have been created by makers.", - "takerAssetFillAmounts": "Array of desired amounts of takerAsset to sell in orders." - }, - "return": "Amounts filled and fees paid by makers and taker. NOTE: makerAssetFilledAmount and takerAssetFilledAmount may include amounts filled of different assets." - }, - "cancelOrder((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))": { - "details": "After calling, the order can not be filled anymore. Throws if order is invalid or sender does not have permission to cancel.", - "params": { "order": "Order to cancel. Order must be OrderStatus.FILLABLE." } - }, - "cancelOrdersUpTo(uint256)": { - "details": "Cancels all orders created by makerAddress with a salt less than or equal to the targetOrderEpoch and senderAddress equal to msg.sender (or null address if msg.sender == makerAddress).", - "params": { - "targetOrderEpoch": "Orders created with a salt less or equal to this value will be cancelled." - } - }, - "executeTransaction(uint256,address,bytes,bytes)": { - "details": "Executes an exchange method call in the context of signer.", - "params": { - "data": "AbiV2 encoded calldata.", - "salt": "Arbitrary number to ensure uniqueness of transaction hash.", - "signature": "Proof of signer transaction by signer.", - "signerAddress": "Address of transaction signer." - } - }, - "fillOrKillOrder((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),uint256,bytes)": { - "details": "Fills the input order. Reverts if exact takerAssetFillAmount not filled.", - "params": { - "order": "Order struct containing order specifications.", - "signature": "Proof that order has been created by maker.", - "takerAssetFillAmount": "Desired amount of takerAsset to sell." - } - }, - "fillOrder((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),uint256,bytes)": { - "details": "Fills the input order.", - "params": { - "order": "Order struct containing order specifications.", - "signature": "Proof that order has been created by maker.", - "takerAssetFillAmount": "Desired amount of takerAsset to sell." - }, - "return": "Amounts filled and fees paid by maker and taker." - }, - "fillOrderNoThrow((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),uint256,bytes)": { - "details": "Fills the input order. Returns false if the transaction would otherwise revert.", - "params": { - "order": "Order struct containing order specifications.", - "signature": "Proof that order has been created by maker.", - "takerAssetFillAmount": "Desired amount of takerAsset to sell." - }, - "return": "Amounts filled and fees paid by maker and taker." - }, - "getAssetProxy(bytes4)": { - "details": "Gets an asset proxy.", - "params": { "assetProxyId": "Id of the asset proxy." }, - "return": "The asset proxy registered to assetProxyId. Returns 0x0 if no proxy is registered." - }, - "getOrderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))": { - "details": "Gets information about an order: status, hash, and amount filled.", - "params": { "order": "Order to gather information on." }, - "return": "OrderInfo Information about the order and its state. See LibOrder.OrderInfo for a complete description." - }, - "getOrdersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[])": { - "details": "Fetches information for all passed in orders.", - "params": { "orders": "Array of order specifications." }, - "return": "Array of OrderInfo instances that correspond to each order." - }, - "isValidSignature(bytes32,address,bytes)": { - "details": "Verifies that a hash has been signed by the given signer.", - "params": { - "hash": "Any 32 byte hash.", - "signature": "Proof that the hash has been signed by signer.", - "signerAddress": "Address that should have signed the given hash." - }, - "return": "True if the address recovered from the provided signature matches the input signer address." - }, - "marketBuyOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[])": { - "details": "Synchronously executes multiple calls of fillOrder until total amount of makerAsset is bought by taker.", - "params": { - "makerAssetFillAmount": "Desired amount of makerAsset to buy.", - "orders": "Array of order specifications.", - "signatures": "Proofs that orders have been signed by makers." - }, - "return": "Amounts filled and fees paid by makers and taker." - }, - "marketBuyOrdersNoThrow((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[])": { - "details": "Synchronously executes multiple fill orders in a single transaction until total amount is bought by taker. Returns false if the transaction would otherwise revert.", - "params": { - "makerAssetFillAmount": "Desired amount of makerAsset to buy.", - "orders": "Array of order specifications.", - "signatures": "Proofs that orders have been signed by makers." - }, - "return": "Amounts filled and fees paid by makers and taker." - }, - "marketSellOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[])": { - "details": "Synchronously executes multiple calls of fillOrder until total amount of takerAsset is sold by taker.", - "params": { - "orders": "Array of order specifications.", - "signatures": "Proofs that orders have been created by makers.", - "takerAssetFillAmount": "Desired amount of takerAsset to sell." - }, - "return": "Amounts filled and fees paid by makers and taker." - }, - "marketSellOrdersNoThrow((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[])": { - "details": "Synchronously executes multiple calls of fillOrder until total amount of takerAsset is sold by taker. Returns false if the transaction would otherwise revert.", - "params": { - "orders": "Array of order specifications.", - "signatures": "Proofs that orders have been signed by makers.", - "takerAssetFillAmount": "Desired amount of takerAsset to sell." - }, - "return": "Amounts filled and fees paid by makers and taker." - }, - "matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)": { - "details": "Match two complementary orders that have a profitable spread. Each order is filled at their respective price point. However, the calculations are carried out as though the orders are both being filled at the right order's price point. The profit made by the left order goes to the taker (who matched the two orders).", - "params": { - "leftOrder": "First order to match.", - "leftSignature": "Proof that order was created by the left maker.", - "rightOrder": "Second order to match.", - "rightSignature": "Proof that order was created by the right maker." - }, - "return": "matchedFillResults Amounts filled and fees paid by maker and taker of matched orders." - }, - "preSign(bytes32,address,bytes)": { - "details": "Approves a hash on-chain using any valid signature type. After presigning a hash, the preSign signature type will become valid for that hash and signer.", - "params": { - "signature": "Proof that the hash has been signed by signer.", - "signerAddress": "Address that should have signed the given hash." - } - }, - "registerAssetProxy(address)": { - "details": "Registers an asset proxy to its asset proxy id. Once an asset proxy is registered, it cannot be unregistered.", - "params": { "assetProxy": "Address of new asset proxy to register." } - }, - "setSignatureValidatorApproval(address,bool)": { - "details": "Approves/unnapproves a Validator contract to verify signatures on signer's behalf.", - "params": { - "approval": "Approval or disapproval of Validator contract.", - "validatorAddress": "Address of Validator contract." - } - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Forwarder.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Forwarder.json deleted file mode 100644 index 3893e1cbf9..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/Forwarder.json +++ /dev/null @@ -1,231 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "Forwarder", - "compilerOutput": { - "abi": [ - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "makerAssetFillAmount", "type": "uint256" }, - { "name": "signatures", "type": "bytes[]" }, - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "feeOrders", - "type": "tuple[]" - }, - { "name": "feeSignatures", "type": "bytes[]" }, - { "name": "feePercentage", "type": "uint256" }, - { "name": "feeRecipient", "type": "address" } - ], - "name": "marketBuyOrdersWithEth", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "orderFillResults", - "type": "tuple" - }, - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "feeOrderFillResults", - "type": "tuple" - } - ], - "payable": true, - "stateMutability": "payable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "assetData", "type": "bytes" }, { "name": "amount", "type": "uint256" }], - "name": "withdrawAsset", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "owner", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "signatures", "type": "bytes[]" }, - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "feeOrders", - "type": "tuple[]" - }, - { "name": "feeSignatures", "type": "bytes[]" }, - { "name": "feePercentage", "type": "uint256" }, - { "name": "feeRecipient", "type": "address" } - ], - "name": "marketSellOrdersWithEth", - "outputs": [ - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "orderFillResults", - "type": "tuple" - }, - { - "components": [ - { "name": "makerAssetFilledAmount", "type": "uint256" }, - { "name": "takerAssetFilledAmount", "type": "uint256" }, - { "name": "makerFeePaid", "type": "uint256" }, - { "name": "takerFeePaid", "type": "uint256" } - ], - "name": "feeOrderFillResults", - "type": "tuple" - } - ], - "payable": true, - "stateMutability": "payable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "newOwner", "type": "address" }], - "name": "transferOwnership", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "inputs": [ - { "name": "_exchange", "type": "address" }, - { "name": "_zrxAssetData", "type": "bytes" }, - { "name": "_wethAssetData", "type": "bytes" } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - }, - { "payable": true, "stateMutability": "payable", "type": "fallback" } - ], - "devdoc": { - "methods": { - "marketBuyOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)": { - "details": "Attempt to purchase makerAssetFillAmount of makerAsset by selling ETH provided with transaction. Any ZRX required to pay fees for primary orders will automatically be purchased by this contract. Any ETH not spent will be refunded to sender.", - "params": { - "feeOrders": "Array of order specifications containing ZRX as makerAsset and WETH as takerAsset. Used to purchase ZRX for primary order fees.", - "feePercentage": "Percentage of WETH sold that will payed as fee to forwarding contract feeRecipient.", - "feeRecipient": "Address that will receive ETH when orders are filled.", - "feeSignatures": "Proofs that feeOrders have been created by makers.", - "makerAssetFillAmount": "Desired amount of makerAsset to purchase.", - "orders": "Array of order specifications used containing desired makerAsset and WETH as takerAsset.", - "signatures": "Proofs that orders have been created by makers." - }, - "return": "Amounts filled and fees paid by maker and taker for both sets of orders." - }, - "marketSellOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)": { - "details": "Purchases as much of orders' makerAssets as possible by selling up to 95% of transaction's ETH value. Any ZRX required to pay fees for primary orders will automatically be purchased by this contract. 5% of ETH value is reserved for paying fees to order feeRecipients (in ZRX) and forwarding contract feeRecipient (in ETH). Any ETH not spent will be refunded to sender.", - "params": { - "feeOrders": "Array of order specifications containing ZRX as makerAsset and WETH as takerAsset. Used to purchase ZRX for primary order fees.", - "feePercentage": "Percentage of WETH sold that will payed as fee to forwarding contract feeRecipient.", - "feeRecipient": "Address that will receive ETH when orders are filled.", - "feeSignatures": "Proofs that feeOrders have been created by makers.", - "orders": "Array of order specifications used containing desired makerAsset and WETH as takerAsset.", - "signatures": "Proofs that orders have been created by makers." - }, - "return": "Amounts filled and fees paid by maker and taker for both sets of orders." - }, - "withdrawAsset(bytes,uint256)": { - "details": "Withdraws assets from this contract. The contract requires a ZRX balance in order to function optimally, and this function allows the ZRX to be withdrawn by owner. It may also be used to withdraw assets that were accidentally sent to this contract.", - "params": { - "amount": "Amount of ERC20 token to withdraw.", - "assetData": "Byte array encoded for the respective asset proxy." - } - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IAssetProxy.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IAssetProxy.json deleted file mode 100644 index b8e46ea08a..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IAssetProxy.json +++ /dev/null @@ -1,114 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "IAssetProxy", - "compilerOutput": { - "abi": [ - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }], - "name": "addAuthorizedAddress", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }], - "name": "removeAuthorizedAddress", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }, { "name": "index", "type": "uint256" }], - "name": "removeAuthorizedAddressAtIndex", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "assetData", "type": "bytes" }, - { "name": "from", "type": "address" }, - { "name": "to", "type": "address" }, - { "name": "amount", "type": "uint256" } - ], - "name": "transferFrom", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getProxyId", - "outputs": [{ "name": "", "type": "bytes4" }], - "payable": false, - "stateMutability": "pure", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getAuthorizedAddresses", - "outputs": [{ "name": "", "type": "address[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "newOwner", "type": "address" }], - "name": "transferOwnership", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - } - ], - "devdoc": { - "methods": { - "addAuthorizedAddress(address)": { - "details": "Authorizes an address.", - "params": { "target": "Address to authorize." } - }, - "getAuthorizedAddresses()": { - "details": "Gets all authorized addresses.", - "return": "Array of authorized addresses." - }, - "getProxyId()": { - "details": "Gets the proxy id associated with the proxy address.", - "return": "Proxy id." - }, - "removeAuthorizedAddress(address)": { - "details": "Removes authorizion of an address.", - "params": { "target": "Address to remove authorization from." } - }, - "removeAuthorizedAddressAtIndex(address,uint256)": { - "details": "Removes authorizion of an address.", - "params": { - "index": "Index of target in authorities array.", - "target": "Address to remove authorization from." - } - }, - "transferFrom(bytes,address,address,uint256)": { - "details": "Transfers assets. Either succeeds or throws.", - "params": { - "amount": "Amount of asset to transfer.", - "assetData": "Byte array encoded for the respective asset proxy.", - "from": "Address to transfer asset from.", - "to": "Address to transfer asset to." - } - } - } - }, - "evm": { "bytecode": { "object": "0x" } } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IValidator.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IValidator.json deleted file mode 100644 index 028119d5b2..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IValidator.json +++ /dev/null @@ -1,36 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "IValidator", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [ - { "name": "hash", "type": "bytes32" }, - { "name": "signerAddress", "type": "address" }, - { "name": "signature", "type": "bytes" } - ], - "name": "isValidSignature", - "outputs": [{ "name": "isValid", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - } - ], - "devdoc": { - "methods": { - "isValidSignature(bytes32,address,bytes)": { - "details": "Verifies that a signature is valid.", - "params": { - "hash": "Message hash that is signed.", - "signature": "Proof of signing.", - "signerAddress": "Address that should have signed the given hash." - }, - "return": "Validity of order signature." - } - } - }, - "evm": { "bytecode": { "object": "0x" } } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IWallet.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IWallet.json deleted file mode 100644 index 19b96845e9..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/IWallet.json +++ /dev/null @@ -1,28 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "IWallet", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [{ "name": "hash", "type": "bytes32" }, { "name": "signature", "type": "bytes" }], - "name": "isValidSignature", - "outputs": [{ "name": "isValid", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - } - ], - "devdoc": { - "methods": { - "isValidSignature(bytes32,bytes)": { - "details": "Verifies that a signature is valid.", - "params": { "hash": "Message hash that is signed.", "signature": "Proof of signing." }, - "return": "Validity of order signature." - } - } - }, - "evm": { "bytecode": { "object": "0x" } } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/MultiAssetProxy.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/MultiAssetProxy.json deleted file mode 100644 index 0d6279eed5..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/MultiAssetProxy.json +++ /dev/null @@ -1,186 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "MultiAssetProxy", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [{ "name": "", "type": "bytes4" }], - "name": "assetProxies", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }], - "name": "addAuthorizedAddress", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "uint256" }], - "name": "authorities", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "assetProxyId", "type": "bytes4" }], - "name": "getAssetProxy", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }], - "name": "removeAuthorizedAddress", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "owner", - "outputs": [{ "name": "", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "target", "type": "address" }, { "name": "index", "type": "uint256" }], - "name": "removeAuthorizedAddressAtIndex", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getProxyId", - "outputs": [{ "name": "", "type": "bytes4" }], - "payable": false, - "stateMutability": "pure", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }], - "name": "authorized", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "assetProxy", "type": "address" }], - "name": "registerAssetProxy", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "getAuthorizedAddresses", - "outputs": [{ "name": "", "type": "address[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "newOwner", "type": "address" }], - "name": "transferOwnership", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { "payable": false, "stateMutability": "nonpayable", "type": "fallback" }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "target", "type": "address" }, - { "indexed": true, "name": "caller", "type": "address" } - ], - "name": "AuthorizedAddressAdded", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "target", "type": "address" }, - { "indexed": true, "name": "caller", "type": "address" } - ], - "name": "AuthorizedAddressRemoved", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": false, "name": "id", "type": "bytes4" }, - { "indexed": false, "name": "assetProxy", "type": "address" } - ], - "name": "AssetProxyRegistered", - "type": "event" - } - ], - "devdoc": { - "methods": { - "addAuthorizedAddress(address)": { - "details": "Authorizes an address.", - "params": { "target": "Address to authorize." } - }, - "getAssetProxy(bytes4)": { - "details": "Gets an asset proxy.", - "params": { "assetProxyId": "Id of the asset proxy." }, - "return": "The asset proxy registered to assetProxyId. Returns 0x0 if no proxy is registered." - }, - "getAuthorizedAddresses()": { - "details": "Gets all authorized addresses.", - "return": "Array of authorized addresses." - }, - "getProxyId()": { - "details": "Gets the proxy id associated with the proxy address.", - "return": "Proxy id." - }, - "registerAssetProxy(address)": { - "details": "Registers an asset proxy to its asset proxy id. Once an asset proxy is registered, it cannot be unregistered.", - "params": { "assetProxy": "Address of new asset proxy to register." } - }, - "removeAuthorizedAddress(address)": { - "details": "Removes authorizion of an address.", - "params": { "target": "Address to remove authorization from." } - }, - "removeAuthorizedAddressAtIndex(address,uint256)": { - "details": "Removes authorizion of an address.", - "params": { - "index": "Index of target in authorities array.", - "target": "Address to remove authorization from." - } - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/OrderValidator.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/OrderValidator.json deleted file mode 100644 index 619ed2427f..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/OrderValidator.json +++ /dev/null @@ -1,242 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "OrderValidator", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "order", - "type": "tuple" - }, - { "name": "takerAddress", "type": "address" } - ], - "name": "getOrderAndTraderInfo", - "outputs": [ - { - "components": [ - { "name": "orderStatus", "type": "uint8" }, - { "name": "orderHash", "type": "bytes32" }, - { "name": "orderTakerAssetFilledAmount", "type": "uint256" } - ], - "name": "orderInfo", - "type": "tuple" - }, - { - "components": [ - { "name": "makerBalance", "type": "uint256" }, - { "name": "makerAllowance", "type": "uint256" }, - { "name": "takerBalance", "type": "uint256" }, - { "name": "takerAllowance", "type": "uint256" }, - { "name": "makerZrxBalance", "type": "uint256" }, - { "name": "makerZrxAllowance", "type": "uint256" }, - { "name": "takerZrxBalance", "type": "uint256" }, - { "name": "takerZrxAllowance", "type": "uint256" } - ], - "name": "traderInfo", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "target", "type": "address" }, { "name": "assetData", "type": "bytes" }], - "name": "getBalanceAndAllowance", - "outputs": [{ "name": "balance", "type": "uint256" }, { "name": "allowance", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "takerAddresses", "type": "address[]" } - ], - "name": "getOrdersAndTradersInfo", - "outputs": [ - { - "components": [ - { "name": "orderStatus", "type": "uint8" }, - { "name": "orderHash", "type": "bytes32" }, - { "name": "orderTakerAssetFilledAmount", "type": "uint256" } - ], - "name": "ordersInfo", - "type": "tuple[]" - }, - { - "components": [ - { "name": "makerBalance", "type": "uint256" }, - { "name": "makerAllowance", "type": "uint256" }, - { "name": "takerBalance", "type": "uint256" }, - { "name": "takerAllowance", "type": "uint256" }, - { "name": "makerZrxBalance", "type": "uint256" }, - { "name": "makerZrxAllowance", "type": "uint256" }, - { "name": "takerZrxBalance", "type": "uint256" }, - { "name": "takerZrxAllowance", "type": "uint256" } - ], - "name": "tradersInfo", - "type": "tuple[]" - } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "orders", - "type": "tuple[]" - }, - { "name": "takerAddresses", "type": "address[]" } - ], - "name": "getTradersInfo", - "outputs": [ - { - "components": [ - { "name": "makerBalance", "type": "uint256" }, - { "name": "makerAllowance", "type": "uint256" }, - { "name": "takerBalance", "type": "uint256" }, - { "name": "takerAllowance", "type": "uint256" }, - { "name": "makerZrxBalance", "type": "uint256" }, - { "name": "makerZrxAllowance", "type": "uint256" }, - { "name": "takerZrxBalance", "type": "uint256" }, - { "name": "takerZrxAllowance", "type": "uint256" } - ], - "name": "", - "type": "tuple[]" - } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "token", "type": "address" }, { "name": "tokenId", "type": "uint256" }], - "name": "getERC721TokenOwner", - "outputs": [{ "name": "owner", "type": "address" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "target", "type": "address" }, { "name": "assetData", "type": "bytes[]" }], - "name": "getBalancesAndAllowances", - "outputs": [{ "name": "", "type": "uint256[]" }, { "name": "", "type": "uint256[]" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [ - { - "components": [ - { "name": "makerAddress", "type": "address" }, - { "name": "takerAddress", "type": "address" }, - { "name": "feeRecipientAddress", "type": "address" }, - { "name": "senderAddress", "type": "address" }, - { "name": "makerAssetAmount", "type": "uint256" }, - { "name": "takerAssetAmount", "type": "uint256" }, - { "name": "makerFee", "type": "uint256" }, - { "name": "takerFee", "type": "uint256" }, - { "name": "expirationTimeSeconds", "type": "uint256" }, - { "name": "salt", "type": "uint256" }, - { "name": "makerAssetData", "type": "bytes" }, - { "name": "takerAssetData", "type": "bytes" } - ], - "name": "order", - "type": "tuple" - }, - { "name": "takerAddress", "type": "address" } - ], - "name": "getTraderInfo", - "outputs": [ - { - "components": [ - { "name": "makerBalance", "type": "uint256" }, - { "name": "makerAllowance", "type": "uint256" }, - { "name": "takerBalance", "type": "uint256" }, - { "name": "takerAllowance", "type": "uint256" }, - { "name": "makerZrxBalance", "type": "uint256" }, - { "name": "makerZrxAllowance", "type": "uint256" }, - { "name": "takerZrxBalance", "type": "uint256" }, - { "name": "takerZrxAllowance", "type": "uint256" } - ], - "name": "traderInfo", - "type": "tuple" - } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [{ "name": "_exchange", "type": "address" }, { "name": "_zrxAssetData", "type": "bytes" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - } - ], - "devdoc": { "methods": { } }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/WETH9.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/WETH9.json deleted file mode 100644 index f40e757f1c..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/WETH9.json +++ /dev/null @@ -1,157 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "WETH9", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [], - "name": "name", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "guy", "type": "address" }, { "name": "wad", "type": "uint256" }], - "name": "approve", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "totalSupply", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "src", "type": "address" }, - { "name": "dst", "type": "address" }, - { "name": "wad", "type": "uint256" } - ], - "name": "transferFrom", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "wad", "type": "uint256" }], - "name": "withdraw", - "outputs": [], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "decimals", - "outputs": [{ "name": "", "type": "uint8" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }], - "name": "balanceOf", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "symbol", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "dst", "type": "address" }, { "name": "wad", "type": "uint256" }], - "name": "transfer", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": false, - "inputs": [], - "name": "deposit", - "outputs": [], - "payable": true, - "stateMutability": "payable", - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "", "type": "address" }, { "name": "", "type": "address" }], - "name": "allowance", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { "payable": true, "stateMutability": "payable", "type": "fallback" }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": true, "name": "_spender", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Approval", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_from", "type": "address" }, - { "indexed": true, "name": "_to", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Transfer", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Deposit", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Withdrawal", - "type": "event" - } - ], - "devdoc": { "methods": {} }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ZRXToken.json b/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ZRXToken.json deleted file mode 100644 index 3f0491292e..0000000000 --- a/python-packages/contract_artifacts/src/zero_ex/contract_artifacts/artifacts/ZRXToken.json +++ /dev/null @@ -1,124 +0,0 @@ -{ - "schemaVersion": "2.0.0", - "contractName": "ZRXToken", - "compilerOutput": { - "abi": [ - { - "constant": true, - "inputs": [], - "name": "name", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_spender", "type": "address" }, { "name": "_value", "type": "uint256" }], - "name": "approve", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "totalSupply", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "type": "function" - }, - { - "constant": false, - "inputs": [ - { "name": "_from", "type": "address" }, - { "name": "_to", "type": "address" }, - { "name": "_value", "type": "uint256" } - ], - "name": "transferFrom", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "decimals", - "outputs": [{ "name": "", "type": "uint8" }], - "payable": false, - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }], - "name": "balanceOf", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "symbol", - "outputs": [{ "name": "", "type": "string" }], - "payable": false, - "type": "function" - }, - { - "constant": false, - "inputs": [{ "name": "_to", "type": "address" }, { "name": "_value", "type": "uint256" }], - "name": "transfer", - "outputs": [{ "name": "", "type": "bool" }], - "payable": false, - "type": "function" - }, - { - "constant": true, - "inputs": [{ "name": "_owner", "type": "address" }, { "name": "_spender", "type": "address" }], - "name": "allowance", - "outputs": [{ "name": "", "type": "uint256" }], - "payable": false, - "type": "function" - }, - { "inputs": [], "payable": false, "type": "constructor" }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_from", "type": "address" }, - { "indexed": true, "name": "_to", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Transfer", - "type": "event" - }, - { - "anonymous": false, - "inputs": [ - { "indexed": true, "name": "_owner", "type": "address" }, - { "indexed": true, "name": "_spender", "type": "address" }, - { "indexed": false, "name": "_value", "type": "uint256" } - ], - "name": "Approval", - "type": "event" - } - ], - "devdoc": { - "methods": { - "transferFrom(address,address,uint256)": { - "details": "ERC20 transferFrom, modified such that an allowance of MAX_UINT represents an unlimited allowance.", - "params": { - "_from": "Address to transfer from.", - "_to": "Address to transfer to.", - "_value": "Amount to transfer." - }, - "return": "Success of transfer." - } - } - }, - "evm": { - "bytecode": { - "object": "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" - } - } - }, - "networks": {} -} diff --git a/python-packages/contract_wrappers/.pylintrc b/python-packages/contract_wrappers/.pylintrc index f7c1a4d9d3..1d5842bc1c 100644 --- a/python-packages/contract_wrappers/.pylintrc +++ b/python-packages/contract_wrappers/.pylintrc @@ -3,4 +3,4 @@ disable=C0330,line-too-long,fixme,too-few-public-methods,too-many-ancestors # C0330 is "bad hanging indent". we use indents per `black`. [SIMILARITIES] -min-similarity-lines=6 +min-similarity-lines=12 diff --git a/python-packages/contract_wrappers/setup.py b/python-packages/contract_wrappers/setup.py index ad9974db4b..780608d725 100755 --- a/python-packages/contract_wrappers/setup.py +++ b/python-packages/contract_wrappers/setup.py @@ -3,10 +3,11 @@ """setuptools module for contract_wrappers package.""" import subprocess # nosec -from shutil import rmtree +from shutil import copy, rmtree from os import environ, path from pathlib import Path from sys import argv +from importlib.util import find_spec from distutils.command.clean import clean import distutils.command.build_py @@ -14,6 +15,38 @@ from setuptools import find_packages, setup from setuptools.command.test import test as TestCommand +BLACK_COMMAND = "black --line-length 79" + + +class PreInstallCommand(distutils.command.build_py.build_py): + """Custom setuptools command class for pulling in generated code.""" + + description = "Pull in code generated by TypeScript" + + def run(self): + """Copy files from TS build area to local src, & `black` them.""" + pkgdir = path.dirname(path.realpath(argv[0])) + copy( + path.join( + pkgdir, + "..", + "..", + "packages", + "python-contract-wrappers", + "generated", + "erc20_token.py", + ), + path.join(pkgdir, "src", "zero_ex", "contract_wrappers"), + ) + if find_spec("black") is None: + subprocess.check_call("pip install black".split()) # nosec + subprocess.check_call( # nosec + ( + BLACK_COMMAND + " src/zero_ex/contract_wrappers/erc20_token.py" + ).split() + ) + + class TestCommandExtension(TestCommand): """Run pytest tests.""" @@ -33,7 +66,7 @@ class LintCommand(distutils.command.build_py.build_py): """Run linter shell commands.""" lint_commands = [ # formatter: - "black --line-length 79 --check --diff src test setup.py".split(), + (BLACK_COMMAND + " --check --diff src test setup.py").split(), # style guide checker (formerly pep8): "pycodestyle src test setup.py".split(), # docstring style checker: @@ -152,6 +185,7 @@ setup( author_email="feuGeneA@users.noreply.github.com", cmdclass={ "clean": CleanCommandExtension, + "pre_install": PreInstallCommand, "lint": LintCommand, "test": TestCommandExtension, "test_publish": TestPublishCommand, diff --git a/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/__init__.py b/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/__init__.py index 6290097216..4e9725f672 100644 --- a/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/__init__.py +++ b/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/__init__.py @@ -91,19 +91,24 @@ we need to tell the WETH token contract to let the 0x contracts transfer our balance: >>> from zero_ex.contract_wrappers import ERC20Token ->>> erc20_wrapper = ERC20Token(ganache) +>>> zrx_wrapper = ERC20Token( +... provider=ganache, +... contract_address=NETWORK_TO_ADDRESSES[NetworkId.GANACHE].zrx_token, +... ) +>>> weth_wrapper = ERC20Token( +... provider=ganache, +... contract_address=NETWORK_TO_ADDRESSES[NetworkId.GANACHE].ether_token, +... ) >>> erc20_proxy_addr = NETWORK_TO_ADDRESSES[NetworkId.GANACHE].erc20_proxy ->>> tx = erc20_wrapper.approve( -... zrx_address, +>>> tx = zrx_wrapper.approve( ... erc20_proxy_addr, ... to_wei(100, 'ether'), ... tx_params=TxParams(from_=maker_address), ... ) ->>> tx = erc20_wrapper.approve( -... weth_address, +>>> tx = weth_wrapper.approve( ... erc20_proxy_addr, ... to_wei(100, 'ether'), ... tx_params=TxParams(from_=taker_address), @@ -157,7 +162,10 @@ fill. This example fills the order completely, but partial fills are possible too. >>> from zero_ex.contract_wrappers import Exchange ->>> exchange_contract = Exchange(ganache) +>>> exchange_contract = Exchange( +... provider=ganache, +... contract_address=NETWORK_TO_ADDRESSES[NetworkId.GANACHE].exchange, +... ) >>> tx_hash = exchange_contract.fill_order( ... order=order, ... taker_amount=order["takerAssetAmount"], @@ -288,5 +296,5 @@ HexBytes('0x...') """ from .tx_params import TxParams -from .erc20_wrapper import ERC20Token +from .erc20_token import ERC20Token from .exchange_wrapper import Exchange diff --git a/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/_base_contract_wrapper.py b/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/_base_contract_wrapper.py index d85fb10893..782c8a9735 100644 --- a/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/_base_contract_wrapper.py +++ b/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/_base_contract_wrapper.py @@ -15,24 +15,28 @@ class BaseContractWrapper: It provides functionality for instantiating a contract instance, calling view functions, and calling functions which require transactions. - - :param provider: instance of :class:`web3.providers.base.BaseProvider` - :param account_address: default None, str of account address - :param private_key: default None, str of private_key """ def __init__( self, provider: BaseProvider, - account_address: str = None, + contract_address: str, private_key: str = None, ): - """Create an instance of BaseContractWrapper.""" + """Create an instance of BaseContractWrapper. + + :param provider: instance of :class:`web3.providers.base.BaseProvider` + :param private_key: If specified, transactions will be signed locally, + via Web3.py's `eth.account.signTransaction()`:code:, before being + sent via `eth.sendRawTransaction()`:code:. + """ self._provider = provider - self._account_address = account_address self._private_key = private_key self._web3 = Web3(provider) self._web3_eth = self._web3.eth # pylint: disable=no-member + self._contract_address = self._validate_and_checksum_address( + contract_address + ) self._can_send_tx = False if self._web3_eth.defaultAccount or self._web3_eth.accounts: @@ -98,7 +102,6 @@ class BaseContractWrapper: # pylint: disable=too-many-arguments def execute_method( self, - address: str, abi: dict, method: str, args: Optional[Union[list, tuple]] = None, @@ -107,7 +110,6 @@ class BaseContractWrapper: ) -> str: """Execute the method on a contract instance. - :param address: string of contract address :param abi: dict of contract ABI :param method: string name of method to call :param args: default None, list or tuple of arguments for the method @@ -117,7 +119,9 @@ class BaseContractWrapper: :returns: str of transaction hash """ - contract_instance = self._contract_instance(address=address, abi=abi) + contract_instance = self._contract_instance( + address=self._contract_address, abi=abi + ) if args is None: args = [] if hasattr(contract_instance.functions, method): @@ -126,5 +130,7 @@ class BaseContractWrapper: func=func, tx_params=tx_params, view_only=view_only ) raise Exception( - "No method {} found on contract {}.".format(address, method) + "No method {} found on contract {}.".format( + self._contract_address, method + ) ) diff --git a/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_wrapper.py b/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_wrapper.py deleted file mode 100644 index a3d76a38f0..0000000000 --- a/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/erc20_wrapper.py +++ /dev/null @@ -1,202 +0,0 @@ -"""Wrapper for Ethereum ERC20 Token smart contract.""" - -from typing import Optional, Tuple, Union - -from hexbytes import HexBytes -from web3.datastructures import AttributeDict -from web3.providers.base import BaseProvider - -from zero_ex.contract_artifacts import abi_by_name - -from ._base_contract_wrapper import BaseContractWrapper -from .tx_params import TxParams - - -class ERC20Token(BaseContractWrapper): - """Wrapper class for Ethereum ERC20 smart contract.""" - - def __init__( - self, - provider: BaseProvider, - account_address: str = None, - private_key: str = None, - ): - """Get an instance of wrapper for ERC20 smart contract. - - :param provider: instance of :class:`web3.providers.base.BaseProvider` - """ - super(ERC20Token, self).__init__( - provider=provider, - account_address=account_address, - private_key=private_key, - ) - - def _erc20(self, token_address): - """Get an instance of the ERC20 smart contract at a specific address. - - :returns: ERC20 contract object - """ - return self._contract_instance( - address=token_address, abi=abi_by_name("ERC20Token") - ) - - # pylint: disable=too-many-arguments - def transfer( - self, - token_address: str, - to_address: str, - value: int, - tx_params: Optional[TxParams] = None, - view_only: bool = False, - ) -> Union[HexBytes, bytes]: - """Transfer the balance from owner's account to another account. - - :param value: integer amount to send - :param tx_params: transaction parameters - :param view_only: whether to use transact() or call() - - :returns: transaction hash - """ - token_address = self._validate_and_checksum_address(token_address) - to_address = self._validate_and_checksum_address(to_address) - # safeguard against fractional inputs - value = int(value) - func = self._erc20(token_address).functions.transfer(to_address, value) - return self._invoke_function_call( - func=func, tx_params=tx_params, view_only=view_only - ) - - # pylint: disable=too-many-arguments - def approve( - self, - token_address: str, - spender_address: str, - value: int, - tx_params: Optional[TxParams] = None, - view_only: bool = False, - ) -> Union[HexBytes, bytes]: - """Approve an address to spend up to `value`:code: of your tokens. - - :param value: amount of allowance - :param tx_params: transaction options - :param view_only: whether to use transact() or call() - - :returns: transaction hash - """ - token_address = self._validate_and_checksum_address(token_address) - spender_address = self._validate_and_checksum_address(spender_address) - # safeguard against fractional inputs - value = int(value) - func = self._erc20(token_address).functions.approve( - spender_address, value - ) - return self._invoke_function_call( - func=func, tx_params=tx_params, view_only=view_only - ) - - # pylint: disable=too-many-arguments - def transfer_from( - self, - token_address: str, - authorized_address: str, - to_address: str, - value: int, - tx_params: Optional[TxParams] = None, - view_only: bool = False, - ) -> Union[HexBytes, bytes]: - """Transfer tokens from `authorized_address`:code: to another address. - - Note that the `authorized_address`:code: must have already called - `approve`:code: for the `spender_address`:code:. - - :param authorized_address: address you have been authorized to transfer - tokens from - :param value: amount to send - :param tx_params: transaction parameters - :param view_only: whether to use transact() or call() - - :returns: transaction hash - """ - token_address = self._validate_and_checksum_address(token_address) - authorized_address = self._validate_and_checksum_address( - authorized_address - ) - to_address = self._validate_and_checksum_address(to_address) - # safeguard against fractional inputs - value = int(value) - func = self._erc20(token_address).functions.transferFrom( - authorized_address, to_address, value - ) - return self._invoke_function_call( - func=func, tx_params=tx_params, view_only=view_only - ) - - def total_supply(self, token_address: str) -> int: - """Get total supply of a given ERC20 Token. - - :returns: amount of tokens - """ - token_address = self._validate_and_checksum_address(token_address) - func = self._erc20(token_address).functions.totalSupply() - return self._invoke_function_call( - func=func, tx_params=None, view_only=True - ) - - def balance_of(self, token_address: str, owner_address: str) -> int: - """Get token balance of a given owner address. - - :returns: amount of tokens - """ - token_address = self._validate_and_checksum_address(token_address) - owner_address = self._validate_and_checksum_address(owner_address) - func = self._erc20(token_address).functions.balanceOf(owner_address) - return self._invoke_function_call( - func=func, tx_params=None, view_only=True - ) - - def allowance( - self, token_address: str, owner_address: str, spender_address: str - ) -> Union[HexBytes, bytes]: - """Get the amount of tokens approved for a spender. - - :returns: amount of tokens - """ - token_address = self._validate_and_checksum_address(token_address) - owner_address = self._validate_and_checksum_address(owner_address) - spender_address = self._validate_and_checksum_address(spender_address) - func = self._erc20(token_address).functions.allowance( - owner_address, spender_address - ) - return self._invoke_function_call( - func=func, tx_params=None, view_only=True - ) - - def get_transfer_event( - self, token_address: str, tx_hash: Union[HexBytes, bytes] - ) -> Tuple[AttributeDict]: - """Get the result of a transfer from its transaction hash. - - :param tx_hash: hash of transfer transaction - """ - tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash) - token_address = self._validate_and_checksum_address(token_address) - return ( - self._erc20(token_address) - .events.Transfer() - .processReceipt(tx_receipt) - ) - - def get_approval_event( - self, token_address: str, tx_hash: Union[HexBytes, bytes] - ) -> Tuple[AttributeDict]: - """Get the result of an approval event from its transaction hash. - - :param tx_hash: hash of approval transaction - """ - tx_receipt = self._web3_eth.getTransactionReceipt(tx_hash) - token_address = self._validate_and_checksum_address(token_address) - return ( - self._erc20(token_address) - .events.Approval() - .processReceipt(tx_receipt) - ) diff --git a/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/exchange_wrapper.py b/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/exchange_wrapper.py index e936ba66b4..12d14bab0f 100644 --- a/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/exchange_wrapper.py +++ b/python-packages/contract_wrappers/src/zero_ex/contract_wrappers/exchange_wrapper.py @@ -32,18 +32,17 @@ class Exchange(BaseContractWrapper): def __init__( self, provider: BaseProvider, - account_address: str = None, + contract_address: str, private_key: str = None, ): """Get an instance of the 0x Exchange smart contract wrapper. :param provider: instance of :class:`web3.providers.base.BaseProvider` - :param account_address: str of account address :param private_key: str of private_key """ super(Exchange, self).__init__( provider=provider, - account_address=account_address, + contract_address=contract_address, private_key=private_key, ) self._web3_net = self._web3.net # pylint: disable=no-member diff --git a/python-packages/contract_wrappers/test/conftest.py b/python-packages/contract_wrappers/test/conftest.py index 206909dabc..9c0fb47097 100644 --- a/python-packages/contract_wrappers/test/conftest.py +++ b/python-packages/contract_wrappers/test/conftest.py @@ -40,24 +40,21 @@ def erc20_proxy_address(): @pytest.fixture(scope="module") -def weth_address(): - """Get address of Wrapped Ether (WETH) token for the Ganache network.""" - return NETWORK_TO_ADDRESSES[NetworkId.GANACHE].ether_token - - -@pytest.fixture(scope="module") -def weth_asset_data(weth_address): # pylint: disable=redefined-outer-name +def weth_asset_data(): # pylint: disable=redefined-outer-name """Get 0x asset data for Wrapped Ether (WETH) token.""" - return asset_data_utils.encode_erc20(weth_address) + return asset_data_utils.encode_erc20( + NETWORK_TO_ADDRESSES[NetworkId.GANACHE].ether_token + ) @pytest.fixture(scope="module") -def weth_instance( - web3_eth, weth_address -): # pylint: disable=redefined-outer-name +def weth_instance(web3_eth): # pylint: disable=redefined-outer-name """Get an instance of the WrapperEther contract.""" return web3_eth.contract( - address=to_checksum_address(weth_address), abi=abi_by_name("WETH9") + address=to_checksum_address( + NETWORK_TO_ADDRESSES[NetworkId.GANACHE].ether_token + ), + abi=abi_by_name("WETH9"), ) diff --git a/python-packages/contract_wrappers/test/test_base_contract_wrapper.py b/python-packages/contract_wrappers/test/test_base_contract_wrapper.py index 8b5ca34dc5..a26e200cd3 100644 --- a/python-packages/contract_wrappers/test/test_base_contract_wrapper.py +++ b/python-packages/contract_wrappers/test/test_base_contract_wrapper.py @@ -3,6 +3,7 @@ import pytest from eth_utils import to_checksum_address +from zero_ex.contract_addresses import NETWORK_TO_ADDRESSES, NetworkId from zero_ex.contract_artifacts import abi_by_name from zero_ex.contract_wrappers._base_contract_wrapper import ( BaseContractWrapper, @@ -12,18 +13,19 @@ from zero_ex.contract_wrappers._base_contract_wrapper import ( @pytest.fixture(scope="module") def contract_wrapper(ganache_provider): """Get a BaseContractWrapper instance for testing.""" - return BaseContractWrapper(provider=ganache_provider) + return BaseContractWrapper( + provider=ganache_provider, + contract_address=NETWORK_TO_ADDRESSES[NetworkId.GANACHE].ether_token, + ) def test_contract_wrapper__execute_method( accounts, contract_wrapper, # pylint: disable=redefined-outer-name erc20_proxy_address, - weth_address, # pylint: disable=redefined-outer-name ): """Test :function:`BaseContractWrapper.execute` method.""" acc1_allowance = contract_wrapper.execute_method( - address=weth_address, abi=abi_by_name("WETH9"), method="allowance", view_only=True, @@ -36,7 +38,6 @@ def test_contract_wrapper__execute_method( with pytest.raises(Exception): contract_wrapper.execute_method( - address=weth_address, abi=abi_by_name("WETH9"), method="send", view_only=True, diff --git a/python-packages/contract_wrappers/test/test_erc20_wrapper.py b/python-packages/contract_wrappers/test/test_erc20_wrapper.py index ca3b1fbfc1..565c15aa4e 100644 --- a/python-packages/contract_wrappers/test/test_erc20_wrapper.py +++ b/python-packages/contract_wrappers/test/test_erc20_wrapper.py @@ -4,6 +4,7 @@ from decimal import Decimal import pytest +from zero_ex.contract_addresses import NETWORK_TO_ADDRESSES, NetworkId from zero_ex.contract_wrappers import ERC20Token, TxParams @@ -13,22 +14,19 @@ MAX_ALLOWANCE = int("{:.0f}".format(Decimal(2) ** 256 - 1)) @pytest.fixture(scope="module") def erc20_wrapper(ganache_provider): """Get an instance of ERC20Token wrapper class for testing.""" - return ERC20Token(ganache_provider) + return ERC20Token( + ganache_provider, NETWORK_TO_ADDRESSES[NetworkId.GANACHE].ether_token + ) def test_erc20_wrapper__balance_of( accounts, erc20_wrapper, # pylint: disable=redefined-outer-name - weth_address, weth_instance, # pylint: disable=redefined-outer-name ): """Test getting baance of an account for an ERC20 token.""" - acc1_original_weth_balance = erc20_wrapper.balance_of( - weth_address, accounts[0] - ) - acc2_original_weth_balance = erc20_wrapper.balance_of( - weth_address, accounts[1] - ) + acc1_original_weth_balance = erc20_wrapper.balance_of(accounts[0]) + acc2_original_weth_balance = erc20_wrapper.balance_of(accounts[1]) expected_difference = 1 * 10 ** 18 @@ -38,8 +36,8 @@ def test_erc20_wrapper__balance_of( weth_instance.functions.deposit().transact( {"from": accounts[1], "value": expected_difference} ) - acc1_weth_balance = erc20_wrapper.balance_of(weth_address, accounts[0]) - acc2_weth_balance = erc20_wrapper.balance_of(weth_address, accounts[1]) + acc1_weth_balance = erc20_wrapper.balance_of(accounts[0]) + acc2_weth_balance = erc20_wrapper.balance_of(accounts[1]) assert ( acc1_weth_balance - acc1_original_weth_balance == expected_difference @@ -53,27 +51,24 @@ def test_erc20_wrapper__approve( accounts, erc20_proxy_address, erc20_wrapper, # pylint: disable=redefined-outer-name - weth_address, # pylint: disable=redefined-outer-name ): """Test approving one account to spend balance from another account.""" erc20_wrapper.approve( - weth_address, erc20_proxy_address, MAX_ALLOWANCE, tx_params=TxParams(from_=accounts[0]), ) erc20_wrapper.approve( - weth_address, erc20_proxy_address, MAX_ALLOWANCE, tx_params=TxParams(from_=accounts[1]), ) acc_1_weth_allowance = erc20_wrapper.allowance( - weth_address, accounts[0], erc20_proxy_address + accounts[0], erc20_proxy_address ) acc_2_weth_allowance = erc20_wrapper.allowance( - weth_address, accounts[1], erc20_proxy_address + accounts[1], erc20_proxy_address ) assert acc_1_weth_allowance == MAX_ALLOWANCE diff --git a/python-packages/contract_wrappers/test/test_exchange_wrapper.py b/python-packages/contract_wrappers/test/test_exchange_wrapper.py index 72f638e631..f5f50b2a50 100644 --- a/python-packages/contract_wrappers/test/test_exchange_wrapper.py +++ b/python-packages/contract_wrappers/test/test_exchange_wrapper.py @@ -5,6 +5,7 @@ import random import pytest from eth_utils import remove_0x_prefix +from zero_ex.contract_addresses import NETWORK_TO_ADDRESSES, NetworkId from zero_ex.contract_wrappers import Exchange, TxParams from zero_ex.json_schemas import assert_valid from zero_ex.order_utils import generate_order_hash_hex, Order, sign_hash @@ -13,7 +14,10 @@ from zero_ex.order_utils import generate_order_hash_hex, Order, sign_hash @pytest.fixture(scope="module") def exchange_wrapper(ganache_provider): """Get an Exchange wrapper instance.""" - return Exchange(provider=ganache_provider) + return Exchange( + provider=ganache_provider, + contract_address=NETWORK_TO_ADDRESSES[NetworkId.GANACHE].exchange, + ) def create_test_order( diff --git a/python-packages/pre_install b/python-packages/pre_install new file mode 100755 index 0000000000..dca70e5bce --- /dev/null +++ b/python-packages/pre_install @@ -0,0 +1,21 @@ +#!/usr/bin/env python + +"""Run setup.py command `pre_install` for all packages that have one.""" + +from os import chdir, path +import subprocess + +PACKAGES = [ + "contract_wrappers", + "contract_artifacts", +] + +for package in PACKAGES: + print(f"Running command `pre_install` in package {package}") + chdir(package) + subprocess.check_call( + ( + path.join(".", "setup.py") + " pre_install" + ).split() + ) + chdir("..") diff --git a/python-packages/sra_client/src/zero_ex/sra_client/__init__.py b/python-packages/sra_client/src/zero_ex/sra_client/__init__.py index abfedf9609..9cbdcd2a81 100644 --- a/python-packages/sra_client/src/zero_ex/sra_client/__init__.py +++ b/python-packages/sra_client/src/zero_ex/sra_client/__init__.py @@ -316,7 +316,11 @@ book. Now let's have the taker fill it: >>> from zero_ex.contract_wrappers import Exchange, TxParams >>> from zero_ex.order_utils import Order ->>> Exchange(eth_node).fill_order( +>>> exchange = Exchange( +... provider=eth_node, +... contract_address=NETWORK_TO_ADDRESSES[NetworkId.GANACHE].exchange +... ) +>>> exchange.fill_order( ... order=order, ... taker_amount=order['makerAssetAmount']/2, # note the half fill ... signature=order['signature'], @@ -330,7 +334,7 @@ Cancelling Note that the above fill was partial: it only filled half of the order. Now we'll have our maker cancel the remaining order: ->>> Exchange(eth_node).cancel_order( +>>> exchange.cancel_order( ... order=order, ... tx_params=TxParams(from_=maker_address) ... )