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

Ensure assertions each get rendered on a new line

Browse Source
This commit is contained in:
Fabio Berger
2019-06-04 13:07:32 +01:00
parent 4d46290ef6
commit 60b7890f16
20 changed files with 4856 additions and 4392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -3,25 +3,25 @@ public {{this.tsName}} = {
{{> typed_params inputs=inputs}}
txData?: Partial<TxData> | undefined,
): Promise<string> {
{{#each inputs}}
{{#assertionType name type}}{{/assertionType}}
{{/each}}
const self = this as any as {{contractName}}Contract;
const encodedData = self._strictEncodeArguments('{{this.functionSignature}}', [{{> params inputs=inputs}}]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.{{this.tsName}}.estimateGasAsync.bind(
self,
{{> params inputs=inputs}}
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
{{#each inputs}}
{{#assertionType name type}}{{/assertionType}}
{{/each}}
const self = this as any as {{contractName}}Contract;
const encodedData = self._strictEncodeArguments('{{this.functionSignature}}', [{{> params inputs=inputs}}]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.{{this.tsName}}.estimateGasAsync.bind(
self,
{{> params inputs=inputs}}
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
{{> typed_params inputs=inputs}}
@@ -29,56 +29,56 @@ public {{this.tsName}} = {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
{{#each inputs}}
{{#assertionType name type}}{{/assertionType}}
{{/each}}
const self = this as any as {{contractName}}Contract;
{{#if inputs}}
const txHashPromise = self.{{this.tsName}}.sendTransactionAsync({{> params input=inputs}}, txData);
{{else}}
const txHashPromise = self.{{this.tsName}}.sendTransactionAsync(txData);
{{/if}}
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
{{#each inputs}}
{{#assertionType name type}}{{/assertionType}}
{{/each}}
const self = this as any as {{contractName}}Contract;
{{#if inputs}}
const txHashPromise = self.{{this.tsName}}.sendTransactionAsync({{> params input=inputs}}, txData);
{{else}}
const txHashPromise = self.{{this.tsName}}.sendTransactionAsync(txData);
{{/if}}
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
{{> typed_params inputs=inputs}}
txData?: Partial<TxData> | undefined,
): Promise<number> {
{{#each inputs}}
{{#assertionType name type}}{{/assertionType}}
{{/each}}
const self = this as any as {{contractName}}Contract;
const encodedData = self._strictEncodeArguments('{{this.functionSignature}}', [{{> params inputs=inputs}}]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
{{#each inputs}}
{{#assertionType name type}}{{/assertionType}}
{{/each}}
const self = this as any as {{contractName}}Contract;
const encodedData = self._strictEncodeArguments('{{this.functionSignature}}', [{{> params inputs=inputs}}]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
{{> typed_params inputs=inputs}}
): string {
{{#each inputs}}
{{#assertionType name type}}{{/assertionType}}
{{/each}}
const self = this as any as {{contractName}}Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('{{this.functionSignature}}', [{{> params inputs=inputs}}]);
return abiEncodedTransactionData;
{{#each inputs}}
{{#assertionType name type}}{{/assertionType}}
{{/each}}
const self = this as any as {{contractName}}Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('{{this.functionSignature}}', [{{> params inputs=inputs}}]);
return abiEncodedTransactionData;
},
{{> callAsync}}
};

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

File diff suppressed because it is too large Load Diff

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

@@ -36,7 +36,8 @@ export class CoordinatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.isString('hash', hash);assert.isString('signature', signature);
assert.isString('hash', hash);
assert.isString('signature', signature);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -150,32 +151,36 @@ export class CoordinatorContract extends BaseContract {
approvalSignatures: string[],
txData?: Partial<TxData> | undefined,
): 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,
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,
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.executeTransaction.estimateGasAsync.bind(
self,
transaction,
txOrigin,
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.executeTransaction.estimateGasAsync.bind(
self,
transaction,
txOrigin,
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
transaction: {salt: BigNumber;signerAddress: string;data: string},
@@ -187,25 +192,29 @@ export class CoordinatorContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('txOrigin', txOrigin);assert.isString('transactionSignature', transactionSignature);assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);assert.isArray('approvalSignatures', approvalSignatures);
const self = this as any as CoordinatorContract;
const txHashPromise = self.executeTransaction.sendTransactionAsync(transaction,
assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures);
const self = this as any as CoordinatorContract;
const txHashPromise = self.executeTransaction.sendTransactionAsync(transaction,
txOrigin,
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
transaction: {salt: BigNumber;signerAddress: string;data: string},
@@ -215,24 +224,28 @@ export class CoordinatorContract extends BaseContract {
approvalSignatures: string[],
txData?: Partial<TxData> | undefined,
): 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,
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,
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
transaction: {salt: BigNumber;signerAddress: string;data: string},
@@ -241,15 +254,19 @@ export class CoordinatorContract extends BaseContract {
approvalExpirationTimeSeconds: BigNumber[],
approvalSignatures: string[],
): 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 abiEncodedTransactionData = self._strictEncodeArguments('executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])', [transaction,
assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures);
const self = this as any as CoordinatorContract;
const abiEncodedTransactionData = self._strictEncodeArguments('executeTransaction((uint256,address,bytes),address,bytes,uint256[],bytes[])', [transaction,
txOrigin,
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
transaction: {salt: BigNumber;signerAddress: string;data: string},
@@ -261,7 +278,11 @@ export class CoordinatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('txOrigin', txOrigin);assert.isString('transactionSignature', transactionSignature);assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);assert.isArray('approvalSignatures', approvalSignatures);
assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -301,7 +322,6 @@ export class CoordinatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -341,7 +361,11 @@ export class CoordinatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('txOrigin', txOrigin);assert.isString('transactionSignature', transactionSignature);assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);assert.isArray('approvalSignatures', approvalSignatures);
assert.isString('txOrigin', txOrigin);
assert.isString('transactionSignature', transactionSignature);
assert.isArray('approvalExpirationTimeSeconds', approvalExpirationTimeSeconds);
assert.isArray('approvalSignatures', approvalSignatures);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -418,7 +442,6 @@ export class CoordinatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,

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

@@ -45,24 +45,24 @@ export class CoordinatorRegistryContract extends BaseContract {
coordinatorEndpoint: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = this as any as CoordinatorRegistryContract;
const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = this as any as CoordinatorRegistryContract;
const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.setCoordinatorEndpoint.estimateGasAsync.bind(
self,
coordinatorEndpoint
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.setCoordinatorEndpoint.estimateGasAsync.bind(
self,
coordinatorEndpoint
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
coordinatorEndpoint: string,
@@ -70,49 +70,49 @@ export class CoordinatorRegistryContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = this as any as CoordinatorRegistryContract;
const txHashPromise = self.setCoordinatorEndpoint.sendTransactionAsync(coordinatorEndpoint
assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = this as any as CoordinatorRegistryContract;
const txHashPromise = self.setCoordinatorEndpoint.sendTransactionAsync(coordinatorEndpoint
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
coordinatorEndpoint: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = this as any as CoordinatorRegistryContract;
const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = this as any as CoordinatorRegistryContract;
const encodedData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
coordinatorEndpoint: string,
): string {
assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = this as any as CoordinatorRegistryContract;
const abiEncodedTransactionData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
assert.isString('coordinatorEndpoint', coordinatorEndpoint);
const self = this as any as CoordinatorRegistryContract;
const abiEncodedTransactionData = self._strictEncodeArguments('setCoordinatorEndpoint(string)', [coordinatorEndpoint
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
coordinatorEndpoint: string,

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

@@ -55,7 +55,6 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -90,26 +89,27 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_spender,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_spender,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_spender: string,
@@ -118,54 +118,57 @@ export class DummyERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_spender,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_spender: string,
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_spender: string,
_value: BigNumber,
): string {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_spender: string,
@@ -174,7 +177,8 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -211,7 +215,6 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -247,28 +250,30 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_from: string,
@@ -278,23 +283,25 @@ export class DummyERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(_from,
_to,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_from: string,
@@ -302,35 +309,39 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_from: string,
_to: string,
_value: BigNumber,
): string {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_from: string,
@@ -340,7 +351,9 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -378,7 +391,6 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -450,7 +462,6 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -485,7 +496,6 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -519,24 +529,24 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('mint(uint256)', [_value
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('mint(uint256)', [_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.mint.estimateGasAsync.bind(
self,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.mint.estimateGasAsync.bind(
self,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_value: BigNumber,
@@ -544,49 +554,49 @@ export class DummyERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.mint.sendTransactionAsync(_value
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.mint.sendTransactionAsync(_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('mint(uint256)', [_value
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('mint(uint256)', [_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_value: BigNumber,
): string {
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('mint(uint256)', [_value
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('mint(uint256)', [_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_value: BigNumber,
@@ -630,26 +640,27 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transfer.estimateGasAsync.bind(
self,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transfer.estimateGasAsync.bind(
self,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_to: string,
@@ -658,54 +669,57 @@ export class DummyERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.transfer.sendTransactionAsync(_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.transfer.sendTransactionAsync(_to,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_to: string,
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_to: string,
_value: BigNumber,
): string {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_to: string,
@@ -714,7 +728,8 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -753,7 +768,8 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.isString('_owner', _owner);assert.isString('_spender', _spender);
assert.isString('_owner', _owner);
assert.isString('_spender', _spender);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -790,26 +806,27 @@ export class DummyERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_target', _target);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('setBalance(address,uint256)', [_target,
assert.isString('_target', _target);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('setBalance(address,uint256)', [_target,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.setBalance.estimateGasAsync.bind(
self,
_target,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.setBalance.estimateGasAsync.bind(
self,
_target,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_target: string,
@@ -818,54 +835,57 @@ export class DummyERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_target', _target);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.setBalance.sendTransactionAsync(_target,
assert.isString('_target', _target);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.setBalance.sendTransactionAsync(_target,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_target: string,
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_target', _target);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('setBalance(address,uint256)', [_target,
assert.isString('_target', _target);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('setBalance(address,uint256)', [_target,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_target: string,
_value: BigNumber,
): string {
assert.isString('_target', _target);assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('setBalance(address,uint256)', [_target,
assert.isString('_target', _target);
assert.isBigNumber('_value', _value);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('setBalance(address,uint256)', [_target,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_target: string,
@@ -874,7 +894,8 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('_target', _target);assert.isBigNumber('_value', _value);
assert.isString('_target', _target);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -910,24 +931,24 @@ export class DummyERC20TokenContract extends BaseContract {
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('newOwner', newOwner);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
newOwner: string,
@@ -935,49 +956,49 @@ export class DummyERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('newOwner', newOwner);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
assert.isString('newOwner', newOwner);
const self = this as any as DummyERC20TokenContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('newOwner', newOwner);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as DummyERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
newOwner: string,
): string {
assert.isString('newOwner', newOwner);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as DummyERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
newOwner: string,
@@ -1021,7 +1042,6 @@ export class DummyERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,

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

File diff suppressed because it is too large Load Diff

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

@@ -34,23 +34,23 @@ export class DutchAuctionContract extends BaseContract {
txData?: Partial<TxData> | undefined,
): 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 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
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.getAuctionDetails.estimateGasAsync.bind(
self,
order
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
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},
@@ -59,48 +59,48 @@ export class DutchAuctionContract extends BaseContract {
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
const self = this as any as DutchAuctionContract;
const txHashPromise = self.getAuctionDetails.sendTransactionAsync(order
const self = this as any as DutchAuctionContract;
const txHashPromise = self.getAuctionDetails.sendTransactionAsync(order
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
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},
txData?: Partial<TxData> | undefined,
): 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 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(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
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},
): 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
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;
},
async callAsync(
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},
@@ -146,30 +146,33 @@ export class DutchAuctionContract extends BaseContract {
sellSignature: string,
txData?: Partial<TxData> | undefined,
): 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,
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
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.matchOrders.estimateGasAsync.bind(
self,
buyOrder,
sellOrder,
buySignature,
sellSignature
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
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},
@@ -180,24 +183,27 @@ export class DutchAuctionContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('buySignature', buySignature);assert.isString('sellSignature', sellSignature);
const self = this as any as DutchAuctionContract;
const txHashPromise = self.matchOrders.sendTransactionAsync(buyOrder,
assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature);
const self = this as any as DutchAuctionContract;
const txHashPromise = self.matchOrders.sendTransactionAsync(buyOrder,
sellOrder,
buySignature,
sellSignature
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
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},
@@ -206,23 +212,26 @@ export class DutchAuctionContract extends BaseContract {
sellSignature: string,
txData?: Partial<TxData> | undefined,
): 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,
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(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
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},
@@ -230,14 +239,17 @@ export class DutchAuctionContract extends BaseContract {
buySignature: string,
sellSignature: string,
): string {
assert.isString('buySignature', buySignature);assert.isString('sellSignature', sellSignature);
const self = this as any as DutchAuctionContract;
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,
assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature);
const self = this as any as DutchAuctionContract;
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,
sellOrder,
buySignature,
sellSignature
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
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},
@@ -248,7 +260,10 @@ export class DutchAuctionContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<{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('sellSignature', sellSignature);
assert.isString('buySignature', buySignature);
assert.isString('sellSignature', sellSignature);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,

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

@@ -52,24 +52,24 @@ export class ERC20ProxyContract extends BaseContract {
target: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.addAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.addAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -77,49 +77,49 @@ export class ERC20ProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const txHashPromise = self.addAuthorizedAddress.sendTransactionAsync(target
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const txHashPromise = self.addAuthorizedAddress.sendTransactionAsync(target
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
): string {
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -199,24 +199,24 @@ export class ERC20ProxyContract extends BaseContract {
target: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -224,49 +224,49 @@ export class ERC20ProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const txHashPromise = self.removeAuthorizedAddress.sendTransactionAsync(target
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const txHashPromise = self.removeAuthorizedAddress.sendTransactionAsync(target
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
): string {
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC20ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -310,7 +310,6 @@ export class ERC20ProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -345,26 +344,27 @@ export class ERC20ProxyContract extends BaseContract {
index: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddressAtIndex.estimateGasAsync.bind(
self,
target,
index
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddressAtIndex.estimateGasAsync.bind(
self,
target,
index
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -373,54 +373,57 @@ export class ERC20ProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as ERC20ProxyContract;
const txHashPromise = self.removeAuthorizedAddressAtIndex.sendTransactionAsync(target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as ERC20ProxyContract;
const txHashPromise = self.removeAuthorizedAddressAtIndex.sendTransactionAsync(target,
index
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
index: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
index: BigNumber,
): string {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as ERC20ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as ERC20ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -429,7 +432,8 @@ export class ERC20ProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('target', target);assert.isBigNumber('index', index);
assert.isString('target', target);
assert.isBigNumber('index', index);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -466,7 +470,6 @@ export class ERC20ProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -538,7 +541,6 @@ export class ERC20ProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string[]
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -572,24 +574,24 @@ export class ERC20ProxyContract extends BaseContract {
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('newOwner', newOwner);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
newOwner: string,
@@ -597,49 +599,49 @@ export class ERC20ProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('newOwner', newOwner);
const self = this as any as ERC20ProxyContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ERC20ProxyContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('newOwner', newOwner);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ERC20ProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
newOwner: string,
): string {
assert.isString('newOwner', newOwner);
const self = this as any as ERC20ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ERC20ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
newOwner: string,

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

@@ -55,26 +55,27 @@ export class ERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_spender,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_spender,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_spender: string,
@@ -83,54 +84,57 @@ export class ERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_spender,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_spender: string,
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_spender: string,
_value: BigNumber,
): string {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_spender: string,
@@ -139,7 +143,8 @@ export class ERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -176,7 +181,6 @@ export class ERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -212,28 +216,30 @@ export class ERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_from: string,
@@ -243,23 +249,25 @@ export class ERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(_from,
_to,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_from: string,
@@ -267,35 +275,39 @@ export class ERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_from: string,
_to: string,
_value: BigNumber,
): string {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_from: string,
@@ -305,7 +317,9 @@ export class ERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -380,26 +394,27 @@ export class ERC20TokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transfer.estimateGasAsync.bind(
self,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transfer.estimateGasAsync.bind(
self,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_to: string,
@@ -408,54 +423,57 @@ export class ERC20TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const txHashPromise = self.transfer.sendTransactionAsync(_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const txHashPromise = self.transfer.sendTransactionAsync(_to,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_to: string,
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_to: string,
_value: BigNumber,
): string {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ERC20TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_to: string,
@@ -464,7 +482,8 @@ export class ERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -503,7 +522,8 @@ export class ERC20TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.isString('_owner', _owner);assert.isString('_spender', _spender);
assert.isString('_owner', _owner);
assert.isString('_spender', _spender);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,

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

@@ -52,24 +52,24 @@ export class ERC721ProxyContract extends BaseContract {
target: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.addAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.addAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -77,49 +77,49 @@ export class ERC721ProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const txHashPromise = self.addAuthorizedAddress.sendTransactionAsync(target
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const txHashPromise = self.addAuthorizedAddress.sendTransactionAsync(target
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
): string {
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -199,24 +199,24 @@ export class ERC721ProxyContract extends BaseContract {
target: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -224,49 +224,49 @@ export class ERC721ProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const txHashPromise = self.removeAuthorizedAddress.sendTransactionAsync(target
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const txHashPromise = self.removeAuthorizedAddress.sendTransactionAsync(target
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
): string {
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as ERC721ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -310,7 +310,6 @@ export class ERC721ProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -345,26 +344,27 @@ export class ERC721ProxyContract extends BaseContract {
index: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddressAtIndex.estimateGasAsync.bind(
self,
target,
index
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddressAtIndex.estimateGasAsync.bind(
self,
target,
index
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -373,54 +373,57 @@ export class ERC721ProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as ERC721ProxyContract;
const txHashPromise = self.removeAuthorizedAddressAtIndex.sendTransactionAsync(target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as ERC721ProxyContract;
const txHashPromise = self.removeAuthorizedAddressAtIndex.sendTransactionAsync(target,
index
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
index: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
index: BigNumber,
): string {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as ERC721ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as ERC721ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -429,7 +432,8 @@ export class ERC721ProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('target', target);assert.isBigNumber('index', index);
assert.isString('target', target);
assert.isBigNumber('index', index);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -466,7 +470,6 @@ export class ERC721ProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -538,7 +541,6 @@ export class ERC721ProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string[]
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -572,24 +574,24 @@ export class ERC721ProxyContract extends BaseContract {
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('newOwner', newOwner);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
newOwner: string,
@@ -597,49 +599,49 @@ export class ERC721ProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('newOwner', newOwner);
const self = this as any as ERC721ProxyContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ERC721ProxyContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('newOwner', newOwner);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ERC721ProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
newOwner: string,
): string {
assert.isString('newOwner', newOwner);
const self = this as any as ERC721ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ERC721ProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
newOwner: string,

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

@@ -100,26 +100,27 @@ export class ERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_approved', _approved);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_approved,
assert.isString('_approved', _approved);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_approved,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_approved,
_tokenId
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_approved,
_tokenId
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_approved: string,
@@ -128,54 +129,57 @@ export class ERC721TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_approved', _approved);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_approved,
assert.isString('_approved', _approved);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_approved,
_tokenId
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_approved: string,
_tokenId: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_approved', _approved);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_approved,
assert.isString('_approved', _approved);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_approved,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_approved: string,
_tokenId: BigNumber,
): string {
assert.isString('_approved', _approved);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_approved,
assert.isString('_approved', _approved);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_approved,
_tokenId
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_approved: string,
@@ -184,7 +188,8 @@ export class ERC721TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('_approved', _approved);assert.isBigNumber('_tokenId', _tokenId);
assert.isString('_approved', _approved);
assert.isBigNumber('_tokenId', _tokenId);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -222,28 +227,30 @@ export class ERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from,
_to,
_tokenId
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from,
_to,
_tokenId
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_from: string,
@@ -253,23 +260,25 @@ export class ERC721TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(_from,
_to,
_tokenId
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_from: string,
@@ -277,35 +286,39 @@ export class ERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_from: string,
_to: string,
_tokenId: BigNumber,
): string {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_tokenId
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_from: string,
@@ -315,7 +328,9 @@ export class ERC721TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -354,28 +369,30 @@ export class ERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256)', [_from,
_to,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.safeTransferFrom1.estimateGasAsync.bind(
self,
_from,
_to,
_tokenId
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.safeTransferFrom1.estimateGasAsync.bind(
self,
_from,
_to,
_tokenId
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_from: string,
@@ -385,23 +402,25 @@ export class ERC721TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.safeTransferFrom1.sendTransactionAsync(_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.safeTransferFrom1.sendTransactionAsync(_from,
_to,
_tokenId
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_from: string,
@@ -409,35 +428,39 @@ export class ERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256)', [_from,
_to,
_tokenId
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_from: string,
_to: string,
_tokenId: BigNumber,
): string {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256)', [_from,
_to,
_tokenId
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_from: string,
@@ -447,7 +470,9 @@ export class ERC721TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -559,26 +584,27 @@ export class ERC721TokenContract extends BaseContract {
_approved: boolean,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_operator', _operator);assert.isBoolean('_approved', _approved);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('setApprovalForAll(address,bool)', [_operator,
assert.isString('_operator', _operator);
assert.isBoolean('_approved', _approved);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('setApprovalForAll(address,bool)', [_operator,
_approved
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.setApprovalForAll.estimateGasAsync.bind(
self,
_operator,
_approved
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.setApprovalForAll.estimateGasAsync.bind(
self,
_operator,
_approved
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_operator: string,
@@ -587,54 +613,57 @@ export class ERC721TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_operator', _operator);assert.isBoolean('_approved', _approved);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.setApprovalForAll.sendTransactionAsync(_operator,
assert.isString('_operator', _operator);
assert.isBoolean('_approved', _approved);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.setApprovalForAll.sendTransactionAsync(_operator,
_approved
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_operator: string,
_approved: boolean,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_operator', _operator);assert.isBoolean('_approved', _approved);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('setApprovalForAll(address,bool)', [_operator,
assert.isString('_operator', _operator);
assert.isBoolean('_approved', _approved);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('setApprovalForAll(address,bool)', [_operator,
_approved
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_operator: string,
_approved: boolean,
): string {
assert.isString('_operator', _operator);assert.isBoolean('_approved', _approved);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('setApprovalForAll(address,bool)', [_operator,
assert.isString('_operator', _operator);
assert.isBoolean('_approved', _approved);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('setApprovalForAll(address,bool)', [_operator,
_approved
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_operator: string,
@@ -643,7 +672,8 @@ export class ERC721TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('_operator', _operator);assert.isBoolean('_approved', _approved);
assert.isString('_operator', _operator);
assert.isBoolean('_approved', _approved);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -682,30 +712,33 @@ export class ERC721TokenContract extends BaseContract {
_data: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);assert.isString('_data', _data);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256,bytes)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
assert.isString('_data', _data);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256,bytes)', [_from,
_to,
_tokenId,
_data
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.safeTransferFrom2.estimateGasAsync.bind(
self,
_from,
_to,
_tokenId,
_data
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.safeTransferFrom2.estimateGasAsync.bind(
self,
_from,
_to,
_tokenId,
_data
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_from: string,
@@ -716,24 +749,27 @@ export class ERC721TokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);assert.isString('_data', _data);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.safeTransferFrom2.sendTransactionAsync(_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
assert.isString('_data', _data);
const self = this as any as ERC721TokenContract;
const txHashPromise = self.safeTransferFrom2.sendTransactionAsync(_from,
_to,
_tokenId,
_data
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_from: string,
@@ -742,23 +778,26 @@ export class ERC721TokenContract extends BaseContract {
_data: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);assert.isString('_data', _data);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256,bytes)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
assert.isString('_data', _data);
const self = this as any as ERC721TokenContract;
const encodedData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256,bytes)', [_from,
_to,
_tokenId,
_data
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_from: string,
@@ -766,14 +805,17 @@ export class ERC721TokenContract extends BaseContract {
_tokenId: BigNumber,
_data: string,
): string {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);assert.isString('_data', _data);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256,bytes)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
assert.isString('_data', _data);
const self = this as any as ERC721TokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('safeTransferFrom(address,address,uint256,bytes)', [_from,
_to,
_tokenId,
_data
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_from: string,
@@ -784,7 +826,10 @@ export class ERC721TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_tokenId', _tokenId);assert.isString('_data', _data);
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_tokenId', _tokenId);
assert.isString('_data', _data);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -825,7 +870,8 @@ export class ERC721TokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_owner', _owner);assert.isString('_operator', _operator);
assert.isString('_owner', _owner);
assert.isString('_operator', _operator);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,

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

File diff suppressed because it is too large Load Diff

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

@@ -39,9 +39,15 @@ export class ForwarderContract extends BaseContract {
feeRecipient: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isArray('orders', orders);assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('marketBuyOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
assert.isArray('orders', orders);
assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('marketBuyOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
makerAssetFillAmount,
signatures,
feeOrders,
@@ -49,26 +55,26 @@ export class ForwarderContract extends BaseContract {
feePercentage,
feeRecipient
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.marketBuyOrdersWithEth.estimateGasAsync.bind(
self,
orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.marketBuyOrdersWithEth.estimateGasAsync.bind(
self,
orders,
makerAssetFillAmount,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
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}>,
@@ -82,9 +88,15 @@ export class ForwarderContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isArray('orders', orders);assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const txHashPromise = self.marketBuyOrdersWithEth.sendTransactionAsync(orders,
assert.isArray('orders', orders);
assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const txHashPromise = self.marketBuyOrdersWithEth.sendTransactionAsync(orders,
makerAssetFillAmount,
signatures,
feeOrders,
@@ -92,17 +104,17 @@ export class ForwarderContract extends BaseContract {
feePercentage,
feeRecipient
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
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}>,
@@ -114,9 +126,15 @@ export class ForwarderContract extends BaseContract {
feeRecipient: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isArray('orders', orders);assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('marketBuyOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
assert.isArray('orders', orders);
assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('marketBuyOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
makerAssetFillAmount,
signatures,
feeOrders,
@@ -124,16 +142,16 @@ export class ForwarderContract extends BaseContract {
feePercentage,
feeRecipient
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
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}>,
@@ -144,9 +162,15 @@ export class ForwarderContract extends BaseContract {
feePercentage: BigNumber,
feeRecipient: string,
): string {
assert.isArray('orders', orders);assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const abiEncodedTransactionData = self._strictEncodeArguments('marketBuyOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
assert.isArray('orders', orders);
assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const abiEncodedTransactionData = self._strictEncodeArguments('marketBuyOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],uint256,bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
makerAssetFillAmount,
signatures,
feeOrders,
@@ -154,7 +178,7 @@ export class ForwarderContract extends BaseContract {
feePercentage,
feeRecipient
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
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}>,
@@ -168,7 +192,13 @@ export class ForwarderContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<[{makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber}, {makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber}]
> {
assert.isArray('orders', orders);assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
assert.isArray('orders', orders);
assert.isBigNumber('makerAssetFillAmount', makerAssetFillAmount);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -210,26 +240,27 @@ export class ForwarderContract extends BaseContract {
amount: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('assetData', assetData);assert.isBigNumber('amount', amount);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('withdrawAsset(bytes,uint256)', [assetData,
assert.isString('assetData', assetData);
assert.isBigNumber('amount', amount);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('withdrawAsset(bytes,uint256)', [assetData,
amount
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.withdrawAsset.estimateGasAsync.bind(
self,
assetData,
amount
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.withdrawAsset.estimateGasAsync.bind(
self,
assetData,
amount
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
assetData: string,
@@ -238,54 +269,57 @@ export class ForwarderContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('assetData', assetData);assert.isBigNumber('amount', amount);
const self = this as any as ForwarderContract;
const txHashPromise = self.withdrawAsset.sendTransactionAsync(assetData,
assert.isString('assetData', assetData);
assert.isBigNumber('amount', amount);
const self = this as any as ForwarderContract;
const txHashPromise = self.withdrawAsset.sendTransactionAsync(assetData,
amount
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
assetData: string,
amount: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('assetData', assetData);assert.isBigNumber('amount', amount);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('withdrawAsset(bytes,uint256)', [assetData,
assert.isString('assetData', assetData);
assert.isBigNumber('amount', amount);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('withdrawAsset(bytes,uint256)', [assetData,
amount
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
assetData: string,
amount: BigNumber,
): string {
assert.isString('assetData', assetData);assert.isBigNumber('amount', amount);
const self = this as any as ForwarderContract;
const abiEncodedTransactionData = self._strictEncodeArguments('withdrawAsset(bytes,uint256)', [assetData,
assert.isString('assetData', assetData);
assert.isBigNumber('amount', amount);
const self = this as any as ForwarderContract;
const abiEncodedTransactionData = self._strictEncodeArguments('withdrawAsset(bytes,uint256)', [assetData,
amount
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
assetData: string,
@@ -294,7 +328,8 @@ export class ForwarderContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('assetData', assetData);assert.isBigNumber('amount', amount);
assert.isString('assetData', assetData);
assert.isBigNumber('amount', amount);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -331,7 +366,6 @@ export class ForwarderContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -370,34 +404,39 @@ export class ForwarderContract extends BaseContract {
feeRecipient: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isArray('orders', orders);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('marketSellOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
assert.isArray('orders', orders);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('marketSellOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.marketSellOrdersWithEth.estimateGasAsync.bind(
self,
orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.marketSellOrdersWithEth.estimateGasAsync.bind(
self,
orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
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}>,
@@ -410,26 +449,31 @@ export class ForwarderContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isArray('orders', orders);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const txHashPromise = self.marketSellOrdersWithEth.sendTransactionAsync(orders,
assert.isArray('orders', orders);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const txHashPromise = self.marketSellOrdersWithEth.sendTransactionAsync(orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
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}>,
@@ -440,25 +484,30 @@ export class ForwarderContract extends BaseContract {
feeRecipient: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isArray('orders', orders);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('marketSellOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
assert.isArray('orders', orders);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('marketSellOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
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}>,
@@ -468,16 +517,21 @@ export class ForwarderContract extends BaseContract {
feePercentage: BigNumber,
feeRecipient: string,
): string {
assert.isArray('orders', orders);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const abiEncodedTransactionData = self._strictEncodeArguments('marketSellOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
assert.isArray('orders', orders);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
const self = this as any as ForwarderContract;
const abiEncodedTransactionData = self._strictEncodeArguments('marketSellOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[],bytes[],uint256,address)', [orders,
signatures,
feeOrders,
feeSignatures,
feePercentage,
feeRecipient
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
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}>,
@@ -490,7 +544,12 @@ export class ForwarderContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<[{makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber}, {makerAssetFilledAmount: BigNumber;takerAssetFilledAmount: BigNumber;makerFeePaid: BigNumber;takerFeePaid: BigNumber}]
> {
assert.isArray('orders', orders);assert.isArray('signatures', signatures);assert.isArray('feeOrders', feeOrders);assert.isArray('feeSignatures', feeSignatures);assert.isBigNumber('feePercentage', feePercentage);assert.isString('feeRecipient', feeRecipient);
assert.isArray('orders', orders);
assert.isArray('signatures', signatures);
assert.isArray('feeOrders', feeOrders);
assert.isArray('feeSignatures', feeSignatures);
assert.isBigNumber('feePercentage', feePercentage);
assert.isString('feeRecipient', feeRecipient);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -530,24 +589,24 @@ export class ForwarderContract extends BaseContract {
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('newOwner', newOwner);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
newOwner: string,
@@ -555,49 +614,49 @@ export class ForwarderContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('newOwner', newOwner);
const self = this as any as ForwarderContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ForwarderContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('newOwner', newOwner);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ForwarderContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
newOwner: string,
): string {
assert.isString('newOwner', newOwner);
const self = this as any as ForwarderContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as ForwarderContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
newOwner: string,

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

@@ -33,24 +33,24 @@ export class IAssetProxyContract extends BaseContract {
target: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.addAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.addAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -58,49 +58,49 @@ export class IAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.addAuthorizedAddress.sendTransactionAsync(target
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.addAuthorizedAddress.sendTransactionAsync(target
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
): string {
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -143,24 +143,24 @@ export class IAssetProxyContract extends BaseContract {
target: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -168,49 +168,49 @@ export class IAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.removeAuthorizedAddress.sendTransactionAsync(target
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.removeAuthorizedAddress.sendTransactionAsync(target
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
): string {
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -254,26 +254,27 @@ export class IAssetProxyContract extends BaseContract {
index: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddressAtIndex.estimateGasAsync.bind(
self,
target,
index
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddressAtIndex.estimateGasAsync.bind(
self,
target,
index
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -282,54 +283,57 @@ export class IAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.removeAuthorizedAddressAtIndex.sendTransactionAsync(target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.removeAuthorizedAddressAtIndex.sendTransactionAsync(target,
index
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
index: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
index: BigNumber,
): string {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -338,7 +342,8 @@ export class IAssetProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('target', target);assert.isBigNumber('index', index);
assert.isString('target', target);
assert.isBigNumber('index', index);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -377,30 +382,33 @@ export class IAssetProxyContract extends BaseContract {
amount: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('assetData', assetData);assert.isString('from', from);assert.isString('to', to);assert.isBigNumber('amount', amount);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferFrom(bytes,address,address,uint256)', [assetData,
assert.isString('assetData', assetData);
assert.isString('from', from);
assert.isString('to', to);
assert.isBigNumber('amount', amount);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferFrom(bytes,address,address,uint256)', [assetData,
from,
to,
amount
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
assetData,
from,
to,
amount
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
assetData,
from,
to,
amount
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
assetData: string,
@@ -411,24 +419,27 @@ export class IAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('assetData', assetData);assert.isString('from', from);assert.isString('to', to);assert.isBigNumber('amount', amount);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(assetData,
assert.isString('assetData', assetData);
assert.isString('from', from);
assert.isString('to', to);
assert.isBigNumber('amount', amount);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(assetData,
from,
to,
amount
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
assetData: string,
@@ -437,23 +448,26 @@ export class IAssetProxyContract extends BaseContract {
amount: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('assetData', assetData);assert.isString('from', from);assert.isString('to', to);assert.isBigNumber('amount', amount);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferFrom(bytes,address,address,uint256)', [assetData,
assert.isString('assetData', assetData);
assert.isString('from', from);
assert.isString('to', to);
assert.isBigNumber('amount', amount);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferFrom(bytes,address,address,uint256)', [assetData,
from,
to,
amount
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
assetData: string,
@@ -461,14 +475,17 @@ export class IAssetProxyContract extends BaseContract {
to: string,
amount: BigNumber,
): string {
assert.isString('assetData', assetData);assert.isString('from', from);assert.isString('to', to);assert.isBigNumber('amount', amount);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(bytes,address,address,uint256)', [assetData,
assert.isString('assetData', assetData);
assert.isString('from', from);
assert.isString('to', to);
assert.isBigNumber('amount', amount);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(bytes,address,address,uint256)', [assetData,
from,
to,
amount
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
assetData: string,
@@ -479,7 +496,10 @@ export class IAssetProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('assetData', assetData);assert.isString('from', from);assert.isString('to', to);assert.isBigNumber('amount', amount);
assert.isString('assetData', assetData);
assert.isString('from', from);
assert.isString('to', to);
assert.isBigNumber('amount', amount);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -518,7 +538,6 @@ export class IAssetProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -553,7 +572,6 @@ export class IAssetProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string[]
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -587,24 +605,24 @@ export class IAssetProxyContract extends BaseContract {
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('newOwner', newOwner);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
newOwner: string,
@@ -612,49 +630,49 @@ export class IAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('newOwner', newOwner);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
assert.isString('newOwner', newOwner);
const self = this as any as IAssetProxyContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('newOwner', newOwner);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as IAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
newOwner: string,
): string {
assert.isString('newOwner', newOwner);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as IAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
newOwner: string,

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

@@ -37,7 +37,9 @@ export class IValidatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('hash', hash);assert.isString('signerAddress', signerAddress);assert.isString('signature', signature);
assert.isString('hash', hash);
assert.isString('signerAddress', signerAddress);
assert.isString('signature', signature);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,

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

@@ -36,7 +36,8 @@ export class IWalletContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('hash', hash);assert.isString('signature', signature);
assert.isString('hash', hash);
assert.isString('signature', signature);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,

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

@@ -96,24 +96,24 @@ export class MultiAssetProxyContract extends BaseContract {
target: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.addAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.addAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -121,49 +121,49 @@ export class MultiAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.addAuthorizedAddress.sendTransactionAsync(target
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.addAuthorizedAddress.sendTransactionAsync(target
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
): string {
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('addAuthorizedAddress(address)', [target
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -280,24 +280,24 @@ export class MultiAssetProxyContract extends BaseContract {
target: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddress.estimateGasAsync.bind(
self,
target
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -305,49 +305,49 @@ export class MultiAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.removeAuthorizedAddress.sendTransactionAsync(target
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.removeAuthorizedAddress.sendTransactionAsync(target
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
): string {
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
assert.isString('target', target);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddress(address)', [target
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -391,7 +391,6 @@ export class MultiAssetProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -426,26 +425,27 @@ export class MultiAssetProxyContract extends BaseContract {
index: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddressAtIndex.estimateGasAsync.bind(
self,
target,
index
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.removeAuthorizedAddressAtIndex.estimateGasAsync.bind(
self,
target,
index
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
target: string,
@@ -454,54 +454,57 @@ export class MultiAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.removeAuthorizedAddressAtIndex.sendTransactionAsync(target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.removeAuthorizedAddressAtIndex.sendTransactionAsync(target,
index
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
target: string,
index: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
target: string,
index: BigNumber,
): string {
assert.isString('target', target);assert.isBigNumber('index', index);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
assert.isString('target', target);
assert.isBigNumber('index', index);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('removeAuthorizedAddressAtIndex(address,uint256)', [target,
index
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
target: string,
@@ -510,7 +513,8 @@ export class MultiAssetProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<void
> {
assert.isString('target', target);assert.isBigNumber('index', index);
assert.isString('target', target);
assert.isBigNumber('index', index);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -547,7 +551,6 @@ export class MultiAssetProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -618,24 +621,24 @@ export class MultiAssetProxyContract extends BaseContract {
assetProxy: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('assetProxy', assetProxy);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('registerAssetProxy(address)', [assetProxy
assert.isString('assetProxy', assetProxy);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('registerAssetProxy(address)', [assetProxy
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.registerAssetProxy.estimateGasAsync.bind(
self,
assetProxy
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.registerAssetProxy.estimateGasAsync.bind(
self,
assetProxy
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
assetProxy: string,
@@ -643,49 +646,49 @@ export class MultiAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('assetProxy', assetProxy);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.registerAssetProxy.sendTransactionAsync(assetProxy
assert.isString('assetProxy', assetProxy);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.registerAssetProxy.sendTransactionAsync(assetProxy
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
assetProxy: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('assetProxy', assetProxy);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('registerAssetProxy(address)', [assetProxy
assert.isString('assetProxy', assetProxy);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('registerAssetProxy(address)', [assetProxy
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
assetProxy: string,
): string {
assert.isString('assetProxy', assetProxy);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('registerAssetProxy(address)', [assetProxy
assert.isString('assetProxy', assetProxy);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('registerAssetProxy(address)', [assetProxy
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
assetProxy: string,
@@ -729,7 +732,6 @@ export class MultiAssetProxyContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string[]
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -763,24 +765,24 @@ export class MultiAssetProxyContract extends BaseContract {
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('newOwner', newOwner);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferOwnership.estimateGasAsync.bind(
self,
newOwner
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
newOwner: string,
@@ -788,49 +790,49 @@ export class MultiAssetProxyContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('newOwner', newOwner);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
assert.isString('newOwner', newOwner);
const self = this as any as MultiAssetProxyContract;
const txHashPromise = self.transferOwnership.sendTransactionAsync(newOwner
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
newOwner: string,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('newOwner', newOwner);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as MultiAssetProxyContract;
const encodedData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
newOwner: string,
): string {
assert.isString('newOwner', newOwner);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
assert.isString('newOwner', newOwner);
const self = this as any as MultiAssetProxyContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferOwnership(address)', [newOwner
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
newOwner: string,

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

@@ -36,6 +36,7 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<[{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.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
@@ -75,7 +76,8 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber]
> {
assert.isString('target', target);assert.isString('assetData', assetData);
assert.isString('target', target);
assert.isString('assetData', assetData);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -114,7 +116,8 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam,
): 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}>]
> {
assert.isArray('orders', orders);assert.isArray('takerAddresses', takerAddresses);
assert.isArray('orders', orders);
assert.isArray('takerAddresses', takerAddresses);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -153,7 +156,8 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<Array<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}>
> {
assert.isArray('orders', orders);assert.isArray('takerAddresses', takerAddresses);
assert.isArray('orders', orders);
assert.isArray('takerAddresses', takerAddresses);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -192,7 +196,8 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.isString('token', token);assert.isBigNumber('tokenId', tokenId);
assert.isString('token', token);
assert.isBigNumber('tokenId', tokenId);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -231,7 +236,8 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<[BigNumber[], BigNumber[]]
> {
assert.isString('target', target);assert.isArray('assetData', assetData);
assert.isString('target', target);
assert.isArray('assetData', assetData);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -270,6 +276,7 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<{makerBalance: BigNumber;makerAllowance: BigNumber;takerBalance: BigNumber;takerAllowance: BigNumber;makerZrxBalance: BigNumber;makerZrxAllowance: BigNumber;takerZrxBalance: BigNumber;takerZrxAllowance: BigNumber}
> {
assert.isString('takerAddress', takerAddress);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,

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

@@ -69,7 +69,6 @@ export class WETH9Contract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -104,26 +103,27 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('guy', guy);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [guy,
assert.isString('guy', guy);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [guy,
wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
guy,
wad
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
guy,
wad
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
guy: string,
@@ -132,54 +132,57 @@ export class WETH9Contract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('guy', guy);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const txHashPromise = self.approve.sendTransactionAsync(guy,
assert.isString('guy', guy);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const txHashPromise = self.approve.sendTransactionAsync(guy,
wad
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
guy: string,
wad: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('guy', guy);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [guy,
assert.isString('guy', guy);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [guy,
wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
guy: string,
wad: BigNumber,
): string {
assert.isString('guy', guy);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [guy,
assert.isString('guy', guy);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [guy,
wad
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
guy: string,
@@ -188,7 +191,8 @@ export class WETH9Contract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('guy', guy);assert.isBigNumber('wad', wad);
assert.isString('guy', guy);
assert.isBigNumber('wad', wad);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -225,7 +229,6 @@ export class WETH9Contract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -261,28 +264,30 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('src', src);assert.isString('dst', dst);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [src,
assert.isString('src', src);
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [src,
dst,
wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
src,
dst,
wad
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
src,
dst,
wad
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
src: string,
@@ -292,23 +297,25 @@ export class WETH9Contract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('src', src);assert.isString('dst', dst);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const txHashPromise = self.transferFrom.sendTransactionAsync(src,
assert.isString('src', src);
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const txHashPromise = self.transferFrom.sendTransactionAsync(src,
dst,
wad
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
src: string,
@@ -316,35 +323,39 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('src', src);assert.isString('dst', dst);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [src,
assert.isString('src', src);
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [src,
dst,
wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
src: string,
dst: string,
wad: BigNumber,
): string {
assert.isString('src', src);assert.isString('dst', dst);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [src,
assert.isString('src', src);
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [src,
dst,
wad
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
src: string,
@@ -354,7 +365,9 @@ export class WETH9Contract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('src', src);assert.isString('dst', dst);assert.isBigNumber('wad', wad);
assert.isString('src', src);
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -391,24 +404,24 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('withdraw(uint256)', [wad
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('withdraw(uint256)', [wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.withdraw.estimateGasAsync.bind(
self,
wad
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.withdraw.estimateGasAsync.bind(
self,
wad
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
wad: BigNumber,
@@ -416,49 +429,49 @@ export class WETH9Contract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const txHashPromise = self.withdraw.sendTransactionAsync(wad
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const txHashPromise = self.withdraw.sendTransactionAsync(wad
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
wad: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('withdraw(uint256)', [wad
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('withdraw(uint256)', [wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
wad: BigNumber,
): string {
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('withdraw(uint256)', [wad
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('withdraw(uint256)', [wad
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
wad: BigNumber,
@@ -502,7 +515,6 @@ export class WETH9Contract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<number
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -574,7 +586,6 @@ export class WETH9Contract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -609,26 +620,27 @@ export class WETH9Contract extends BaseContract {
wad: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('dst', dst);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [dst,
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [dst,
wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transfer.estimateGasAsync.bind(
self,
dst,
wad
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transfer.estimateGasAsync.bind(
self,
dst,
wad
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
dst: string,
@@ -637,54 +649,57 @@ export class WETH9Contract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('dst', dst);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const txHashPromise = self.transfer.sendTransactionAsync(dst,
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const txHashPromise = self.transfer.sendTransactionAsync(dst,
wad
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
dst: string,
wad: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('dst', dst);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [dst,
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [dst,
wad
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
dst: string,
wad: BigNumber,
): string {
assert.isString('dst', dst);assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [dst,
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [dst,
wad
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
dst: string,
@@ -693,7 +708,8 @@ export class WETH9Contract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('dst', dst);assert.isBigNumber('wad', wad);
assert.isString('dst', dst);
assert.isBigNumber('wad', wad);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -728,73 +744,68 @@ export class WETH9Contract extends BaseContract {
async sendTransactionAsync(
txData?: Partial<TxData> | undefined,
): Promise<string> {
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('deposit()', []);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.deposit.estimateGasAsync.bind(
self,
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('deposit()', []);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.deposit.estimateGasAsync.bind(
self,
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
txData?: Partial<TxData>,
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
const self = this as any as WETH9Contract;
const txHashPromise = self.deposit.sendTransactionAsync(txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
const self = this as any as WETH9Contract;
const txHashPromise = self.deposit.sendTransactionAsync(txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
txData?: Partial<TxData> | undefined,
): Promise<number> {
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('deposit()', []);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const self = this as any as WETH9Contract;
const encodedData = self._strictEncodeArguments('deposit()', []);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
): string {
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('deposit()', []);
return abiEncodedTransactionData;
const self = this as any as WETH9Contract;
const abiEncodedTransactionData = self._strictEncodeArguments('deposit()', []);
return abiEncodedTransactionData;
},
async callAsync(
callData: Partial<CallData> = {},
defaultBlock?: BlockParam,
): Promise<void
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -831,7 +842,8 @@ export class WETH9Contract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.isString('index_0', index_0);assert.isString('index_1', index_1);
assert.isString('index_0', index_0);
assert.isString('index_1', index_1);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,

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

@@ -55,7 +55,6 @@ export class ZRXTokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -90,26 +89,27 @@ export class ZRXTokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_spender,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.approve.estimateGasAsync.bind(
self,
_spender,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_spender: string,
@@ -118,54 +118,57 @@ export class ZRXTokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const txHashPromise = self.approve.sendTransactionAsync(_spender,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_spender: string,
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_spender: string,
_value: BigNumber,
): string {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('approve(address,uint256)', [_spender,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_spender: string,
@@ -174,7 +177,8 @@ export class ZRXTokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_spender', _spender);assert.isBigNumber('_value', _value);
assert.isString('_spender', _spender);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -211,7 +215,6 @@ export class ZRXTokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -247,28 +250,30 @@ export class ZRXTokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transferFrom.estimateGasAsync.bind(
self,
_from,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_from: string,
@@ -278,23 +283,25 @@ export class ZRXTokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const txHashPromise = self.transferFrom.sendTransactionAsync(_from,
_to,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_from: string,
@@ -302,35 +309,39 @@ export class ZRXTokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_from: string,
_to: string,
_value: BigNumber,
): string {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transferFrom(address,address,uint256)', [_from,
_to,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_from: string,
@@ -340,7 +351,9 @@ export class ZRXTokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_from', _from);assert.isString('_to', _to);assert.isBigNumber('_value', _value);
assert.isString('_from', _from);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -378,7 +391,6 @@ export class ZRXTokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<number
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -450,7 +462,6 @@ export class ZRXTokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<string
> {
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -485,26 +496,27 @@ export class ZRXTokenContract extends BaseContract {
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<string> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transfer.estimateGasAsync.bind(
self,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
self.transfer.estimateGasAsync.bind(
self,
_to,
_value
),
);
const txHash = await self._web3Wrapper.sendTransactionAsync(txDataWithDefaults);
return txHash;
},
awaitTransactionSuccessAsync(
_to: string,
@@ -513,54 +525,57 @@ export class ZRXTokenContract extends BaseContract {
pollingIntervalMs?: number,
timeoutMs?: number,
): PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const txHashPromise = self.transfer.sendTransactionAsync(_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const txHashPromise = self.transfer.sendTransactionAsync(_to,
_value
, txData);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
return new PromiseWithTransactionHash<TransactionReceiptWithDecodedLogs>(
txHashPromise,
(async (): Promise<TransactionReceiptWithDecodedLogs> => {
// When the transaction hash resolves, wait for it to be mined.
return self._web3Wrapper.awaitTransactionSuccessAsync(
await txHashPromise,
pollingIntervalMs,
timeoutMs,
);
})(),
);
},
async estimateGasAsync(
_to: string,
_value: BigNumber,
txData?: Partial<TxData> | undefined,
): Promise<number> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const encodedData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
const txDataWithDefaults = await BaseContract._applyDefaultsToTxDataAsync(
{
to: self.address,
...txData,
data: encodedData,
},
self._web3Wrapper.getContractDefaults(),
);
const gas = await self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
return gas;
},
getABIEncodedTransactionData(
_to: string,
_value: BigNumber,
): string {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
const self = this as any as ZRXTokenContract;
const abiEncodedTransactionData = self._strictEncodeArguments('transfer(address,uint256)', [_to,
_value
]);
return abiEncodedTransactionData;
return abiEncodedTransactionData;
},
async callAsync(
_to: string,
@@ -569,7 +584,8 @@ export class ZRXTokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<boolean
> {
assert.isString('_to', _to);assert.isBigNumber('_value', _value);
assert.isString('_to', _to);
assert.isBigNumber('_value', _value);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,
@@ -608,7 +624,8 @@ export class ZRXTokenContract extends BaseContract {
defaultBlock?: BlockParam,
): Promise<BigNumber
> {
assert.isString('_owner', _owner);assert.isString('_spender', _spender);
assert.isString('_owner', _owner);
assert.isString('_spender', _spender);
assert.doesConformToSchema('callData', callData, schemas.callDataSchema, [
schemas.addressSchema,
schemas.numberSchema,