diff options
14 files changed, 193 insertions, 191 deletions
diff --git a/packages/base-contract/src/index.ts b/packages/base-contract/src/index.ts index 9723dc9c8..30546725c 100644 --- a/packages/base-contract/src/index.ts +++ b/packages/base-contract/src/index.ts @@ -1,23 +1,11 @@ -import { abiUtils, BigNumber } from '@0x/utils'; +import { AbiEncoder, abiUtils } from '@0x/utils'; import { Web3Wrapper } from '@0x/web3-wrapper'; -import { - AbiDefinition, - AbiType, - ConstructorAbi, - ContractAbi, - DataItem, - MethodAbi, - Provider, - TxData, - TxDataPayable, -} from 'ethereum-types'; +import { AbiDefinition, AbiType, ConstructorAbi, ContractAbi, DataItem, MethodAbi, Provider, TxData, TxDataPayable } from 'ethereum-types'; import * as ethers from 'ethers'; import * as _ from 'lodash'; import { formatABIDataItem } from './utils'; -import { AbiEncoder } from '@0x/utils'; - export interface AbiEncoderByFunctionSignature { [key: string]: AbiEncoder.Method; } @@ -143,7 +131,7 @@ export class BaseContract { if (inputAbi === undefined) { throw new Error(`Undefined Method Input ABI`); } - const abiEncodedArguments = abiEncoder.encode(functionArguments); ////BaseContract.strictArgumentEncodingCheck(inputAbi, functionArguments); + const abiEncodedArguments = abiEncoder.encode(functionArguments); return abiEncodedArguments; } constructor( diff --git a/packages/utils/src/abi_encoder/abstract_data_types/data_type.ts b/packages/utils/src/abi_encoder/abstract_data_types/data_type.ts index dc897d810..d9e854f51 100644 --- a/packages/utils/src/abi_encoder/abstract_data_types/data_type.ts +++ b/packages/utils/src/abi_encoder/abstract_data_types/data_type.ts @@ -58,9 +58,13 @@ export abstract class DataType { } public getSignature(detailed?: boolean): string { - if (_.isEmpty(this._dataItem.name) || !detailed) return this.getSignatureType(); + if (_.isEmpty(this._dataItem.name) || !detailed) { + return this.getSignatureType(); + } const name = this.getDataItem().name; - const shortName = name.indexOf('.') > 0 ? name.substr(name.lastIndexOf('.') + 1) : name; + const lastIndexOfScopeDelimiter = name.lastIndexOf('.'); + const isScopedName = !_.isUndefined(lastIndexOfScopeDelimiter) && lastIndexOfScopeDelimiter > 0; + const shortName = isScopedName ? name.substr((lastIndexOfScopeDelimiter as number) + 1) : name; const detailedSignature = `${shortName} ${this.getSignatureType()}`; return detailedSignature; } diff --git a/packages/utils/src/abi_encoder/abstract_data_types/types/blob.ts b/packages/utils/src/abi_encoder/abstract_data_types/types/blob.ts index 4252b782c..a091e55b9 100644 --- a/packages/utils/src/abi_encoder/abstract_data_types/types/blob.ts +++ b/packages/utils/src/abi_encoder/abstract_data_types/types/blob.ts @@ -9,8 +9,6 @@ import { DecodingRules } from '../../utils/rules'; import { DataType } from '../data_type'; import { DataTypeFactory } from '../interfaces'; -import * as ethUtil from 'ethereumjs-util'; - export abstract class AbstractBlobDataType extends DataType { protected _sizeKnownAtCompileTime: boolean; diff --git a/packages/utils/src/abi_encoder/abstract_data_types/types/set.ts b/packages/utils/src/abi_encoder/abstract_data_types/types/set.ts index 28d11c4b5..e4be96235 100644 --- a/packages/utils/src/abi_encoder/abstract_data_types/types/set.ts +++ b/packages/utils/src/abi_encoder/abstract_data_types/types/set.ts @@ -13,7 +13,6 @@ import { DataType } from '../data_type'; import { DataTypeFactory, MemberIndexByName } from '../interfaces'; import { AbstractPointerDataType } from './pointer'; -import { logUtils } from '../../../log_utils'; export abstract class AbstractSetDataType extends DataType { protected readonly _arrayLength: number | undefined; diff --git a/packages/utils/src/abi_encoder/evm_data_type_factory.ts b/packages/utils/src/abi_encoder/evm_data_type_factory.ts index dcfcc9c5a..6d59ec01a 100644 --- a/packages/utils/src/abi_encoder/evm_data_type_factory.ts +++ b/packages/utils/src/abi_encoder/evm_data_type_factory.ts @@ -132,15 +132,23 @@ export class EvmDataTypeFactory implements DataTypeFactory { private constructor() {} } -// Convenience function +/** + * Convenience function for creating a DataType from different inputs. + * @param input A single or set of DataItem or a DataType signature. + * A signature in the form of '<type>' is interpreted as a `DataItem` + * For example, 'string' is interpreted as {type: 'string'} + * A signature in the form '(<type1>, <type2>, ..., <typen>)' is interpreted as `DataItem[]` + * For eaxmple, '(string, uint256)' is interpreted as [{type: 'string'}, {type: 'uint256'}] + * @return DataType corresponding to input. + */ export function create(input: DataItem | DataItem[] | string): DataType { // Handle different types of input const isSignature = typeof input === 'string'; const isTupleSignature = isSignature && (input as string).startsWith('('); - const parseAsTuple = isTupleSignature || _.isArray(input); + const shouldParseAsTuple = isTupleSignature || _.isArray(input); // Create input `dataItem` let dataItem: DataItem; - if (parseAsTuple) { + if (shouldParseAsTuple) { const dataItems = isSignature ? generateDataItemsFromSignature(input as string) : (input as DataItem[]); dataItem = { name: '', diff --git a/packages/utils/src/abi_encoder/evm_data_types/array.ts b/packages/utils/src/abi_encoder/evm_data_types/array.ts index 8b71dc913..449de0568 100644 --- a/packages/utils/src/abi_encoder/evm_data_types/array.ts +++ b/packages/utils/src/abi_encoder/evm_data_types/array.ts @@ -7,7 +7,6 @@ import { constants } from '../utils/constants'; export class ArrayDataType extends AbstractSetDataType { private static readonly _MATCHER = RegExp('^(.+)\\[([0-9]*)\\]$'); - private readonly _arraySignature: string; private readonly _elementType: string; public static matchType(type: string): boolean { @@ -35,7 +34,6 @@ export class ArrayDataType extends AbstractSetDataType { super(dataItem, dataTypeFactory, isArray, arrayLength, arrayElementType); // Set array properties this._elementType = arrayElementType; - this._arraySignature = this._computeSignature(); } public getSignatureType(): string { @@ -43,9 +41,13 @@ export class ArrayDataType extends AbstractSetDataType { } public getSignature(detailed?: boolean): string { - if (_.isEmpty(this.getDataItem().name) || !detailed) return this.getSignatureType(); + if (_.isEmpty(this.getDataItem().name) || !detailed) { + return this.getSignatureType(); + } const name = this.getDataItem().name; - const shortName = name.indexOf('.') > 0 ? name.substr(name.lastIndexOf('.') + 1) : name; + const lastIndexOfScopeDelimiter = name.lastIndexOf('.'); + const isScopedName = !_.isUndefined(lastIndexOfScopeDelimiter) && lastIndexOfScopeDelimiter > 0; + const shortName = isScopedName ? name.substr((lastIndexOfScopeDelimiter as number) + 1) : name; const detailedSignature = `${shortName} ${this._computeSignature(detailed)}`; return detailedSignature; } diff --git a/packages/utils/src/abi_encoder/evm_data_types/int.ts b/packages/utils/src/abi_encoder/evm_data_types/int.ts index 144a0eb6a..8d98e195b 100644 --- a/packages/utils/src/abi_encoder/evm_data_types/int.ts +++ b/packages/utils/src/abi_encoder/evm_data_types/int.ts @@ -50,7 +50,8 @@ export class IntDataType extends AbstractBlobDataType { public decodeValue(calldata: RawCalldata): BigNumber | number { const valueBuf = calldata.popWord(); const value = EncoderMath.safeDecodeNumericValue(valueBuf, this._minValue, this._maxValue); - if (this._width === 8) { + const numberOfBytesInUint8 = 8; + if (this._width === numberOfBytesInUint8) { return value.toNumber(); } return value; diff --git a/packages/utils/src/abi_encoder/evm_data_types/method.ts b/packages/utils/src/abi_encoder/evm_data_types/method.ts index 44456cd0a..6e3fdcf6d 100644 --- a/packages/utils/src/abi_encoder/evm_data_types/method.ts +++ b/packages/utils/src/abi_encoder/evm_data_types/method.ts @@ -8,7 +8,6 @@ import { AbstractSetDataType } from '../abstract_data_types/types/set'; import { constants } from '../utils/constants'; import { DecodingRules, EncodingRules } from '../utils/rules'; -import { ArrayDataType } from './array'; import { TupleDataType } from './tuple'; export class MethodDataType extends AbstractSetDataType { diff --git a/packages/utils/src/abi_encoder/evm_data_types/tuple.ts b/packages/utils/src/abi_encoder/evm_data_types/tuple.ts index 54964235c..3d1cb5a92 100644 --- a/packages/utils/src/abi_encoder/evm_data_types/tuple.ts +++ b/packages/utils/src/abi_encoder/evm_data_types/tuple.ts @@ -5,7 +5,6 @@ import { DataTypeFactory } from '../abstract_data_types/interfaces'; import { AbstractSetDataType } from '../abstract_data_types/types/set'; export class TupleDataType extends AbstractSetDataType { - //private readonly _signature: string; public static matchType(type: string): boolean { return type === SolidityTypes.Tuple; @@ -16,7 +15,6 @@ export class TupleDataType extends AbstractSetDataType { if (!TupleDataType.matchType(dataItem.type)) { throw new Error(`Tried to instantiate Tuple with bad input: ${dataItem}`); } - //this._signature = } public getSignatureType(): string { @@ -24,9 +22,13 @@ export class TupleDataType extends AbstractSetDataType { } public getSignature(detailed?: boolean): string { - if (_.isEmpty(this.getDataItem().name) || !detailed) return this.getSignatureType(); + if (_.isEmpty(this.getDataItem().name) || !detailed) { + return this.getSignatureType(); + } const name = this.getDataItem().name; - const shortName = name.indexOf('.') > 0 ? name.substr(name.lastIndexOf('.') + 1) : name; + const lastIndexOfScopeDelimiter = name.lastIndexOf('.'); + const isScopedName = !_.isUndefined(lastIndexOfScopeDelimiter) && lastIndexOfScopeDelimiter > 0; + const shortName = isScopedName ? name.substr((lastIndexOfScopeDelimiter as number) + 1) : name; const detailedSignature = `${shortName} ${this._computeSignatureOfMembers(detailed)}`; return detailedSignature; } diff --git a/packages/utils/src/abi_encoder/evm_data_types/uint.ts b/packages/utils/src/abi_encoder/evm_data_types/uint.ts index 940fda072..8e382e8dc 100644 --- a/packages/utils/src/abi_encoder/evm_data_types/uint.ts +++ b/packages/utils/src/abi_encoder/evm_data_types/uint.ts @@ -49,7 +49,8 @@ export class UIntDataType extends AbstractBlobDataType { public decodeValue(calldata: RawCalldata): BigNumber | number { const valueBuf = calldata.popWord(); const value = EncoderMath.safeDecodeNumericValue(valueBuf, UIntDataType._MIN_VALUE, this._maxValue); - if (this._width === 8) { + const numberOfBytesInUint8 = 8; + if (this._width === numberOfBytesInUint8) { return value.toNumber(); } return value; diff --git a/packages/utils/src/abi_encoder/utils/signatureParser.ts b/packages/utils/src/abi_encoder/utils/signatureParser.ts index c4796e24e..315784cea 100644 --- a/packages/utils/src/abi_encoder/utils/signatureParser.ts +++ b/packages/utils/src/abi_encoder/utils/signatureParser.ts @@ -1,21 +1,15 @@ +import { DataItem } from 'ethereum-types'; import * as _ from 'lodash'; -import { DataItem } from 'ethereum-protocol'; - -/* -export function generateDataItemFromSignature(signature: string): DataItem { - const dataItems = generateDataItemsFromSignature(signature); - if (dataItems.length === 1) { - return dataItems[0]; - } - // signature represents a tuple - return { - name: '', - type: 'tuple', - components: dataItems - }; -}*/ - +/** + * Returns an array of DataItem's corresponding to the input signature. + * A signature can be in two forms: '<DataItem.type>' or '(<DataItem1.type>, <DataItem2.type>, ...) + * An example of the first form would be 'address' or 'uint256' + * An example of the second form would be '(address, uint256)' + * Signatures can also include a name field, for example: 'foo address' or '(foo address, bar uint256)' + * @param signature of input DataItems + * @return DataItems derived from input signature + */ export function generateDataItemsFromSignature(signature: string): DataItem[] { let trimmedSignature = signature; if (signature.startsWith('(')) { @@ -25,7 +19,7 @@ export function generateDataItemsFromSignature(signature: string): DataItem[] { trimmedSignature = signature.substr(1, signature.length - 2); } trimmedSignature += ','; - let currTokenIsArray = false; + let isCurrTokenArray = false; let currTokenArrayModifier = ''; let isParsingArrayModifier = false; let currToken = ''; @@ -46,7 +40,7 @@ export function generateDataItemsFromSignature(signature: string): DataItem[] { case '[': if (parenCount === 0) { isParsingArrayModifier = true; - currTokenIsArray = true; + isCurrTokenArray = true; currTokenArrayModifier += '['; } else { currToken += char; @@ -70,26 +64,24 @@ export function generateDataItemsFromSignature(signature: string): DataItem[] { break; case ',': if (parenCount === 0) { - //throw new Error(`Generating Data Items`); + // Generate new DataItem from token const components = currToken.startsWith('(') ? generateDataItemsFromSignature(currToken) : []; const isTuple = !_.isEmpty(components); - const isArray = currTokenIsArray; - let dataItem: DataItem = { name: currTokenName, type: '' }; + const dataItem: DataItem = { name: currTokenName, type: '' }; if (isTuple) { dataItem.type = 'tuple'; dataItem.components = components; } else { dataItem.type = currToken; } - if (isArray) { + if (isCurrTokenArray) { dataItem.type += currTokenArrayModifier; } - dataItems.push(dataItem); - + // reset token state currTokenName = ''; currToken = ''; - currTokenIsArray = false; + isCurrTokenArray = false; currTokenArrayModifier = ''; break; } else { diff --git a/packages/utils/test/abi_encoder/evm_data_types_test.ts b/packages/utils/test/abi_encoder/evm_data_types_test.ts index 3c7bafc0a..54d536a7e 100644 --- a/packages/utils/test/abi_encoder/evm_data_types_test.ts +++ b/packages/utils/test/abi_encoder/evm_data_types_test.ts @@ -27,9 +27,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Dynamic size; Static elements', async () => { // Create DataType object @@ -46,9 +46,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Fixed size; Dynamic elements', async () => { // Create DataType object @@ -65,9 +65,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Dynamic size; Dynamic elements', async () => { // Create DataType object @@ -84,9 +84,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Dynamic Size; Multidimensional; Dynamic Elements', async () => { // Create DataType object @@ -106,9 +106,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Dynamic Size; Multidimensional; Static Elements', async () => { // Create DataType object @@ -128,9 +128,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Static Size; Multidimensional; Static Elements', async () => { // Create DataType object @@ -149,9 +149,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Static Size; Multidimensional; Dynamic Elements', async () => { // Create DataType object @@ -170,9 +170,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Static size; Too Few Elements', async () => { // Create DataType object @@ -230,9 +230,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs, decodingRules); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args, encodingRules); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args, encodingRules); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Dynamic elements only', async () => { // Create DataType object @@ -254,9 +254,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs, decodingRules); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Nested Static Array', async () => { // Create DataType object @@ -278,9 +278,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs, decodingRules); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Nested Dynamic Array', async () => { // Create DataType object @@ -302,9 +302,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs, decodingRules); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Nested Static Multidimensional Array', async () => { // Create DataType object @@ -328,9 +328,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs, decodingRules); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Nested Dynamic Multidimensional Array', async () => { // Create DataType object @@ -354,9 +354,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs, decodingRules); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Static and dynamic elements mixed', async () => { // Create DataType object @@ -388,9 +388,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs, decodingRules); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Missing Key', async () => { // Create DataType object @@ -424,9 +424,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Invalid Address - input is not valid hex', async () => { // Create DataType object @@ -467,9 +467,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('False', async () => { // Create DataType object @@ -485,9 +485,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); }); @@ -513,9 +513,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Int256 - Negative Base Case', async () => { // Create DataType object @@ -531,9 +531,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Int256 - Positive Value', async () => { // Create DataType object @@ -549,9 +549,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Int256 - Negative Value', async () => { // Create DataType object @@ -567,9 +567,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Int256 - Value too large', async () => { // Create DataType object @@ -607,9 +607,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Int32 - Negative Base Case', async () => { // Create DataType object @@ -625,9 +625,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Int32 - Positive Value', async () => { // Create DataType object @@ -643,9 +643,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Int32 - Negative Value', async () => { // Create DataType object @@ -661,9 +661,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Int32 - Value too large', async () => { // Create DataType object @@ -711,9 +711,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('UInt256 - Positive Value', async () => { // Create DataType object @@ -729,9 +729,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('UInt256 - Zero Value', async () => { // Create DataType object @@ -747,9 +747,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('UInt256 - Value too large', async () => { // Create DataType object @@ -787,9 +787,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('UInt32 - Positive Value', async () => { // Create DataType object @@ -805,9 +805,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('UInt32 - Zero Value', async () => { // Create DataType object @@ -823,9 +823,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('UInt32 - Value too large', async () => { // Create DataType object @@ -866,9 +866,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Single Byte (bytes1)', async () => { // Create DataType object @@ -884,9 +884,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('4 Bytes (bytes4)', async () => { // Create DataType object @@ -902,9 +902,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('4 Bytes (bytes4); Encoder must pad input', async () => { // Create DataType object @@ -922,9 +922,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const paddedArgs = '0x1a180000'; expect(decodedArgs).to.be.deep.equal(paddedArgs); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('32 Bytes (bytes32)', async () => { // Create DataType object @@ -940,9 +940,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('32 Bytes (bytes32); Encoder must pad input', async () => { // Create DataType object @@ -960,9 +960,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const paddedArgs = '0x1a18bf6100000000000000000000000000000000000000000000000000000000'; expect(decodedArgs).to.be.deep.equal(paddedArgs); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Should throw when pass in too many bytes (bytes4)', async () => { // Create DataType object @@ -1031,9 +1031,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Spans multiple EVM words', async () => { // Create DataType object @@ -1052,9 +1052,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Input as Buffer', async () => { // Create DataType object @@ -1073,9 +1073,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Should throw when pass in bad hex (no 0x prefix)', async () => { // Create DataType object @@ -1118,9 +1118,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('Spans multiple EVM words', async () => { // Create DataType object @@ -1139,9 +1139,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); it('String that begins with 0x prefix', async () => { // Create DataType object @@ -1160,9 +1160,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => { const decodedArgs = dataType.decode(encodedArgs); expect(decodedArgs).to.be.deep.equal(args); // Validate signature - const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); - const encodedArgscreate = dataTypecreate.encode(args); - expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); + const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true)); + const argsEncodedFromSignature = dataTypeFromSignature.encode(args); + expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs); }); }); }); diff --git a/packages/utils/test/abi_encoder/methods_test.ts b/packages/utils/test/abi_encoder/methods_test.ts index 472212e3c..920cb1799 100644 --- a/packages/utils/test/abi_encoder/methods_test.ts +++ b/packages/utils/test/abi_encoder/methods_test.ts @@ -199,7 +199,9 @@ describe('ABI Encoder: Method Encoding / Decoding', () => { it('Unfixed Length Array / Static Members ABI', async () => { // Generate calldata const method = new AbiEncoder.Method(AbiSamples.dynamicArrayStaticMembersAbi); + // tslint:disable custom-no-magic-numbers const args = [[127, 14, 54]]; + // tslint:enable custom-no-magic-numbers const calldata = method.encode(args, encodingRules); // Validate calldata const expectedCalldata = @@ -213,7 +215,9 @@ describe('ABI Encoder: Method Encoding / Decoding', () => { it('Fixed Length Array / Static Members ABI', async () => { // Generate calldata const method = new AbiEncoder.Method(AbiSamples.staticArrayAbi); + // tslint:disable custom-no-magic-numbers const args = [[127, 14, 54]]; + // tslint:enable custom-no-magic-numbers const calldata = method.encode(args, encodingRules); // Validate calldata const expectedCalldata = @@ -310,7 +314,9 @@ describe('ABI Encoder: Method Encoding / Decoding', () => { it('Large, Nested ABI', async () => { // Construct Calldata const method = new AbiEncoder.Method(AbiSamples.largeNestedAbi); + // tslint:disable custom-no-magic-numbers const someStaticArray = [127, 14, 54]; + // tslint:enable custom-no-magic-numbers const someStaticArrayWithDynamicMembers = [ 'the little piping piper piped a piping pipper papper', 'the kid knows how to write poems, what can I say -- I guess theres a lot I could say to try to fill this line with a lot of text.', diff --git a/packages/utils/test/abi_encoder/optimizer_test.ts b/packages/utils/test/abi_encoder/optimizer_test.ts index a7c920678..c0640583d 100644 --- a/packages/utils/test/abi_encoder/optimizer_test.ts +++ b/packages/utils/test/abi_encoder/optimizer_test.ts @@ -232,7 +232,9 @@ describe('ABI Encoder: Optimized Method Encoding/Decoding', () => { it('Array Elements Duplicated as Tuple Fields', async () => { // Generate calldata const method = new AbiEncoder.Method(OptimizedAbis.arrayElementsDuplicatedAsTupleFields); + // tslint:disable custom-no-magic-numbers const array = [100, 150, 200, 225]; + // tslint:enable custom-no-magic-numbers const tuple = [ [new BigNumber(array[0])], [new BigNumber(array[1])], |