crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Progress

Browse Source
This commit is contained in:
Greg Hysen 2018-12-17 18:26:03 -08:00
parent 797d7c7878
commit 285fb3dead
23 changed files with 1246 additions and 2823 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
contracts/protocol/test/asset_proxy/proxies.ts
View File

@ -78,6 +78,7 @@ describe('Asset Transfer Proxies', () => {
await blockchainLifecycle.revertAsync();
});
before(async () => {
console.log('1');
const accounts = await web3Wrapper.getAvailableAddressesAsync();
const usedAddresses = ([owner, notAuthorized, authorized, fromAddress, toAddress] = _.slice(accounts, 0, 5));
@ -93,6 +94,7 @@ describe('Asset Transfer Proxies', () => {
txDefaults,
);
console.log('2');
// Configure ERC20Proxy
await web3Wrapper.awaitTransactionSuccessAsync(
await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
@ -100,6 +102,7 @@ describe('Asset Transfer Proxies', () => {
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('3');
await web3Wrapper.awaitTransactionSuccessAsync(
await erc20Proxy.addAuthorizedAddress.sendTransactionAsync(multiAssetProxy.address, {
from: owner,
@ -107,6 +110,8 @@ describe('Asset Transfer Proxies', () => {
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('4');
// Configure ERC721Proxy
await web3Wrapper.awaitTransactionSuccessAsync(
await erc721Proxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
@ -114,6 +119,8 @@ describe('Asset Transfer Proxies', () => {
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('5');
await web3Wrapper.awaitTransactionSuccessAsync(
await erc721Proxy.addAuthorizedAddress.sendTransactionAsync(multiAssetProxy.address, {
from: owner,
@ -121,6 +128,8 @@ describe('Asset Transfer Proxies', () => {
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('6');
// Configure MultiAssetProxy
await web3Wrapper.awaitTransactionSuccessAsync(
await multiAssetProxy.addAuthorizedAddress.sendTransactionAsync(authorized, {
@ -128,12 +137,16 @@ describe('Asset Transfer Proxies', () => {
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('7');
await web3Wrapper.awaitTransactionSuccessAsync(
await multiAssetProxy.registerAssetProxy.sendTransactionAsync(erc20Proxy.address, {
from: owner,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('8');
await web3Wrapper.awaitTransactionSuccessAsync(
await multiAssetProxy.registerAssetProxy.sendTransactionAsync(erc721Proxy.address, {
from: owner,
@ -141,6 +154,8 @@ describe('Asset Transfer Proxies', () => {
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('9');
// Deploy and configure ERC20 tokens
const numDummyErc20ToDeploy = 2;
[erc20TokenA, erc20TokenB] = await erc20Wrapper.deployDummyTokensAsync(
@ -166,11 +181,14 @@ describe('Asset Transfer Proxies', () => {
constants.DUMMY_TOKEN_TOTAL_SUPPLY,
);
console.log('10');
await erc20Wrapper.setBalancesAndAllowancesAsync();
await web3Wrapper.awaitTransactionSuccessAsync(
await noReturnErc20Token.setBalance.sendTransactionAsync(fromAddress, constants.INITIAL_ERC20_BALANCE),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('11');
await web3Wrapper.awaitTransactionSuccessAsync(
await noReturnErc20Token.approve.sendTransactionAsync(
erc20Proxy.address,
@ -179,6 +197,7 @@ describe('Asset Transfer Proxies', () => {
),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('12');
await web3Wrapper.awaitTransactionSuccessAsync(
await multipleReturnErc20Token.setBalance.sendTransactionAsync(
fromAddress,
@ -186,6 +205,7 @@ describe('Asset Transfer Proxies', () => {
),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('13');
await web3Wrapper.awaitTransactionSuccessAsync(
await multipleReturnErc20Token.approve.sendTransactionAsync(
erc20Proxy.address,
@ -194,6 +214,7 @@ describe('Asset Transfer Proxies', () => {
),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('14');
// Deploy and configure ERC721 tokens and receiver
[erc721TokenA, erc721TokenB] = await erc721Wrapper.deployDummyTokensAsync();
@ -202,9 +223,12 @@ describe('Asset Transfer Proxies', () => {
provider,
txDefaults,
);
console.log('15');
await erc721Wrapper.setBalancesAndAllowancesAsync();
console.log('16');
const erc721Balances = await erc721Wrapper.getBalancesAsync();
console.log('17');
erc721AFromTokenId = erc721Balances[fromAddress][erc721TokenA.address][0];
erc721BFromTokenId = erc721Balances[fromAddress][erc721TokenB.address][0];
});

24
contracts/protocol/test/exchange/core.ts
View File

@ -1035,18 +1035,18 @@ describe('Exchange core', () => {
});
});
describe('getOrderInfo', () => {
describe.only('getOrderInfo', () => {
beforeEach(async () => {
signedOrder = await orderFactory.newSignedOrderAsync();
});
it('should return the correct orderInfo for an unfilled valid order', async () => {
it.only('should return the correct orderInfo for an unfilled valid order', async () => {
const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
const expectedTakerAssetFilledAmount = new BigNumber(0);
const expectedOrderStatus = OrderStatus.Fillable;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for a fully filled order', async () => {
await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
@ -1056,7 +1056,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.FullyFilled;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for a partially filled order', async () => {
const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
@ -1067,7 +1067,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.Fillable;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for a cancelled and unfilled order', async () => {
await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
@ -1077,7 +1077,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.Cancelled;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for a cancelled and partially filled order', async () => {
const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
@ -1089,7 +1089,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.Cancelled;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for an expired and unfilled order', async () => {
const currentTimestamp = await getLatestBlockTimestampAsync();
@ -1101,7 +1101,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.Expired;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for an expired and partially filled order', async () => {
const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
@ -1115,7 +1115,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.Expired;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for an expired and fully filled order', async () => {
await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
@ -1129,7 +1129,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.FullyFilled;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for an order with a makerAssetAmount of 0', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({ makerAssetAmount: new BigNumber(0) });
@ -1139,7 +1139,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.InvalidMakerAssetAmount;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
it('should return the correct orderInfo for an order with a takerAssetAmount of 0', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({ takerAssetAmount: new BigNumber(0) });
@ -1149,7 +1149,7 @@ describe('Exchange core', () => {
const expectedOrderStatus = OrderStatus.InvalidTakerAssetAmount;
expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
expect(orderInfo.orderStatus).to.be.bignumber.equal(expectedOrderStatus);
});
});
});

4
contracts/protocol/test/utils/erc721_wrapper.ts
View File

@ -102,12 +102,15 @@ export class ERC721Wrapper {
public async approveAsync(to: string, tokenAddress: string, tokenId: BigNumber): Promise<void> {
const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
const tokenOwner = await this.ownerOfAsync(tokenAddress, tokenId);
console.log('a');
console.log(to, ':', tokenId, ':', tokenOwner);
await this._web3Wrapper.awaitTransactionSuccessAsync(
await tokenContract.approve.sendTransactionAsync(to, tokenId, {
from: tokenOwner,
}),
constants.AWAIT_TRANSACTION_MINED_MS,
);
console.log('b');
}
public async transferFromAsync(
tokenAddress: string,
@ -144,6 +147,7 @@ export class ERC721Wrapper {
public async ownerOfAsync(tokenAddress: string, tokenId: BigNumber): Promise<string> {
const tokenContract = this._getTokenContractFromAssetData(tokenAddress);
const owner = await tokenContract.ownerOf.callAsync(tokenId);
console.log(`OWNER OF = ${owner}`);
return owner;
}
public async isOwnerAsync(userAddress: string, tokenAddress: string, tokenId: BigNumber): Promise<boolean> {

2
packages/abi-gen-templates/contract.handlebars
View File

@ -85,7 +85,7 @@ export class {{contractName}}Contract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('{{contractName}}', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

8
packages/abi-gen-templates/partials/callAsync.handlebars
View File

@ -7,9 +7,8 @@ async callAsync(
const functionSignature = '{{this.functionSignature}}';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[{{> params inputs=inputs}}] = BaseContract._formatABIDataItemList(inputAbi, [{{> params inputs=inputs}}], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [{{> params inputs=inputs}}]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.{{this.name}};
const encodedData = ethersFunction.encode([{{> params inputs=inputs}}]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([{{> params inputs=inputs}}]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -20,7 +19,8 @@ async callAsync(
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: '{{this.name}}'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));

16
packages/abi-gen-templates/partials/tx.handlebars
View File

@ -9,10 +9,8 @@ public {{this.tsName}} = {
{{/this.payable}}
): Promise<string> {
const self = this as any as {{contractName}}Contract;
const inputAbi = self._lookupAbi('{{this.functionSignature}}').inputs;
[{{> params inputs=inputs}}] = BaseContract._formatABIDataItemList(inputAbi, [{{> params inputs=inputs}}], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [{{> params inputs=inputs}}]);
const encodedData = self._lookupEthersInterface('{{this.functionSignature}}').functions.{{this.name}}.encode([{{> params inputs=inputs}}]);
const abiEncoder = self._lookupAbiEncoder('{{this.functionSignature}}');
const encodedData = abiEncoder.encode([{{> params inputs=inputs}}], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -33,9 +31,8 @@ public {{this.tsName}} = {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as {{contractName}}Contract;
const inputAbi = self._lookupAbi('{{this.functionSignature}}').inputs;
[{{> params inputs=inputs}}] = BaseContract._formatABIDataItemList(inputAbi, [{{> params inputs=inputs}}], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('{{this.functionSignature}}').functions.{{this.name}}.encode([{{> params inputs=inputs}}]);
const abiEncoder = self._lookupAbiEncoder('{{this.functionSignature}}');
const encodedData = abiEncoder.encode([{{> params inputs=inputs}}]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -51,9 +48,8 @@ public {{this.tsName}} = {
{{> typed_params inputs=inputs}}
): string {
const self = this as any as {{contractName}}Contract;
const inputAbi = self._lookupAbi('{{this.functionSignature}}').inputs;
[{{> params inputs=inputs}}] = BaseContract._formatABIDataItemList(inputAbi, [{{> params inputs=inputs}}], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('{{this.functionSignature}}').functions.{{this.name}}.encode([{{> params inputs=inputs}}]);
const abiEncoder = self._lookupAbiEncoder('{{this.functionSignature}}');
const abiEncodedTransactionData = abiEncoder.encode([{{> params inputs=inputs}}]);
return abiEncodedTransactionData;
},
{{> callAsync}}

552
packages/abi-gen-wrappers/src/generated-wrappers/asset_proxy_owner.ts
View File

File diff suppressed because it is too large Load Diff

313
packages/abi-gen-wrappers/src/generated-wrappers/dummy_erc20_token.ts
View File

@ -46,9 +46,8 @@ export class DummyERC20TokenContract extends BaseContract {
const functionSignature = 'name()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.name;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -59,7 +58,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'name'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -73,18 +73,10 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
[_spender,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -107,13 +99,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC20TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -132,13 +119,8 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
): string {
const self = this as any as DummyERC20TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_spender,
_value
]);
return abiEncodedTransactionData;
@ -158,11 +140,8 @@ export class DummyERC20TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_spender,
_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -175,7 +154,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -192,9 +172,8 @@ export class DummyERC20TokenContract extends BaseContract {
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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -205,7 +184,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -220,22 +200,11 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -260,15 +229,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC20TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_from,
_to,
_value
]);
@ -289,15 +251,8 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
): string {
const self = this as any as DummyERC20TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_value
]);
@ -321,12 +276,8 @@ export class DummyERC20TokenContract extends BaseContract {
_to,
_value
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_from,
_to,
_value
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferFrom;
const encodedData = ethersFunction.encode([_from,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_value
]);
@ -340,7 +291,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -357,9 +309,8 @@ export class DummyERC20TokenContract extends BaseContract {
const functionSignature = 'decimals()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.decimals;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -370,7 +321,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'decimals'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -390,10 +342,8 @@ export class DummyERC20TokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -405,7 +355,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -422,9 +373,8 @@ export class DummyERC20TokenContract extends BaseContract {
const functionSignature = 'owner()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.owner;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -435,7 +385,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'owner'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -452,9 +403,8 @@ export class DummyERC20TokenContract extends BaseContract {
const functionSignature = 'symbol()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.symbol;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -465,7 +415,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'symbol'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -478,14 +429,9 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('mint(uint256)').inputs;
[_value
] = BaseContract._formatABIDataItemList(inputAbi, [_value
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_value
]);
const encodedData = self._lookupEthersInterface('mint(uint256)').functions.mint.encode([_value
]);
const abiEncoder = self._lookupAbiEncoder('mint(uint256)');
const encodedData = abiEncoder.encode([_value
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -506,11 +452,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('mint(uint256)').inputs;
[_value
] = BaseContract._formatABIDataItemList(inputAbi, [_value
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('mint(uint256)').functions.mint.encode([_value
const abiEncoder = self._lookupAbiEncoder('mint(uint256)');
const encodedData = abiEncoder.encode([_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -527,11 +470,8 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
): string {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('mint(uint256)').inputs;
[_value
] = BaseContract._formatABIDataItemList(inputAbi, [_value
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('mint(uint256)').functions.mint.encode([_value
const abiEncoder = self._lookupAbiEncoder('mint(uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_value
]);
return abiEncodedTransactionData;
},
@ -547,10 +487,8 @@ export class DummyERC20TokenContract extends BaseContract {
[_value
] = BaseContract._formatABIDataItemList(inputAbi, [_value
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_value
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.mint;
const encodedData = ethersFunction.encode([_value
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -562,7 +500,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'mint'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -576,18 +515,10 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
[_to,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -610,13 +541,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC20TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const encodedData = abiEncoder.encode([_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -635,13 +561,8 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
): string {
const self = this as any as DummyERC20TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_to,
_value
]);
return abiEncodedTransactionData;
@ -661,11 +582,8 @@ export class DummyERC20TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_to,
_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -678,7 +596,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -701,11 +620,8 @@ export class DummyERC20TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner,
_spender
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -718,7 +634,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -732,18 +649,10 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('setBalance(address,uint256)').inputs;
[_target,
const abiEncoder = self._lookupAbiEncoder('setBalance(address,uint256)');
const encodedData = abiEncoder.encode([_target,
_value
] = BaseContract._formatABIDataItemList(inputAbi, [_target,
_value
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_target,
_value
]);
const encodedData = self._lookupEthersInterface('setBalance(address,uint256)').functions.setBalance.encode([_target,
_value
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -766,13 +675,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('setBalance(address,uint256)').inputs;
[_target,
_value
] = BaseContract._formatABIDataItemList(inputAbi, [_target,
_value
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('setBalance(address,uint256)').functions.setBalance.encode([_target,
const abiEncoder = self._lookupAbiEncoder('setBalance(address,uint256)');
const encodedData = abiEncoder.encode([_target,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -791,13 +695,8 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
): string {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('setBalance(address,uint256)').inputs;
[_target,
_value
] = BaseContract._formatABIDataItemList(inputAbi, [_target,
_value
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('setBalance(address,uint256)').functions.setBalance.encode([_target,
const abiEncoder = self._lookupAbiEncoder('setBalance(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_target,
_value
]);
return abiEncodedTransactionData;
@ -817,11 +716,8 @@ export class DummyERC20TokenContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [_target,
_value
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_target,
_value
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.setBalance;
const encodedData = ethersFunction.encode([_target,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_target,
_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -834,7 +730,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'setBalance'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -847,14 +744,9 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
]);
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -875,11 +767,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -896,11 +785,8 @@ export class DummyERC20TokenContract extends BaseContract {
newOwner: string,
): string {
const self = this as any as DummyERC20TokenContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const abiEncodedTransactionData = abiEncoder.encode([newOwner
]);
return abiEncodedTransactionData;
},
@ -916,10 +802,8 @@ export class DummyERC20TokenContract extends BaseContract {
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferOwnership;
const encodedData = ethersFunction.encode([newOwner
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([newOwner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -931,7 +815,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'transferOwnership'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -948,9 +833,8 @@ export class DummyERC20TokenContract extends BaseContract {
const functionSignature = 'MAX_MINT_AMOUNT()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.MAX_MINT_AMOUNT;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -961,7 +845,8 @@ export class DummyERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'MAX_MINT_AMOUNT'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -1039,7 +924,7 @@ _totalSupply
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('DummyERC20Token', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

423
packages/abi-gen-wrappers/src/generated-wrappers/dummy_erc721_token.ts
View File

@ -54,9 +54,8 @@ export class DummyERC721TokenContract extends BaseContract {
const functionSignature = 'name()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.name;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -67,7 +66,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'name'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -87,10 +87,8 @@ export class DummyERC721TokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -102,7 +100,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -116,18 +115,10 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
[_approved,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -150,13 +141,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_approved,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -175,13 +161,8 @@ export class DummyERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
): string {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_approved,
_tokenId
]);
return abiEncodedTransactionData;
@ -201,11 +182,8 @@ export class DummyERC721TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_approved,
_tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -218,7 +196,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -233,22 +212,11 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -273,15 +241,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -302,15 +263,8 @@ export class DummyERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
): string {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -334,12 +288,8 @@ export class DummyERC721TokenContract extends BaseContract {
_to,
_tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_from,
_to,
_tokenId
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferFrom;
const encodedData = ethersFunction.encode([_from,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -353,7 +303,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -367,18 +318,10 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('mint(address,uint256)').inputs;
[_to,
const abiEncoder = self._lookupAbiEncoder('mint(address,uint256)');
const encodedData = abiEncoder.encode([_to,
_tokenId
] = BaseContract._formatABIDataItemList(inputAbi, [_to,
_tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_to,
_tokenId
]);
const encodedData = self._lookupEthersInterface('mint(address,uint256)').functions.mint.encode([_to,
_tokenId
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -401,13 +344,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('mint(address,uint256)').inputs;
[_to,
_tokenId
] = BaseContract._formatABIDataItemList(inputAbi, [_to,
_tokenId
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('mint(address,uint256)').functions.mint.encode([_to,
const abiEncoder = self._lookupAbiEncoder('mint(address,uint256)');
const encodedData = abiEncoder.encode([_to,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -426,13 +364,8 @@ export class DummyERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
): string {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('mint(address,uint256)').inputs;
[_to,
_tokenId
] = BaseContract._formatABIDataItemList(inputAbi, [_to,
_tokenId
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('mint(address,uint256)').functions.mint.encode([_to,
const abiEncoder = self._lookupAbiEncoder('mint(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_to,
_tokenId
]);
return abiEncodedTransactionData;
@ -452,11 +385,8 @@ export class DummyERC721TokenContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [_to,
_tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_to,
_tokenId
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.mint;
const encodedData = ethersFunction.encode([_to,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_to,
_tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -469,7 +399,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'mint'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -484,22 +415,11 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -524,15 +444,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -553,15 +466,8 @@ export class DummyERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
): string {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -585,12 +491,8 @@ export class DummyERC721TokenContract extends BaseContract {
_to,
_tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_from,
_to,
_tokenId
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.safeTransferFrom;
const encodedData = ethersFunction.encode([_from,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -604,7 +506,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -624,10 +527,8 @@ export class DummyERC721TokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -639,7 +540,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -659,10 +561,8 @@ export class DummyERC721TokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -674,7 +574,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -691,9 +592,8 @@ export class DummyERC721TokenContract extends BaseContract {
const functionSignature = 'owner()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.owner;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -704,7 +604,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'owner'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -721,9 +622,8 @@ export class DummyERC721TokenContract extends BaseContract {
const functionSignature = 'symbol()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.symbol;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -734,7 +634,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'symbol'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -748,18 +649,10 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('burn(address,uint256)').inputs;
[_owner,
const abiEncoder = self._lookupAbiEncoder('burn(address,uint256)');
const encodedData = abiEncoder.encode([_owner,
_tokenId
] = BaseContract._formatABIDataItemList(inputAbi, [_owner,
_tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_owner,
_tokenId
]);
const encodedData = self._lookupEthersInterface('burn(address,uint256)').functions.burn.encode([_owner,
_tokenId
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -782,13 +675,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('burn(address,uint256)').inputs;
[_owner,
_tokenId
] = BaseContract._formatABIDataItemList(inputAbi, [_owner,
_tokenId
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('burn(address,uint256)').functions.burn.encode([_owner,
const abiEncoder = self._lookupAbiEncoder('burn(address,uint256)');
const encodedData = abiEncoder.encode([_owner,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -807,13 +695,8 @@ export class DummyERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
): string {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('burn(address,uint256)').inputs;
[_owner,
_tokenId
] = BaseContract._formatABIDataItemList(inputAbi, [_owner,
_tokenId
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('burn(address,uint256)').functions.burn.encode([_owner,
const abiEncoder = self._lookupAbiEncoder('burn(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_owner,
_tokenId
]);
return abiEncodedTransactionData;
@ -833,11 +716,8 @@ export class DummyERC721TokenContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [_owner,
_tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_owner,
_tokenId
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.burn;
const encodedData = ethersFunction.encode([_owner,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner,
_tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -850,7 +730,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'burn'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -864,18 +745,10 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('setApprovalForAll(address,bool)').inputs;
[_operator,
const abiEncoder = self._lookupAbiEncoder('setApprovalForAll(address,bool)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -898,13 +771,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('setApprovalForAll(address,bool)');
const encodedData = abiEncoder.encode([_operator,
_approved
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -923,13 +791,8 @@ export class DummyERC721TokenContract extends BaseContract {
_approved: boolean,
): string {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('setApprovalForAll(address,bool)');
const abiEncodedTransactionData = abiEncoder.encode([_operator,
_approved
]);
return abiEncodedTransactionData;
@ -949,11 +812,8 @@ export class DummyERC721TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_operator,
_approved
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -966,7 +826,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -982,26 +843,12 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256,bytes)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256,bytes)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -1028,17 +875,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256,bytes)');
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId,
_data
@ -1061,17 +899,8 @@ export class DummyERC721TokenContract extends BaseContract {
_data: string,
): string {
const self = this as any as DummyERC721TokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256,bytes)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_tokenId,
_data
@ -1099,13 +928,8 @@ export class DummyERC721TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId,
_data
@ -1120,7 +944,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -1143,11 +968,8 @@ export class DummyERC721TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner,
_operator
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -1160,7 +982,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -1173,14 +996,9 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
]);
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -1201,11 +1019,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -1222,11 +1037,8 @@ export class DummyERC721TokenContract extends BaseContract {
newOwner: string,
): string {
const self = this as any as DummyERC721TokenContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const abiEncodedTransactionData = abiEncoder.encode([newOwner
]);
return abiEncodedTransactionData;
},
@ -1242,10 +1054,8 @@ export class DummyERC721TokenContract extends BaseContract {
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferOwnership;
const encodedData = ethersFunction.encode([newOwner
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([newOwner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -1257,7 +1067,8 @@ export class DummyERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'transferOwnership'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -1321,7 +1132,7 @@ _symbol
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('DummyERC721Token', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

188
packages/abi-gen-wrappers/src/generated-wrappers/erc20_proxy.ts
View File

@ -40,14 +40,9 @@ export class ERC20ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target
]);
const encodedData = self._lookupEthersInterface('addAuthorizedAddress(address)').functions.addAuthorizedAddress.encode([target
]);
const abiEncoder = self._lookupAbiEncoder('addAuthorizedAddress(address)');
const encodedData = abiEncoder.encode([target
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -68,11 +63,8 @@ export class ERC20ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('addAuthorizedAddress(address)').functions.addAuthorizedAddress.encode([target
const abiEncoder = self._lookupAbiEncoder('addAuthorizedAddress(address)');
const encodedData = abiEncoder.encode([target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -89,11 +81,8 @@ export class ERC20ProxyContract extends BaseContract {
target: string,
): string {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('addAuthorizedAddress(address)').functions.addAuthorizedAddress.encode([target
const abiEncoder = self._lookupAbiEncoder('addAuthorizedAddress(address)');
const abiEncodedTransactionData = abiEncoder.encode([target
]);
return abiEncodedTransactionData;
},
@ -109,10 +98,8 @@ export class ERC20ProxyContract extends BaseContract {
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.addAuthorizedAddress;
const encodedData = ethersFunction.encode([target
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([target
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -124,7 +111,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'addAuthorizedAddress'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -144,10 +132,8 @@ export class ERC20ProxyContract extends BaseContract {
[index_0
] = BaseContract._formatABIDataItemList(inputAbi, [index_0
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [index_0
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.authorities;
const encodedData = ethersFunction.encode([index_0
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([index_0
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -159,7 +145,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'authorities'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -172,14 +159,9 @@ export class ERC20ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target
]);
const encodedData = self._lookupEthersInterface('removeAuthorizedAddress(address)').functions.removeAuthorizedAddress.encode([target
]);
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddress(address)');
const encodedData = abiEncoder.encode([target
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -200,11 +182,8 @@ export class ERC20ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('removeAuthorizedAddress(address)').functions.removeAuthorizedAddress.encode([target
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddress(address)');
const encodedData = abiEncoder.encode([target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -221,11 +200,8 @@ export class ERC20ProxyContract extends BaseContract {
target: string,
): string {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('removeAuthorizedAddress(address)').functions.removeAuthorizedAddress.encode([target
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddress(address)');
const abiEncodedTransactionData = abiEncoder.encode([target
]);
return abiEncodedTransactionData;
},
@ -241,10 +217,8 @@ export class ERC20ProxyContract extends BaseContract {
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.removeAuthorizedAddress;
const encodedData = ethersFunction.encode([target
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([target
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -256,7 +230,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'removeAuthorizedAddress'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -273,9 +248,8 @@ export class ERC20ProxyContract extends BaseContract {
const functionSignature = 'owner()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.owner;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -286,7 +260,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'owner'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -300,18 +275,10 @@ export class ERC20ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddressAtIndex(address,uint256)').inputs;
[target,
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddressAtIndex(address,uint256)');
const encodedData = abiEncoder.encode([target,
index
] = BaseContract._formatABIDataItemList(inputAbi, [target,
index
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target,
index
]);
const encodedData = self._lookupEthersInterface('removeAuthorizedAddressAtIndex(address,uint256)').functions.removeAuthorizedAddressAtIndex.encode([target,
index
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -334,13 +301,8 @@ export class ERC20ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddressAtIndex(address,uint256)').inputs;
[target,
index
] = BaseContract._formatABIDataItemList(inputAbi, [target,
index
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('removeAuthorizedAddressAtIndex(address,uint256)').functions.removeAuthorizedAddressAtIndex.encode([target,
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddressAtIndex(address,uint256)');
const encodedData = abiEncoder.encode([target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -359,13 +321,8 @@ export class ERC20ProxyContract extends BaseContract {
index: BigNumber,
): string {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddressAtIndex(address,uint256)').inputs;
[target,
index
] = BaseContract._formatABIDataItemList(inputAbi, [target,
index
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('removeAuthorizedAddressAtIndex(address,uint256)').functions.removeAuthorizedAddressAtIndex.encode([target,
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddressAtIndex(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([target,
index
]);
return abiEncodedTransactionData;
@ -385,11 +342,8 @@ export class ERC20ProxyContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [target,
index
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target,
index
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.removeAuthorizedAddressAtIndex;
const encodedData = ethersFunction.encode([target,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([target,
index
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -402,7 +356,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'removeAuthorizedAddressAtIndex'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -419,9 +374,8 @@ export class ERC20ProxyContract extends BaseContract {
const functionSignature = 'getProxyId()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getProxyId;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -432,7 +386,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getProxyId'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -452,10 +407,8 @@ export class ERC20ProxyContract extends BaseContract {
[index_0
] = BaseContract._formatABIDataItemList(inputAbi, [index_0
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [index_0
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.authorized;
const encodedData = ethersFunction.encode([index_0
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([index_0
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -467,7 +420,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'authorized'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -484,9 +438,8 @@ export class ERC20ProxyContract extends BaseContract {
const functionSignature = 'getAuthorizedAddresses()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getAuthorizedAddresses;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -497,7 +450,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getAuthorizedAddresses'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -510,14 +464,9 @@ export class ERC20ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
]);
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -538,11 +487,8 @@ export class ERC20ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -559,11 +505,8 @@ export class ERC20ProxyContract extends BaseContract {
newOwner: string,
): string {
const self = this as any as ERC20ProxyContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const abiEncodedTransactionData = abiEncoder.encode([newOwner
]);
return abiEncodedTransactionData;
},
@ -579,10 +522,8 @@ export class ERC20ProxyContract extends BaseContract {
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferOwnership;
const encodedData = ethersFunction.encode([newOwner
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([newOwner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -594,7 +535,8 @@ export class ERC20ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'transferOwnership'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -644,7 +586,7 @@ export class ERC20ProxyContract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('ERC20Proxy', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

163
packages/abi-gen-wrappers/src/generated-wrappers/erc20_token.ts
View File

@ -43,18 +43,10 @@ export class ERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC20TokenContract;
const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
[_spender,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -77,13 +69,8 @@ export class ERC20TokenContract extends BaseContract {
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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -102,13 +89,8 @@ export class ERC20TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_spender,
_value
]);
return abiEncodedTransactionData;
@ -128,11 +110,8 @@ export class ERC20TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_spender,
_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -145,7 +124,8 @@ export class ERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -162,9 +142,8 @@ export class ERC20TokenContract extends BaseContract {
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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -175,7 +154,8 @@ export class ERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -190,22 +170,11 @@ export class ERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC20TokenContract;
const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -230,15 +199,8 @@ export class ERC20TokenContract extends BaseContract {
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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_from,
_to,
_value
]);
@ -259,15 +221,8 @@ export class ERC20TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_value
]);
@ -291,12 +246,8 @@ export class ERC20TokenContract extends BaseContract {
_to,
_value
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_from,
_to,
_value
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferFrom;
const encodedData = ethersFunction.encode([_from,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_value
]);
@ -310,7 +261,8 @@ export class ERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -330,10 +282,8 @@ export class ERC20TokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -345,7 +295,8 @@ export class ERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -359,18 +310,10 @@ export class ERC20TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC20TokenContract;
const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
[_to,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -393,13 +336,8 @@ export class ERC20TokenContract extends BaseContract {
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,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const encodedData = abiEncoder.encode([_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -418,13 +356,8 @@ export class ERC20TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_to,
_value
]);
return abiEncodedTransactionData;
@ -444,11 +377,8 @@ export class ERC20TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_to,
_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -461,7 +391,8 @@ export class ERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -484,11 +415,8 @@ export class ERC20TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner,
_spender
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -501,7 +429,8 @@ export class ERC20TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -551,7 +480,7 @@ export class ERC20TokenContract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('ERC20Token', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

188
packages/abi-gen-wrappers/src/generated-wrappers/erc721_proxy.ts
View File

@ -40,14 +40,9 @@ export class ERC721ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target
]);
const encodedData = self._lookupEthersInterface('addAuthorizedAddress(address)').functions.addAuthorizedAddress.encode([target
]);
const abiEncoder = self._lookupAbiEncoder('addAuthorizedAddress(address)');
const encodedData = abiEncoder.encode([target
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -68,11 +63,8 @@ export class ERC721ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('addAuthorizedAddress(address)').functions.addAuthorizedAddress.encode([target
const abiEncoder = self._lookupAbiEncoder('addAuthorizedAddress(address)');
const encodedData = abiEncoder.encode([target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -89,11 +81,8 @@ export class ERC721ProxyContract extends BaseContract {
target: string,
): string {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('addAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('addAuthorizedAddress(address)').functions.addAuthorizedAddress.encode([target
const abiEncoder = self._lookupAbiEncoder('addAuthorizedAddress(address)');
const abiEncodedTransactionData = abiEncoder.encode([target
]);
return abiEncodedTransactionData;
},
@ -109,10 +98,8 @@ export class ERC721ProxyContract extends BaseContract {
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.addAuthorizedAddress;
const encodedData = ethersFunction.encode([target
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([target
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -124,7 +111,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'addAuthorizedAddress'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -144,10 +132,8 @@ export class ERC721ProxyContract extends BaseContract {
[index_0
] = BaseContract._formatABIDataItemList(inputAbi, [index_0
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [index_0
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.authorities;
const encodedData = ethersFunction.encode([index_0
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([index_0
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -159,7 +145,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'authorities'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -172,14 +159,9 @@ export class ERC721ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target
]);
const encodedData = self._lookupEthersInterface('removeAuthorizedAddress(address)').functions.removeAuthorizedAddress.encode([target
]);
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddress(address)');
const encodedData = abiEncoder.encode([target
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -200,11 +182,8 @@ export class ERC721ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('removeAuthorizedAddress(address)').functions.removeAuthorizedAddress.encode([target
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddress(address)');
const encodedData = abiEncoder.encode([target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -221,11 +200,8 @@ export class ERC721ProxyContract extends BaseContract {
target: string,
): string {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddress(address)').inputs;
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('removeAuthorizedAddress(address)').functions.removeAuthorizedAddress.encode([target
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddress(address)');
const abiEncodedTransactionData = abiEncoder.encode([target
]);
return abiEncodedTransactionData;
},
@ -241,10 +217,8 @@ export class ERC721ProxyContract extends BaseContract {
[target
] = BaseContract._formatABIDataItemList(inputAbi, [target
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.removeAuthorizedAddress;
const encodedData = ethersFunction.encode([target
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([target
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -256,7 +230,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'removeAuthorizedAddress'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -273,9 +248,8 @@ export class ERC721ProxyContract extends BaseContract {
const functionSignature = 'owner()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.owner;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -286,7 +260,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'owner'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -300,18 +275,10 @@ export class ERC721ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddressAtIndex(address,uint256)').inputs;
[target,
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddressAtIndex(address,uint256)');
const encodedData = abiEncoder.encode([target,
index
] = BaseContract._formatABIDataItemList(inputAbi, [target,
index
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target,
index
]);
const encodedData = self._lookupEthersInterface('removeAuthorizedAddressAtIndex(address,uint256)').functions.removeAuthorizedAddressAtIndex.encode([target,
index
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -334,13 +301,8 @@ export class ERC721ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddressAtIndex(address,uint256)').inputs;
[target,
index
] = BaseContract._formatABIDataItemList(inputAbi, [target,
index
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('removeAuthorizedAddressAtIndex(address,uint256)').functions.removeAuthorizedAddressAtIndex.encode([target,
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddressAtIndex(address,uint256)');
const encodedData = abiEncoder.encode([target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -359,13 +321,8 @@ export class ERC721ProxyContract extends BaseContract {
index: BigNumber,
): string {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('removeAuthorizedAddressAtIndex(address,uint256)').inputs;
[target,
index
] = BaseContract._formatABIDataItemList(inputAbi, [target,
index
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('removeAuthorizedAddressAtIndex(address,uint256)').functions.removeAuthorizedAddressAtIndex.encode([target,
const abiEncoder = self._lookupAbiEncoder('removeAuthorizedAddressAtIndex(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([target,
index
]);
return abiEncodedTransactionData;
@ -385,11 +342,8 @@ export class ERC721ProxyContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [target,
index
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target,
index
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.removeAuthorizedAddressAtIndex;
const encodedData = ethersFunction.encode([target,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([target,
index
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -402,7 +356,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'removeAuthorizedAddressAtIndex'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -419,9 +374,8 @@ export class ERC721ProxyContract extends BaseContract {
const functionSignature = 'getProxyId()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getProxyId;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -432,7 +386,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getProxyId'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -452,10 +407,8 @@ export class ERC721ProxyContract extends BaseContract {
[index_0
] = BaseContract._formatABIDataItemList(inputAbi, [index_0
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [index_0
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.authorized;
const encodedData = ethersFunction.encode([index_0
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([index_0
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -467,7 +420,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'authorized'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -484,9 +438,8 @@ export class ERC721ProxyContract extends BaseContract {
const functionSignature = 'getAuthorizedAddresses()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getAuthorizedAddresses;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -497,7 +450,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getAuthorizedAddresses'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -510,14 +464,9 @@ export class ERC721ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
]);
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -538,11 +487,8 @@ export class ERC721ProxyContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -559,11 +505,8 @@ export class ERC721ProxyContract extends BaseContract {
newOwner: string,
): string {
const self = this as any as ERC721ProxyContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const abiEncodedTransactionData = abiEncoder.encode([newOwner
]);
return abiEncodedTransactionData;
},
@ -579,10 +522,8 @@ export class ERC721ProxyContract extends BaseContract {
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferOwnership;
const encodedData = ethersFunction.encode([newOwner
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([newOwner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -594,7 +535,8 @@ export class ERC721ProxyContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'transferOwnership'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -644,7 +586,7 @@ export class ERC721ProxyContract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('ERC721Proxy', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

281
packages/abi-gen-wrappers/src/generated-wrappers/erc721_token.ts
View File

@ -57,10 +57,8 @@ export class ERC721TokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -72,7 +70,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -86,18 +85,10 @@ export class ERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721TokenContract;
const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
[_approved,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -120,13 +111,8 @@ export class ERC721TokenContract extends BaseContract {
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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_approved,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -145,13 +131,8 @@ export class ERC721TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_approved,
_tokenId
]);
return abiEncodedTransactionData;
@ -171,11 +152,8 @@ export class ERC721TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_approved,
_tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -188,7 +166,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -203,22 +182,11 @@ export class ERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721TokenContract;
const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -243,15 +211,8 @@ export class ERC721TokenContract extends BaseContract {
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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -272,15 +233,8 @@ export class ERC721TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -304,12 +258,8 @@ export class ERC721TokenContract extends BaseContract {
_to,
_tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_from,
_to,
_tokenId
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferFrom;
const encodedData = ethersFunction.encode([_from,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -323,7 +273,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -338,22 +289,11 @@ export class ERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721TokenContract;
const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -378,15 +318,8 @@ export class ERC721TokenContract extends BaseContract {
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,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -407,15 +340,8 @@ export class ERC721TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -439,12 +365,8 @@ export class ERC721TokenContract extends BaseContract {
_to,
_tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_from,
_to,
_tokenId
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.safeTransferFrom;
const encodedData = ethersFunction.encode([_from,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId
]);
@ -458,7 +380,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -478,10 +401,8 @@ export class ERC721TokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -493,7 +414,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -513,10 +435,8 @@ export class ERC721TokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -528,7 +448,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -542,18 +463,10 @@ export class ERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721TokenContract;
const inputAbi = self._lookupAbi('setApprovalForAll(address,bool)').inputs;
[_operator,
const abiEncoder = self._lookupAbiEncoder('setApprovalForAll(address,bool)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -576,13 +489,8 @@ export class ERC721TokenContract extends BaseContract {
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,
const abiEncoder = self._lookupAbiEncoder('setApprovalForAll(address,bool)');
const encodedData = abiEncoder.encode([_operator,
_approved
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -601,13 +509,8 @@ export class ERC721TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder('setApprovalForAll(address,bool)');
const abiEncodedTransactionData = abiEncoder.encode([_operator,
_approved
]);
return abiEncodedTransactionData;
@ -627,11 +530,8 @@ export class ERC721TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_operator,
_approved
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -644,7 +544,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -660,26 +561,12 @@ export class ERC721TokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ERC721TokenContract;
const inputAbi = self._lookupAbi('safeTransferFrom(address,address,uint256,bytes)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256,bytes)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -706,17 +593,8 @@ export class ERC721TokenContract extends BaseContract {
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,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256,bytes)');
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId,
_data
@ -739,17 +617,8 @@ export class ERC721TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder('safeTransferFrom(address,address,uint256,bytes)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_tokenId,
_data
@ -777,13 +646,8 @@ export class ERC721TokenContract extends BaseContract {
_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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_tokenId,
_data
@ -798,7 +662,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -821,11 +686,8 @@ export class ERC721TokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner,
_operator
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -838,7 +700,8 @@ export class ERC721TokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -888,7 +751,7 @@ export class ERC721TokenContract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('ERC721Token', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

1054
packages/abi-gen-wrappers/src/generated-wrappers/exchange.ts
View File

File diff suppressed because it is too large Load Diff

246
packages/abi-gen-wrappers/src/generated-wrappers/forwarder.ts
View File

@ -27,38 +27,15 @@ export class ForwarderContract extends BaseContract {
txData: Partial<TxDataPayable> = {},
): Promise<string> {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('marketBuyOrdersWithEth(tuple[],uint256,bytes[],tuple[],bytes[],uint256,address)').inputs;
[orders,
const abiEncoder = self._lookupAbiEncoder('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)');
const encodedData = abiEncoder.encode([orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
] = BaseContract._formatABIDataItemList(inputAbi, [orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
const encodedData = self._lookupEthersInterface('marketBuyOrdersWithEth(tuple[],uint256,bytes[],tuple[],bytes[],uint256,address)').functions.marketBuyOrdersWithEth.encode([orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -91,23 +68,8 @@ export class ForwarderContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('marketBuyOrdersWithEth(tuple[],uint256,bytes[],tuple[],bytes[],uint256,address)').inputs;
[orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
] = BaseContract._formatABIDataItemList(inputAbi, [orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('marketBuyOrdersWithEth(tuple[],uint256,bytes[],tuple[],bytes[],uint256,address)').functions.marketBuyOrdersWithEth.encode([orders,
const abiEncoder = self._lookupAbiEncoder('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)');
const encodedData = abiEncoder.encode([orders,
makerAssetFillAmount,
signatures,
feeOrders,
@ -136,23 +98,8 @@ export class ForwarderContract extends BaseContract {
feeRecipient: string,
): string {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('marketBuyOrdersWithEth(tuple[],uint256,bytes[],tuple[],bytes[],uint256,address)').inputs;
[orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
] = BaseContract._formatABIDataItemList(inputAbi, [orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('marketBuyOrdersWithEth(tuple[],uint256,bytes[],tuple[],bytes[],uint256,address)').functions.marketBuyOrdersWithEth.encode([orders,
const abiEncoder = self._lookupAbiEncoder('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)');
const abiEncodedTransactionData = abiEncoder.encode([orders,
makerAssetFillAmount,
signatures,
feeOrders,
@ -175,7 +122,7 @@ export class ForwarderContract extends BaseContract {
): Promise<[{makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber}, {makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber}]
> {
const self = this as any as ForwarderContract;
const functionSignature = 'marketBuyOrdersWithEth(tuple[],uint256,bytes[],tuple[],bytes[],uint256,address)';
const functionSignature = '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)';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[orders,
makerAssetFillAmount,
@ -192,16 +139,8 @@ export class ForwarderContract extends BaseContract {
feePercentage,
feeRecipient
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.marketBuyOrdersWithEth;
const encodedData = ethersFunction.encode([orders,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([orders,
makerAssetFillAmount,
signatures,
feeOrders,
@ -219,7 +158,8 @@ export class ForwarderContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'marketBuyOrdersWithEth'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -233,18 +173,10 @@ export class ForwarderContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('withdrawAsset(bytes,uint256)').inputs;
[assetData,
const abiEncoder = self._lookupAbiEncoder('withdrawAsset(bytes,uint256)');
const encodedData = abiEncoder.encode([assetData,
amount
] = BaseContract._formatABIDataItemList(inputAbi, [assetData,
amount
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [assetData,
amount
]);
const encodedData = self._lookupEthersInterface('withdrawAsset(bytes,uint256)').functions.withdrawAsset.encode([assetData,
amount
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -267,13 +199,8 @@ export class ForwarderContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('withdrawAsset(bytes,uint256)').inputs;
[assetData,
amount
] = BaseContract._formatABIDataItemList(inputAbi, [assetData,
amount
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('withdrawAsset(bytes,uint256)').functions.withdrawAsset.encode([assetData,
const abiEncoder = self._lookupAbiEncoder('withdrawAsset(bytes,uint256)');
const encodedData = abiEncoder.encode([assetData,
amount
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -292,13 +219,8 @@ export class ForwarderContract extends BaseContract {
amount: BigNumber,
): string {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('withdrawAsset(bytes,uint256)').inputs;
[assetData,
amount
] = BaseContract._formatABIDataItemList(inputAbi, [assetData,
amount
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('withdrawAsset(bytes,uint256)').functions.withdrawAsset.encode([assetData,
const abiEncoder = self._lookupAbiEncoder('withdrawAsset(bytes,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([assetData,
amount
]);
return abiEncodedTransactionData;
@ -318,11 +240,8 @@ export class ForwarderContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [assetData,
amount
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [assetData,
amount
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.withdrawAsset;
const encodedData = ethersFunction.encode([assetData,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([assetData,
amount
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -335,7 +254,8 @@ export class ForwarderContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'withdrawAsset'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -352,9 +272,8 @@ export class ForwarderContract extends BaseContract {
const functionSignature = 'owner()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.owner;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -365,7 +284,8 @@ export class ForwarderContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'owner'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -383,34 +303,14 @@ export class ForwarderContract extends BaseContract {
txData: Partial<TxDataPayable> = {},
): Promise<string> {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('marketSellOrdersWithEth(tuple[],bytes[],tuple[],bytes[],uint256,address)').inputs;
[orders,
const abiEncoder = self._lookupAbiEncoder('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)');
const encodedData = abiEncoder.encode([orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
] = BaseContract._formatABIDataItemList(inputAbi, [orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
const encodedData = self._lookupEthersInterface('marketSellOrdersWithEth(tuple[],bytes[],tuple[],bytes[],uint256,address)').functions.marketSellOrdersWithEth.encode([orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -441,21 +341,8 @@ export class ForwarderContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('marketSellOrdersWithEth(tuple[],bytes[],tuple[],bytes[],uint256,address)').inputs;
[orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
] = BaseContract._formatABIDataItemList(inputAbi, [orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('marketSellOrdersWithEth(tuple[],bytes[],tuple[],bytes[],uint256,address)').functions.marketSellOrdersWithEth.encode([orders,
const abiEncoder = self._lookupAbiEncoder('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)');
const encodedData = abiEncoder.encode([orders,
signatures,
feeOrders,
feeSignatures,
@ -482,21 +369,8 @@ export class ForwarderContract extends BaseContract {
feeRecipient: string,
): string {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('marketSellOrdersWithEth(tuple[],bytes[],tuple[],bytes[],uint256,address)').inputs;
[orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
] = BaseContract._formatABIDataItemList(inputAbi, [orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('marketSellOrdersWithEth(tuple[],bytes[],tuple[],bytes[],uint256,address)').functions.marketSellOrdersWithEth.encode([orders,
const abiEncoder = self._lookupAbiEncoder('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)');
const abiEncodedTransactionData = abiEncoder.encode([orders,
signatures,
feeOrders,
feeSignatures,
@ -517,7 +391,7 @@ export class ForwarderContract extends BaseContract {
): Promise<[{makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber}, {makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber}]
> {
const self = this as any as ForwarderContract;
const functionSignature = 'marketSellOrdersWithEth(tuple[],bytes[],tuple[],bytes[],uint256,address)';
const functionSignature = '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)';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[orders,
signatures,
@ -532,15 +406,8 @@ export class ForwarderContract extends BaseContract {
feePercentage,
feeRecipient
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.marketSellOrdersWithEth;
const encodedData = ethersFunction.encode([orders,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([orders,
signatures,
feeOrders,
feeSignatures,
@ -557,7 +424,8 @@ export class ForwarderContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'marketSellOrdersWithEth'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -570,14 +438,9 @@ export class ForwarderContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
]);
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -598,11 +461,8 @@ export class ForwarderContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const encodedData = abiEncoder.encode([newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -619,11 +479,8 @@ export class ForwarderContract extends BaseContract {
newOwner: string,
): string {
const self = this as any as ForwarderContract;
const inputAbi = self._lookupAbi('transferOwnership(address)').inputs;
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('transferOwnership(address)').functions.transferOwnership.encode([newOwner
const abiEncoder = self._lookupAbiEncoder('transferOwnership(address)');
const abiEncodedTransactionData = abiEncoder.encode([newOwner
]);
return abiEncodedTransactionData;
},
@ -639,10 +496,8 @@ export class ForwarderContract extends BaseContract {
[newOwner
] = BaseContract._formatABIDataItemList(inputAbi, [newOwner
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [newOwner
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferOwnership;
const encodedData = ethersFunction.encode([newOwner
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([newOwner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -654,7 +509,8 @@ export class ForwarderContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'transferOwnership'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -725,7 +581,7 @@ _wethAssetData
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('Forwarder', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

13
packages/abi-gen-wrappers/src/generated-wrappers/i_validator.ts
View File

@ -34,12 +34,8 @@ export class IValidatorContract extends BaseContract {
signerAddress,
signature
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [hash,
signerAddress,
signature
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.isValidSignature;
const encodedData = ethersFunction.encode([hash,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([hash,
signerAddress,
signature
]);
@ -53,7 +49,8 @@ export class IValidatorContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'isValidSignature'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -103,7 +100,7 @@ export class IValidatorContract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('IValidator', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

12
packages/abi-gen-wrappers/src/generated-wrappers/i_wallet.ts
View File

@ -31,11 +31,8 @@ export class IWalletContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [hash,
signature
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [hash,
signature
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.isValidSignature;
const encodedData = ethersFunction.encode([hash,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([hash,
signature
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -48,7 +45,8 @@ export class IWalletContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'isValidSignature'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -98,7 +96,7 @@ export class IWalletContract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('IWallet', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

80
packages/abi-gen-wrappers/src/generated-wrappers/order_validator.ts
View File

@ -24,18 +24,15 @@ export class OrderValidatorContract extends BaseContract {
): Promise<[{orderStatus: number;orderHash: string;orderTakerAssetFilledAmount: BigNumber}, {makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}]
> {
const self = this as any as OrderValidatorContract;
const functionSignature = 'getOrderAndTraderInfo({address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes},address)';
const functionSignature = 'getOrderAndTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[order,
takerAddress
] = BaseContract._formatABIDataItemList(inputAbi, [order,
takerAddress
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [order,
takerAddress
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getOrderAndTraderInfo;
const encodedData = ethersFunction.encode([order,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([order,
takerAddress
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -48,7 +45,8 @@ export class OrderValidatorContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getOrderAndTraderInfo'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -71,11 +69,8 @@ export class OrderValidatorContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [target,
assetData
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target,
assetData
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getBalanceAndAllowance;
const encodedData = ethersFunction.encode([target,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([target,
assetData
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -88,7 +83,8 @@ export class OrderValidatorContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getBalanceAndAllowance'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -104,18 +100,15 @@ export class OrderValidatorContract extends BaseContract {
): Promise<[Array<{orderStatus: number;orderHash: string;orderTakerAssetFilledAmount: BigNumber}>, Array<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}>]
> {
const self = this as any as OrderValidatorContract;
const functionSignature = 'getOrdersAndTradersInfo(tuple[],address[])';
const functionSignature = 'getOrdersAndTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[orders,
takerAddresses
] = BaseContract._formatABIDataItemList(inputAbi, [orders,
takerAddresses
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [orders,
takerAddresses
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getOrdersAndTradersInfo;
const encodedData = ethersFunction.encode([orders,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([orders,
takerAddresses
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -128,7 +121,8 @@ export class OrderValidatorContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getOrdersAndTradersInfo'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -144,18 +138,15 @@ export class OrderValidatorContract extends BaseContract {
): Promise<Array<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}>
> {
const self = this as any as OrderValidatorContract;
const functionSignature = 'getTradersInfo(tuple[],address[])';
const functionSignature = 'getTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[orders,
takerAddresses
] = BaseContract._formatABIDataItemList(inputAbi, [orders,
takerAddresses
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [orders,
takerAddresses
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getTradersInfo;
const encodedData = ethersFunction.encode([orders,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([orders,
takerAddresses
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -168,7 +159,8 @@ export class OrderValidatorContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getTradersInfo'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -191,11 +183,8 @@ export class OrderValidatorContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [token,
tokenId
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [token,
tokenId
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getERC721TokenOwner;
const encodedData = ethersFunction.encode([token,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([token,
tokenId
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -208,7 +197,8 @@ export class OrderValidatorContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getERC721TokenOwner'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -231,11 +221,8 @@ export class OrderValidatorContract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [target,
assetData
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [target,
assetData
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getBalancesAndAllowances;
const encodedData = ethersFunction.encode([target,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([target,
assetData
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -248,7 +235,8 @@ export class OrderValidatorContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getBalancesAndAllowances'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -264,18 +252,15 @@ export class OrderValidatorContract extends BaseContract {
): Promise<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}
> {
const self = this as any as OrderValidatorContract;
const functionSignature = 'getTraderInfo({address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes},address)';
const functionSignature = 'getTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[order,
takerAddress
] = BaseContract._formatABIDataItemList(inputAbi, [order,
takerAddress
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [order,
takerAddress
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.getTraderInfo;
const encodedData = ethersFunction.encode([order,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([order,
takerAddress
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -288,7 +273,8 @@ export class OrderValidatorContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'getTraderInfo'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -352,7 +338,7 @@ _zrxAssetData
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('OrderValidator', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

245
packages/abi-gen-wrappers/src/generated-wrappers/weth9.ts
View File

@ -60,9 +60,8 @@ export class WETH9Contract extends BaseContract {
const functionSignature = 'name()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.name;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -73,7 +72,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'name'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -87,18 +87,10 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
[guy,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([guy,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [guy,
wad
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [guy,
wad
]);
const encodedData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([guy,
wad
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -121,13 +113,8 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
[guy,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [guy,
wad
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([guy,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([guy,
wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -146,13 +133,8 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
): string {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
[guy,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [guy,
wad
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('approve(address,uint256)').functions.approve.encode([guy,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([guy,
wad
]);
return abiEncodedTransactionData;
@ -172,11 +154,8 @@ export class WETH9Contract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [guy,
wad
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [guy,
wad
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.approve;
const encodedData = ethersFunction.encode([guy,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([guy,
wad
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -189,7 +168,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -206,9 +186,8 @@ export class WETH9Contract extends BaseContract {
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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -219,7 +198,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -234,22 +214,11 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
[src,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([src,
dst,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [src,
dst,
wad
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [src,
dst,
wad
]);
const encodedData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([src,
dst,
wad
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -274,15 +243,8 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
[src,
dst,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [src,
dst,
wad
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([src,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([src,
dst,
wad
]);
@ -303,15 +265,8 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
): string {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
[src,
dst,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [src,
dst,
wad
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('transferFrom(address,address,uint256)').functions.transferFrom.encode([src,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([src,
dst,
wad
]);
@ -335,12 +290,8 @@ export class WETH9Contract extends BaseContract {
dst,
wad
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [src,
dst,
wad
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferFrom;
const encodedData = ethersFunction.encode([src,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([src,
dst,
wad
]);
@ -354,7 +305,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -367,14 +319,9 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('withdraw(uint256)').inputs;
[wad
] = BaseContract._formatABIDataItemList(inputAbi, [wad
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [wad
]);
const encodedData = self._lookupEthersInterface('withdraw(uint256)').functions.withdraw.encode([wad
]);
const abiEncoder = self._lookupAbiEncoder('withdraw(uint256)');
const encodedData = abiEncoder.encode([wad
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -395,11 +342,8 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('withdraw(uint256)').inputs;
[wad
] = BaseContract._formatABIDataItemList(inputAbi, [wad
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('withdraw(uint256)').functions.withdraw.encode([wad
const abiEncoder = self._lookupAbiEncoder('withdraw(uint256)');
const encodedData = abiEncoder.encode([wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -416,11 +360,8 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
): string {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('withdraw(uint256)').inputs;
[wad
] = BaseContract._formatABIDataItemList(inputAbi, [wad
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('withdraw(uint256)').functions.withdraw.encode([wad
const abiEncoder = self._lookupAbiEncoder('withdraw(uint256)');
const abiEncodedTransactionData = abiEncoder.encode([wad
]);
return abiEncodedTransactionData;
},
@ -436,10 +377,8 @@ export class WETH9Contract extends BaseContract {
[wad
] = BaseContract._formatABIDataItemList(inputAbi, [wad
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [wad
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.withdraw;
const encodedData = ethersFunction.encode([wad
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([wad
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -451,7 +390,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'withdraw'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -468,9 +408,8 @@ export class WETH9Contract extends BaseContract {
const functionSignature = 'decimals()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.decimals;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -481,7 +420,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'decimals'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -501,10 +441,8 @@ export class WETH9Contract extends BaseContract {
[index_0
] = BaseContract._formatABIDataItemList(inputAbi, [index_0
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [index_0
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.balanceOf;
const encodedData = ethersFunction.encode([index_0
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([index_0
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -516,7 +454,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -533,9 +472,8 @@ export class WETH9Contract extends BaseContract {
const functionSignature = 'symbol()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.symbol;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -546,7 +484,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'symbol'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -560,18 +499,10 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
[dst,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const encodedData = abiEncoder.encode([dst,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [dst,
wad
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [dst,
wad
]);
const encodedData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer.encode([dst,
wad
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -594,13 +525,8 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
[dst,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [dst,
wad
], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer.encode([dst,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const encodedData = abiEncoder.encode([dst,
wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -619,13 +545,8 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
): string {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
[dst,
wad
] = BaseContract._formatABIDataItemList(inputAbi, [dst,
wad
], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('transfer(address,uint256)').functions.transfer.encode([dst,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([dst,
wad
]);
return abiEncodedTransactionData;
@ -645,11 +566,8 @@ export class WETH9Contract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [dst,
wad
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [dst,
wad
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transfer;
const encodedData = ethersFunction.encode([dst,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([dst,
wad
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -662,7 +580,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -674,10 +593,8 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxDataPayable> = {},
): Promise<string> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('deposit()').inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const encodedData = self._lookupEthersInterface('deposit()').functions.deposit.encode([]);
const abiEncoder = self._lookupAbiEncoder('deposit()');
const encodedData = abiEncoder.encode([], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -696,9 +613,8 @@ export class WETH9Contract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('deposit()').inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString);
const encodedData = self._lookupEthersInterface('deposit()').functions.deposit.encode([]);
const abiEncoder = self._lookupAbiEncoder('deposit()');
const encodedData = abiEncoder.encode([]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -713,9 +629,8 @@ export class WETH9Contract extends BaseContract {
getABIEncodedTransactionData(
): string {
const self = this as any as WETH9Contract;
const inputAbi = self._lookupAbi('deposit()').inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString);
const abiEncodedTransactionData = self._lookupEthersInterface('deposit()').functions.deposit.encode([]);
const abiEncoder = self._lookupAbiEncoder('deposit()');
const abiEncodedTransactionData = abiEncoder.encode([]);
return abiEncodedTransactionData;
},
async callAsync(
@ -727,9 +642,8 @@ export class WETH9Contract extends BaseContract {
const functionSignature = 'deposit()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.deposit;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -740,7 +654,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'deposit'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -763,11 +678,8 @@ export class WETH9Contract extends BaseContract {
] = BaseContract._formatABIDataItemList(inputAbi, [index_0,
index_1
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [index_0,
index_1
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.allowance;
const encodedData = ethersFunction.encode([index_0,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([index_0,
index_1
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -780,7 +692,8 @@ export class WETH9Contract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -830,7 +743,7 @@ export class WETH9Contract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('WETH9', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

187
packages/abi-gen-wrappers/src/generated-wrappers/zrx_token.ts
View File

@ -46,9 +46,8 @@ export class ZRXTokenContract extends BaseContract {
const functionSignature = 'name()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.name;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -59,7 +58,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'name'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -73,18 +73,10 @@ export class ZRXTokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ZRXTokenContract;
const inputAbi = self._lookupAbi('approve(address,uint256)').inputs;
[_spender,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -107,13 +99,8 @@ export class ZRXTokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ZRXTokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const encodedData = abiEncoder.encode([_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -132,13 +119,8 @@ export class ZRXTokenContract extends BaseContract {
_value: BigNumber,
): string {
const self = this as any as ZRXTokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_spender,
_value
]);
return abiEncodedTransactionData;
@ -158,11 +140,8 @@ export class ZRXTokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_spender,
_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -175,7 +154,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -192,9 +172,8 @@ export class ZRXTokenContract extends BaseContract {
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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -205,7 +184,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -220,22 +200,11 @@ export class ZRXTokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ZRXTokenContract;
const inputAbi = self._lookupAbi('transferFrom(address,address,uint256)').inputs;
[_from,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -260,15 +229,8 @@ export class ZRXTokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ZRXTokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const encodedData = abiEncoder.encode([_from,
_to,
_value
]);
@ -289,15 +251,8 @@ export class ZRXTokenContract extends BaseContract {
_value: BigNumber,
): string {
const self = this as any as ZRXTokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_from,
_to,
_value
]);
@ -321,12 +276,8 @@ export class ZRXTokenContract extends BaseContract {
_to,
_value
], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, [_from,
_to,
_value
]);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.transferFrom;
const encodedData = ethersFunction.encode([_from,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_from,
_to,
_value
]);
@ -340,7 +291,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -357,9 +309,8 @@ export class ZRXTokenContract extends BaseContract {
const functionSignature = 'decimals()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.decimals;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -370,7 +321,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'decimals'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -390,10 +342,8 @@ export class ZRXTokenContract extends BaseContract {
[_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 abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
@ -405,7 +355,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -422,9 +373,8 @@ export class ZRXTokenContract extends BaseContract {
const functionSignature = 'symbol()';
const inputAbi = self._lookupAbi(functionSignature).inputs;
[] = BaseContract._formatABIDataItemList(inputAbi, [], BaseContract._bigNumberToString.bind(self));
BaseContract.strictArgumentEncodingCheck(inputAbi, []);
const ethersFunction = self._lookupEthersInterface(functionSignature).functions.symbol;
const encodedData = ethersFunction.encode([]);
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -435,7 +385,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
const outputAbi = (_.find(self.abi, {name: 'symbol'}) as MethodAbi).outputs;
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._lowercaseAddress.bind(this));
resultArray = BaseContract._formatABIDataItemList(outputAbi, resultArray, BaseContract._bnToBigNumber.bind(this));
@ -449,18 +400,10 @@ export class ZRXTokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<string> {
const self = this as any as ZRXTokenContract;
const inputAbi = self._lookupAbi('transfer(address,uint256)').inputs;
[_to,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const encodedData = abiEncoder.encode([_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
]);
], {optimize: false});
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
@ -483,13 +426,8 @@ export class ZRXTokenContract extends BaseContract {
txData: Partial<TxData> = {},
): Promise<number> {
const self = this as any as ZRXTokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const encodedData = abiEncoder.encode([_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -508,13 +446,8 @@ export class ZRXTokenContract extends BaseContract {
_value: BigNumber,
): string {
const self = this as any as ZRXTokenContract;
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,
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
const abiEncodedTransactionData = abiEncoder.encode([_to,
_value
]);
return abiEncodedTransactionData;
@ -534,11 +467,8 @@ export class ZRXTokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_to,
_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -551,7 +481,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -574,11 +505,8 @@ export class ZRXTokenContract extends BaseContract {
] = 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,
const abiEncoder = self._lookupAbiEncoder(functionSignature);
const encodedData = abiEncoder.encode([_owner,
_spender
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
@ -591,7 +519,8 @@ export class ZRXTokenContract extends BaseContract {
);
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
let resultArray = ethersFunction.decode(rawCallResult);
const decodingRules = {structsAsObjects: false};
let resultArray = abiEncoder.decodeReturnValues(rawCallResult, decodingRules);
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));
@ -641,7 +570,7 @@ export class ZRXTokenContract extends BaseContract {
}
constructor(abi: ContractAbi, address: string, provider: Provider, txDefaults?: Partial<TxData>) {
super('ZRXToken', abi, address, provider, txDefaults);
classUtils.bindAll(this, ['_ethersInterfacesByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', 'abi', '_web3Wrapper']);
}
} // tslint:disable:max-file-line-count
// tslint:enable:no-unbound-method

4
packages/abi-gen/src/index.ts
View File

@ -1,6 +1,6 @@
#!/usr/bin/env node
import { abiUtils, logUtils } from '@0x/utils';
import { AbiEncoder, abiUtils, logUtils } from '@0x/utils';
import chalk from 'chalk';
import { AbiDefinition, ConstructorAbi, EventAbi, MethodAbi } from 'ethereum-types';
import { sync as globSync } from 'glob';
@ -133,7 +133,7 @@ for (const abiFileName of abiFileNames) {
singleReturnValue: methodAbi.outputs.length === 1,
hasReturnValue: methodAbi.outputs.length !== 0,
tsName: sanitizedMethodAbis[methodAbiIndex].name,
functionSignature: abiUtils.getFunctionSignature(methodAbi),
functionSignature: new AbiEncoder.Method(methodAbi).getSignature(),
};
return methodData;
});

25
packages/base-contract/src/index.ts
View File

@ -16,8 +16,10 @@ import * as _ from 'lodash';
import { formatABIDataItem } from './utils';
export interface EthersInterfaceByFunctionSignature {
[key: string]: ethers.utils.Interface;
import { AbiEncoder } from '@0x/utils';
export interface AbiEncoderByFunctionSignature {
[key: string]: AbiEncoder.Method;
}
const REVERT_ERROR_SELECTOR = '08c379a0';
@ -26,7 +28,7 @@ const REVERT_ERROR_SELECTOR_BYTES_LENGTH = 4;
const REVERT_ERROR_SELECTOR_END = REVERT_ERROR_SELECTOR_OFFSET + REVERT_ERROR_SELECTOR_BYTES_LENGTH * 2;
export class BaseContract {
protected _ethersInterfacesByFunctionSignature: EthersInterfaceByFunctionSignature;
protected _abiEncoderByFunctionSignature: AbiEncoderByFunctionSignature;
protected _web3Wrapper: Web3Wrapper;
public abi: ContractAbi;
public address: string;
@ -117,12 +119,12 @@ export class BaseContract {
}
}
}
protected _lookupEthersInterface(functionSignature: string): ethers.utils.Interface {
const ethersInterface = this._ethersInterfacesByFunctionSignature[functionSignature];
if (_.isUndefined(ethersInterface)) {
protected _lookupAbiEncoder(functionSignature: string): AbiEncoder.Method {
const abiEncoder = this._abiEncoderByFunctionSignature[functionSignature];
if (_.isUndefined(abiEncoder)) {
throw new Error(`Failed to lookup method with function signature '${functionSignature}'`);
}
return ethersInterface;
return abiEncoder;
}
protected _lookupAbi(functionSignature: string): MethodAbi {
const methodAbi = _.find(this.abi, (abiDefinition: AbiDefinition) => {
@ -130,7 +132,7 @@ export class BaseContract {
return false;
}
// tslint:disable-next-line:no-unnecessary-type-assertion
const abiFunctionSignature = abiUtils.getFunctionSignature(abiDefinition as MethodAbi);
const abiFunctionSignature = new AbiEncoder.Method(abiDefinition as MethodAbi).getSignature();
if (abiFunctionSignature === functionSignature) {
return true;
}
@ -152,10 +154,11 @@ export class BaseContract {
const methodAbis = this.abi.filter(
(abiDefinition: AbiDefinition) => abiDefinition.type === AbiType.Function,
) as MethodAbi[];
this._ethersInterfacesByFunctionSignature = {};
this._abiEncoderByFunctionSignature = {};
_.each(methodAbis, methodAbi => {
const functionSignature = abiUtils.getFunctionSignature(methodAbi);
this._ethersInterfacesByFunctionSignature[functionSignature] = new ethers.utils.Interface([methodAbi]);
const abiEncoder = new AbiEncoder.Method(methodAbi);
const functionSignature = abiEncoder.getSignature();
this._abiEncoderByFunctionSignature[functionSignature] = abiEncoder;
});
}
}

17
packages/utils/src/abi_encoder/abstract_data_types/types/set.ts
View File

@ -134,20 +134,21 @@ export abstract class AbstractSetDataType extends DataType {
const block = new SetCalldataBlock(this.getDataItem().name, this.getSignature(), parentName);
// Create blocks for members of set.
const memberCalldataBlocks: CalldataBlock[] = [];
const childMap = _.cloneDeep(this._memberIndexByName);
_.forOwn(obj, (value: any, key: string) => {
if (!(key in childMap)) {
let duplicateObj = _.cloneDeep(obj) as {[key:string]: any};
_.forEach(this._memberIndexByName, (memberIndex: number, memberName: string) => {
if (!(memberName in obj)) {
throw new Error(
`Could not assign tuple to object: unrecognized key '${key}' in object ${this.getDataItem().name}`,
`Could not assign tuple to object: missing field '${memberName}' in object ${obj}`,
);
}
const memberBlock = this._members[this._memberIndexByName[key]].generateCalldataBlock(value, block);
const memberValue: any = duplicateObj[memberName];
const memberBlock = this._members[memberIndex].generateCalldataBlock(memberValue, block);
memberCalldataBlocks.push(memberBlock);
delete childMap[key];
delete duplicateObj[memberName];
});
// Sanity check that all members have been included.
if (Object.keys(childMap).length !== 0) {
throw new Error(`Could not assign tuple to object: missing keys ${Object.keys(childMap)}`);
if (Object.keys(duplicateObj).length !== 0) {
throw new Error(`Could not assign tuple to object: unrecognized keys ${Object.keys(duplicateObj)}`);
}
// Associate member blocks with Set block.
block.setMembers(memberCalldataBlocks);