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

Reuse getABIEncodedTransactionData

Browse Source
This commit is contained in:
Jacob Evans
2019-11-16 11:47:26 +10:00
parent aa10844d9e
commit 62def596af
20 changed files with 1405 additions and 1444 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -491,8 +491,7 @@ export class CoordinatorContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [hash, signature]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -518,8 +517,10 @@ export class CoordinatorContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [transaction]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -536,8 +537,10 @@ export class CoordinatorContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [approval]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -560,15 +563,8 @@ export class CoordinatorContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
transaction,
txOrigin.toLowerCase(),
transactionSignature,
approvalExpirationTimeSeconds,
approvalSignatures,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -583,26 +579,18 @@ export class CoordinatorContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
transaction, ...txData,
txOrigin.toLowerCase(), data: this.getABIEncodedTransactionData(),
transactionSignature, });
approvalExpirationTimeSeconds,
approvalSignatures,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
transaction, { ...callData, data: this.getABIEncodedTransactionData() },
txOrigin.toLowerCase(), defaultBlock,
transactionSignature, );
approvalExpirationTimeSeconds,
approvalSignatures,
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -624,8 +612,10 @@ export class CoordinatorContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -669,14 +659,10 @@ export class CoordinatorContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
transaction, { ...callData, data: this.getABIEncodedTransactionData() },
txOrigin.toLowerCase(), defaultBlock,
transactionSignature, );
approvalExpirationTimeSeconds,
approvalSignatures,
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -743,8 +729,7 @@ export class CoordinatorContract extends BaseContract {
}> }>
> { > {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [data]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue< return abiEncoder.strictDecodeReturnValue<
Array<{ Array<{
@@ -934,8 +919,10 @@ export class CoordinatorContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },

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

@@ -292,9 +292,8 @@ export class CoordinatorRegistryContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [coordinatorEndpoint]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -309,14 +308,18 @@ export class CoordinatorRegistryContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [coordinatorEndpoint]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [coordinatorEndpoint]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -337,8 +340,10 @@ export class CoordinatorRegistryContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [coordinatorOperator.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },

231
packages/abi-gen-wrappers/src/generated-wrappers/dev_utils.ts generated
View File

@@ -1526,8 +1526,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[number, string, string]> { ): Promise<[number, string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[number, string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[number, string, string]>(rawCallResult);
}, },
@@ -1549,8 +1548,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult);
}, },
@@ -1573,8 +1571,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1599,8 +1596,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[string, string, string]> { ): Promise<[string, string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string, string]>(rawCallResult);
}, },
@@ -1625,8 +1621,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[string, string, string, string]> { ): Promise<[string, string, string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string, string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string, string, string]>(rawCallResult);
}, },
@@ -1654,8 +1649,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[string, string, BigNumber[], BigNumber[], string]> { ): Promise<[string, string, BigNumber[], BigNumber[], string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string, BigNumber[], BigNumber[], string]>( return abiEncoder.strictDecodeReturnValue<[string, string, BigNumber[], BigNumber[], string]>(
rawCallResult, rawCallResult,
@@ -1679,8 +1673,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult);
}, },
@@ -1706,8 +1699,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[string, string, BigNumber]> { ): Promise<[string, string, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string, BigNumber]>(rawCallResult);
}, },
@@ -1732,8 +1724,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[number, string, string]> { ): Promise<[number, string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[number, string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[number, string, string]>(rawCallResult);
}, },
@@ -1755,8 +1746,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[number, string]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[number, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[number, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[number, string]>(rawCallResult);
}, },
@@ -1781,8 +1771,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[number, BigNumber, BigNumber]> { ): Promise<[number, BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[number, BigNumber, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[number, BigNumber, BigNumber]>(rawCallResult);
}, },
@@ -1807,8 +1796,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[string, BigNumber[], string[]]> { ): Promise<[string, BigNumber[], string[]]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, BigNumber[], string[]]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, BigNumber[], string[]]>(rawCallResult);
}, },
@@ -1830,8 +1818,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult);
}, },
@@ -1856,8 +1843,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[string, string, BigNumber]> { ): Promise<[string, string, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string, BigNumber]>(rawCallResult);
}, },
@@ -1879,8 +1865,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, number]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, number]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, number]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, number]>(rawCallResult);
}, },
@@ -1905,8 +1890,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[number, string, string, string]> { ): Promise<[number, string, string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[number, string, string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[number, string, string, string]>(rawCallResult);
}, },
@@ -1928,8 +1912,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult);
}, },
@@ -1954,8 +1937,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[string, string, string, string]> { ): Promise<[string, string, string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string, string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string, string, string]>(rawCallResult);
}, },
@@ -1981,8 +1963,7 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[string, string, string, string]> { ): Promise<[string, string, string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string, string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string, string, string]>(rawCallResult);
}, },
@@ -2004,8 +1985,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[number, string]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[number, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[number, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[number, string]>(rawCallResult);
}, },
@@ -2027,8 +2007,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [encoded]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[string, string]>(rawCallResult);
}, },
@@ -2100,8 +2079,7 @@ export class DevUtilsContract extends BaseContract {
] ]
> { > {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [transactionData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue< return abiEncoder.strictDecodeReturnValue<
[ [
@@ -2158,13 +2136,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
tokenAddress.toLowerCase(),
tokenIds,
tokenValues,
callbackData,
]);
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2192,8 +2164,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [tokenAddress.toLowerCase()]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2218,11 +2189,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
tokenAddress.toLowerCase(),
tokenId,
]);
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2247,8 +2214,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [amounts, nestedAssetData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2280,12 +2246,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
staticCallTargetAddress.toLowerCase(),
staticCallData,
expectedReturnDataHash,
]);
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2314,11 +2275,10 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
ownerAddress.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
assetData, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2343,11 +2303,10 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
ownerAddress.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
assetData, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2378,11 +2337,10 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
ownerAddress.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
assetData, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber]>(rawCallResult);
}, },
@@ -2407,11 +2365,10 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
ownerAddress.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
assetData, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult);
}, },
@@ -2436,11 +2393,10 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
ownerAddress.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
assetData, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult);
}, },
@@ -2471,11 +2427,10 @@ export class DevUtilsContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber[], BigNumber[]]> { ): Promise<[BigNumber[], BigNumber[]]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
ownerAddress.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
assetData, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber[], BigNumber[]]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[BigNumber[], BigNumber[]]>(rawCallResult);
}, },
@@ -2497,8 +2452,10 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [addresses]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult);
}, },
@@ -2550,8 +2507,10 @@ export class DevUtilsContract extends BaseContract {
[{ orderStatus: number; orderHash: string; orderTakerAssetFilledAmount: BigNumber }, BigNumber, boolean] [{ orderStatus: number; orderHash: string; orderTakerAssetFilledAmount: BigNumber }, BigNumber, boolean]
> { > {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [order, signature]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue< return abiEncoder.strictDecodeReturnValue<
[ [
@@ -2617,8 +2576,10 @@ export class DevUtilsContract extends BaseContract {
] ]
> { > {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [orders, signatures]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue< return abiEncoder.strictDecodeReturnValue<
[ [
@@ -2673,13 +2634,8 @@ export class DevUtilsContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
order,
takerAddress.toLowerCase(),
takerAssetFillAmount,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2694,22 +2650,18 @@ export class DevUtilsContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
order, ...txData,
takerAddress.toLowerCase(), data: this.getABIEncodedTransactionData(),
takerAssetFillAmount, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
order, { ...callData, data: this.getABIEncodedTransactionData() },
takerAddress.toLowerCase(), defaultBlock,
takerAssetFillAmount, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number>(rawCallResult);
}, },
@@ -2763,13 +2715,8 @@ export class DevUtilsContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
orders,
takerAddresses,
takerAssetFillAmounts,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2784,22 +2731,18 @@ export class DevUtilsContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
orders, ...txData,
takerAddresses, data: this.getABIEncodedTransactionData(),
takerAssetFillAmounts, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number[]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number[]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
orders, { ...callData, data: this.getABIEncodedTransactionData() },
takerAddresses, defaultBlock,
takerAssetFillAmounts, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number[]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number[]>(rawCallResult);
}, },
@@ -2824,11 +2767,10 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
ownerAddress.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
assetData, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2845,8 +2787,7 @@ export class DevUtilsContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },

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

@@ -509,8 +509,10 @@ export class DummyERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -528,11 +530,10 @@ export class DummyERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_owner.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_spender.toLowerCase(), defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -558,9 +559,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_spender.toLowerCase(), _value]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -575,14 +575,18 @@ export class DummyERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_spender.toLowerCase(), _value]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_spender.toLowerCase(), _value]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -604,8 +608,10 @@ export class DummyERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_owner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -621,8 +627,10 @@ export class DummyERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -645,9 +653,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_value]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -662,14 +669,18 @@ export class DummyERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_value]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_value]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -685,8 +696,10 @@ export class DummyERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -702,8 +715,10 @@ export class DummyERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -728,9 +743,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_target.toLowerCase(), _value]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -745,14 +759,18 @@ export class DummyERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_target.toLowerCase(), _value]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_target.toLowerCase(), _value]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -768,8 +786,10 @@ export class DummyERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -789,8 +809,10 @@ export class DummyERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -816,9 +838,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _value]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -833,14 +854,18 @@ export class DummyERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _value]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _value]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -868,13 +893,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_from.toLowerCase(),
_to.toLowerCase(),
_value,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -889,22 +909,18 @@ export class DummyERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_from.toLowerCase(), ...txData,
_to.toLowerCase(), data: this.getABIEncodedTransactionData(),
_value, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_to.toLowerCase(), defaultBlock,
_value, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -923,9 +939,8 @@ export class DummyERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -940,14 +955,18 @@ export class DummyERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },

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

@@ -572,9 +572,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_approved.toLowerCase(), _tokenId]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -589,14 +588,18 @@ export class DummyERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_approved.toLowerCase(), _tokenId]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_approved.toLowerCase(), _tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -619,8 +622,10 @@ export class DummyERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_owner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -646,9 +651,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_owner.toLowerCase(), _tokenId]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -663,14 +667,18 @@ export class DummyERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_owner.toLowerCase(), _tokenId]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_owner.toLowerCase(), _tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -692,8 +700,10 @@ export class DummyERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -711,11 +721,10 @@ export class DummyERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_owner.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_operator.toLowerCase(), defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -741,9 +750,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _tokenId]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -758,14 +766,18 @@ export class DummyERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _tokenId]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -781,8 +793,10 @@ export class DummyERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -798,8 +812,10 @@ export class DummyERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -822,8 +838,10 @@ export class DummyERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -851,13 +869,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_from.toLowerCase(),
_to.toLowerCase(),
_tokenId,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -872,22 +885,18 @@ export class DummyERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_from.toLowerCase(), ...txData,
_to.toLowerCase(), data: this.getABIEncodedTransactionData(),
_tokenId, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_to.toLowerCase(), defaultBlock,
_tokenId, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -931,14 +940,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_from.toLowerCase(),
_to.toLowerCase(),
_tokenId,
_data,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -953,24 +956,18 @@ export class DummyERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_from.toLowerCase(), ...txData,
_to.toLowerCase(), data: this.getABIEncodedTransactionData(),
_tokenId, });
_data,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_to.toLowerCase(), defaultBlock,
_tokenId, );
_data,
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1001,12 +998,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_operator.toLowerCase(),
_approved,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1021,20 +1014,18 @@ export class DummyERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_operator.toLowerCase(), ...txData,
_approved, data: this.getABIEncodedTransactionData(),
]); });
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_operator.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_approved, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1050,8 +1041,10 @@ export class DummyERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1081,13 +1074,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_from.toLowerCase(),
_to.toLowerCase(),
_tokenId,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1102,22 +1090,18 @@ export class DummyERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_from.toLowerCase(), ...txData,
_to.toLowerCase(), data: this.getABIEncodedTransactionData(),
_tokenId, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_to.toLowerCase(), defaultBlock,
_tokenId, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1140,9 +1124,8 @@ export class DummyERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1157,14 +1140,18 @@ export class DummyERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },

210
packages/abi-gen-wrappers/src/generated-wrappers/erc1155_mintable.ts generated
View File

@@ -728,8 +728,10 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -745,8 +747,10 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -764,8 +768,10 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [owner.toLowerCase(), id]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -783,8 +789,10 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [owners, ids]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber[]>(rawCallResult);
}, },
@@ -810,9 +818,8 @@ export class ERC1155MintableContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [uri, isNF]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -827,14 +834,18 @@ export class ERC1155MintableContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [uri, isNF]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [uri, isNF]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -859,9 +870,8 @@ export class ERC1155MintableContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [type_, uri]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -876,14 +886,18 @@ export class ERC1155MintableContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [type_, uri]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [type_, uri]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -900,8 +914,10 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -921,8 +937,7 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [id]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -942,8 +957,7 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [id]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -961,11 +975,10 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
owner.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
operator.toLowerCase(), defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -985,8 +998,7 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [id]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -1006,8 +1018,7 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [id]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -1027,8 +1038,7 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [id]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -1048,8 +1058,7 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [id]); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
const rawCallResult = await self._evmExecAsync(encodedData);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -1066,8 +1075,10 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1094,9 +1105,8 @@ export class ERC1155MintableContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [id, to, quantities]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1111,14 +1121,18 @@ export class ERC1155MintableContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [id, to, quantities]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [id, to, quantities]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1143,9 +1157,8 @@ export class ERC1155MintableContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [type_, to]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1160,14 +1173,18 @@ export class ERC1155MintableContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [type_, to]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [type_, to]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1187,8 +1204,10 @@ export class ERC1155MintableContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [id]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1225,15 +1244,8 @@ export class ERC1155MintableContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
from.toLowerCase(),
to.toLowerCase(),
ids,
values,
data,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1248,26 +1260,18 @@ export class ERC1155MintableContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
from.toLowerCase(), ...txData,
to.toLowerCase(), data: this.getABIEncodedTransactionData(),
ids, });
values,
data,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
to.toLowerCase(), defaultBlock,
ids, );
values,
data,
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1310,15 +1314,8 @@ export class ERC1155MintableContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
from.toLowerCase(),
to.toLowerCase(),
id,
value,
data,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1333,26 +1330,18 @@ export class ERC1155MintableContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
from.toLowerCase(), ...txData,
to.toLowerCase(), data: this.getABIEncodedTransactionData(),
id, });
value,
data,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
to.toLowerCase(), defaultBlock,
id, );
value,
data,
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1383,9 +1372,8 @@ export class ERC1155MintableContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [operator.toLowerCase(), approved]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1400,14 +1388,18 @@ export class ERC1155MintableContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [operator.toLowerCase(), approved]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [operator.toLowerCase(), approved]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },

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

@@ -357,9 +357,8 @@ export class ERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_spender.toLowerCase(), _value]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -374,14 +373,18 @@ export class ERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_spender.toLowerCase(), _value]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_spender.toLowerCase(), _value]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -401,8 +404,10 @@ export class ERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -430,13 +435,8 @@ export class ERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_from.toLowerCase(),
_to.toLowerCase(),
_value,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -451,22 +451,18 @@ export class ERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_from.toLowerCase(), ...txData,
_to.toLowerCase(), data: this.getABIEncodedTransactionData(),
_value, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_to.toLowerCase(), defaultBlock,
_value, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -488,8 +484,10 @@ export class ERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_owner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -515,9 +513,8 @@ export class ERC20TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _value]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -532,14 +529,18 @@ export class ERC20TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _value]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_to.toLowerCase(), _value]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -557,11 +558,10 @@ export class ERC20TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_owner.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_spender.toLowerCase(), defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },

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

@@ -448,9 +448,8 @@ export class ERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_approved.toLowerCase(), _tokenId]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -465,14 +464,18 @@ export class ERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_approved.toLowerCase(), _tokenId]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_approved.toLowerCase(), _tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -495,8 +498,10 @@ export class ERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_owner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -518,8 +523,10 @@ export class ERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -537,11 +544,10 @@ export class ERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_owner.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_operator.toLowerCase(), defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -564,8 +570,10 @@ export class ERC721TokenContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -593,13 +601,8 @@ export class ERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_from.toLowerCase(),
_to.toLowerCase(),
_tokenId,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -614,22 +617,18 @@ export class ERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_from.toLowerCase(), ...txData,
_to.toLowerCase(), data: this.getABIEncodedTransactionData(),
_tokenId, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_to.toLowerCase(), defaultBlock,
_tokenId, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -673,14 +672,8 @@ export class ERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_from.toLowerCase(),
_to.toLowerCase(),
_tokenId,
_data,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -695,24 +688,18 @@ export class ERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_from.toLowerCase(), ...txData,
_to.toLowerCase(), data: this.getABIEncodedTransactionData(),
_tokenId, });
_data,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_to.toLowerCase(), defaultBlock,
_tokenId, );
_data,
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -743,12 +730,8 @@ export class ERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_operator.toLowerCase(),
_approved,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -763,20 +746,18 @@ export class ERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_operator.toLowerCase(), ...txData,
_approved, data: this.getABIEncodedTransactionData(),
]); });
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_operator.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_approved, defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -806,13 +787,8 @@ export class ERC721TokenContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_from.toLowerCase(),
_to.toLowerCase(),
_tokenId,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -827,22 +803,18 @@ export class ERC721TokenContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_from.toLowerCase(), ...txData,
_to.toLowerCase(), data: this.getABIEncodedTransactionData(),
_tokenId, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_from.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
_to.toLowerCase(), defaultBlock,
_tokenId, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },

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

File diff suppressed because it is too large Load Diff

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

@@ -458,9 +458,8 @@ export class ForwarderContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -475,14 +474,18 @@ export class ForwarderContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -541,15 +544,8 @@ export class ForwarderContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
orders,
makerAssetBuyAmount,
signatures,
feePercentage,
feeRecipient.toLowerCase(),
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -564,14 +560,10 @@ export class ForwarderContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
orders, ...txData,
makerAssetBuyAmount, data: this.getABIEncodedTransactionData(),
signatures, });
feePercentage,
feeRecipient.toLowerCase(),
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync( async callAsync(
@@ -579,14 +571,10 @@ export class ForwarderContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
orders, { ...callData, data: this.getABIEncodedTransactionData() },
makerAssetBuyAmount, defaultBlock,
signatures, );
feePercentage,
feeRecipient.toLowerCase(),
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber]>(rawCallResult);
}, },
@@ -646,14 +634,8 @@ export class ForwarderContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
orders,
signatures,
feePercentage,
feeRecipient.toLowerCase(),
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -668,13 +650,10 @@ export class ForwarderContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
orders, ...txData,
signatures, data: this.getABIEncodedTransactionData(),
feePercentage, });
feeRecipient.toLowerCase(),
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync( async callAsync(
@@ -682,13 +661,10 @@ export class ForwarderContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
orders, { ...callData, data: this.getABIEncodedTransactionData() },
signatures, defaultBlock,
feePercentage, );
feeRecipient.toLowerCase(),
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber]>(rawCallResult);
}, },
@@ -709,8 +685,10 @@ export class ForwarderContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -729,9 +707,8 @@ export class ForwarderContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -746,14 +723,18 @@ export class ForwarderContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -780,9 +761,8 @@ export class ForwarderContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [assetData, amount]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -797,14 +777,18 @@ export class ForwarderContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [assetData, amount]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [assetData, amount]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },

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

@@ -187,12 +187,10 @@ export class IValidatorContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
hash, { ...callData, data: this.getABIEncodedTransactionData() },
signerAddress.toLowerCase(), defaultBlock,
signature, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },

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

@@ -181,8 +181,10 @@ export class IWalletContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [hash, signature]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },

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

@@ -773,8 +773,10 @@ export class OrderValidatorContract extends BaseContract {
] ]
> { > {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [order, takerAddress.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue< return abiEncoder.strictDecodeReturnValue<
[ [
@@ -809,8 +811,10 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase(), assetData]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber]>(rawCallResult);
}, },
@@ -876,8 +880,10 @@ export class OrderValidatorContract extends BaseContract {
] ]
> { > {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [orders, takerAddresses]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue< return abiEncoder.strictDecodeReturnValue<
[ [
@@ -951,8 +957,10 @@ export class OrderValidatorContract extends BaseContract {
}> }>
> { > {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [orders, takerAddresses]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue< return abiEncoder.strictDecodeReturnValue<
Array<{ Array<{
@@ -981,8 +989,10 @@ export class OrderValidatorContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [token.toLowerCase(), tokenId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1006,8 +1016,10 @@ export class OrderValidatorContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber[], BigNumber[]]> { ): Promise<[BigNumber[], BigNumber[]]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase(), assetData]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber[], BigNumber[]]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[BigNumber[], BigNumber[]]>(rawCallResult);
}, },
@@ -1063,8 +1075,10 @@ export class OrderValidatorContract extends BaseContract {
takerZrxAllowance: BigNumber; takerZrxAllowance: BigNumber;
}> { }> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [order, takerAddress.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<{ return abiEncoder.strictDecodeReturnValue<{
makerBalance: BigNumber; makerBalance: BigNumber;

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

@@ -1655,9 +1655,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1672,14 +1671,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1702,9 +1705,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [addr.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1719,14 +1721,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [addr.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [addr.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1748,8 +1754,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]>( return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]>(
rawCallResult, rawCallResult,
@@ -1768,8 +1776,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1786,8 +1796,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -1803,8 +1815,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number>(rawCallResult);
}, },
@@ -1820,8 +1834,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number>(rawCallResult);
}, },
@@ -1845,8 +1861,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId, member.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1868,8 +1886,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1899,9 +1919,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [operatorShare, addOperatorAsMaker]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1916,14 +1935,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [operatorShare, addOperatorAsMaker]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [operatorShare, addOperatorAsMaker]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1939,8 +1962,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1956,8 +1981,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1986,9 +2013,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [poolId, newOperatorShare]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2003,14 +2029,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [poolId, newOperatorShare]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId, newOperatorShare]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2034,9 +2064,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, []);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2051,14 +2080,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, []); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2074,8 +2107,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2102,9 +2137,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2119,14 +2153,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2146,8 +2184,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string[]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string[]>(rawCallResult);
}, },
@@ -2169,8 +2209,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2197,8 +2239,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ currentEpoch: BigNumber; currentEpochBalance: BigNumber; nextEpochBalance: BigNumber }> { ): Promise<{ currentEpoch: BigNumber; currentEpochBalance: BigNumber; nextEpochBalance: BigNumber }> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [stakeStatus]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<{ return abiEncoder.strictDecodeReturnValue<{
currentEpoch: BigNumber; currentEpoch: BigNumber;
@@ -2232,8 +2276,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ currentEpoch: BigNumber; currentEpochBalance: BigNumber; nextEpochBalance: BigNumber }> { ): Promise<{ currentEpoch: BigNumber; currentEpochBalance: BigNumber; nextEpochBalance: BigNumber }> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [staker.toLowerCase(), stakeStatus]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<{ return abiEncoder.strictDecodeReturnValue<{
currentEpoch: BigNumber; currentEpoch: BigNumber;
@@ -2260,8 +2306,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, number, BigNumber, number, number]> { ): Promise<[BigNumber, number, BigNumber, number, number]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, number, BigNumber, number, number]>( return abiEncoder.strictDecodeReturnValue<[BigNumber, number, BigNumber, number, number]>(
rawCallResult, rawCallResult,
@@ -2293,8 +2341,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ currentEpoch: BigNumber; currentEpochBalance: BigNumber; nextEpochBalance: BigNumber }> { ): Promise<{ currentEpoch: BigNumber; currentEpochBalance: BigNumber; nextEpochBalance: BigNumber }> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [staker.toLowerCase(), poolId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<{ return abiEncoder.strictDecodeReturnValue<{
currentEpoch: BigNumber; currentEpoch: BigNumber;
@@ -2322,8 +2372,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ operator: string; operatorShare: number }> { ): Promise<{ operator: string; operatorShare: number }> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<{ operator: string; operatorShare: number }>(rawCallResult); return abiEncoder.strictDecodeReturnValue<{ operator: string; operatorShare: number }>(rawCallResult);
}, },
@@ -2350,8 +2402,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ feesCollected: BigNumber; weightedStake: BigNumber; membersStake: BigNumber }> { ): Promise<{ feesCollected: BigNumber; weightedStake: BigNumber; membersStake: BigNumber }> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<{ return abiEncoder.strictDecodeReturnValue<{
feesCollected: BigNumber; feesCollected: BigNumber;
@@ -2377,8 +2431,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [staker.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2406,8 +2462,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{ currentEpoch: BigNumber; currentEpochBalance: BigNumber; nextEpochBalance: BigNumber }> { ): Promise<{ currentEpoch: BigNumber; currentEpochBalance: BigNumber; nextEpochBalance: BigNumber }> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<{ return abiEncoder.strictDecodeReturnValue<{
currentEpoch: BigNumber; currentEpoch: BigNumber;
@@ -2431,8 +2489,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2452,8 +2512,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2476,9 +2538,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, []);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2493,14 +2554,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, []); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2523,9 +2588,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2540,14 +2604,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2563,8 +2631,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2580,8 +2650,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2613,9 +2685,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [from, to, amount]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2630,14 +2701,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [from, to, amount]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [from, to, amount]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2653,8 +2728,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2688,13 +2765,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
makerAddress.toLowerCase(),
payerAddress.toLowerCase(),
protocolFee,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2709,22 +2781,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
makerAddress.toLowerCase(), ...txData,
payerAddress.toLowerCase(), data: this.getABIEncodedTransactionData(),
protocolFee, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
makerAddress.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
payerAddress.toLowerCase(), defaultBlock,
protocolFee, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2745,8 +2813,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -2770,8 +2840,10 @@ export class StakingContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0, index_1]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber]>(rawCallResult);
}, },
@@ -2794,9 +2866,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2811,14 +2882,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2843,9 +2918,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase(), index]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2860,14 +2934,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase(), index]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase(), index]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2890,9 +2968,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [addr.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -2907,14 +2984,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [addr.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [addr.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -2930,8 +3011,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number>(rawCallResult);
}, },
@@ -2948,8 +3031,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -2989,15 +3074,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
_epochDurationInSeconds,
_rewardDelegatedStakeWeight,
_minimumPoolStake,
_cobbDouglasAlphaNumerator,
_cobbDouglasAlphaDenominator,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -3012,26 +3090,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
_epochDurationInSeconds, ...txData,
_rewardDelegatedStakeWeight, data: this.getABIEncodedTransactionData(),
_minimumPoolStake, });
_cobbDouglasAlphaNumerator,
_cobbDouglasAlphaDenominator,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
_epochDurationInSeconds, { ...callData, data: this.getABIEncodedTransactionData() },
_rewardDelegatedStakeWeight, defaultBlock,
_minimumPoolStake, );
_cobbDouglasAlphaNumerator,
_cobbDouglasAlphaDenominator,
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -3061,9 +3131,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [amount]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -3078,14 +3147,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [amount]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [amount]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -3101,8 +3174,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -3121,9 +3196,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -3138,14 +3212,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -3170,9 +3248,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [amount]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -3187,14 +3264,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [amount]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [amount]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -3211,8 +3292,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -3228,8 +3311,10 @@ export class StakingContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -3253,9 +3338,8 @@ export class StakingContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -3270,14 +3354,18 @@ export class StakingContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [poolId]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },

225
packages/abi-gen-wrappers/src/generated-wrappers/staking_proxy.ts generated
View File

@@ -742,9 +742,8 @@ export class StakingProxyContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -759,14 +758,18 @@ export class StakingProxyContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -788,8 +791,10 @@ export class StakingProxyContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]>( return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber, BigNumber, BigNumber]>(
rawCallResult, rawCallResult,
@@ -810,8 +815,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -834,9 +841,8 @@ export class StakingProxyContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [_stakingContract.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -851,14 +857,18 @@ export class StakingProxyContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [_stakingContract.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [_stakingContract.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -875,8 +885,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -893,8 +905,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -918,9 +932,8 @@ export class StakingProxyContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [data]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -935,14 +948,18 @@ export class StakingProxyContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [data]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [data]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string[]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string[]>(rawCallResult);
}, },
@@ -958,8 +975,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number>(rawCallResult);
}, },
@@ -975,8 +994,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number>(rawCallResult);
}, },
@@ -992,8 +1013,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1009,8 +1032,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1031,9 +1056,8 @@ export class StakingProxyContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, []);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1048,14 +1072,18 @@ export class StakingProxyContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, []); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1071,8 +1099,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1092,8 +1122,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string[]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string[]>(rawCallResult);
}, },
@@ -1109,8 +1141,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1126,8 +1160,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1143,8 +1179,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1161,8 +1199,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1186,8 +1226,10 @@ export class StakingProxyContract extends BaseContract {
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<[BigNumber, BigNumber, BigNumber]> { ): Promise<[BigNumber, BigNumber, BigNumber]> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0, index_1]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber]>(rawCallResult); return abiEncoder.strictDecodeReturnValue<[BigNumber, BigNumber, BigNumber]>(rawCallResult);
}, },
@@ -1210,9 +1252,8 @@ export class StakingProxyContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1227,14 +1268,18 @@ export class StakingProxyContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1259,9 +1304,8 @@ export class StakingProxyContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase(), index]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1276,14 +1320,18 @@ export class StakingProxyContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase(), index]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [target.toLowerCase(), index]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1299,8 +1347,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number>(rawCallResult);
}, },
@@ -1317,8 +1367,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -1334,8 +1386,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -1354,9 +1408,8 @@ export class StakingProxyContract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -1371,14 +1424,18 @@ export class StakingProxyContract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [newOwner.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -1395,8 +1452,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -1412,8 +1471,10 @@ export class StakingProxyContract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },

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

@@ -471,8 +471,10 @@ export class WETH9Contract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -492,9 +494,8 @@ export class WETH9Contract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [guy.toLowerCase(), wad]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -509,14 +510,18 @@ export class WETH9Contract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [guy.toLowerCase(), wad]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [guy.toLowerCase(), wad]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -532,8 +537,10 @@ export class WETH9Contract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -554,13 +561,8 @@ export class WETH9Contract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [
src.toLowerCase(),
dst.toLowerCase(),
wad,
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -575,22 +577,18 @@ export class WETH9Contract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [ const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
src.toLowerCase(), ...txData,
dst.toLowerCase(), data: this.getABIEncodedTransactionData(),
wad, });
]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData });
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
src.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
dst.toLowerCase(), defaultBlock,
wad, );
]);
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -609,9 +607,8 @@ export class WETH9Contract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [wad]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -626,14 +623,18 @@ export class WETH9Contract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [wad]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [wad]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -649,8 +650,10 @@ export class WETH9Contract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<number>(rawCallResult); return abiEncoder.strictDecodeReturnValue<number>(rawCallResult);
}, },
@@ -667,8 +670,10 @@ export class WETH9Contract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [index_0.toLowerCase()]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },
@@ -684,8 +689,10 @@ export class WETH9Contract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<string>(rawCallResult); return abiEncoder.strictDecodeReturnValue<string>(rawCallResult);
}, },
@@ -705,9 +712,8 @@ export class WETH9Contract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [dst.toLowerCase(), wad]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -722,14 +728,18 @@ export class WETH9Contract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [dst.toLowerCase(), wad]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [dst.toLowerCase(), wad]); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult); return abiEncoder.strictDecodeReturnValue<boolean>(rawCallResult);
}, },
@@ -747,9 +757,8 @@ export class WETH9Contract extends BaseContract {
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, []);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -764,14 +773,18 @@ export class WETH9Contract extends BaseContract {
return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts); return self._promiseWithTransactionHash(this.sendTransactionAsync(txData, opts), opts);
}, },
async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> { async estimateGasAsync(txData?: Partial<TxData> | undefined): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, []); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData }); ...txData,
data: this.getABIEncodedTransactionData(),
});
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, []); const rawCallResult = await self._performCallAsync(
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); { ...callData, data: this.getABIEncodedTransactionData() },
defaultBlock,
);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<void>(rawCallResult); return abiEncoder.strictDecodeReturnValue<void>(rawCallResult);
}, },
@@ -789,11 +802,10 @@ export class WETH9Contract extends BaseContract {
return { return {
async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> { async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [ const rawCallResult = await self._performCallAsync(
index_0.toLowerCase(), { ...callData, data: this.getABIEncodedTransactionData() },
index_1.toLowerCase(), defaultBlock,
]); );
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock);
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult); return abiEncoder.strictDecodeReturnValue<BigNumber>(rawCallResult);
}, },

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

@@ -65,7 +65,7 @@ export class {{contractName}}Contract extends BaseContract {
{{else~}} {{else~}}
public static deployedBytecode = '{{this.deployedBytecode}}'; public static deployedBytecode = '{{this.deployedBytecode}}';
{{/ifEquals~}} {{/ifEquals~}}
private readonly _methodABIIndex: { [name:string]: number } = {}; private readonly _methodABIIndex: { [name: string]: number } = {};
{{#if events~}} {{#if events~}}
private readonly _subscriptionManager: SubscriptionManager<{{contractName}}EventArgs, {{contractName}}Events>; private readonly _subscriptionManager: SubscriptionManager<{{contractName}}EventArgs, {{contractName}}Events>;
{{/if~}} {{/if~}}

5
packages/abi-gen/templates/TypeScript/partials/method_call.handlebars
View File

@@ -3,11 +3,10 @@ async callAsync(
defaultBlock?: BlockParam, defaultBlock?: BlockParam,
): Promise<{{> return_type outputs=outputs}}> { ): Promise<{{> return_type outputs=outputs}}> {
BaseContract._assertCallParams(callData, defaultBlock); BaseContract._assertCallParams(callData, defaultBlock);
const encodedData = self._strictEncodeArguments(functionSignature, [{{> normalized_params inputs=inputs}}]);
{{#ifEquals this.stateMutability "pure"}} {{#ifEquals this.stateMutability "pure"}}
const rawCallResult = await self._evmExecAsync(encodedData); const rawCallResult = await self._evmExecAsync(this.getABIEncodedTransactionData());
{{else}} {{else}}
const rawCallResult = await self._performCallAsync({ ...callData, data: encodedData }, defaultBlock); const rawCallResult = await self._performCallAsync({ ...callData, data: this.getABIEncodedTransactionData() }, defaultBlock);
{{/ifEquals}} {{/ifEquals}}
const abiEncoder = self._lookupAbiEncoder(functionSignature); const abiEncoder = self._lookupAbiEncoder(functionSignature);
return abiEncoder.strictDecodeReturnValue<{{> return_type outputs=outputs}}>(rawCallResult); return abiEncoder.strictDecodeReturnValue<{{> return_type outputs=outputs}}>(rawCallResult);

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

@@ -2,9 +2,8 @@ async sendTransactionAsync(
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
opts: SendTransactionOpts = { shouldValidate: true }, opts: SendTransactionOpts = { shouldValidate: true },
): Promise<string> { ): Promise<string> {
const encodedData = self._strictEncodeArguments(functionSignature, [{{> normalized_params inputs=inputs}}]);
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync( const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
{ ...txData, data: encodedData }, { ...txData, data: this.getABIEncodedTransactionData() },
this.estimateGasAsync.bind(this), this.estimateGasAsync.bind(this),
); );
if (opts.shouldValidate !== false) { if (opts.shouldValidate !== false) {
@@ -21,7 +20,8 @@ awaitTransactionSuccessAsync(
async estimateGasAsync( async estimateGasAsync(
txData?: Partial<TxData> | undefined, txData?: Partial<TxData> | undefined,
): Promise<number> { ): Promise<number> {
const encodedData = self._strictEncodeArguments(functionSignature, [{{> normalized_params inputs=inputs}}]); const txDataWithDefaults = await self._applyDefaultsToTxDataAsync(
const txDataWithDefaults = await self._applyDefaultsToTxDataAsync({ ...txData, data: encodedData, }); { ...txData, data: this.getABIEncodedTransactionData() }
);
return self._web3Wrapper.estimateGasAsync(txDataWithDefaults); return self._web3Wrapper.estimateGasAsync(txDataWithDefaults);
}, },

3
packages/base-contract/src/subscription_manager.ts
View File

@@ -108,8 +108,7 @@ export class SubscriptionManager<ContractEventArgs, ContractEvents extends strin
): void { ): void {
const logs: LogEntry[] = rawLogs.map(rawLog => marshaller.unmarshalLog(rawLog)); const logs: LogEntry[] = rawLogs.map(rawLog => marshaller.unmarshalLog(rawLog));
logs.forEach(log => { logs.forEach(log => {
Object.keys(this._filters).forEach((filterToken: string) => { Object.entries(this._filters).forEach(([filterToken, filter]) => {
const filter = this._filters[filterToken];
if (filterUtils.matchesFilter(log, filter)) { if (filterUtils.matchesFilter(log, filter)) {
const decodedLog = this._tryToDecodeLogOrNoop(log) as LogWithDecodedArgs<ArgsType>; const decodedLog = this._tryToDecodeLogOrNoop(log) as LogWithDecodedArgs<ArgsType>;
const logEvent = { const logEvent = {