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

updated contract wrappers

Browse Source
This commit is contained in:
Greg Hysen 2019-07-29 12:24:19 +02:00
parent c2f34baee0
commit 048e48b03a
20 changed files with 10166 additions and 11067 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

588
packages/abi-gen-wrappers/src/generated-wrappers/coordinator.ts generated
View File

@ -1,7 +1,7 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma // tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace // tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable // tslint:disable:no-unused-variable
import { BaseContract, PromiseWithTransactionHash } from '@0x/base-contract'; import { BaseContract,PromiseWithTransactionHash } from '@0x/base-contract';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { import {
BlockParam, BlockParam,
@ -23,6 +23,7 @@ import { assert } from '@0x/assert';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
// tslint:enable:no-unused-variable // tslint:enable:no-unused-variable
/* istanbul ignore next */ /* istanbul ignore next */
// tslint:disable:no-parameter-reassignment // tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name // tslint:disable-next-line:class-name
@ -33,7 +34,8 @@ export class CoordinatorContract extends BaseContract {
signature: string, signature: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<string> { ): Promise<string
> {
assert.isString('hash', hash); assert.isString('hash', hash);
assert.isString('signature', signature); assert.isString('signature', signature);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -44,8 +46,10 @@ export class CoordinatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments('getSignerAddress(bytes32,bytes)', [hash, signature]); const encodedData = self._strictEncodeArguments('getSignerAddress(bytes32,bytes)', [hash,
signature
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -54,35 +58,38 @@ export class CoordinatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('getSignerAddress(bytes32,bytes)'); const abiEncoder = self._lookupAbiEncoder('getSignerAddress(bytes32,bytes)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<string>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<string
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(hash: string, signature: string): string { getABIEncodedTransactionData(
hash: string,
signature: string,
): string {
assert.isString('hash', hash); assert.isString('hash', hash);
assert.isString('signature', signature); assert.isString('signature', signature);
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('getSignerAddress(bytes32,bytes)', [ const abiEncodedTransactionData = self._strictEncodeArguments('getSignerAddress(bytes32,bytes)', [hash,
hash, signature
signature, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public getTransactionHash = { public getTransactionHash = {
async callAsync( async callAsync(
transaction: { salt: BigNumber; signerAddress: string; data: string }, transaction: {salt: BigNumber;signerAddress: string;data: string},
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<string> { ): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
schemas.numberSchema, schemas.numberSchema,
@ -91,10 +98,9 @@ export class CoordinatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments('getTransactionHash((uint256,address,bytes))', [ const encodedData = self._strictEncodeArguments('getTransactionHash((uint256,address,bytes))', [transaction
transaction, ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -103,38 +109,35 @@ export class CoordinatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('getTransactionHash((uint256,address,bytes))'); const abiEncoder = self._lookupAbiEncoder('getTransactionHash((uint256,address,bytes))');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<string>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<string
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(transaction: { salt: BigNumber; signerAddress: string; data: string }): string { getABIEncodedTransactionData(
const self = (this as any) as CoordinatorContract; transaction: {salt: BigNumber;signerAddress: string;data: string},
const abiEncodedTransactionData = self._strictEncodeArguments( ): string {
'getTransactionHash((uint256,address,bytes))',
[transaction], const self = this as any as CoordinatorContract;
); const abiEncodedTransactionData = self._strictEncodeArguments('getTransactionHash((uint256,address,bytes))', [transaction
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public getCoordinatorApprovalHash = { public getCoordinatorApprovalHash = {
async callAsync( async callAsync(
approval: { approval: {txOrigin: string;transactionHash: string;transactionSignature: string;approvalExpirationTimeSeconds: BigNumber},
txOrigin: string;
transactionHash: string;
transactionSignature: string;
approvalExpirationTimeSeconds: BigNumber;
},
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<string> { ): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
schemas.numberSchema, schemas.numberSchema,
@ -143,11 +146,9 @@ export class CoordinatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('getCoordinatorApprovalHash((address,bytes32,bytes,uint256))', [approval
'getCoordinatorApprovalHash((address,bytes32,bytes,uint256))', ]);
[approval],
);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -156,81 +157,73 @@ export class CoordinatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('getCoordinatorApprovalHash((address,bytes32,bytes,uint256))'); const abiEncoder = self._lookupAbiEncoder('getCoordinatorApprovalHash((address,bytes32,bytes,uint256))');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<string>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<string
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(approval: { getABIEncodedTransactionData(
txOrigin: string; approval: {txOrigin: string;transactionHash: string;transactionSignature: string;approvalExpirationTimeSeconds: BigNumber},
transactionHash: string; ): string {
transactionSignature: string;
approvalExpirationTimeSeconds: BigNumber; const self = this as any as CoordinatorContract;
}): string { const abiEncodedTransactionData = self._strictEncodeArguments('getCoordinatorApprovalHash((address,bytes32,bytes,uint256))', [approval
const self = (this as any) as CoordinatorContract; ]);
const abiEncodedTransactionData = self._strictEncodeArguments(
'getCoordinatorApprovalHash((address,bytes32,bytes,uint256))',
[approval],
);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public executeTransaction = { public executeTransaction = {
async sendTransactionAsync( async sendTransactionAsync(
transaction: { salt: BigNumber; signerAddress: string; data: string }, transaction: {salt: BigNumber;signerAddress: string;data: string},
txOrigin: string, txOrigin: string,
transactionSignature: string, transactionSignature: string,
approvalExpirationTimeSeconds: BigNumber[], approvalExpirationTimeSeconds: BigNumber[],
approvalSignatures: string[], approvalSignatures: string[],
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<string> { ): Promise<string> {
assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures);
const self = (this as any) as CoordinatorContract;
const encodedData = self._strictEncodeArguments(
'executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])',
[
transaction,
txOrigin.toLowerCase(),
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures,
],
);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.executeTransaction.estimateGasAsync.bind(
self,
transaction,
txOrigin.toLowerCase(),
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures,
),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); assert.isString('txOrigin', txOrigin);
return txHash; assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures);
const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments('executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])', [transaction,
txOrigin.toLowerCase(),
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.executeTransaction.estimateGasAsync.bind(
self,
transaction,
txOrigin.toLowerCase(),
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
}, },
awaitTransactionSuccessAsync( awaitTransactionSuccessAsync(
transaction: { salt: BigNumber; signerAddress: string; data: string }, transaction: {salt: BigNumber;signerAddress: string;data: string},
txOrigin: string, txOrigin: string,
transactionSignature: string, transactionSignature: string,
approvalExpirationTimeSeconds: BigNumber[], approvalExpirationTimeSeconds: BigNumber[],
@ -239,78 +232,76 @@ export class CoordinatorContract extends BaseContract {
pollingIntervalMs?: number, pollingIntervalMs?: number,
timeoutMs?: number, timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> { ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature); assert.isString('txOrigin', txOrigin);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds); assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalSignatures', approvalSignatures); assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
const self = (this as any) as CoordinatorContract; assert.isArray('approvalSignatures', approvalSignatures);
const txHashPromise = self.executeTransaction.sendTransactionAsync( const self = this as any as CoordinatorContract;
transaction, const txHashPromise = self.executeTransaction.sendTransactionAsync(transaction,
txOrigin.toLowerCase(), txOrigin.toLowerCase(),
transactionSignature, transactionSignature,
approvalExpirationTimeSeconds, approvalExpirationTimeSeconds,
approvalSignatures, approvalSignatures
txData, , txData);
); return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>( txHashPromise,
txHashPromise, (async (): Promise<TransactionReceiptWithDecodedLogs> => {
(async (): Promise<TransactionReceiptWithDecodedLogs> => { // When the transaction hash resolves, wait for it to be mined.
// When the transaction hash resolves, wait for it to be mined. return self._web3Wrapper.awaitTransactionSuccessAsync(
return self._web3Wrapper.awaitTransactionSuccessAsync( await txHashPromise,
await txHashPromise, pollingIntervalMs,
pollingIntervalMs, timeoutMs,
timeoutMs, );
); })(),
})(), );
);
}, },
async estimateGasAsync( async estimateGasAsync(
transaction: { salt: BigNumber; signerAddress: string; data: string }, transaction: {salt: BigNumber;signerAddress: string;data: string},
txOrigin: string, txOrigin: string,
transactionSignature: string, transactionSignature: string,
approvalExpirationTimeSeconds: BigNumber[], approvalExpirationTimeSeconds: BigNumber[],
approvalSignatures: string[], approvalSignatures: string[],
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<number> { ): Promise<number> {
assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures);
const self = (this as any) as CoordinatorContract;
const encodedData = self._strictEncodeArguments(
'executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])',
[
transaction,
txOrigin.toLowerCase(),
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures,
],
);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); assert.isString('txOrigin', txOrigin);
return gas; assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures);
const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments('executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])', [transaction,
txOrigin.toLowerCase(),
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
}, },
async callAsync( async callAsync(
transaction: { salt: BigNumber; signerAddress: string; data: string }, transaction: {salt: BigNumber;signerAddress: string;data: string},
txOrigin: string, txOrigin: string,
transactionSignature: string, transactionSignature: string,
approvalExpirationTimeSeconds: BigNumber[], approvalExpirationTimeSeconds: BigNumber[],
approvalSignatures: string[], approvalSignatures: string[],
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<void> { ): Promise<void
> {
assert.isString('txOrigin', txOrigin); assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature); assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds); assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
@ -323,17 +314,13 @@ export class CoordinatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])', [transaction,
'executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])', txOrigin.toLowerCase(),
[ transactionSignature,
transaction, approvalExpirationTimeSeconds,
txOrigin.toLowerCase(), approvalSignatures
transactionSignature, ]);
approvalExpirationTimeSeconds,
approvalSignatures,
],
);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -342,47 +329,45 @@ export class CoordinatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder( const abiEncoder = self._lookupAbiEncoder('executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])');
'executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])',
);
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<void>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<void
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData( getABIEncodedTransactionData(
transaction: { salt: BigNumber; signerAddress: string; data: string }, transaction: {salt: BigNumber;signerAddress: string;data: string},
txOrigin: string, txOrigin: string,
transactionSignature: string, transactionSignature: string,
approvalExpirationTimeSeconds: BigNumber[], approvalExpirationTimeSeconds: BigNumber[],
approvalSignatures: string[], approvalSignatures: string[],
): string { ): string {
assert.isString('txOrigin', txOrigin); assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature); assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds); assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures); assert.isArray('approvalSignatures', approvalSignatures);
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments( const abiEncodedTransactionData = self._strictEncodeArguments('executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])', [transaction,
'executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])', txOrigin.toLowerCase(),
[ transactionSignature,
transaction, approvalExpirationTimeSeconds,
txOrigin.toLowerCase(), approvalSignatures
transactionSignature, ]);
approvalExpirationTimeSeconds,
approvalSignatures,
],
);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public EIP712_EXCHANGE_DOMAIN_HASH = { public EIP712_EXCHANGE_DOMAIN_HASH = {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(
callData: Partial<CallData> = {},
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
schemas.numberSchema, schemas.numberSchema,
@ -391,7 +376,7 @@ export class CoordinatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments('EIP712_EXCHANGE_DOMAIN_HASH()', []); const encodedData = self._strictEncodeArguments('EIP712_EXCHANGE_DOMAIN_HASH()', []);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
@ -401,34 +386,36 @@ export class CoordinatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('EIP712_EXCHANGE_DOMAIN_HASH()'); const abiEncoder = self._lookupAbiEncoder('EIP712_EXCHANGE_DOMAIN_HASH()');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<string>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<string
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(): string { getABIEncodedTransactionData(
const self = (this as any) as CoordinatorContract; ): string {
const self = this as any as CoordinatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('EIP712_EXCHANGE_DOMAIN_HASH()', []); const abiEncodedTransactionData = self._strictEncodeArguments('EIP712_EXCHANGE_DOMAIN_HASH()', []);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public assertValidCoordinatorApprovals = { public assertValidCoordinatorApprovals = {
async callAsync( async callAsync(
transaction: { salt: BigNumber; signerAddress: string; data: string }, transaction: {salt: BigNumber;signerAddress: string;data: string},
txOrigin: string, txOrigin: string,
transactionSignature: string, transactionSignature: string,
approvalExpirationTimeSeconds: BigNumber[], approvalExpirationTimeSeconds: BigNumber[],
approvalSignatures: string[], approvalSignatures: string[],
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<void> { ): Promise<void
> {
assert.isString('txOrigin', txOrigin); assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature); assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds); assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
@ -441,17 +428,13 @@ export class CoordinatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('assertValidCoordinatorApprovals((uint256,address,bytes),address,bytes,uint256[],bytes[])', [transaction,
'assertValidCoordinatorApprovals((uint256,address,bytes),address,bytes,uint256[],bytes[])', txOrigin.toLowerCase(),
[ transactionSignature,
transaction, approvalExpirationTimeSeconds,
txOrigin.toLowerCase(), approvalSignatures
transactionSignature, ]);
approvalExpirationTimeSeconds,
approvalSignatures,
],
);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -460,42 +443,36 @@ export class CoordinatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder( const abiEncoder = self._lookupAbiEncoder('assertValidCoordinatorApprovals((uint256,address,bytes),address,bytes,uint256[],bytes[])');
'assertValidCoordinatorApprovals((uint256,address,bytes),address,bytes,uint256[],bytes[])',
);
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<void>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<void
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData( getABIEncodedTransactionData(
transaction: { salt: BigNumber; signerAddress: string; data: string }, transaction: {salt: BigNumber;signerAddress: string;data: string},
txOrigin: string, txOrigin: string,
transactionSignature: string, transactionSignature: string,
approvalExpirationTimeSeconds: BigNumber[], approvalExpirationTimeSeconds: BigNumber[],
approvalSignatures: string[], approvalSignatures: string[],
): string { ): string {
assert.isString('txOrigin', txOrigin); assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature); assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds); assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures); assert.isArray('approvalSignatures', approvalSignatures);
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments( const abiEncodedTransactionData = self._strictEncodeArguments('assertValidCoordinatorApprovals((uint256,address,bytes),address,bytes,uint256[],bytes[])', [transaction,
'assertValidCoordinatorApprovals((uint256,address,bytes),address,bytes,uint256[],bytes[])', txOrigin.toLowerCase(),
[ transactionSignature,
transaction, approvalExpirationTimeSeconds,
txOrigin.toLowerCase(), approvalSignatures
transactionSignature, ]);
approvalExpirationTimeSeconds,
approvalSignatures,
],
);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
@ -504,21 +481,7 @@ export class CoordinatorContract extends BaseContract {
data: string, data: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise< ): Promise<Array<{makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string}>
Array<{
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
}>
> { > {
assert.isString('data', data); assert.isString('data', data);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -529,8 +492,9 @@ export class CoordinatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments('decodeOrdersFromFillData(bytes)', [data]); const encodedData = self._strictEncodeArguments('decodeOrdersFromFillData(bytes)', [data
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -539,42 +503,33 @@ export class CoordinatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('decodeOrdersFromFillData(bytes)'); const abiEncoder = self._lookupAbiEncoder('decodeOrdersFromFillData(bytes)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue< const result = abiEncoder.strictDecodeReturnValue<Array<{makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string}>
Array<{ >(rawCallResult);
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
}>
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(data: string): string { getABIEncodedTransactionData(
data: string,
): string {
assert.isString('data', data); assert.isString('data', data);
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('decodeOrdersFromFillData(bytes)', [data]); const abiEncodedTransactionData = self._strictEncodeArguments('decodeOrdersFromFillData(bytes)', [data
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public EIP712_COORDINATOR_DOMAIN_HASH = { public EIP712_COORDINATOR_DOMAIN_HASH = {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(
callData: Partial<CallData> = {},
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
schemas.numberSchema, schemas.numberSchema,
@ -583,7 +538,7 @@ export class CoordinatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorContract; const self = this as any as CoordinatorContract;
const encodedData = self._strictEncodeArguments('EIP712_COORDINATOR_DOMAIN_HASH()', []); const encodedData = self._strictEncodeArguments('EIP712_COORDINATOR_DOMAIN_HASH()', []);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
@ -593,30 +548,30 @@ export class CoordinatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('EIP712_COORDINATOR_DOMAIN_HASH()'); const abiEncoder = self._lookupAbiEncoder('EIP712_COORDINATOR_DOMAIN_HASH()');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<string>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<string
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(): string { getABIEncodedTransactionData(
const self = (this as any) as CoordinatorContract; ): string {
const self = this as any as CoordinatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('EIP712_COORDINATOR_DOMAIN_HASH()', []); const abiEncodedTransactionData = self._strictEncodeArguments('EIP712_COORDINATOR_DOMAIN_HASH()', []);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public static async deployFrom0xArtifactAsync( public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact, artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact }, logDecodeDependencies: { [contractName: string]: (ContractArtifact | SimpleContractArtifact) },
_exchange: string, _exchange: string,
): Promise<CoordinatorContract> { ): Promise<CoordinatorContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -629,18 +584,9 @@ export class CoordinatorContract extends BaseContract {
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object; const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi; const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce( const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce((accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), {});
(accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), return CoordinatorContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly, _exchange
{}, );
);
return CoordinatorContract.deployAsync(
bytecode,
abi,
provider,
txDefaults,
logDecodeDependenciesAbiOnly,
_exchange,
);
} }
public static async deployAsync( public static async deployAsync(
bytecode: string, bytecode: string,
@ -648,7 +594,7 @@ export class CoordinatorContract extends BaseContract {
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractAbi }, logDecodeDependencies: { [contractName: string]: ContractAbi },
_exchange: string, _exchange: string,
): Promise<CoordinatorContract> { ): Promise<CoordinatorContract> {
assert.isHexString('bytecode', bytecode); assert.isHexString('bytecode', bytecode);
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
@ -658,17 +604,20 @@ export class CoordinatorContract extends BaseContract {
]); ]);
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi); const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[_exchange] = BaseContract._formatABIDataItemList( [_exchange
] = BaseContract._formatABIDataItemList(
constructorAbi.inputs, constructorAbi.inputs,
[_exchange], [_exchange
],
BaseContract._bigNumberToString, BaseContract._bigNumberToString,
); );
const iface = new ethers.utils.Interface(abi); const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction; const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, [_exchange]); const txData = deployInfo.encode(bytecode, [_exchange
]);
const web3Wrapper = new Web3Wrapper(provider); const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ data: txData }, {data: txData},
txDefaults, txDefaults,
web3Wrapper.estimateGasAsync.bind(web3Wrapper), web3Wrapper.estimateGasAsync.bind(web3Wrapper),
); );
@ -676,16 +625,13 @@ export class CoordinatorContract extends BaseContract {
logUtils.log(`transactionHash: ${txHash}`); logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`Coordinator successfully deployed at ${txReceipt.contractAddress}`); logUtils.log(`Coordinator successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new CoordinatorContract( const contractInstance = new CoordinatorContract(txReceipt.contractAddress as string, provider, txDefaults, logDecodeDependencies);
txReceipt.contractAddress as string, contractInstance.constructorArgs = [_exchange
provider, ];
txDefaults,
logDecodeDependencies,
);
contractInstance.constructorArgs = [_exchange];
return contractInstance; return contractInstance;
} }
/** /**
* @returns The contract ABI * @returns The contract ABI
*/ */
@ -733,7 +679,7 @@ export class CoordinatorContract extends BaseContract {
name: 'data', name: 'data',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
], ],
name: 'getTransactionHash', name: 'getTransactionHash',
@ -770,7 +716,7 @@ export class CoordinatorContract extends BaseContract {
name: 'approvalExpirationTimeSeconds', name: 'approvalExpirationTimeSeconds',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
], ],
name: 'getCoordinatorApprovalHash', name: 'getCoordinatorApprovalHash',
@ -803,7 +749,7 @@ export class CoordinatorContract extends BaseContract {
name: 'data', name: 'data',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
{ {
name: 'txOrigin', name: 'txOrigin',
@ -823,14 +769,16 @@ export class CoordinatorContract extends BaseContract {
}, },
], ],
name: 'executeTransaction', name: 'executeTransaction',
outputs: [], outputs: [
],
payable: false, payable: false,
stateMutability: 'nonpayable', stateMutability: 'nonpayable',
type: 'function', type: 'function',
}, },
{ {
constant: true, constant: true,
inputs: [], inputs: [
],
name: 'EIP712_EXCHANGE_DOMAIN_HASH', name: 'EIP712_EXCHANGE_DOMAIN_HASH',
outputs: [ outputs: [
{ {
@ -861,7 +809,7 @@ export class CoordinatorContract extends BaseContract {
name: 'data', name: 'data',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
{ {
name: 'txOrigin', name: 'txOrigin',
@ -881,7 +829,8 @@ export class CoordinatorContract extends BaseContract {
}, },
], ],
name: 'assertValidCoordinatorApprovals', name: 'assertValidCoordinatorApprovals',
outputs: [], outputs: [
],
payable: false, payable: false,
stateMutability: 'view', stateMutability: 'view',
type: 'function', type: 'function',
@ -948,7 +897,7 @@ export class CoordinatorContract extends BaseContract {
name: 'takerAssetData', name: 'takerAssetData',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
], ],
payable: false, payable: false,
@ -957,7 +906,8 @@ export class CoordinatorContract extends BaseContract {
}, },
{ {
constant: true, constant: true,
inputs: [], inputs: [
],
name: 'EIP712_COORDINATOR_DOMAIN_HASH', name: 'EIP712_COORDINATOR_DOMAIN_HASH',
outputs: [ outputs: [
{ {
@ -976,7 +926,8 @@ export class CoordinatorContract extends BaseContract {
type: 'address', type: 'address',
}, },
], ],
outputs: [], outputs: [
],
payable: false, payable: false,
stateMutability: 'nonpayable', stateMutability: 'nonpayable',
type: 'constructor', type: 'constructor',
@ -984,12 +935,7 @@ export class CoordinatorContract extends BaseContract {
] as ContractAbi; ] as ContractAbi;
return abi; return abi;
} }
constructor( constructor(address: string, supportedProvider: SupportedProvider, txDefaults?: Partial<TxData>, logDecodeDependencies?: { [contractName: string]: ContractAbi }) {
address: string,
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
) {
super('Coordinator', CoordinatorContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies); super('Coordinator', CoordinatorContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']); classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
} }

238
packages/abi-gen-wrappers/src/generated-wrappers/coordinator_registry.ts generated
View File

@ -1,14 +1,11 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma // tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace // tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable // tslint:disable:no-unused-variable
import { import { BaseContract,
BaseContract,
BlockRange, BlockRange,
EventCallback, EventCallback,
IndexedFilterValues, IndexedFilterValues,
SubscriptionManager, SubscriptionManager,PromiseWithTransactionHash } from '@0x/base-contract';
PromiseWithTransactionHash,
} from '@0x/base-contract';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { import {
BlockParam, BlockParam,
@ -31,7 +28,8 @@ import { assert } from '@0x/assert';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
// tslint:enable:no-unused-variable // tslint:enable:no-unused-variable
export type CoordinatorRegistryEventArgs = CoordinatorRegistryCoordinatorEndpointSetEventArgs; export type CoordinatorRegistryEventArgs =
| CoordinatorRegistryCoordinatorEndpointSetEventArgs;
export enum CoordinatorRegistryEvents { export enum CoordinatorRegistryEvents {
CoordinatorEndpointSet = 'CoordinatorEndpointSet', CoordinatorEndpointSet = 'CoordinatorEndpointSet',
@ -42,30 +40,38 @@ export interface CoordinatorRegistryCoordinatorEndpointSetEventArgs extends Deco
coordinatorEndpoint: string; coordinatorEndpoint: string;
} }
/* istanbul ignore next */ /* istanbul ignore next */
// tslint:disable:no-parameter-reassignment // tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name // tslint:disable-next-line:class-name
export class CoordinatorRegistryContract extends BaseContract { export class CoordinatorRegistryContract extends BaseContract {
public setCoordinatorEndpoint = { public setCoordinatorEndpoint = {
async sendTransactionAsync(coordinatorEndpoint: string, txData?: Partial<TxData> | undefined): Promise<string> { async sendTransactionAsync(
assert.isString('coordinatorEndpoint', coordinatorEndpoint); coordinatorEndpoint: string,
const self = (this as any) as CoordinatorRegistryContract; txData?: Partial<TxData> | undefined,
const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint]); ): Promise<string> {
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( assert.isString('coordinatorEndpoint', coordinatorEndpoint);
{ const self = this as any as CoordinatorRegistryContract;
to: self.address, const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
...txData, ]);
data: encodedData, const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
}, {
self._web3Wrapper.getContractDefaults(), to: self.address,
self.setCoordinatorEndpoint.estimateGasAsync.bind(self, coordinatorEndpoint), ...txData,
); data: encodedData,
if (txDataWithDefaults.from !== undefined) { },
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase(); self._web3Wrapper.getContractDefaults(),
} self.setCoordinatorEndpoint.estimateGasAsync.bind(
self,
coordinatorEndpoint
),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash; return txHash;
}, },
awaitTransactionSuccessAsync( awaitTransactionSuccessAsync(
coordinatorEndpoint: string, coordinatorEndpoint: string,
@ -73,45 +79,51 @@ export class CoordinatorRegistryContract extends BaseContract {
pollingIntervalMs?: number, pollingIntervalMs?: number,
timeoutMs?: number, timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> { ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('coordinatorEndpoint', coordinatorEndpoint); assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = (this as any) as CoordinatorRegistryContract; const self = this as any as CoordinatorRegistryContract;
const txHashPromise = self.setCoordinatorEndpoint.sendTransactionAsync(coordinatorEndpoint, txData); const txHashPromise = self.setCoordinatorEndpoint.sendTransactionAsync(coordinatorEndpoint
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>( , txData);
txHashPromise, return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
(async (): Promise<TransactionReceiptWithDecodedLogs> => { txHashPromise,
// When the transaction hash resolves, wait for it to be mined. (async (): Promise<TransactionReceiptWithDecodedLogs> => {
return self._web3Wrapper.awaitTransactionSuccessAsync( // When the transaction hash resolves, wait for it to be mined.
await txHashPromise, return self._web3Wrapper.awaitTransactionSuccessAsync(
pollingIntervalMs, await txHashPromise,
timeoutMs, pollingIntervalMs,
); timeoutMs,
})(), );
); })(),
);
}, },
async estimateGasAsync(coordinatorEndpoint: string, txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(
assert.isString('coordinatorEndpoint', coordinatorEndpoint); coordinatorEndpoint: string,
const self = (this as any) as CoordinatorRegistryContract; txData?: Partial<TxData> | undefined,
const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint]); ): Promise<number> {
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( assert.isString('coordinatorEndpoint', coordinatorEndpoint);
{ const self = this as any as CoordinatorRegistryContract;
to: self.address, const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
...txData, ]);
data: encodedData, const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
}, {
self._web3Wrapper.getContractDefaults(), to: self.address,
); ...txData,
if (txDataWithDefaults.from !== undefined) { data: encodedData,
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase(); },
} self._web3Wrapper.getContractDefaults(),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas; return gas;
}, },
async callAsync( async callAsync(
coordinatorEndpoint: string, coordinatorEndpoint: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<void> { ): Promise<void
> {
assert.isString('coordinatorEndpoint', coordinatorEndpoint); assert.isString('coordinatorEndpoint', coordinatorEndpoint);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -121,8 +133,9 @@ export class CoordinatorRegistryContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorRegistryContract; const self = this as any as CoordinatorRegistryContract;
const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint]); const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -131,24 +144,24 @@ export class CoordinatorRegistryContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('setCoordinatorEndpoint(string)'); const abiEncoder = self._lookupAbiEncoder('setCoordinatorEndpoint(string)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<void>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<void
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(coordinatorEndpoint: string): string { getABIEncodedTransactionData(
coordinatorEndpoint: string,
): string {
assert.isString('coordinatorEndpoint', coordinatorEndpoint); assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = (this as any) as CoordinatorRegistryContract; const self = this as any as CoordinatorRegistryContract;
const abiEncodedTransactionData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [ const abiEncodedTransactionData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
coordinatorEndpoint, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
@ -157,7 +170,8 @@ export class CoordinatorRegistryContract extends BaseContract {
coordinatorOperator: string, coordinatorOperator: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<string> { ): Promise<string
> {
assert.isString('coordinatorOperator', coordinatorOperator); assert.isString('coordinatorOperator', coordinatorOperator);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -167,10 +181,9 @@ export class CoordinatorRegistryContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as CoordinatorRegistryContract; const self = this as any as CoordinatorRegistryContract;
const encodedData = self._strictEncodeArguments('getCoordinatorEndpoint(address)', [ const encodedData = self._strictEncodeArguments('getCoordinatorEndpoint(address)', [coordinatorOperator.toLowerCase()
coordinatorOperator.toLowerCase(), ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -179,33 +192,33 @@ export class CoordinatorRegistryContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('getCoordinatorEndpoint(address)'); const abiEncoder = self._lookupAbiEncoder('getCoordinatorEndpoint(address)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<string>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<string
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(coordinatorOperator: string): string { getABIEncodedTransactionData(
coordinatorOperator: string,
): string {
assert.isString('coordinatorOperator', coordinatorOperator); assert.isString('coordinatorOperator', coordinatorOperator);
const self = (this as any) as CoordinatorRegistryContract; const self = this as any as CoordinatorRegistryContract;
const abiEncodedTransactionData = self._strictEncodeArguments('getCoordinatorEndpoint(address)', [ const abiEncodedTransactionData = self._strictEncodeArguments('getCoordinatorEndpoint(address)', [coordinatorOperator.toLowerCase()
coordinatorOperator.toLowerCase(), ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
private readonly _subscriptionManager: SubscriptionManager<CoordinatorRegistryEventArgs, CoordinatorRegistryEvents>; private readonly _subscriptionManager: SubscriptionManager<CoordinatorRegistryEventArgs, CoordinatorRegistryEvents>;
public static async deployFrom0xArtifactAsync( public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact, artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact }, logDecodeDependencies: { [contractName: string]: (ContractArtifact | SimpleContractArtifact) },
): Promise<CoordinatorRegistryContract> { ): Promise<CoordinatorRegistryContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -218,17 +231,8 @@ export class CoordinatorRegistryContract extends BaseContract {
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object; const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi; const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce( const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce((accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), {});
(accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), return CoordinatorRegistryContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly, );
{},
);
return CoordinatorRegistryContract.deployAsync(
bytecode,
abi,
provider,
txDefaults,
logDecodeDependenciesAbiOnly,
);
} }
public static async deployAsync( public static async deployAsync(
bytecode: string, bytecode: string,
@ -245,13 +249,17 @@ export class CoordinatorRegistryContract extends BaseContract {
]); ]);
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi); const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString); [] = BaseContract._formatABIDataItemList(
constructorAbi.inputs,
[],
BaseContract._bigNumberToString,
);
const iface = new ethers.utils.Interface(abi); const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction; const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, []); const txData = deployInfo.encode(bytecode, []);
const web3Wrapper = new Web3Wrapper(provider); const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ data: txData }, {data: txData},
txDefaults, txDefaults,
web3Wrapper.estimateGasAsync.bind(web3Wrapper), web3Wrapper.estimateGasAsync.bind(web3Wrapper),
); );
@ -259,16 +267,12 @@ export class CoordinatorRegistryContract extends BaseContract {
logUtils.log(`transactionHash: ${txHash}`); logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`CoordinatorRegistry successfully deployed at ${txReceipt.contractAddress}`); logUtils.log(`CoordinatorRegistry successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new CoordinatorRegistryContract( const contractInstance = new CoordinatorRegistryContract(txReceipt.contractAddress as string, provider, txDefaults, logDecodeDependencies);
txReceipt.contractAddress as string,
provider,
txDefaults,
logDecodeDependencies,
);
contractInstance.constructorArgs = []; contractInstance.constructorArgs = [];
return contractInstance; return contractInstance;
} }
/** /**
* @returns The contract ABI * @returns The contract ABI
*/ */
@ -283,7 +287,8 @@ export class CoordinatorRegistryContract extends BaseContract {
}, },
], ],
name: 'setCoordinatorEndpoint', name: 'setCoordinatorEndpoint',
outputs: [], outputs: [
],
payable: false, payable: false,
stateMutability: 'nonpayable', stateMutability: 'nonpayable',
type: 'function', type: 'function',
@ -308,8 +313,10 @@ export class CoordinatorRegistryContract extends BaseContract {
type: 'function', type: 'function',
}, },
{ {
inputs: [], inputs: [
outputs: [], ],
outputs: [
],
payable: false, payable: false,
stateMutability: 'nonpayable', stateMutability: 'nonpayable',
type: 'constructor', type: 'constructor',
@ -329,7 +336,8 @@ export class CoordinatorRegistryContract extends BaseContract {
}, },
], ],
name: 'CoordinatorEndpointSet', name: 'CoordinatorEndpointSet',
outputs: [], outputs: [
],
type: 'event', type: 'event',
}, },
] as ContractAbi; ] as ContractAbi;
@ -403,20 +411,8 @@ export class CoordinatorRegistryContract extends BaseContract {
); );
return logs; return logs;
} }
constructor( constructor(address: string, supportedProvider: SupportedProvider, txDefaults?: Partial<TxData>, logDecodeDependencies?: { [contractName: string]: ContractAbi }) {
address: string, super('CoordinatorRegistry', CoordinatorRegistryContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies);
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
) {
super(
'CoordinatorRegistry',
CoordinatorRegistryContract.ABI(),
address,
supportedProvider,
txDefaults,
logDecodeDependencies,
);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']); classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
this._subscriptionManager = new SubscriptionManager<CoordinatorRegistryEventArgs, CoordinatorRegistryEvents>( this._subscriptionManager = new SubscriptionManager<CoordinatorRegistryEventArgs, CoordinatorRegistryEvents>(
CoordinatorRegistryContract.ABI(), CoordinatorRegistryContract.ABI(),

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

671
packages/abi-gen-wrappers/src/generated-wrappers/dutch_auction.ts generated
View File

@ -1,7 +1,7 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma // tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace // tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable // tslint:disable:no-unused-variable
import { BaseContract, PromiseWithTransactionHash } from '@0x/base-contract'; import { BaseContract,PromiseWithTransactionHash } from '@0x/base-contract';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { import {
BlockParam, BlockParam,
@ -23,144 +23,91 @@ import { assert } from '@0x/assert';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
// tslint:enable:no-unused-variable // tslint:enable:no-unused-variable
/* istanbul ignore next */ /* istanbul ignore next */
// tslint:disable:no-parameter-reassignment // tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name // tslint:disable-next-line:class-name
export class DutchAuctionContract extends BaseContract { export class DutchAuctionContract extends BaseContract {
public getAuctionDetails = { public getAuctionDetails = {
async sendTransactionAsync( async sendTransactionAsync(
order: { order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string; txData?: Partial<TxData> | undefined,
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
txData?: Partial<TxData> | undefined,
): Promise<string> { ): Promise<string> {
const self = (this as any) as DutchAuctionContract;
const encodedData = self._strictEncodeArguments(
'getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))',
[order],
);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.getAuctionDetails.estimateGasAsync.bind(self, order),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); const self = this as any as DutchAuctionContract;
return txHash; const encodedData = self._strictEncodeArguments('getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))', [order
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.getAuctionDetails.estimateGasAsync.bind(
self,
order
),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
}, },
awaitTransactionSuccessAsync( awaitTransactionSuccessAsync(
order: { order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
txData?: Partial<TxData>, txData?: Partial<TxData>,
pollingIntervalMs?: number, pollingIntervalMs?: number,
timeoutMs?: number, timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> { ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
const self = (this as any) as DutchAuctionContract;
const txHashPromise = self.getAuctionDetails.sendTransactionAsync(order, txData); const self = this as any as DutchAuctionContract;
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>( const txHashPromise = self.getAuctionDetails.sendTransactionAsync(order
txHashPromise, , txData);
(async (): Promise<TransactionReceiptWithDecodedLogs> => { return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
// When the transaction hash resolves, wait for it to be mined. txHashPromise,
return self._web3Wrapper.awaitTransactionSuccessAsync( (async (): Promise<TransactionReceiptWithDecodedLogs> => {
await txHashPromise, // When the transaction hash resolves, wait for it to be mined.
pollingIntervalMs, return self._web3Wrapper.awaitTransactionSuccessAsync(
timeoutMs, await txHashPromise,
); pollingIntervalMs,
})(), timeoutMs,
); );
})(),
);
}, },
async estimateGasAsync( async estimateGasAsync(
order: { order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<number> { ): Promise<number> {
const self = (this as any) as DutchAuctionContract;
const encodedData = self._strictEncodeArguments(
'getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))',
[order],
);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); const self = this as any as DutchAuctionContract;
return gas; const encodedData = self._strictEncodeArguments('getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))', [order
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
}, },
async callAsync( async callAsync(
order: { order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ ): Promise<{beginTimeSeconds: BigNumber;endTimeSeconds: BigNumber;beginAmount: BigNumber;endAmount: BigNumber;currentAmount: BigNumber;currentTimeSeconds: BigNumber}
beginTimeSeconds: BigNumber; > {
endTimeSeconds: BigNumber;
beginAmount: BigNumber;
endAmount: BigNumber;
currentAmount: BigNumber;
currentTimeSeconds: BigNumber;
}> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
schemas.numberSchema, schemas.numberSchema,
@ -169,11 +116,9 @@ export class DutchAuctionContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as DutchAuctionContract; const self = this as any as DutchAuctionContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))', [order
'getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))', ]);
[order],
);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -182,266 +127,141 @@ export class DutchAuctionContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder( const abiEncoder = self._lookupAbiEncoder('getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))');
'getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))',
);
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<{ const result = abiEncoder.strictDecodeReturnValue<{beginTimeSeconds: BigNumber;endTimeSeconds: BigNumber;beginAmount: BigNumber;endAmount: BigNumber;currentAmount: BigNumber;currentTimeSeconds: BigNumber}
beginTimeSeconds: BigNumber; >(rawCallResult);
endTimeSeconds: BigNumber;
beginAmount: BigNumber;
endAmount: BigNumber;
currentAmount: BigNumber;
currentTimeSeconds: BigNumber;
}>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(order: { getABIEncodedTransactionData(
makerAddress: string; order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
takerAddress: string; ): string {
feeRecipientAddress: string;
senderAddress: string; const self = this as any as DutchAuctionContract;
makerAssetAmount: BigNumber; const abiEncodedTransactionData = self._strictEncodeArguments('getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))', [order
takerAssetAmount: BigNumber; ]);
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
}): string {
const self = (this as any) as DutchAuctionContract;
const abiEncodedTransactionData = self._strictEncodeArguments(
'getAuctionDetails((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes))',
[order],
);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public matchOrders = { public matchOrders = {
async sendTransactionAsync( async sendTransactionAsync(
buyOrder: { buyOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string; sellOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
sellOrder: {
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
buySignature: string, buySignature: string,
sellSignature: string, sellSignature: string,
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<string> { ): Promise<string> {
assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature);
const self = (this as any) as DutchAuctionContract;
const encodedData = self._strictEncodeArguments(
'matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)',
[buyOrder, sellOrder, buySignature, sellSignature],
);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.matchOrders.estimateGasAsync.bind(self, buyOrder, sellOrder, buySignature, sellSignature),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash; assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature);
const self = this as any as DutchAuctionContract;
const encodedData = self._strictEncodeArguments('matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)', [buyOrder,
sellOrder,
buySignature,
sellSignature
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.matchOrders.estimateGasAsync.bind(
self,
buyOrder,
sellOrder,
buySignature,
sellSignature
),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
}, },
awaitTransactionSuccessAsync( awaitTransactionSuccessAsync(
buyOrder: { buyOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string; sellOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
sellOrder: {
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
buySignature: string, buySignature: string,
sellSignature: string, sellSignature: string,
txData?: Partial<TxData>, txData?: Partial<TxData>,
pollingIntervalMs?: number, pollingIntervalMs?: number,
timeoutMs?: number, timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> { ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature);
const self = (this as any) as DutchAuctionContract; assert.isString('buySignature', buySignature);
const txHashPromise = self.matchOrders.sendTransactionAsync( assert.isString('sellSignature', sellSignature);
buyOrder, const self = this as any as DutchAuctionContract;
sellOrder, const txHashPromise = self.matchOrders.sendTransactionAsync(buyOrder,
buySignature, sellOrder,
sellSignature, buySignature,
txData, sellSignature
); , txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>( return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise, txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => { (async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined. // When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync( return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise, await txHashPromise,
pollingIntervalMs, pollingIntervalMs,
timeoutMs, timeoutMs,
); );
})(), })(),
); );
}, },
async estimateGasAsync( async estimateGasAsync(
buyOrder: { buyOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string; sellOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
sellOrder: {
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
buySignature: string, buySignature: string,
sellSignature: string, sellSignature: string,
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<number> { ): Promise<number> {
assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature);
const self = (this as any) as DutchAuctionContract;
const encodedData = self._strictEncodeArguments(
'matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)',
[buyOrder, sellOrder, buySignature, sellSignature],
);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas; assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature);
const self = this as any as DutchAuctionContract;
const encodedData = self._strictEncodeArguments('matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)', [buyOrder,
sellOrder,
buySignature,
sellSignature
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
}, },
async callAsync( async callAsync(
buyOrder: { buyOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string; sellOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
sellOrder: {
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
buySignature: string, buySignature: string,
sellSignature: string, sellSignature: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ ): Promise<{left: {makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber};right: {makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber};leftMakerAssetSpreadAmount: BigNumber}
left: { > {
makerAssetFilledAmount: BigNumber;
takerAssetFilledAmount: BigNumber;
makerFeePaid: BigNumber;
takerFeePaid: BigNumber;
};
right: {
makerAssetFilledAmount: BigNumber;
takerAssetFilledAmount: BigNumber;
makerFeePaid: BigNumber;
takerFeePaid: BigNumber;
};
leftMakerAssetSpreadAmount: BigNumber;
}> {
assert.isString('buySignature', buySignature); assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature); assert.isString('sellSignature', sellSignature);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -452,11 +272,12 @@ export class DutchAuctionContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as DutchAuctionContract; const self = this as any as DutchAuctionContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)', [buyOrder,
'matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)', sellOrder,
[buyOrder, sellOrder, buySignature, sellSignature], buySignature,
); sellSignature
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -465,82 +286,42 @@ export class DutchAuctionContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder( const abiEncoder = self._lookupAbiEncoder('matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)');
'matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)',
);
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<{ const result = abiEncoder.strictDecodeReturnValue<{left: {makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber};right: {makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber};leftMakerAssetSpreadAmount: BigNumber}
left: { >(rawCallResult);
makerAssetFilledAmount: BigNumber;
takerAssetFilledAmount: BigNumber;
makerFeePaid: BigNumber;
takerFeePaid: BigNumber;
};
right: {
makerAssetFilledAmount: BigNumber;
takerAssetFilledAmount: BigNumber;
makerFeePaid: BigNumber;
takerFeePaid: BigNumber;
};
leftMakerAssetSpreadAmount: BigNumber;
}>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData( getABIEncodedTransactionData(
buyOrder: { buyOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string; sellOrder: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
takerAddress: string; buySignature: string,
feeRecipientAddress: string; sellSignature: string,
senderAddress: string; ): string {
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
sellOrder: {
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
buySignature: string,
sellSignature: string,
): string {
assert.isString('buySignature', buySignature); assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature); assert.isString('sellSignature', sellSignature);
const self = (this as any) as DutchAuctionContract; const self = this as any as DutchAuctionContract;
const abiEncodedTransactionData = self._strictEncodeArguments( const abiEncodedTransactionData = self._strictEncodeArguments('matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)', [buyOrder,
'matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),bytes,bytes)', sellOrder,
[buyOrder, sellOrder, buySignature, sellSignature], buySignature,
); sellSignature
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public static async deployFrom0xArtifactAsync( public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact, artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact }, logDecodeDependencies: { [contractName: string]: (ContractArtifact | SimpleContractArtifact) },
_exchange: string, _exchange: string,
): Promise<DutchAuctionContract> { ): Promise<DutchAuctionContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -553,18 +334,9 @@ export class DutchAuctionContract extends BaseContract {
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object; const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi; const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce( const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce((accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), {});
(accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), return DutchAuctionContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly, _exchange
{}, );
);
return DutchAuctionContract.deployAsync(
bytecode,
abi,
provider,
txDefaults,
logDecodeDependenciesAbiOnly,
_exchange,
);
} }
public static async deployAsync( public static async deployAsync(
bytecode: string, bytecode: string,
@ -572,7 +344,7 @@ export class DutchAuctionContract extends BaseContract {
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractAbi }, logDecodeDependencies: { [contractName: string]: ContractAbi },
_exchange: string, _exchange: string,
): Promise<DutchAuctionContract> { ): Promise<DutchAuctionContract> {
assert.isHexString('bytecode', bytecode); assert.isHexString('bytecode', bytecode);
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
@ -582,17 +354,20 @@ export class DutchAuctionContract extends BaseContract {
]); ]);
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi); const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[_exchange] = BaseContract._formatABIDataItemList( [_exchange
] = BaseContract._formatABIDataItemList(
constructorAbi.inputs, constructorAbi.inputs,
[_exchange], [_exchange
],
BaseContract._bigNumberToString, BaseContract._bigNumberToString,
); );
const iface = new ethers.utils.Interface(abi); const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction; const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, [_exchange]); const txData = deployInfo.encode(bytecode, [_exchange
]);
const web3Wrapper = new Web3Wrapper(provider); const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ data: txData }, {data: txData},
txDefaults, txDefaults,
web3Wrapper.estimateGasAsync.bind(web3Wrapper), web3Wrapper.estimateGasAsync.bind(web3Wrapper),
); );
@ -600,16 +375,13 @@ export class DutchAuctionContract extends BaseContract {
logUtils.log(`transactionHash: ${txHash}`); logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`DutchAuction successfully deployed at ${txReceipt.contractAddress}`); logUtils.log(`DutchAuction successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new DutchAuctionContract( const contractInstance = new DutchAuctionContract(txReceipt.contractAddress as string, provider, txDefaults, logDecodeDependencies);
txReceipt.contractAddress as string, contractInstance.constructorArgs = [_exchange
provider, ];
txDefaults,
logDecodeDependencies,
);
contractInstance.constructorArgs = [_exchange];
return contractInstance; return contractInstance;
} }
/** /**
* @returns The contract ABI * @returns The contract ABI
*/ */
@ -670,7 +442,7 @@ export class DutchAuctionContract extends BaseContract {
name: 'takerAssetData', name: 'takerAssetData',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
], ],
name: 'getAuctionDetails', name: 'getAuctionDetails',
@ -703,7 +475,7 @@ export class DutchAuctionContract extends BaseContract {
name: 'currentTimeSeconds', name: 'currentTimeSeconds',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
], ],
payable: false, payable: false,
@ -765,7 +537,7 @@ export class DutchAuctionContract extends BaseContract {
name: 'takerAssetData', name: 'takerAssetData',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
{ {
name: 'sellOrder', name: 'sellOrder',
@ -819,7 +591,7 @@ export class DutchAuctionContract extends BaseContract {
name: 'takerAssetData', name: 'takerAssetData',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
{ {
name: 'buySignature', name: 'buySignature',
@ -856,7 +628,7 @@ export class DutchAuctionContract extends BaseContract {
name: 'takerFeePaid', name: 'takerFeePaid',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
{ {
name: 'right', name: 'right',
@ -878,13 +650,13 @@ export class DutchAuctionContract extends BaseContract {
name: 'takerFeePaid', name: 'takerFeePaid',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
{ {
name: 'leftMakerAssetSpreadAmount', name: 'leftMakerAssetSpreadAmount',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
], ],
payable: false, payable: false,
@ -898,7 +670,8 @@ export class DutchAuctionContract extends BaseContract {
type: 'address', type: 'address',
}, },
], ],
outputs: [], outputs: [
],
payable: false, payable: false,
stateMutability: 'nonpayable', stateMutability: 'nonpayable',
type: 'constructor', type: 'constructor',
@ -906,20 +679,8 @@ export class DutchAuctionContract extends BaseContract {
] as ContractAbi; ] as ContractAbi;
return abi; return abi;
} }
constructor( constructor(address: string, supportedProvider: SupportedProvider, txDefaults?: Partial<TxData>, logDecodeDependencies?: { [contractName: string]: ContractAbi }) {
address: string, super('DutchAuction', DutchAuctionContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies);
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
) {
super(
'DutchAuction',
DutchAuctionContract.ABI(),
address,
supportedProvider,
txDefaults,
logDecodeDependencies,
);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']); classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
} }
} }

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

File diff suppressed because it is too large Load Diff

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

@ -1,14 +1,11 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma // tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace // tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable // tslint:disable:no-unused-variable
import { import { BaseContract,
BaseContract,
BlockRange, BlockRange,
EventCallback, EventCallback,
IndexedFilterValues, IndexedFilterValues,
SubscriptionManager, SubscriptionManager,PromiseWithTransactionHash } from '@0x/base-contract';
PromiseWithTransactionHash,
} from '@0x/base-contract';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { import {
BlockParam, BlockParam,
@ -31,7 +28,9 @@ import { assert } from '@0x/assert';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
// tslint:enable:no-unused-variable // tslint:enable:no-unused-variable
export type ERC20TokenEventArgs = ERC20TokenTransferEventArgs | ERC20TokenApprovalEventArgs; export type ERC20TokenEventArgs =
| ERC20TokenTransferEventArgs
| ERC20TokenApprovalEventArgs;
export enum ERC20TokenEvents { export enum ERC20TokenEvents {
Transfer = 'Transfer', Transfer = 'Transfer',
@ -50,6 +49,7 @@ export interface ERC20TokenApprovalEventArgs extends DecodedLogArgs {
_value: BigNumber; _value: BigNumber;
} }
/* istanbul ignore next */ /* istanbul ignore next */
// tslint:disable:no-parameter-reassignment // tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name // tslint:disable-next-line:class-name
@ -58,30 +58,33 @@ export class ERC20TokenContract extends BaseContract {
async sendTransactionAsync( async sendTransactionAsync(
_spender: string, _spender: string,
_value: BigNumber, _value: BigNumber,
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<string> { ): Promise<string> {
assert.isString('_spender', _spender); assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [ const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender.toLowerCase(),
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_spender.toLowerCase(), _spender.toLowerCase(),
_value, _value
]); ),
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( );
{ if (txDataWithDefaults.from !== undefined) {
to: self.address, txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
...txData, }
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(self, _spender.toLowerCase(), _value),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash; return txHash;
}, },
awaitTransactionSuccessAsync( awaitTransactionSuccessAsync(
_spender: string, _spender: string,
@ -90,55 +93,57 @@ export class ERC20TokenContract extends BaseContract {
pollingIntervalMs?: number, pollingIntervalMs?: number,
timeoutMs?: number, timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> { ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_spender', _spender); assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_spender.toLowerCase(), _value, txData); const txHashPromise = self.approve.sendTransactionAsync(_spender.toLowerCase(),
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>( _value
txHashPromise, , txData);
(async (): Promise<TransactionReceiptWithDecodedLogs> => { return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
// When the transaction hash resolves, wait for it to be mined. txHashPromise,
return self._web3Wrapper.awaitTransactionSuccessAsync( (async (): Promise<TransactionReceiptWithDecodedLogs> => {
await txHashPromise, // When the transaction hash resolves, wait for it to be mined.
pollingIntervalMs, return self._web3Wrapper.awaitTransactionSuccessAsync(
timeoutMs, await txHashPromise,
); pollingIntervalMs,
})(), timeoutMs,
); );
})(),
);
}, },
async estimateGasAsync( async estimateGasAsync(
_spender: string, _spender: string,
_value: BigNumber, _value: BigNumber,
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<number> { ): Promise<number> {
assert.isString('_spender', _spender); assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [ const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender.toLowerCase(),
_spender.toLowerCase(), _value
_value, ]);
]); const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( {
{ to: self.address,
to: self.address, ...txData,
...txData, data: encodedData,
data: encodedData, },
}, self._web3Wrapper.getContractDefaults(),
self._web3Wrapper.getContractDefaults(), );
); if (txDataWithDefaults.from !== undefined) {
if (txDataWithDefaults.from !== undefined) { txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase(); }
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas; return gas;
}, },
async callAsync( async callAsync(
_spender: string, _spender: string,
_value: BigNumber, _value: BigNumber,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<boolean> { ): Promise<boolean
> {
assert.isString('_spender', _spender); assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -149,11 +154,10 @@ export class ERC20TokenContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [ const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender.toLowerCase(),
_spender.toLowerCase(), _value
_value, ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -162,31 +166,36 @@ export class ERC20TokenContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)'); const abiEncoder = self._lookupAbiEncoder('approve(address,uint256)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<boolean
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(_spender: string, _value: BigNumber): string { getABIEncodedTransactionData(
_spender: string,
_value: BigNumber,
): string {
assert.isString('_spender', _spender); assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [ const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_spender.toLowerCase(),
_spender.toLowerCase(), _value
_value, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public totalSupply = { public totalSupply = {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(
callData: Partial<CallData> = {},
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
schemas.numberSchema, schemas.numberSchema,
@ -195,7 +204,7 @@ export class ERC20TokenContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('totalSupply()', []); const encodedData = self._strictEncodeArguments('totalSupply()', []);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
@ -205,20 +214,20 @@ export class ERC20TokenContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('totalSupply()'); const abiEncoder = self._lookupAbiEncoder('totalSupply()');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<BigNumber
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(): string { getABIEncodedTransactionData(
const self = (this as any) as ERC20TokenContract; ): string {
const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('totalSupply()', []); const abiEncodedTransactionData = self._strictEncodeArguments('totalSupply()', []);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
@ -228,32 +237,36 @@ export class ERC20TokenContract extends BaseContract {
_from: string, _from: string,
_to: string, _to: string,
_value: BigNumber, _value: BigNumber,
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<string> { ): Promise<string> {
assert.isString('_from', _from); assert.isString('_from', _from);
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [ const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from.toLowerCase(),
_to.toLowerCase(),
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from.toLowerCase(), _from.toLowerCase(),
_to.toLowerCase(), _to.toLowerCase(),
_value, _value
]); ),
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( );
{ if (txDataWithDefaults.from !== undefined) {
to: self.address, txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
...txData, }
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(self, _from.toLowerCase(), _to.toLowerCase(), _value),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash; return txHash;
}, },
awaitTransactionSuccessAsync( awaitTransactionSuccessAsync(
_from: string, _from: string,
@ -263,27 +276,25 @@ export class ERC20TokenContract extends BaseContract {
pollingIntervalMs?: number, pollingIntervalMs?: number,
timeoutMs?: number, timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> { ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_from', _from); assert.isString('_from', _from);
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync( const txHashPromise = self.transferFrom.sendTransactionAsync(_from.toLowerCase(),
_from.toLowerCase(), _to.toLowerCase(),
_to.toLowerCase(), _value
_value, , txData);
txData, return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
); txHashPromise,
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>( (async (): Promise<TransactionReceiptWithDecodedLogs> => {
txHashPromise, // When the transaction hash resolves, wait for it to be mined.
(async (): Promise<TransactionReceiptWithDecodedLogs> => { return self._web3Wrapper.awaitTransactionSuccessAsync(
// When the transaction hash resolves, wait for it to be mined. await txHashPromise,
return self._web3Wrapper.awaitTransactionSuccessAsync( pollingIntervalMs,
await txHashPromise, timeoutMs,
pollingIntervalMs, );
timeoutMs, })(),
); );
})(),
);
}, },
async estimateGasAsync( async estimateGasAsync(
_from: string, _from: string,
@ -291,29 +302,28 @@ export class ERC20TokenContract extends BaseContract {
_value: BigNumber, _value: BigNumber,
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<number> { ): Promise<number> {
assert.isString('_from', _from); assert.isString('_from', _from);
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [ const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from.toLowerCase(),
_from.toLowerCase(), _to.toLowerCase(),
_to.toLowerCase(), _value
_value, ]);
]); const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( {
{ to: self.address,
to: self.address, ...txData,
...txData, data: encodedData,
data: encodedData, },
}, self._web3Wrapper.getContractDefaults(),
self._web3Wrapper.getContractDefaults(), );
); if (txDataWithDefaults.from !== undefined) {
if (txDataWithDefaults.from !== undefined) { txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase(); }
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas; return gas;
}, },
async callAsync( async callAsync(
_from: string, _from: string,
@ -321,7 +331,8 @@ export class ERC20TokenContract extends BaseContract {
_value: BigNumber, _value: BigNumber,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<boolean> { ): Promise<boolean
> {
assert.isString('_from', _from); assert.isString('_from', _from);
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
@ -333,12 +344,11 @@ export class ERC20TokenContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [ const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from.toLowerCase(),
_from.toLowerCase(), _to.toLowerCase(),
_to.toLowerCase(), _value
_value, ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -347,28 +357,30 @@ export class ERC20TokenContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)'); const abiEncoder = self._lookupAbiEncoder('transferFrom(address,address,uint256)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<boolean
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(_from: string, _to: string, _value: BigNumber): string { getABIEncodedTransactionData(
_from: string,
_to: string,
_value: BigNumber,
): string {
assert.isString('_from', _from); assert.isString('_from', _from);
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [ const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from.toLowerCase(),
_from.toLowerCase(), _to.toLowerCase(),
_to.toLowerCase(), _value
_value, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
@ -377,7 +389,8 @@ export class ERC20TokenContract extends BaseContract {
_owner: string, _owner: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<BigNumber> { ): Promise<BigNumber
> {
assert.isString('_owner', _owner); assert.isString('_owner', _owner);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -387,8 +400,9 @@ export class ERC20TokenContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('balanceOf(address)', [_owner.toLowerCase()]); const encodedData = self._strictEncodeArguments('balanceOf(address)', [_owner.toLowerCase()
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -397,22 +411,24 @@ export class ERC20TokenContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('balanceOf(address)'); const abiEncoder = self._lookupAbiEncoder('balanceOf(address)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<BigNumber
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(_owner: string): string { getABIEncodedTransactionData(
_owner: string,
): string {
assert.isString('_owner', _owner); assert.isString('_owner', _owner);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('balanceOf(address)', [_owner.toLowerCase()]); const abiEncodedTransactionData = self._strictEncodeArguments('balanceOf(address)', [_owner.toLowerCase()
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
@ -420,27 +436,33 @@ export class ERC20TokenContract extends BaseContract {
async sendTransactionAsync( async sendTransactionAsync(
_to: string, _to: string,
_value: BigNumber, _value: BigNumber,
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<string> { ): Promise<string> {
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to.toLowerCase(), _value]); const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to.toLowerCase(),
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( _value
{ ]);
to: self.address, const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
...txData, {
data: encodedData, to: self.address,
}, ...txData,
self._web3Wrapper.getContractDefaults(), data: encodedData,
self.transfer.estimateGasAsync.bind(self, _to.toLowerCase(), _value), },
); self._web3Wrapper.getContractDefaults(),
if (txDataWithDefaults.from !== undefined) { self.transfer.estimateGasAsync.bind(
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase(); self,
} _to.toLowerCase(),
_value
),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults); const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash; return txHash;
}, },
awaitTransactionSuccessAsync( awaitTransactionSuccessAsync(
_to: string, _to: string,
@ -449,48 +471,57 @@ export class ERC20TokenContract extends BaseContract {
pollingIntervalMs?: number, pollingIntervalMs?: number,
timeoutMs?: number, timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> { ): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const txHashPromise = self.transfer.sendTransactionAsync(_to.toLowerCase(), _value, txData); const txHashPromise = self.transfer.sendTransactionAsync(_to.toLowerCase(),
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>( _value
txHashPromise, , txData);
(async (): Promise<TransactionReceiptWithDecodedLogs> => { return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
// When the transaction hash resolves, wait for it to be mined. txHashPromise,
return self._web3Wrapper.awaitTransactionSuccessAsync( (async (): Promise<TransactionReceiptWithDecodedLogs> => {
await txHashPromise, // When the transaction hash resolves, wait for it to be mined.
pollingIntervalMs, return self._web3Wrapper.awaitTransactionSuccessAsync(
timeoutMs, await txHashPromise,
); pollingIntervalMs,
})(), timeoutMs,
); );
})(),
);
}, },
async estimateGasAsync(_to: string, _value: BigNumber, txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(
assert.isString('_to', _to); _to: string,
assert.isBigNumber('_value', _value); _value: BigNumber,
const self = (this as any) as ERC20TokenContract; txData?: Partial<TxData> | undefined,
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to.toLowerCase(), _value]); ): Promise<number> {
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( assert.isString('_to', _to);
{ assert.isBigNumber('_value', _value);
to: self.address, const self = this as any as ERC20TokenContract;
...txData, const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to.toLowerCase(),
data: encodedData, _value
}, ]);
self._web3Wrapper.getContractDefaults(), const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
); {
if (txDataWithDefaults.from !== undefined) { to: self.address,
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase(); ...txData,
} data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
if (txDataWithDefaults.from !== undefined) {
txDataWithDefaults.from = txDataWithDefaults.from.toLowerCase();
}
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults); const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas; return gas;
}, },
async callAsync( async callAsync(
_to: string, _to: string,
_value: BigNumber, _value: BigNumber,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<boolean> { ): Promise<boolean
> {
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -501,8 +532,10 @@ export class ERC20TokenContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to.toLowerCase(), _value]); const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to.toLowerCase(),
_value
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -511,26 +544,27 @@ export class ERC20TokenContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)'); const abiEncoder = self._lookupAbiEncoder('transfer(address,uint256)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<boolean
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(_to: string, _value: BigNumber): string { getABIEncodedTransactionData(
_to: string,
_value: BigNumber,
): string {
assert.isString('_to', _to); assert.isString('_to', _to);
assert.isBigNumber('_value', _value); assert.isBigNumber('_value', _value);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [ const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [_to.toLowerCase(),
_to.toLowerCase(), _value
_value, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
@ -540,7 +574,8 @@ export class ERC20TokenContract extends BaseContract {
_spender: string, _spender: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<BigNumber> { ): Promise<BigNumber
> {
assert.isString('_owner', _owner); assert.isString('_owner', _owner);
assert.isString('_spender', _spender); assert.isString('_spender', _spender);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -551,11 +586,10 @@ export class ERC20TokenContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('allowance(address,address)', [ const encodedData = self._strictEncodeArguments('allowance(address,address)', [_owner.toLowerCase(),
_owner.toLowerCase(), _spender.toLowerCase()
_spender.toLowerCase(), ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -564,35 +598,36 @@ export class ERC20TokenContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('allowance(address,address)'); const abiEncoder = self._lookupAbiEncoder('allowance(address,address)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<BigNumber
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(_owner: string, _spender: string): string { getABIEncodedTransactionData(
_owner: string,
_spender: string,
): string {
assert.isString('_owner', _owner); assert.isString('_owner', _owner);
assert.isString('_spender', _spender); assert.isString('_spender', _spender);
const self = (this as any) as ERC20TokenContract; const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('allowance(address,address)', [ const abiEncodedTransactionData = self._strictEncodeArguments('allowance(address,address)', [_owner.toLowerCase(),
_owner.toLowerCase(), _spender.toLowerCase()
_spender.toLowerCase(), ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
private readonly _subscriptionManager: SubscriptionManager<ERC20TokenEventArgs, ERC20TokenEvents>; private readonly _subscriptionManager: SubscriptionManager<ERC20TokenEventArgs, ERC20TokenEvents>;
public static async deployFrom0xArtifactAsync( public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact, artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact }, logDecodeDependencies: { [contractName: string]: (ContractArtifact | SimpleContractArtifact) },
): Promise<ERC20TokenContract> { ): Promise<ERC20TokenContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -605,11 +640,8 @@ export class ERC20TokenContract extends BaseContract {
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object; const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi; const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce( const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce((accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), {});
(accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), return ERC20TokenContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly, );
{},
);
return ERC20TokenContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly);
} }
public static async deployAsync( public static async deployAsync(
bytecode: string, bytecode: string,
@ -626,13 +658,17 @@ export class ERC20TokenContract extends BaseContract {
]); ]);
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi); const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString); [] = BaseContract._formatABIDataItemList(
constructorAbi.inputs,
[],
BaseContract._bigNumberToString,
);
const iface = new ethers.utils.Interface(abi); const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction; const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, []); const txData = deployInfo.encode(bytecode, []);
const web3Wrapper = new Web3Wrapper(provider); const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ data: txData }, {data: txData},
txDefaults, txDefaults,
web3Wrapper.estimateGasAsync.bind(web3Wrapper), web3Wrapper.estimateGasAsync.bind(web3Wrapper),
); );
@ -640,16 +676,12 @@ export class ERC20TokenContract extends BaseContract {
logUtils.log(`transactionHash: ${txHash}`); logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`ERC20Token successfully deployed at ${txReceipt.contractAddress}`); logUtils.log(`ERC20Token successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new ERC20TokenContract( const contractInstance = new ERC20TokenContract(txReceipt.contractAddress as string, provider, txDefaults, logDecodeDependencies);
txReceipt.contractAddress as string,
provider,
txDefaults,
logDecodeDependencies,
);
contractInstance.constructorArgs = []; contractInstance.constructorArgs = [];
return contractInstance; return contractInstance;
} }
/** /**
* @returns The contract ABI * @returns The contract ABI
*/ */
@ -680,7 +712,8 @@ export class ERC20TokenContract extends BaseContract {
}, },
{ {
constant: true, constant: true,
inputs: [], inputs: [
],
name: 'totalSupply', name: 'totalSupply',
outputs: [ outputs: [
{ {
@ -804,7 +837,8 @@ export class ERC20TokenContract extends BaseContract {
}, },
], ],
name: 'Transfer', name: 'Transfer',
outputs: [], outputs: [
],
type: 'event', type: 'event',
}, },
{ {
@ -827,7 +861,8 @@ export class ERC20TokenContract extends BaseContract {
}, },
], ],
name: 'Approval', name: 'Approval',
outputs: [], outputs: [
],
type: 'event', type: 'event',
}, },
] as ContractAbi; ] as ContractAbi;
@ -901,12 +936,7 @@ export class ERC20TokenContract extends BaseContract {
); );
return logs; return logs;
} }
constructor( constructor(address: string, supportedProvider: SupportedProvider, txDefaults?: Partial<TxData>, logDecodeDependencies?: { [contractName: string]: ContractAbi }) {
address: string,
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
) {
super('ERC20Token', ERC20TokenContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies); super('ERC20Token', ERC20TokenContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']); classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
this._subscriptionManager = new SubscriptionManager<ERC20TokenEventArgs, ERC20TokenEvents>( this._subscriptionManager = new SubscriptionManager<ERC20TokenEventArgs, ERC20TokenEvents>(

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

70
packages/abi-gen-wrappers/src/generated-wrappers/eth_balance_checker.ts generated
View File

@ -1,7 +1,7 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma // tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace // tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable // tslint:disable:no-unused-variable
import { BaseContract, PromiseWithTransactionHash } from '@0x/base-contract'; import { BaseContract,PromiseWithTransactionHash } from '@0x/base-contract';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { import {
BlockParam, BlockParam,
@ -23,6 +23,7 @@ import { assert } from '@0x/assert';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
// tslint:enable:no-unused-variable // tslint:enable:no-unused-variable
/* istanbul ignore next */ /* istanbul ignore next */
// tslint:disable:no-parameter-reassignment // tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name // tslint:disable-next-line:class-name
@ -32,7 +33,8 @@ export class EthBalanceCheckerContract extends BaseContract {
addresses: string[], addresses: string[],
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<BigNumber[]> { ): Promise<BigNumber[]
> {
assert.isArray('addresses', addresses); assert.isArray('addresses', addresses);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -42,8 +44,9 @@ export class EthBalanceCheckerContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as EthBalanceCheckerContract; const self = this as any as EthBalanceCheckerContract;
const encodedData = self._strictEncodeArguments('getEthBalances(address[])', [addresses]); const encodedData = self._strictEncodeArguments('getEthBalances(address[])', [addresses
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -52,30 +55,32 @@ export class EthBalanceCheckerContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('getEthBalances(address[])'); const abiEncoder = self._lookupAbiEncoder('getEthBalances(address[])');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<BigNumber[]
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(addresses: string[]): string { getABIEncodedTransactionData(
addresses: string[],
): string {
assert.isArray('addresses', addresses); assert.isArray('addresses', addresses);
const self = (this as any) as EthBalanceCheckerContract; const self = this as any as EthBalanceCheckerContract;
const abiEncodedTransactionData = self._strictEncodeArguments('getEthBalances(address[])', [addresses]); const abiEncodedTransactionData = self._strictEncodeArguments('getEthBalances(address[])', [addresses
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public static async deployFrom0xArtifactAsync( public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact, artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact }, logDecodeDependencies: { [contractName: string]: (ContractArtifact | SimpleContractArtifact) },
): Promise<EthBalanceCheckerContract> { ): Promise<EthBalanceCheckerContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -88,11 +93,8 @@ export class EthBalanceCheckerContract extends BaseContract {
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object; const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi; const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce( const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce((accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), {});
(accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), return EthBalanceCheckerContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly, );
{},
);
return EthBalanceCheckerContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly);
} }
public static async deployAsync( public static async deployAsync(
bytecode: string, bytecode: string,
@ -109,13 +111,17 @@ export class EthBalanceCheckerContract extends BaseContract {
]); ]);
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi); const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString); [] = BaseContract._formatABIDataItemList(
constructorAbi.inputs,
[],
BaseContract._bigNumberToString,
);
const iface = new ethers.utils.Interface(abi); const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction; const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, []); const txData = deployInfo.encode(bytecode, []);
const web3Wrapper = new Web3Wrapper(provider); const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ data: txData }, {data: txData},
txDefaults, txDefaults,
web3Wrapper.estimateGasAsync.bind(web3Wrapper), web3Wrapper.estimateGasAsync.bind(web3Wrapper),
); );
@ -123,16 +129,12 @@ export class EthBalanceCheckerContract extends BaseContract {
logUtils.log(`transactionHash: ${txHash}`); logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`EthBalanceChecker successfully deployed at ${txReceipt.contractAddress}`); logUtils.log(`EthBalanceChecker successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new EthBalanceCheckerContract( const contractInstance = new EthBalanceCheckerContract(txReceipt.contractAddress as string, provider, txDefaults, logDecodeDependencies);
txReceipt.contractAddress as string,
provider,
txDefaults,
logDecodeDependencies,
);
contractInstance.constructorArgs = []; contractInstance.constructorArgs = [];
return contractInstance; return contractInstance;
} }
/** /**
* @returns The contract ABI * @returns The contract ABI
*/ */
@ -160,20 +162,8 @@ export class EthBalanceCheckerContract extends BaseContract {
] as ContractAbi; ] as ContractAbi;
return abi; return abi;
} }
constructor( constructor(address: string, supportedProvider: SupportedProvider, txDefaults?: Partial<TxData>, logDecodeDependencies?: { [contractName: string]: ContractAbi }) {
address: string, super('EthBalanceChecker', EthBalanceCheckerContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies);
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
) {
super(
'EthBalanceChecker',
EthBalanceCheckerContract.ABI(),
address,
supportedProvider,
txDefaults,
logDecodeDependencies,
);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']); classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
} }
} }

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

854
packages/abi-gen-wrappers/src/generated-wrappers/i_asset_proxy.ts generated
View File

File diff suppressed because it is too large Load Diff

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

@ -1,7 +1,7 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma // tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace // tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable // tslint:disable:no-unused-variable
import { BaseContract, PromiseWithTransactionHash } from '@0x/base-contract'; import { BaseContract,PromiseWithTransactionHash } from '@0x/base-contract';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { import {
BlockParam, BlockParam,
@ -23,6 +23,7 @@ import { assert } from '@0x/assert';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
// tslint:enable:no-unused-variable // tslint:enable:no-unused-variable
/* istanbul ignore next */ /* istanbul ignore next */
// tslint:disable:no-parameter-reassignment // tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name // tslint:disable-next-line:class-name
@ -34,7 +35,8 @@ export class IValidatorContract extends BaseContract {
signature: string, signature: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<boolean> { ): Promise<boolean
> {
assert.isString('hash', hash); assert.isString('hash', hash);
assert.isString('signerAddress', signerAddress); assert.isString('signerAddress', signerAddress);
assert.isString('signature', signature); assert.isString('signature', signature);
@ -46,12 +48,11 @@ export class IValidatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as IValidatorContract; const self = this as any as IValidatorContract;
const encodedData = self._strictEncodeArguments('isValidSignature(bytes32,address,bytes)', [ const encodedData = self._strictEncodeArguments('isValidSignature(bytes32,address,bytes)', [hash,
hash, signerAddress.toLowerCase(),
signerAddress.toLowerCase(), signature
signature, ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -60,36 +61,38 @@ export class IValidatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('isValidSignature(bytes32,address,bytes)'); const abiEncoder = self._lookupAbiEncoder('isValidSignature(bytes32,address,bytes)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<boolean
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(hash: string, signerAddress: string, signature: string): string { getABIEncodedTransactionData(
hash: string,
signerAddress: string,
signature: string,
): string {
assert.isString('hash', hash); assert.isString('hash', hash);
assert.isString('signerAddress', signerAddress); assert.isString('signerAddress', signerAddress);
assert.isString('signature', signature); assert.isString('signature', signature);
const self = (this as any) as IValidatorContract; const self = this as any as IValidatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('isValidSignature(bytes32,address,bytes)', [ const abiEncodedTransactionData = self._strictEncodeArguments('isValidSignature(bytes32,address,bytes)', [hash,
hash, signerAddress.toLowerCase(),
signerAddress.toLowerCase(), signature
signature, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public static async deployFrom0xArtifactAsync( public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact, artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact }, logDecodeDependencies: { [contractName: string]: (ContractArtifact | SimpleContractArtifact) },
): Promise<IValidatorContract> { ): Promise<IValidatorContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -102,11 +105,8 @@ export class IValidatorContract extends BaseContract {
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object; const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi; const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce( const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce((accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), {});
(accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), return IValidatorContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly, );
{},
);
return IValidatorContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly);
} }
public static async deployAsync( public static async deployAsync(
bytecode: string, bytecode: string,
@ -123,13 +123,17 @@ export class IValidatorContract extends BaseContract {
]); ]);
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi); const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString); [] = BaseContract._formatABIDataItemList(
constructorAbi.inputs,
[],
BaseContract._bigNumberToString,
);
const iface = new ethers.utils.Interface(abi); const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction; const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, []); const txData = deployInfo.encode(bytecode, []);
const web3Wrapper = new Web3Wrapper(provider); const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ data: txData }, {data: txData},
txDefaults, txDefaults,
web3Wrapper.estimateGasAsync.bind(web3Wrapper), web3Wrapper.estimateGasAsync.bind(web3Wrapper),
); );
@ -137,16 +141,12 @@ export class IValidatorContract extends BaseContract {
logUtils.log(`transactionHash: ${txHash}`); logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`IValidator successfully deployed at ${txReceipt.contractAddress}`); logUtils.log(`IValidator successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new IValidatorContract( const contractInstance = new IValidatorContract(txReceipt.contractAddress as string, provider, txDefaults, logDecodeDependencies);
txReceipt.contractAddress as string,
provider,
txDefaults,
logDecodeDependencies,
);
contractInstance.constructorArgs = []; contractInstance.constructorArgs = [];
return contractInstance; return contractInstance;
} }
/** /**
* @returns The contract ABI * @returns The contract ABI
*/ */
@ -182,12 +182,7 @@ export class IValidatorContract extends BaseContract {
] as ContractAbi; ] as ContractAbi;
return abi; return abi;
} }
constructor( constructor(address: string, supportedProvider: SupportedProvider, txDefaults?: Partial<TxData>, logDecodeDependencies?: { [contractName: string]: ContractAbi }) {
address: string,
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
) {
super('IValidator', IValidatorContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies); super('IValidator', IValidatorContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']); classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
} }

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

@ -1,7 +1,7 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma // tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace // tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable // tslint:disable:no-unused-variable
import { BaseContract, PromiseWithTransactionHash } from '@0x/base-contract'; import { BaseContract,PromiseWithTransactionHash } from '@0x/base-contract';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { import {
BlockParam, BlockParam,
@ -23,6 +23,7 @@ import { assert } from '@0x/assert';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
// tslint:enable:no-unused-variable // tslint:enable:no-unused-variable
/* istanbul ignore next */ /* istanbul ignore next */
// tslint:disable:no-parameter-reassignment // tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name // tslint:disable-next-line:class-name
@ -33,7 +34,8 @@ export class IWalletContract extends BaseContract {
signature: string, signature: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<boolean> { ): Promise<boolean
> {
assert.isString('hash', hash); assert.isString('hash', hash);
assert.isString('signature', signature); assert.isString('signature', signature);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -44,8 +46,10 @@ export class IWalletContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as IWalletContract; const self = this as any as IWalletContract;
const encodedData = self._strictEncodeArguments('isValidSignature(bytes32,bytes)', [hash, signature]); const encodedData = self._strictEncodeArguments('isValidSignature(bytes32,bytes)', [hash,
signature
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -54,34 +58,35 @@ export class IWalletContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('isValidSignature(bytes32,bytes)'); const abiEncoder = self._lookupAbiEncoder('isValidSignature(bytes32,bytes)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<boolean
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(hash: string, signature: string): string { getABIEncodedTransactionData(
hash: string,
signature: string,
): string {
assert.isString('hash', hash); assert.isString('hash', hash);
assert.isString('signature', signature); assert.isString('signature', signature);
const self = (this as any) as IWalletContract; const self = this as any as IWalletContract;
const abiEncodedTransactionData = self._strictEncodeArguments('isValidSignature(bytes32,bytes)', [ const abiEncodedTransactionData = self._strictEncodeArguments('isValidSignature(bytes32,bytes)', [hash,
hash, signature
signature, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public static async deployFrom0xArtifactAsync( public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact, artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact }, logDecodeDependencies: { [contractName: string]: (ContractArtifact | SimpleContractArtifact) },
): Promise<IWalletContract> { ): Promise<IWalletContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -94,11 +99,8 @@ export class IWalletContract extends BaseContract {
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object; const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi; const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce( const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce((accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), {});
(accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), return IWalletContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly, );
{},
);
return IWalletContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly);
} }
public static async deployAsync( public static async deployAsync(
bytecode: string, bytecode: string,
@ -115,13 +117,17 @@ export class IWalletContract extends BaseContract {
]); ]);
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi); const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[] = BaseContract._formatABIDataItemList(constructorAbi.inputs, [], BaseContract._bigNumberToString); [] = BaseContract._formatABIDataItemList(
constructorAbi.inputs,
[],
BaseContract._bigNumberToString,
);
const iface = new ethers.utils.Interface(abi); const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction; const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, []); const txData = deployInfo.encode(bytecode, []);
const web3Wrapper = new Web3Wrapper(provider); const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ data: txData }, {data: txData},
txDefaults, txDefaults,
web3Wrapper.estimateGasAsync.bind(web3Wrapper), web3Wrapper.estimateGasAsync.bind(web3Wrapper),
); );
@ -129,16 +135,12 @@ export class IWalletContract extends BaseContract {
logUtils.log(`transactionHash: ${txHash}`); logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`IWallet successfully deployed at ${txReceipt.contractAddress}`); logUtils.log(`IWallet successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new IWalletContract( const contractInstance = new IWalletContract(txReceipt.contractAddress as string, provider, txDefaults, logDecodeDependencies);
txReceipt.contractAddress as string,
provider,
txDefaults,
logDecodeDependencies,
);
contractInstance.constructorArgs = []; contractInstance.constructorArgs = [];
return contractInstance; return contractInstance;
} }
/** /**
* @returns The contract ABI * @returns The contract ABI
*/ */
@ -170,12 +172,7 @@ export class IWalletContract extends BaseContract {
] as ContractAbi; ] as ContractAbi;
return abi; return abi;
} }
constructor( constructor(address: string, supportedProvider: SupportedProvider, txDefaults?: Partial<TxData>, logDecodeDependencies?: { [contractName: string]: ContractAbi }) {
address: string,
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
) {
super('IWallet', IWalletContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies); super('IWallet', IWalletContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']); classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
} }

963
packages/abi-gen-wrappers/src/generated-wrappers/multi_asset_proxy.ts generated
View File

File diff suppressed because it is too large Load Diff

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

@ -1,7 +1,7 @@
// tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma // tslint:disable:no-consecutive-blank-lines ordered-imports align trailing-comma
// tslint:disable:whitespace no-unbound-method no-trailing-whitespace // tslint:disable:whitespace no-unbound-method no-trailing-whitespace
// tslint:disable:no-unused-variable // tslint:disable:no-unused-variable
import { BaseContract, PromiseWithTransactionHash } from '@0x/base-contract'; import { BaseContract,PromiseWithTransactionHash } from '@0x/base-contract';
import { schemas } from '@0x/json-schemas'; import { schemas } from '@0x/json-schemas';
import { import {
BlockParam, BlockParam,
@ -23,44 +23,20 @@ import { assert } from '@0x/assert';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
// tslint:enable:no-unused-variable // tslint:enable:no-unused-variable
/* istanbul ignore next */ /* istanbul ignore next */
// tslint:disable:no-parameter-reassignment // tslint:disable:no-parameter-reassignment
// tslint:disable-next-line:class-name // tslint:disable-next-line:class-name
export class OrderValidatorContract extends BaseContract { export class OrderValidatorContract extends BaseContract {
public getOrderAndTraderInfo = { public getOrderAndTraderInfo = {
async callAsync( async callAsync(
order: { order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
takerAddress: string, takerAddress: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise< ): Promise<[{orderStatus: number;orderHash: string;orderTakerAssetFilledAmount: BigNumber}, {makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}]
[
{ orderStatus: number; orderHash: string; orderTakerAssetFilledAmount: BigNumber },
{
makerBalance: BigNumber;
makerAllowance: BigNumber;
takerBalance: BigNumber;
takerAllowance: BigNumber;
makerZrxBalance: BigNumber;
makerZrxAllowance: BigNumber;
takerZrxBalance: BigNumber;
takerZrxAllowance: BigNumber;
}
]
> { > {
assert.isString('takerAddress', takerAddress); assert.isString('takerAddress', takerAddress);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -70,11 +46,10 @@ export class OrderValidatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('getOrderAndTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)', [order,
'getOrderAndTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)', takerAddress.toLowerCase()
[order, takerAddress.toLowerCase()], ]);
);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -83,57 +58,27 @@ export class OrderValidatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder( const abiEncoder = self._lookupAbiEncoder('getOrderAndTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)');
'getOrderAndTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)',
);
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue< const result = abiEncoder.strictDecodeReturnValue<[{orderStatus: number;orderHash: string;orderTakerAssetFilledAmount: BigNumber}, {makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}]
[ >(rawCallResult);
{ orderStatus: number; orderHash: string; orderTakerAssetFilledAmount: BigNumber },
{
makerBalance: BigNumber;
makerAllowance: BigNumber;
takerBalance: BigNumber;
takerAllowance: BigNumber;
makerZrxBalance: BigNumber;
makerZrxAllowance: BigNumber;
takerZrxBalance: BigNumber;
takerZrxAllowance: BigNumber;
}
]
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData( getABIEncodedTransactionData(
order: { order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string; takerAddress: string,
takerAddress: string; ): string {
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
takerAddress: string,
): string {
assert.isString('takerAddress', takerAddress); assert.isString('takerAddress', takerAddress);
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments( const abiEncodedTransactionData = self._strictEncodeArguments('getOrderAndTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)', [order,
'getOrderAndTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)', takerAddress.toLowerCase()
[order, takerAddress.toLowerCase()], ]);
);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
@ -143,7 +88,8 @@ export class OrderValidatorContract extends BaseContract {
assetData: string, assetData: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber]
> {
assert.isString('target', target); assert.isString('target', target);
assert.isString('assetData', assetData); assert.isString('assetData', assetData);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -154,11 +100,10 @@ export class OrderValidatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const encodedData = self._strictEncodeArguments('getBalanceAndAllowance(address,bytes)', [ const encodedData = self._strictEncodeArguments('getBalanceAndAllowance(address,bytes)', [target.toLowerCase(),
target.toLowerCase(), assetData
assetData, ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -167,62 +112,37 @@ export class OrderValidatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('getBalanceAndAllowance(address,bytes)'); const abiEncoder = self._lookupAbiEncoder('getBalanceAndAllowance(address,bytes)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber]>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber]
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(target: string, assetData: string): string { getABIEncodedTransactionData(
target: string,
assetData: string,
): string {
assert.isString('target', target); assert.isString('target', target);
assert.isString('assetData', assetData); assert.isString('assetData', assetData);
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('getBalanceAndAllowance(address,bytes)', [ const abiEncodedTransactionData = self._strictEncodeArguments('getBalanceAndAllowance(address,bytes)', [target.toLowerCase(),
target.toLowerCase(), assetData
assetData, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public getOrdersAndTradersInfo = { public getOrdersAndTradersInfo = {
async callAsync( async callAsync(
orders: Array<{ orders: Array<{makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string}>,
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
}>,
takerAddresses: string[], takerAddresses: string[],
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise< ): 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}>]
[
Array<{ orderStatus: number; orderHash: string; orderTakerAssetFilledAmount: BigNumber }>,
Array<{
makerBalance: BigNumber;
makerAllowance: BigNumber;
takerBalance: BigNumber;
takerAllowance: BigNumber;
makerZrxBalance: BigNumber;
makerZrxAllowance: BigNumber;
takerZrxBalance: BigNumber;
takerZrxAllowance: BigNumber;
}>
]
> { > {
assert.isArray('orders', orders); assert.isArray('orders', orders);
assert.isArray('takerAddresses', takerAddresses); assert.isArray('takerAddresses', takerAddresses);
@ -234,11 +154,10 @@ export class OrderValidatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('getOrdersAndTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])', [orders,
'getOrdersAndTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])', takerAddresses
[orders, takerAddresses], ]);
);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -247,91 +166,37 @@ export class OrderValidatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder( const abiEncoder = self._lookupAbiEncoder('getOrdersAndTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])');
'getOrdersAndTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])',
);
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue< const result = abiEncoder.strictDecodeReturnValue<[Array<{orderStatus: number;orderHash: string;orderTakerAssetFilledAmount: BigNumber}>, Array<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}>]
[ >(rawCallResult);
Array<{ orderStatus: number; orderHash: string; orderTakerAssetFilledAmount: BigNumber }>,
Array<{
makerBalance: BigNumber;
makerAllowance: BigNumber;
takerBalance: BigNumber;
takerAllowance: BigNumber;
makerZrxBalance: BigNumber;
makerZrxAllowance: BigNumber;
takerZrxBalance: BigNumber;
takerZrxAllowance: BigNumber;
}>
]
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData( getABIEncodedTransactionData(
orders: Array<{ orders: Array<{makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string}>,
makerAddress: string; takerAddresses: string[],
takerAddress: string; ): string {
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
}>,
takerAddresses: string[],
): string {
assert.isArray('orders', orders); assert.isArray('orders', orders);
assert.isArray('takerAddresses', takerAddresses); assert.isArray('takerAddresses', takerAddresses);
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments( const abiEncodedTransactionData = self._strictEncodeArguments('getOrdersAndTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])', [orders,
'getOrdersAndTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])', takerAddresses
[orders, takerAddresses], ]);
);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public getTradersInfo = { public getTradersInfo = {
async callAsync( async callAsync(
orders: Array<{ orders: Array<{makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string}>,
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
}>,
takerAddresses: string[], takerAddresses: string[],
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise< ): Promise<Array<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}>
Array<{
makerBalance: BigNumber;
makerAllowance: BigNumber;
takerBalance: BigNumber;
takerAllowance: BigNumber;
makerZrxBalance: BigNumber;
makerZrxAllowance: BigNumber;
takerZrxBalance: BigNumber;
takerZrxAllowance: BigNumber;
}>
> { > {
assert.isArray('orders', orders); assert.isArray('orders', orders);
assert.isArray('takerAddresses', takerAddresses); assert.isArray('takerAddresses', takerAddresses);
@ -343,11 +208,10 @@ export class OrderValidatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('getTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])', [orders,
'getTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])', takerAddresses
[orders, takerAddresses], ]);
);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -356,55 +220,27 @@ export class OrderValidatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder( const abiEncoder = self._lookupAbiEncoder('getTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])');
'getTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])',
);
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue< const result = abiEncoder.strictDecodeReturnValue<Array<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}>
Array<{ >(rawCallResult);
makerBalance: BigNumber;
makerAllowance: BigNumber;
takerBalance: BigNumber;
takerAllowance: BigNumber;
makerZrxBalance: BigNumber;
makerZrxAllowance: BigNumber;
takerZrxBalance: BigNumber;
takerZrxAllowance: BigNumber;
}>
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData( getABIEncodedTransactionData(
orders: Array<{ orders: Array<{makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string}>,
makerAddress: string; takerAddresses: string[],
takerAddress: string; ): string {
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
}>,
takerAddresses: string[],
): string {
assert.isArray('orders', orders); assert.isArray('orders', orders);
assert.isArray('takerAddresses', takerAddresses); assert.isArray('takerAddresses', takerAddresses);
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments( const abiEncodedTransactionData = self._strictEncodeArguments('getTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])', [orders,
'getTradersInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],address[])', takerAddresses
[orders, takerAddresses], ]);
);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
@ -414,7 +250,8 @@ export class OrderValidatorContract extends BaseContract {
tokenId: BigNumber, tokenId: BigNumber,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<string> { ): Promise<string
> {
assert.isString('token', token); assert.isString('token', token);
assert.isBigNumber('tokenId', tokenId); assert.isBigNumber('tokenId', tokenId);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -425,11 +262,10 @@ export class OrderValidatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const encodedData = self._strictEncodeArguments('getERC721TokenOwner(address,uint256)', [ const encodedData = self._strictEncodeArguments('getERC721TokenOwner(address,uint256)', [token.toLowerCase(),
token.toLowerCase(), tokenId
tokenId, ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -438,26 +274,27 @@ export class OrderValidatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('getERC721TokenOwner(address,uint256)'); const abiEncoder = self._lookupAbiEncoder('getERC721TokenOwner(address,uint256)');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<string>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<string
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(token: string, tokenId: BigNumber): string { getABIEncodedTransactionData(
token: string,
tokenId: BigNumber,
): string {
assert.isString('token', token); assert.isString('token', token);
assert.isBigNumber('tokenId', tokenId); assert.isBigNumber('tokenId', tokenId);
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('getERC721TokenOwner(address,uint256)', [ const abiEncodedTransactionData = self._strictEncodeArguments('getERC721TokenOwner(address,uint256)', [token.toLowerCase(),
token.toLowerCase(), tokenId
tokenId, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
@ -467,7 +304,8 @@ export class OrderValidatorContract extends BaseContract {
assetData: string[], assetData: string[],
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber[], BigNumber[]]> { ): Promise<[BigNumber[], BigNumber[]]
> {
assert.isString('target', target); assert.isString('target', target);
assert.isArray('assetData', assetData); assert.isArray('assetData', assetData);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
@ -478,11 +316,10 @@ export class OrderValidatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const encodedData = self._strictEncodeArguments('getBalancesAndAllowances(address,bytes[])', [ const encodedData = self._strictEncodeArguments('getBalancesAndAllowances(address,bytes[])', [target.toLowerCase(),
target.toLowerCase(), assetData
assetData, ]);
]);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -491,58 +328,39 @@ export class OrderValidatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder('getBalancesAndAllowances(address,bytes[])'); const abiEncoder = self._lookupAbiEncoder('getBalancesAndAllowances(address,bytes[])');
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<[BigNumber[], BigNumber[]]>(rawCallResult); const result = abiEncoder.strictDecodeReturnValue<[BigNumber[], BigNumber[]]
>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData(target: string, assetData: string[]): string { getABIEncodedTransactionData(
target: string,
assetData: string[],
): string {
assert.isString('target', target); assert.isString('target', target);
assert.isArray('assetData', assetData); assert.isArray('assetData', assetData);
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('getBalancesAndAllowances(address,bytes[])', [ const abiEncodedTransactionData = self._strictEncodeArguments('getBalancesAndAllowances(address,bytes[])', [target.toLowerCase(),
target.toLowerCase(), assetData
assetData, ]);
]);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public getTraderInfo = { public getTraderInfo = {
async callAsync( async callAsync(
order: { order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string;
takerAddress: string;
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
takerAddress: string, takerAddress: string,
callData: Partial<CallData> = {}, callData: Partial<CallData> = {},
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ ): Promise<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}
makerBalance: BigNumber; > {
makerAllowance: BigNumber;
takerBalance: BigNumber;
takerAllowance: BigNumber;
makerZrxBalance: BigNumber;
makerZrxAllowance: BigNumber;
takerZrxBalance: BigNumber;
takerZrxAllowance: BigNumber;
}> {
assert.isString('takerAddress', takerAddress); assert.isString('takerAddress', takerAddress);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [ assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -552,11 +370,10 @@ export class OrderValidatorContract extends BaseContract {
if (defaultBlock !== undefined) { if (defaultBlock !== undefined) {
assert.isBlockParam('defaultBlock', defaultBlock); assert.isBlockParam('defaultBlock', defaultBlock);
} }
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const encodedData = self._strictEncodeArguments( const encodedData = self._strictEncodeArguments('getTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)', [order,
'getTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)', takerAddress.toLowerCase()
[order, takerAddress.toLowerCase()], ]);
);
const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const callDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ {
to: self.address, to: self.address,
@ -565,62 +382,37 @@ export class OrderValidatorContract extends BaseContract {
}, },
self._web3Wrapper.getContractDefaults(), self._web3Wrapper.getContractDefaults(),
); );
callDataWithDefaults.from = callDataWithDefaults.from callDataWithDefaults.from = callDataWithDefaults.from ? callDataWithDefaults.from.toLowerCase() : callDataWithDefaults.from;
? callDataWithDefaults.from.toLowerCase()
: callDataWithDefaults.from;
const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock); const rawCallResult = await self._web3Wrapper.callAsync(callDataWithDefaults, defaultBlock);
BaseContract._throwIfRevertWithReasonCallResult(rawCallResult); BaseContract._throwIfRevertWithReasonCallResult(rawCallResult);
const abiEncoder = self._lookupAbiEncoder( const abiEncoder = self._lookupAbiEncoder('getTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)');
'getTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)',
);
// tslint:disable boolean-naming // tslint:disable boolean-naming
const result = abiEncoder.strictDecodeReturnValue<{ const result = abiEncoder.strictDecodeReturnValue<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}
makerBalance: BigNumber; >(rawCallResult);
makerAllowance: BigNumber;
takerBalance: BigNumber;
takerAllowance: BigNumber;
makerZrxBalance: BigNumber;
makerZrxAllowance: BigNumber;
takerZrxBalance: BigNumber;
takerZrxAllowance: BigNumber;
}>(rawCallResult);
// tslint:enable boolean-naming // tslint:enable boolean-naming
return result; return result;
}, },
getABIEncodedTransactionData( getABIEncodedTransactionData(
order: { order: {makerAddress: string;takerAddress: string;feeRecipientAddress: string;senderAddress: string;makerAssetAmount: BigNumber;takerAssetAmount: BigNumber;makerFee: BigNumber;takerFee: BigNumber;expirationTimeSeconds: BigNumber;salt: BigNumber;makerAssetData: string;takerAssetData: string},
makerAddress: string; takerAddress: string,
takerAddress: string; ): string {
feeRecipientAddress: string;
senderAddress: string;
makerAssetAmount: BigNumber;
takerAssetAmount: BigNumber;
makerFee: BigNumber;
takerFee: BigNumber;
expirationTimeSeconds: BigNumber;
salt: BigNumber;
makerAssetData: string;
takerAssetData: string;
},
takerAddress: string,
): string {
assert.isString('takerAddress', takerAddress); assert.isString('takerAddress', takerAddress);
const self = (this as any) as OrderValidatorContract; const self = this as any as OrderValidatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments( const abiEncodedTransactionData = self._strictEncodeArguments('getTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)', [order,
'getTraderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),address)', takerAddress.toLowerCase()
[order, takerAddress.toLowerCase()], ]);
);
return abiEncodedTransactionData; return abiEncodedTransactionData;
}, },
}; };
public static async deployFrom0xArtifactAsync( public static async deployFrom0xArtifactAsync(
artifact: ContractArtifact | SimpleContractArtifact, artifact: ContractArtifact | SimpleContractArtifact,
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractArtifact | SimpleContractArtifact }, logDecodeDependencies: { [contractName: string]: (ContractArtifact | SimpleContractArtifact) },
_exchange: string, _exchange: string,
_zrxAssetData: string, _zrxAssetData: string,
): Promise<OrderValidatorContract> { ): Promise<OrderValidatorContract> {
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
schemas.addressSchema, schemas.addressSchema,
@ -633,19 +425,10 @@ export class OrderValidatorContract extends BaseContract {
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const bytecode = artifact.compilerOutput.evm.bytecode.object; const bytecode = artifact.compilerOutput.evm.bytecode.object;
const abi = artifact.compilerOutput.abi; const abi = artifact.compilerOutput.abi;
const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce( const logDecodeDependenciesAbiOnly = Object.entries(logDecodeDependencies).reduce((accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), {});
(accumulator, [key, value]) => Object.assign(accumulator, { [key]: value.compilerOutput.abi }), return OrderValidatorContract.deployAsync(bytecode, abi, provider, txDefaults, logDecodeDependenciesAbiOnly, _exchange,
{}, _zrxAssetData
); );
return OrderValidatorContract.deployAsync(
bytecode,
abi,
provider,
txDefaults,
logDecodeDependenciesAbiOnly,
_exchange,
_zrxAssetData,
);
} }
public static async deployAsync( public static async deployAsync(
bytecode: string, bytecode: string,
@ -653,8 +436,8 @@ export class OrderValidatorContract extends BaseContract {
supportedProvider: SupportedProvider, supportedProvider: SupportedProvider,
txDefaults: Partial<TxData>, txDefaults: Partial<TxData>,
logDecodeDependencies: { [contractName: string]: ContractAbi }, logDecodeDependencies: { [contractName: string]: ContractAbi },
_exchange: string, _exchange: string,
_zrxAssetData: string, _zrxAssetData: string,
): Promise<OrderValidatorContract> { ): Promise<OrderValidatorContract> {
assert.isHexString('bytecode', bytecode); assert.isHexString('bytecode', bytecode);
assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [ assert.doesConformToSchema('txDefaults', txDefaults, schemas.txDataSchema, [
@ -664,17 +447,23 @@ export class OrderValidatorContract extends BaseContract {
]); ]);
const provider = providerUtils.standardizeOrThrow(supportedProvider); const provider = providerUtils.standardizeOrThrow(supportedProvider);
const constructorAbi = BaseContract._lookupConstructorAbi(abi); const constructorAbi = BaseContract._lookupConstructorAbi(abi);
[_exchange, _zrxAssetData] = BaseContract._formatABIDataItemList( [_exchange,
_zrxAssetData
] = BaseContract._formatABIDataItemList(
constructorAbi.inputs, constructorAbi.inputs,
[_exchange, _zrxAssetData], [_exchange,
_zrxAssetData
],
BaseContract._bigNumberToString, BaseContract._bigNumberToString,
); );
const iface = new ethers.utils.Interface(abi); const iface = new ethers.utils.Interface(abi);
const deployInfo = iface.deployFunction; const deployInfo = iface.deployFunction;
const txData = deployInfo.encode(bytecode, [_exchange, _zrxAssetData]); const txData = deployInfo.encode(bytecode, [_exchange,
_zrxAssetData
]);
const web3Wrapper = new Web3Wrapper(provider); const web3Wrapper = new Web3Wrapper(provider);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync( const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{ data: txData }, {data: txData},
txDefaults, txDefaults,
web3Wrapper.estimateGasAsync.bind(web3Wrapper), web3Wrapper.estimateGasAsync.bind(web3Wrapper),
); );
@ -682,16 +471,14 @@ export class OrderValidatorContract extends BaseContract {
logUtils.log(`transactionHash: ${txHash}`); logUtils.log(`transactionHash: ${txHash}`);
const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash); const txReceipt = await web3Wrapper.awaitTransactionSuccessAsync(txHash);
logUtils.log(`OrderValidator successfully deployed at ${txReceipt.contractAddress}`); logUtils.log(`OrderValidator successfully deployed at ${txReceipt.contractAddress}`);
const contractInstance = new OrderValidatorContract( const contractInstance = new OrderValidatorContract(txReceipt.contractAddress as string, provider, txDefaults, logDecodeDependencies);
txReceipt.contractAddress as string, contractInstance.constructorArgs = [_exchange,
provider, _zrxAssetData
txDefaults, ];
logDecodeDependencies,
);
contractInstance.constructorArgs = [_exchange, _zrxAssetData];
return contractInstance; return contractInstance;
} }
/** /**
* @returns The contract ABI * @returns The contract ABI
*/ */
@ -752,7 +539,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'takerAssetData', name: 'takerAssetData',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
{ {
name: 'takerAddress', name: 'takerAddress',
@ -777,7 +564,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'orderTakerAssetFilledAmount', name: 'orderTakerAssetFilledAmount',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
{ {
name: 'traderInfo', name: 'traderInfo',
@ -815,7 +602,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'takerZrxAllowance', name: 'takerZrxAllowance',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
], ],
payable: false, payable: false,
@ -904,7 +691,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'takerAssetData', name: 'takerAssetData',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
{ {
name: 'takerAddresses', name: 'takerAddresses',
@ -929,7 +716,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'orderTakerAssetFilledAmount', name: 'orderTakerAssetFilledAmount',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
{ {
name: 'tradersInfo', name: 'tradersInfo',
@ -967,7 +754,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'takerZrxAllowance', name: 'takerZrxAllowance',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
], ],
payable: false, payable: false,
@ -1029,7 +816,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'takerAssetData', name: 'takerAssetData',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
{ {
name: 'takerAddresses', name: 'takerAddresses',
@ -1074,7 +861,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'takerZrxAllowance', name: 'takerZrxAllowance',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
], ],
payable: false, payable: false,
@ -1186,7 +973,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'takerAssetData', name: 'takerAssetData',
type: 'bytes', type: 'bytes',
}, },
], ]
}, },
{ {
name: 'takerAddress', name: 'takerAddress',
@ -1231,7 +1018,7 @@ export class OrderValidatorContract extends BaseContract {
name: 'takerZrxAllowance', name: 'takerZrxAllowance',
type: 'uint256', type: 'uint256',
}, },
], ]
}, },
], ],
payable: false, payable: false,
@ -1249,7 +1036,8 @@ export class OrderValidatorContract extends BaseContract {
type: 'bytes', type: 'bytes',
}, },
], ],
outputs: [], outputs: [
],
payable: false, payable: false,
stateMutability: 'nonpayable', stateMutability: 'nonpayable',
type: 'constructor', type: 'constructor',
@ -1257,20 +1045,8 @@ export class OrderValidatorContract extends BaseContract {
] as ContractAbi; ] as ContractAbi;
return abi; return abi;
} }
constructor( constructor(address: string, supportedProvider: SupportedProvider, txDefaults?: Partial<TxData>, logDecodeDependencies?: { [contractName: string]: ContractAbi }) {
address: string, super('OrderValidator', OrderValidatorContract.ABI(), address, supportedProvider, txDefaults, logDecodeDependencies);
supportedProvider: SupportedProvider,
txDefaults?: Partial<TxData>,
logDecodeDependencies?: { [contractName: string]: ContractAbi },
) {
super(
'OrderValidator',
OrderValidatorContract.ABI(),
address,
supportedProvider,
txDefaults,
logDecodeDependencies,
);
classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']); classUtils.bindAll(this, ['_abiEncoderByFunctionSignature', 'address', '_web3Wrapper']);
} }
} }

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff