diff options
Diffstat (limited to 'packages/contracts')
| -rw-r--r-- | packages/contracts/generated-wrappers/erc20_token.ts | 556 | ||||
| -rw-r--r-- | packages/contracts/generated-wrappers/erc721_token.ts | 893 | ||||
| -rw-r--r-- | packages/contracts/package.json | 10 | ||||
| -rw-r--r-- | packages/contracts/src/index.ts | 5 | ||||
| -rw-r--r-- | packages/contracts/src/wrappers/index.ts | 2 |
5 files changed, 1459 insertions, 7 deletions
diff --git a/packages/contracts/generated-wrappers/erc20_token.ts b/packages/contracts/generated-wrappers/erc20_token.ts new file mode 100644 index 000000000..3f8f9cd92 --- /dev/null +++ b/packages/contracts/generated-wrappers/erc20_token.ts @@ -0,0 +1,556 @@ +// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma whitespace class-name +// tslint:disable:no-unused-variable +// tslint:disable:no-unbound-method +import { BaseContract } from '@0xproject/base-contract'; +import { BlockParam, BlockParamLiteral, CallData, ContractAbi, ContractArtifact, DecodedLogArgs, MethodAbi, Provider, TxData, TxDataPayable } from 'ethereum-types'; +import { BigNumber, classUtils, logUtils } from '@0xproject/utils'; +import { Web3Wrapper } from '@0xproject/web3-wrapper'; +import * as ethers from 'ethers'; +import * as _ from 'lodash'; +// tslint:enable:no-unused-variable + +export type ERC20TokenEventArgs = + | ERC20TokenTransferEventArgs + | ERC20TokenApprovalEventArgs; + +export enum ERC20TokenEvents { + Transfer = 'Transfer', + Approval = 'Approval', +} + +export interface ERC20TokenTransferEventArgs extends DecodedLogArgs { + _from: string; + _to: string; + _value: BigNumber; +} + +export interface ERC20TokenApprovalEventArgs extends DecodedLogArgs { + _owner: string; + _spender: string; + _value: BigNumber; +} + + +/* istanbul ignore next */ +// tslint:disable:no-parameter-reassignment +// tslint:disable-next-line:class-name +export class ERC20TokenContract extends BaseContract { + public approve = { + async sendTransactionAsync( + _spender: string, + _value: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<string> { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('approve(address,uint256)').inputs; + [_spender, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_spender, + _value + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_spender, + _value + ]); + const encodedData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([_spender, + _value + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + self.approve.estimateGasAsync.bind( + self, + _spender, + _value + ), + ); + const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); + return txHash; + }, + async estimateGasAsync( + _spender: string, + _value: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<number> { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('approve(address,uint256)').inputs; + [_spender, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_spender, + _value + ], BaseContract._bigNumberToString); + const encodedData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([_spender, + _value + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); + return gas; + }, + getABIEncodedTransactionData( + _spender: string, + _value: BigNumber, + ): string { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('approve(address,uint256)').inputs; + [_spender, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_spender, + _value + ], BaseContract._bigNumberToString); + const abiEncodedTransactionData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([_spender, + _value + ]); + return abiEncodedTransactionData; + }, + async callAsync( + _spender: string, + _value: BigNumber, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<boolean + > { + const self = this as any as ERC20TokenContract; + const functionSignature = 'approve(address,uint256)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_spender, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_spender, + _value + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_spender, + _value + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.approve; + const encodedData = ethersFunction.encode([_spender, + _value + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'approve'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public totalSupply = { + async callAsync( + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<BigNumber + > { + const self = this as any as ERC20TokenContract; + const functionSignature = 'totalSupply()'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, []); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.totalSupply; + const encodedData = ethersFunction.encode([]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'totalSupply'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public transferFrom = { + async sendTransactionAsync( + _from: string, + _to: string, + _value: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<string> { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs; + [_from, + _to, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _value + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_from, + _to, + _value + ]); + const encodedData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([_from, + _to, + _value + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + self.transferFrom.estimateGasAsync.bind( + self, + _from, + _to, + _value + ), + ); + const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); + return txHash; + }, + async estimateGasAsync( + _from: string, + _to: string, + _value: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<number> { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs; + [_from, + _to, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _value + ], BaseContract._bigNumberToString); + const encodedData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([_from, + _to, + _value + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); + return gas; + }, + getABIEncodedTransactionData( + _from: string, + _to: string, + _value: BigNumber, + ): string { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs; + [_from, + _to, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _value + ], BaseContract._bigNumberToString); + const abiEncodedTransactionData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([_from, + _to, + _value + ]); + return abiEncodedTransactionData; + }, + async callAsync( + _from: string, + _to: string, + _value: BigNumber, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<boolean + > { + const self = this as any as ERC20TokenContract; + const functionSignature = 'transferFrom(address,address,uint256)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_from, + _to, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _value + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_from, + _to, + _value + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferFrom; + const encodedData = ethersFunction.encode([_from, + _to, + _value + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'transferFrom'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public balanceOf = { + async callAsync( + _owner: string, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<BigNumber + > { + const self = this as any as ERC20TokenContract; + const functionSignature = 'balanceOf(address)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_owner + ] = BaseContract._formatABIDataItemList(inputAbi, [_owner + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_owner + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.balanceOf; + const encodedData = ethersFunction.encode([_owner + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'balanceOf'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public transfer = { + async sendTransactionAsync( + _to: string, + _value: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<string> { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs; + [_to, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_to, + _value + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_to, + _value + ]); + const encodedData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer.encode([_to, + _value + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + self.transfer.estimateGasAsync.bind( + self, + _to, + _value + ), + ); + const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); + return txHash; + }, + async estimateGasAsync( + _to: string, + _value: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<number> { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs; + [_to, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_to, + _value + ], BaseContract._bigNumberToString); + const encodedData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer.encode([_to, + _value + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); + return gas; + }, + getABIEncodedTransactionData( + _to: string, + _value: BigNumber, + ): string { + const self = this as any as ERC20TokenContract; + const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs; + [_to, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_to, + _value + ], BaseContract._bigNumberToString); + const abiEncodedTransactionData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer.encode([_to, + _value + ]); + return abiEncodedTransactionData; + }, + async callAsync( + _to: string, + _value: BigNumber, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<boolean + > { + const self = this as any as ERC20TokenContract; + const functionSignature = 'transfer(address,uint256)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_to, + _value + ] = BaseContract._formatABIDataItemList(inputAbi, [_to, + _value + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_to, + _value + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transfer; + const encodedData = ethersFunction.encode([_to, + _value + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'transfer'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public allowance = { + async callAsync( + _owner: string, + _spender: string, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<BigNumber + > { + const self = this as any as ERC20TokenContract; + const functionSignature = 'allowance(address,address)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_owner, + _spender + ] = BaseContract._formatABIDataItemList(inputAbi, [_owner, + _spender + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_owner, + _spender + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.allowance; + const encodedData = ethersFunction.encode([_owner, + _spender + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'allowance'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public static async deployFrom0xArtifactAsync( + artifact: ContractArtifact, + provider: Provider, + txDefaults: Partial<TxData>, + ): Promise<ERC20TokenContract> { + if (_.isUndefined(artifact.compilerOutput)) { + throw new Error('Compiler output not found in the artifact file'); + } + const bytecode = artifact.compilerOutput.evm.bytecode.object; + const abi = artifact.compilerOutput.abi; + return ERC20TokenContract.deployAsync(bytecode, abi, provider, txDefaults, ); + } + public static async deployAsync( + bytecode: string, + abi: ContractAbi, + provider: Provider, + txDefaults: Partial<TxData>, + ): Promise<ERC20TokenContract> { + const constructorAbi = BaseContract._lookupConstructorAbi(abi); + [] = BaseContract._formatABIDataItemList( + constructorAbi.inputs, + [], + BaseContract._bigNumberToString, + ); + const iface = new ethers.Interface(abi); + const deployInfo = iface.deployFunction; + const txData = deployInfo.encode(bytecode, []); + const web3Wrapper = new Web3Wrapper(provider); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + {data: txData}, + txDefaults, + web3Wrapper.estimateGasAsync.bind(web3Wrapper), + ); + const txHash = await web3Wrapper.sendTransactionAsync(txDataWithDefaults); + logUtils.log(`transactionHash: ${txHash}`); + const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); + logUtils.log(`ERC20Token successfully deployed at ${txReceipt.contractAddress}`); + const contractInstance = new ERC20TokenContract(abi, txReceipt.contractAddress as string, provider, txDefaults); + contractInstance.constructorArgs = []; + return contractInstance; + } + constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) { + super('ERC20Token', abi, address, provider, txDefaults); + classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']); + } +} // tslint:disable:max-file-line-count +// tslint:enable:no-unbound-method diff --git a/packages/contracts/generated-wrappers/erc721_token.ts b/packages/contracts/generated-wrappers/erc721_token.ts new file mode 100644 index 000000000..6c4aa644b --- /dev/null +++ b/packages/contracts/generated-wrappers/erc721_token.ts @@ -0,0 +1,893 @@ +// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma whitespace class-name +// tslint:disable:no-unused-variable +// tslint:disable:no-unbound-method +import { BaseContract } from '@0xproject/base-contract'; +import { BlockParam, BlockParamLiteral, CallData, ContractAbi, ContractArtifact, DecodedLogArgs, MethodAbi, Provider, TxData, TxDataPayable } from 'ethereum-types'; +import { BigNumber, classUtils, logUtils } from '@0xproject/utils'; +import { Web3Wrapper } from '@0xproject/web3-wrapper'; +import * as ethers from 'ethers'; +import * as _ from 'lodash'; +// tslint:enable:no-unused-variable + +export type ERC721TokenEventArgs = + | ERC721TokenTransferEventArgs + | ERC721TokenApprovalEventArgs + | ERC721TokenApprovalForAllEventArgs; + +export enum ERC721TokenEvents { + Transfer = 'Transfer', + Approval = 'Approval', + ApprovalForAll = 'ApprovalForAll', +} + +export interface ERC721TokenTransferEventArgs extends DecodedLogArgs { + _from: string; + _to: string; + _tokenId: BigNumber; +} + +export interface ERC721TokenApprovalEventArgs extends DecodedLogArgs { + _owner: string; + _approved: string; + _tokenId: BigNumber; +} + +export interface ERC721TokenApprovalForAllEventArgs extends DecodedLogArgs { + _owner: string; + _operator: string; + _approved: boolean; +} + + +/* istanbul ignore next */ +// tslint:disable:no-parameter-reassignment +// tslint:disable-next-line:class-name +export class ERC721TokenContract extends BaseContract { + public getApproved = { + async callAsync( + _tokenId: BigNumber, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<string + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'getApproved(uint256)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_tokenId + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_tokenId + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getApproved; + const encodedData = ethersFunction.encode([_tokenId + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'getApproved'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public approve = { + async sendTransactionAsync( + _approved: string, + _tokenId: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<string> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('approve(address,uint256)').inputs; + [_approved, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_approved, + _tokenId + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_approved, + _tokenId + ]); + const encodedData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([_approved, + _tokenId + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + self.approve.estimateGasAsync.bind( + self, + _approved, + _tokenId + ), + ); + const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); + return txHash; + }, + async estimateGasAsync( + _approved: string, + _tokenId: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<number> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('approve(address,uint256)').inputs; + [_approved, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_approved, + _tokenId + ], BaseContract._bigNumberToString); + const encodedData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([_approved, + _tokenId + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); + return gas; + }, + getABIEncodedTransactionData( + _approved: string, + _tokenId: BigNumber, + ): string { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('approve(address,uint256)').inputs; + [_approved, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_approved, + _tokenId + ], BaseContract._bigNumberToString); + const abiEncodedTransactionData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([_approved, + _tokenId + ]); + return abiEncodedTransactionData; + }, + async callAsync( + _approved: string, + _tokenId: BigNumber, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<void + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'approve(address,uint256)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_approved, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_approved, + _tokenId + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_approved, + _tokenId + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.approve; + const encodedData = ethersFunction.encode([_approved, + _tokenId + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'approve'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray; + }, + }; + public transferFrom = { + async sendTransactionAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<string> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs; + [_from, + _to, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_from, + _to, + _tokenId + ]); + const encodedData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([_from, + _to, + _tokenId + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + self.transferFrom.estimateGasAsync.bind( + self, + _from, + _to, + _tokenId + ), + ); + const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); + return txHash; + }, + async estimateGasAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<number> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs; + [_from, + _to, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId + ], BaseContract._bigNumberToString); + const encodedData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([_from, + _to, + _tokenId + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); + return gas; + }, + getABIEncodedTransactionData( + _from: string, + _to: string, + _tokenId: BigNumber, + ): string { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs; + [_from, + _to, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId + ], BaseContract._bigNumberToString); + const abiEncodedTransactionData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([_from, + _to, + _tokenId + ]); + return abiEncodedTransactionData; + }, + async callAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<void + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'transferFrom(address,address,uint256)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_from, + _to, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_from, + _to, + _tokenId + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferFrom; + const encodedData = ethersFunction.encode([_from, + _to, + _tokenId + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'transferFrom'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray; + }, + }; + public safeTransferFrom1 = { + async sendTransactionAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<string> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256)').inputs; + [_from, + _to, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_from, + _to, + _tokenId + ]); + const encodedData = self._lookupEthersInterface('safeTransferFrom(address,address,uint256)').functions.safeTransferFrom.encode([_from, + _to, + _tokenId + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + self.safeTransferFrom1.estimateGasAsync.bind( + self, + _from, + _to, + _tokenId + ), + ); + const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); + return txHash; + }, + async estimateGasAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + txData: Partial<TxData> = {}, + ): Promise<number> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256)').inputs; + [_from, + _to, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId + ], BaseContract._bigNumberToString); + const encodedData = self._lookupEthersInterface('safeTransferFrom(address,address,uint256)').functions.safeTransferFrom.encode([_from, + _to, + _tokenId + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); + return gas; + }, + getABIEncodedTransactionData( + _from: string, + _to: string, + _tokenId: BigNumber, + ): string { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256)').inputs; + [_from, + _to, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId + ], BaseContract._bigNumberToString); + const abiEncodedTransactionData = self._lookupEthersInterface('safeTransferFrom(address,address,uint256)').functions.safeTransferFrom.encode([_from, + _to, + _tokenId + ]); + return abiEncodedTransactionData; + }, + async callAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<void + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'safeTransferFrom(address,address,uint256)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_from, + _to, + _tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_from, + _to, + _tokenId + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.safeTransferFrom; + const encodedData = ethersFunction.encode([_from, + _to, + _tokenId + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'safeTransferFrom'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray; + }, + }; + public ownerOf = { + async callAsync( + _tokenId: BigNumber, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<string + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'ownerOf(uint256)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_tokenId + ] = BaseContract._formatABIDataItemList(inputAbi, [_tokenId + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_tokenId + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.ownerOf; + const encodedData = ethersFunction.encode([_tokenId + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'ownerOf'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public balanceOf = { + async callAsync( + _owner: string, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<BigNumber + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'balanceOf(address)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_owner + ] = BaseContract._formatABIDataItemList(inputAbi, [_owner + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_owner + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.balanceOf; + const encodedData = ethersFunction.encode([_owner + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'balanceOf'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public setApprovalForAll = { + async sendTransactionAsync( + _operator: string, + _approved: boolean, + txData: Partial<TxData> = {}, + ): Promise<string> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('setApprovalForAll(address,bool)').inputs; + [_operator, + _approved + ] = BaseContract._formatABIDataItemList(inputAbi, [_operator, + _approved + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_operator, + _approved + ]); + const encodedData = self._lookupEthersInterface('setApprovalForAll(address,bool)').functions.setApprovalForAll.encode([_operator, + _approved + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + self.setApprovalForAll.estimateGasAsync.bind( + self, + _operator, + _approved + ), + ); + const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); + return txHash; + }, + async estimateGasAsync( + _operator: string, + _approved: boolean, + txData: Partial<TxData> = {}, + ): Promise<number> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('setApprovalForAll(address,bool)').inputs; + [_operator, + _approved + ] = BaseContract._formatABIDataItemList(inputAbi, [_operator, + _approved + ], BaseContract._bigNumberToString); + const encodedData = self._lookupEthersInterface('setApprovalForAll(address,bool)').functions.setApprovalForAll.encode([_operator, + _approved + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); + return gas; + }, + getABIEncodedTransactionData( + _operator: string, + _approved: boolean, + ): string { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('setApprovalForAll(address,bool)').inputs; + [_operator, + _approved + ] = BaseContract._formatABIDataItemList(inputAbi, [_operator, + _approved + ], BaseContract._bigNumberToString); + const abiEncodedTransactionData = self._lookupEthersInterface('setApprovalForAll(address,bool)').functions.setApprovalForAll.encode([_operator, + _approved + ]); + return abiEncodedTransactionData; + }, + async callAsync( + _operator: string, + _approved: boolean, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<void + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'setApprovalForAll(address,bool)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_operator, + _approved + ] = BaseContract._formatABIDataItemList(inputAbi, [_operator, + _approved + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_operator, + _approved + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.setApprovalForAll; + const encodedData = ethersFunction.encode([_operator, + _approved + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'setApprovalForAll'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray; + }, + }; + public safeTransferFrom2 = { + async sendTransactionAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + _data: string, + txData: Partial<TxData> = {}, + ): Promise<string> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256,bytes)').inputs; + [_from, + _to, + _tokenId, + _data + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId, + _data + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_from, + _to, + _tokenId, + _data + ]); + const encodedData = self._lookupEthersInterface('safeTransferFrom(address,address,uint256,bytes)').functions.safeTransferFrom.encode([_from, + _to, + _tokenId, + _data + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + self.safeTransferFrom2.estimateGasAsync.bind( + self, + _from, + _to, + _tokenId, + _data + ), + ); + const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); + return txHash; + }, + async estimateGasAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + _data: string, + txData: Partial<TxData> = {}, + ): Promise<number> { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256,bytes)').inputs; + [_from, + _to, + _tokenId, + _data + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId, + _data + ], BaseContract._bigNumberToString); + const encodedData = self._lookupEthersInterface('safeTransferFrom(address,address,uint256,bytes)').functions.safeTransferFrom.encode([_from, + _to, + _tokenId, + _data + ]); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...txData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); + return gas; + }, + getABIEncodedTransactionData( + _from: string, + _to: string, + _tokenId: BigNumber, + _data: string, + ): string { + const self = this as any as ERC721TokenContract; + const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256,bytes)').inputs; + [_from, + _to, + _tokenId, + _data + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId, + _data + ], BaseContract._bigNumberToString); + const abiEncodedTransactionData = self._lookupEthersInterface('safeTransferFrom(address,address,uint256,bytes)').functions.safeTransferFrom.encode([_from, + _to, + _tokenId, + _data + ]); + return abiEncodedTransactionData; + }, + async callAsync( + _from: string, + _to: string, + _tokenId: BigNumber, + _data: string, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<void + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'safeTransferFrom(address,address,uint256,bytes)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_from, + _to, + _tokenId, + _data + ] = BaseContract._formatABIDataItemList(inputAbi, [_from, + _to, + _tokenId, + _data + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_from, + _to, + _tokenId, + _data + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.safeTransferFrom; + const encodedData = ethersFunction.encode([_from, + _to, + _tokenId, + _data + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'safeTransferFrom'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray; + }, + }; + public isApprovedForAll = { + async callAsync( + _owner: string, + _operator: string, + callData: Partial<CallData> = {}, + defaultBlock?: BlockParam, + ): Promise<boolean + > { + const self = this as any as ERC721TokenContract; + const functionSignature = 'isApprovedForAll(address,address)'; + const inputAbi = self._lookupAbi(functionSignature).inputs; + [_owner, + _operator + ] = BaseContract._formatABIDataItemList(inputAbi, [_owner, + _operator + ], BaseContract._bigNumberToString.bind(self)); + BaseContract.strictArgumentEncodingCheck(inputAbi, [_owner, + _operator + ]); + const ethersFunction = self._lookupEthersInterface(functionSignature).functions.isApprovedForAll; + const encodedData = ethersFunction.encode([_owner, + _operator + ]); + const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + { + to: self.address, + ...callData, + data: encodedData, + }, + self._web3Wrapper.getContractDefaults(), + ); + const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); + BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); + let resultArray = ethersFunction.decode(rawCallResult); + const outputAbi = (_.find(self.abi, {name: 'isApprovedForAll'}) as MethodAbi).outputs; + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this)); + resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this)); + return resultArray[0]; + }, + }; + public static async deployFrom0xArtifactAsync( + artifact: ContractArtifact, + provider: Provider, + txDefaults: Partial<TxData>, + ): Promise<ERC721TokenContract> { + if (_.isUndefined(artifact.compilerOutput)) { + throw new Error('Compiler output not found in the artifact file'); + } + const bytecode = artifact.compilerOutput.evm.bytecode.object; + const abi = artifact.compilerOutput.abi; + return ERC721TokenContract.deployAsync(bytecode, abi, provider, txDefaults, ); + } + public static async deployAsync( + bytecode: string, + abi: ContractAbi, + provider: Provider, + txDefaults: Partial<TxData>, + ): Promise<ERC721TokenContract> { + const constructorAbi = BaseContract._lookupConstructorAbi(abi); + [] = BaseContract._formatABIDataItemList( + constructorAbi.inputs, + [], + BaseContract._bigNumberToString, + ); + const iface = new ethers.Interface(abi); + const deployInfo = iface.deployFunction; + const txData = deployInfo.encode(bytecode, []); + const web3Wrapper = new Web3Wrapper(provider); + const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( + {data: txData}, + txDefaults, + web3Wrapper.estimateGasAsync.bind(web3Wrapper), + ); + const txHash = await web3Wrapper.sendTransactionAsync(txDataWithDefaults); + logUtils.log(`transactionHash: ${txHash}`); + const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); + logUtils.log(`ERC721Token successfully deployed at ${txReceipt.contractAddress}`); + const contractInstance = new ERC721TokenContract(abi, txReceipt.contractAddress as string, provider, txDefaults); + contractInstance.constructorArgs = []; + return contractInstance; + } + constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) { + super('ERC721Token', abi, address, provider, txDefaults); + classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']); + } +} // tslint:disable:max-file-line-count +// tslint:enable:no-unbound-method diff --git a/packages/contracts/package.json b/packages/contracts/package.json index b147e8827..087e35a41 100644 --- a/packages/contracts/package.json +++ b/packages/contracts/package.json @@ -1,7 +1,6 @@ { - "private": true, - "name": "contracts", - "version": "2.1.49", + "name": "@0xproject/contracts", + "version": "2.0.0", "engines": { "node": ">=6.12" }, @@ -32,7 +31,7 @@ "lint-contracts": "solhint contracts/**/**/**/**/*.sol" }, "config": { - "abis": "generated-artifacts/@(AssetProxyOwner|DummyERC20Token|DummyERC721Receiver|DummyERC721Token|DummyMultipleReturnERC20Token|DummyNoReturnERC20Token|ERC20Proxy|ERC721Proxy|Forwarder|Exchange|ExchangeWrapper|IAssetData|IAssetProxy|InvalidERC721Receiver|MixinAuthorizable|MultiSigWallet|MultiSigWalletWithTimeLock|OrderValidator|ReentrantERC20Token|TestAssetProxyOwner|TestAssetProxyDispatcher|TestConstants|TestExchangeInternals|TestLibBytes|TestLibs|TestSignatureValidator|TestStaticCallReceiver|Validator|Wallet|Whitelist|WETH9|ZRXToken).json" + "abis": "generated-artifacts/@(AssetProxyOwner|DummyERC20Token|DummyERC721Receiver|DummyERC721Token|DummyMultipleReturnERC20Token|DummyNoReturnERC20Token|ERC20Token|ERC20Proxy|ERC721Token|ERC721Proxy|Forwarder|Exchange|ExchangeWrapper|IAssetData|IAssetProxy|InvalidERC721Receiver|MixinAuthorizable|MultiSigWallet|MultiSigWalletWithTimeLock|OrderValidator|ReentrantERC20Token|TestAssetProxyOwner|TestAssetProxyDispatcher|TestConstants|TestExchangeInternals|TestLibBytes|TestLibs|TestSignatureValidator|TestStaticCallReceiver|Validator|Wallet|Whitelist|WETH9|ZRXToken).json" }, "repository": { "type": "git", @@ -86,5 +85,8 @@ "ethers": "~4.0.4", "js-combinatorics": "^0.5.3", "lodash": "^4.17.5" + }, + "publishConfig": { + "access": "public" } } diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts index 714259158..72f75c594 100644 --- a/packages/contracts/src/index.ts +++ b/packages/contracts/src/index.ts @@ -1,4 +1,3 @@ -import * as artifacts from './artifacts'; +export * from './artifacts'; import * as wrappers from './wrappers'; - -export { wrappers, artifacts }; +export { wrappers }; diff --git a/packages/contracts/src/wrappers/index.ts b/packages/contracts/src/wrappers/index.ts index 89c398424..64f1dc6a3 100644 --- a/packages/contracts/src/wrappers/index.ts +++ b/packages/contracts/src/wrappers/index.ts @@ -7,6 +7,8 @@ export * from '../../generated-wrappers/dummy_multiple_return_erc20_token'; export * from '../../generated-wrappers/dummy_no_return_erc20_token'; export * from '../../generated-wrappers/erc20_proxy'; export * from '../../generated-wrappers/erc721_proxy'; +export * from '../../generated-wrappers/erc20_token'; +export * from '../../generated-wrappers/erc721_token'; export * from '../../generated-wrappers/exchange'; export * from '../../generated-wrappers/exchange_wrapper'; export * from '../../generated-wrappers/forwarder'; |