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

Ran prettier and linter

Browse Source
This commit is contained in:
Greg Hysen
2018-12-23 20:50:02 -08:00
parent 6d832deb62
commit 86caa4a0bb
14 changed files with 193 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,23 +1,11 @@
import { abiUtils, BigNumber } from '@0x/utils'; import { AbiEncoder, abiUtils } from '@0x/utils';
import { Web3Wrapper } from '@0x/web3-wrapper'; import { Web3Wrapper } from '@0x/web3-wrapper';
import { import { AbiDefinition, AbiType, ConstructorAbi, ContractAbi, DataItem, MethodAbi, Provider, TxData, TxDataPayable } from 'ethereum-types';
AbiDefinition,
AbiType,
ConstructorAbi,
ContractAbi,
DataItem,
MethodAbi,
Provider,
TxData,
TxDataPayable,
} from 'ethereum-types';
import * as ethers from 'ethers'; import * as ethers from 'ethers';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { formatABIDataItem } from './utils'; import { formatABIDataItem } from './utils';
import { AbiEncoder } from '@0x/utils';
export interface AbiEncoderByFunctionSignature { export interface AbiEncoderByFunctionSignature {
[key: string]: AbiEncoder.Method; [key: string]: AbiEncoder.Method;
} }
@@ -143,7 +131,7 @@ export class BaseContract {
if (inputAbi === undefined) { if (inputAbi === undefined) {
throw new Error(`Undefined Method Input ABI`); throw new Error(`Undefined Method Input ABI`);
} }
const abiEncodedArguments = abiEncoder.encode(functionArguments); ////BaseContract.strictArgumentEncodingCheck(inputAbi, functionArguments); const abiEncodedArguments = abiEncoder.encode(functionArguments);
return abiEncodedArguments; return abiEncodedArguments;
} }
constructor( constructor(

8
packages/utils/src/abi_encoder/abstract_data_types/data_type.ts
View File

@@ -58,9 +58,13 @@ export abstract class DataType {
} }
public getSignature(detailed?: boolean): string { 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 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()}`; const detailedSignature = `${shortName} ${this.getSignatureType()}`;
return detailedSignature; return detailedSignature;
} }

2
packages/utils/src/abi_encoder/abstract_data_types/types/blob.ts
View File

@@ -9,8 +9,6 @@ import { DecodingRules } from '../../utils/rules';
import { DataType } from '../data_type'; import { DataType } from '../data_type';
import { DataTypeFactory } from '../interfaces'; import { DataTypeFactory } from '../interfaces';
import * as ethUtil from 'ethereumjs-util';
export abstract class AbstractBlobDataType extends DataType { export abstract class AbstractBlobDataType extends DataType {
protected _sizeKnownAtCompileTime: boolean; protected _sizeKnownAtCompileTime: boolean;

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

@@ -13,7 +13,6 @@ import { DataType } from '../data_type';
import { DataTypeFactory, MemberIndexByName } from '../interfaces'; import { DataTypeFactory, MemberIndexByName } from '../interfaces';
import { AbstractPointerDataType } from './pointer'; import { AbstractPointerDataType } from './pointer';
import { logUtils } from '../../../log_utils';
export abstract class AbstractSetDataType extends DataType { export abstract class AbstractSetDataType extends DataType {
protected readonly _arrayLength: number | undefined; protected readonly _arrayLength: number | undefined;

14
packages/utils/src/abi_encoder/evm_data_type_factory.ts
View File

@@ -132,15 +132,23 @@ export class EvmDataTypeFactory implements DataTypeFactory {
private constructor() {} 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 { export function create(input: DataItem | DataItem[] | string): DataType {
// Handle different types of input // Handle different types of input
const isSignature = typeof input === 'string'; const isSignature = typeof input === 'string';
const isTupleSignature = isSignature && (input as string).startsWith('('); const isTupleSignature = isSignature && (input as string).startsWith('(');
const parseAsTuple = isTupleSignature || _.isArray(input); const shouldParseAsTuple = isTupleSignature || _.isArray(input);
// Create input `dataItem` // Create input `dataItem`
let dataItem: DataItem; let dataItem: DataItem;
if (parseAsTuple) { if (shouldParseAsTuple) {
const dataItems = isSignature ? generateDataItemsFromSignature(input as string) : (input as DataItem[]); const dataItems = isSignature ? generateDataItemsFromSignature(input as string) : (input as DataItem[]);
dataItem = { dataItem = {
name: '', name: '',

10
packages/utils/src/abi_encoder/evm_data_types/array.ts
View File

@@ -7,7 +7,6 @@ import { constants } from '../utils/constants';
export class ArrayDataType extends AbstractSetDataType { export class ArrayDataType extends AbstractSetDataType {
private static readonly _MATCHER = RegExp('^(.+)\\[([0-9]*)\\]$'); private static readonly _MATCHER = RegExp('^(.+)\\[([0-9]*)\\]$');
private readonly _arraySignature: string;
private readonly _elementType: string; private readonly _elementType: string;
public static matchType(type: string): boolean { public static matchType(type: string): boolean {
@@ -35,7 +34,6 @@ export class ArrayDataType extends AbstractSetDataType {
super(dataItem, dataTypeFactory, isArray, arrayLength, arrayElementType); super(dataItem, dataTypeFactory, isArray, arrayLength, arrayElementType);
// Set array properties // Set array properties
this._elementType = arrayElementType; this._elementType = arrayElementType;
this._arraySignature = this._computeSignature();
} }
public getSignatureType(): string { public getSignatureType(): string {
@@ -43,9 +41,13 @@ export class ArrayDataType extends AbstractSetDataType {
} }
public getSignature(detailed?: boolean): string { 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 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)}`; const detailedSignature = `${shortName} ${this._computeSignature(detailed)}`;
return detailedSignature; return detailedSignature;
} }

3
packages/utils/src/abi_encoder/evm_data_types/int.ts
View File

@@ -50,7 +50,8 @@ export class IntDataType extends AbstractBlobDataType {
public decodeValue(calldata: RawCalldata): BigNumber | number { public decodeValue(calldata: RawCalldata): BigNumber | number {
const valueBuf = calldata.popWord(); const valueBuf = calldata.popWord();
const value = EncoderMath.safeDecodeNumericValue(valueBuf, this._minValue, this._maxValue); 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.toNumber();
} }
return value; return value;

1
packages/utils/src/abi_encoder/evm_data_types/method.ts
View File

@@ -8,7 +8,6 @@ import { AbstractSetDataType } from '../abstract_data_types/types/set';
import { constants } from '../utils/constants'; import { constants } from '../utils/constants';
import { DecodingRules, EncodingRules } from '../utils/rules'; import { DecodingRules, EncodingRules } from '../utils/rules';
import { ArrayDataType } from './array';
import { TupleDataType } from './tuple'; import { TupleDataType } from './tuple';
export class MethodDataType extends AbstractSetDataType { export class MethodDataType extends AbstractSetDataType {

10
packages/utils/src/abi_encoder/evm_data_types/tuple.ts
View File

@@ -5,7 +5,6 @@ import { DataTypeFactory } from '../abstract_data_types/interfaces';
import { AbstractSetDataType } from '../abstract_data_types/types/set'; import { AbstractSetDataType } from '../abstract_data_types/types/set';
export class TupleDataType extends AbstractSetDataType { export class TupleDataType extends AbstractSetDataType {
//private readonly _signature: string;
public static matchType(type: string): boolean { public static matchType(type: string): boolean {
return type === SolidityTypes.Tuple; return type === SolidityTypes.Tuple;
@@ -16,7 +15,6 @@ export class TupleDataType extends AbstractSetDataType {
if (!TupleDataType.matchType(dataItem.type)) { if (!TupleDataType.matchType(dataItem.type)) {
throw new Error(`Tried to instantiate Tuple with bad input: ${dataItem}`); throw new Error(`Tried to instantiate Tuple with bad input: ${dataItem}`);
} }
//this._signature =
} }
public getSignatureType(): string { public getSignatureType(): string {
@@ -24,9 +22,13 @@ export class TupleDataType extends AbstractSetDataType {
} }
public getSignature(detailed?: boolean): string { 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 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)}`; const detailedSignature = `${shortName} ${this._computeSignatureOfMembers(detailed)}`;
return detailedSignature; return detailedSignature;
} }

3
packages/utils/src/abi_encoder/evm_data_types/uint.ts
View File

@@ -49,7 +49,8 @@ export class UIntDataType extends AbstractBlobDataType {
public decodeValue(calldata: RawCalldata): BigNumber | number { public decodeValue(calldata: RawCalldata): BigNumber | number {
const valueBuf = calldata.popWord(); const valueBuf = calldata.popWord();
const value = EncoderMath.safeDecodeNumericValue(valueBuf, UIntDataType._MIN_VALUE, this._maxValue); 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.toNumber();
} }
return value; return value;

42
packages/utils/src/abi_encoder/utils/signatureParser.ts
View File

@@ -1,21 +1,15 @@
import { DataItem } from 'ethereum-types';
import * as _ from 'lodash'; import * as _ from 'lodash';
import { DataItem } from 'ethereum-protocol'; /**
* 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>, ...)
export function generateDataItemFromSignature(signature: string): DataItem { * An example of the first form would be 'address' or 'uint256'
const dataItems = generateDataItemsFromSignature(signature); * An example of the second form would be '(address, uint256)'
if (dataItems.length === 1) { * Signatures can also include a name field, for example: 'foo address' or '(foo address, bar uint256)'
return dataItems[0]; * @param signature of input DataItems
} * @return DataItems derived from input signature
// signature represents a tuple */
return {
name: '',
type: 'tuple',
components: dataItems
};
}*/
export function generateDataItemsFromSignature(signature: string): DataItem[] { export function generateDataItemsFromSignature(signature: string): DataItem[] {
let trimmedSignature = signature; let trimmedSignature = signature;
if (signature.startsWith('(')) { if (signature.startsWith('(')) {
@@ -25,7 +19,7 @@ export function generateDataItemsFromSignature(signature: string): DataItem[] {
trimmedSignature = signature.substr(1, signature.length - 2); trimmedSignature = signature.substr(1, signature.length - 2);
} }
trimmedSignature += ','; trimmedSignature += ',';
let currTokenIsArray = false; let isCurrTokenArray = false;
let currTokenArrayModifier = ''; let currTokenArrayModifier = '';
let isParsingArrayModifier = false; let isParsingArrayModifier = false;
let currToken = ''; let currToken = '';
@@ -46,7 +40,7 @@ export function generateDataItemsFromSignature(signature: string): DataItem[] {
case '[': case '[':
if (parenCount === 0) { if (parenCount === 0) {
isParsingArrayModifier = true; isParsingArrayModifier = true;
currTokenIsArray = true; isCurrTokenArray = true;
currTokenArrayModifier += '['; currTokenArrayModifier += '[';
} else { } else {
currToken += char; currToken += char;
@@ -70,26 +64,24 @@ export function generateDataItemsFromSignature(signature: string): DataItem[] {
break; break;
case ',': case ',':
if (parenCount === 0) { if (parenCount === 0) {
//throw new Error(`Generating Data Items`); // Generate new DataItem from token
const components = currToken.startsWith('(') ? generateDataItemsFromSignature(currToken) : []; const components = currToken.startsWith('(') ? generateDataItemsFromSignature(currToken) : [];
const isTuple = !_.isEmpty(components); const isTuple = !_.isEmpty(components);
const isArray = currTokenIsArray; const dataItem: DataItem = { name: currTokenName, type: '' };
let dataItem: DataItem = { name: currTokenName, type: '' };
if (isTuple) { if (isTuple) {
dataItem.type = 'tuple'; dataItem.type = 'tuple';
dataItem.components = components; dataItem.components = components;
} else { } else {
dataItem.type = currToken; dataItem.type = currToken;
} }
if (isArray) { if (isCurrTokenArray) {
dataItem.type += currTokenArrayModifier; dataItem.type += currTokenArrayModifier;
} }
dataItems.push(dataItem); dataItems.push(dataItem);
// reset token state
currTokenName = ''; currTokenName = '';
currToken = ''; currToken = '';
currTokenIsArray = false; isCurrTokenArray = false;
currTokenArrayModifier = ''; currTokenArrayModifier = '';
break; break;
} else { } else {

264
packages/utils/test/abi_encoder/evm_data_types_test.ts
View File

@@ -27,9 +27,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Dynamic size; Static elements', async () => { it('Dynamic size; Static elements', async () => {
// Create DataType object // Create DataType object
@@ -46,9 +46,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Fixed size; Dynamic elements', async () => { it('Fixed size; Dynamic elements', async () => {
// Create DataType object // Create DataType object
@@ -65,9 +65,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Dynamic size; Dynamic elements', async () => { it('Dynamic size; Dynamic elements', async () => {
// Create DataType object // Create DataType object
@@ -84,9 +84,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Dynamic Size; Multidimensional; Dynamic Elements', async () => { it('Dynamic Size; Multidimensional; Dynamic Elements', async () => {
// Create DataType object // Create DataType object
@@ -106,9 +106,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Dynamic Size; Multidimensional; Static Elements', async () => { it('Dynamic Size; Multidimensional; Static Elements', async () => {
// Create DataType object // Create DataType object
@@ -128,9 +128,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Static Size; Multidimensional; Static Elements', async () => { it('Static Size; Multidimensional; Static Elements', async () => {
// Create DataType object // Create DataType object
@@ -149,9 +149,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Static Size; Multidimensional; Dynamic Elements', async () => { it('Static Size; Multidimensional; Dynamic Elements', async () => {
// Create DataType object // Create DataType object
@@ -170,9 +170,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Static size; Too Few Elements', async () => { it('Static size; Too Few Elements', async () => {
// Create DataType object // Create DataType object
@@ -230,9 +230,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs, decodingRules); const decodedArgs = dataType.decode(encodedArgs, decodingRules);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args, encodingRules); const argsEncodedFromSignature = dataTypeFromSignature.encode(args, encodingRules);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Dynamic elements only', async () => { it('Dynamic elements only', async () => {
// Create DataType object // Create DataType object
@@ -254,9 +254,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs, decodingRules); const decodedArgs = dataType.decode(encodedArgs, decodingRules);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Nested Static Array', async () => { it('Nested Static Array', async () => {
// Create DataType object // Create DataType object
@@ -278,9 +278,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs, decodingRules); const decodedArgs = dataType.decode(encodedArgs, decodingRules);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Nested Dynamic Array', async () => { it('Nested Dynamic Array', async () => {
// Create DataType object // Create DataType object
@@ -302,9 +302,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs, decodingRules); const decodedArgs = dataType.decode(encodedArgs, decodingRules);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Nested Static Multidimensional Array', async () => { it('Nested Static Multidimensional Array', async () => {
// Create DataType object // Create DataType object
@@ -328,9 +328,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs, decodingRules); const decodedArgs = dataType.decode(encodedArgs, decodingRules);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Nested Dynamic Multidimensional Array', async () => { it('Nested Dynamic Multidimensional Array', async () => {
// Create DataType object // Create DataType object
@@ -354,9 +354,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs, decodingRules); const decodedArgs = dataType.decode(encodedArgs, decodingRules);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Static and dynamic elements mixed', async () => { it('Static and dynamic elements mixed', async () => {
// Create DataType object // Create DataType object
@@ -388,9 +388,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs, decodingRules); const decodedArgs = dataType.decode(encodedArgs, decodingRules);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Missing Key', async () => { it('Missing Key', async () => {
// Create DataType object // Create DataType object
@@ -424,9 +424,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Invalid Address - input is not valid hex', async () => { it('Invalid Address - input is not valid hex', async () => {
// Create DataType object // Create DataType object
@@ -467,9 +467,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('False', async () => { it('False', async () => {
// Create DataType object // Create DataType object
@@ -485,9 +485,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
}); });
@@ -513,9 +513,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Int256 - Negative Base Case', async () => { it('Int256 - Negative Base Case', async () => {
// Create DataType object // Create DataType object
@@ -531,9 +531,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Int256 - Positive Value', async () => { it('Int256 - Positive Value', async () => {
// Create DataType object // Create DataType object
@@ -549,9 +549,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Int256 - Negative Value', async () => { it('Int256 - Negative Value', async () => {
// Create DataType object // Create DataType object
@@ -567,9 +567,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Int256 - Value too large', async () => { it('Int256 - Value too large', async () => {
// Create DataType object // Create DataType object
@@ -607,9 +607,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Int32 - Negative Base Case', async () => { it('Int32 - Negative Base Case', async () => {
// Create DataType object // Create DataType object
@@ -625,9 +625,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Int32 - Positive Value', async () => { it('Int32 - Positive Value', async () => {
// Create DataType object // Create DataType object
@@ -643,9 +643,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Int32 - Negative Value', async () => { it('Int32 - Negative Value', async () => {
// Create DataType object // Create DataType object
@@ -661,9 +661,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Int32 - Value too large', async () => { it('Int32 - Value too large', async () => {
// Create DataType object // Create DataType object
@@ -711,9 +711,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('UInt256 - Positive Value', async () => { it('UInt256 - Positive Value', async () => {
// Create DataType object // Create DataType object
@@ -729,9 +729,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('UInt256 - Zero Value', async () => { it('UInt256 - Zero Value', async () => {
// Create DataType object // Create DataType object
@@ -747,9 +747,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('UInt256 - Value too large', async () => { it('UInt256 - Value too large', async () => {
// Create DataType object // Create DataType object
@@ -787,9 +787,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('UInt32 - Positive Value', async () => { it('UInt32 - Positive Value', async () => {
// Create DataType object // Create DataType object
@@ -805,9 +805,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('UInt32 - Zero Value', async () => { it('UInt32 - Zero Value', async () => {
// Create DataType object // Create DataType object
@@ -823,9 +823,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('UInt32 - Value too large', async () => { it('UInt32 - Value too large', async () => {
// Create DataType object // Create DataType object
@@ -866,9 +866,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Single Byte (bytes1)', async () => { it('Single Byte (bytes1)', async () => {
// Create DataType object // Create DataType object
@@ -884,9 +884,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('4 Bytes (bytes4)', async () => { it('4 Bytes (bytes4)', async () => {
// Create DataType object // Create DataType object
@@ -902,9 +902,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('4 Bytes (bytes4); Encoder must pad input', async () => { it('4 Bytes (bytes4); Encoder must pad input', async () => {
// Create DataType object // Create DataType object
@@ -922,9 +922,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const paddedArgs = '0x1a180000'; const paddedArgs = '0x1a180000';
expect(decodedArgs).to.be.deep.equal(paddedArgs); expect(decodedArgs).to.be.deep.equal(paddedArgs);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('32 Bytes (bytes32)', async () => { it('32 Bytes (bytes32)', async () => {
// Create DataType object // Create DataType object
@@ -940,9 +940,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('32 Bytes (bytes32); Encoder must pad input', async () => { it('32 Bytes (bytes32); Encoder must pad input', async () => {
// Create DataType object // Create DataType object
@@ -960,9 +960,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const paddedArgs = '0x1a18bf6100000000000000000000000000000000000000000000000000000000'; const paddedArgs = '0x1a18bf6100000000000000000000000000000000000000000000000000000000';
expect(decodedArgs).to.be.deep.equal(paddedArgs); expect(decodedArgs).to.be.deep.equal(paddedArgs);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Should throw when pass in too many bytes (bytes4)', async () => { it('Should throw when pass in too many bytes (bytes4)', async () => {
// Create DataType object // Create DataType object
@@ -1031,9 +1031,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Spans multiple EVM words', async () => { it('Spans multiple EVM words', async () => {
// Create DataType object // Create DataType object
@@ -1052,9 +1052,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Input as Buffer', async () => { it('Input as Buffer', async () => {
// Create DataType object // Create DataType object
@@ -1073,9 +1073,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Should throw when pass in bad hex (no 0x prefix)', async () => { it('Should throw when pass in bad hex (no 0x prefix)', async () => {
// Create DataType object // Create DataType object
@@ -1118,9 +1118,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('Spans multiple EVM words', async () => { it('Spans multiple EVM words', async () => {
// Create DataType object // Create DataType object
@@ -1139,9 +1139,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
it('String that begins with 0x prefix', async () => { it('String that begins with 0x prefix', async () => {
// Create DataType object // Create DataType object
@@ -1160,9 +1160,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs); const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args); expect(decodedArgs).to.be.deep.equal(args);
// Validate signature // Validate signature
const dataTypecreate = AbiEncoder.create(dataType.getSignature(true)); const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
const encodedArgscreate = dataTypecreate.encode(args); const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs); expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
}); });
}); });
}); });

6
packages/utils/test/abi_encoder/methods_test.ts
View File

@@ -199,7 +199,9 @@ describe('ABI Encoder: Method Encoding / Decoding', () => {
it('Unfixed Length Array / Static Members ABI', async () => { it('Unfixed Length Array / Static Members ABI', async () => {
// Generate calldata // Generate calldata
const method = new AbiEncoder.Method(AbiSamples.dynamicArrayStaticMembersAbi); const method = new AbiEncoder.Method(AbiSamples.dynamicArrayStaticMembersAbi);
// tslint:disable custom-no-magic-numbers
const args = [[127, 14, 54]]; const args = [[127, 14, 54]];
// tslint:enable custom-no-magic-numbers
const calldata = method.encode(args, encodingRules); const calldata = method.encode(args, encodingRules);
// Validate calldata // Validate calldata
const expectedCalldata = const expectedCalldata =
@@ -213,7 +215,9 @@ describe('ABI Encoder: Method Encoding / Decoding', () => {
it('Fixed Length Array / Static Members ABI', async () => { it('Fixed Length Array / Static Members ABI', async () => {
// Generate calldata // Generate calldata
const method = new AbiEncoder.Method(AbiSamples.staticArrayAbi); const method = new AbiEncoder.Method(AbiSamples.staticArrayAbi);
// tslint:disable custom-no-magic-numbers
const args = [[127, 14, 54]]; const args = [[127, 14, 54]];
// tslint:enable custom-no-magic-numbers
const calldata = method.encode(args, encodingRules); const calldata = method.encode(args, encodingRules);
// Validate calldata // Validate calldata
const expectedCalldata = const expectedCalldata =
@@ -310,7 +314,9 @@ describe('ABI Encoder: Method Encoding / Decoding', () => {
it('Large, Nested ABI', async () => { it('Large, Nested ABI', async () => {
// Construct Calldata // Construct Calldata
const method = new AbiEncoder.Method(AbiSamples.largeNestedAbi); const method = new AbiEncoder.Method(AbiSamples.largeNestedAbi);
// tslint:disable custom-no-magic-numbers
const someStaticArray = [127, 14, 54]; const someStaticArray = [127, 14, 54];
// tslint:enable custom-no-magic-numbers
const someStaticArrayWithDynamicMembers = [ const someStaticArrayWithDynamicMembers = [
'the little piping piper piped a piping pipper papper', '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.', '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.',

2
packages/utils/test/abi_encoder/optimizer_test.ts
View File

@@ -232,7 +232,9 @@ describe('ABI Encoder: Optimized Method Encoding/Decoding', () => {
it('Array Elements Duplicated as Tuple Fields', async () => { it('Array Elements Duplicated as Tuple Fields', async () => {
// Generate calldata // Generate calldata
const method = new AbiEncoder.Method(OptimizedAbis.arrayElementsDuplicatedAsTupleFields); const method = new AbiEncoder.Method(OptimizedAbis.arrayElementsDuplicatedAsTupleFields);
// tslint:disable custom-no-magic-numbers
const array = [100, 150, 200, 225]; const array = [100, 150, 200, 225];
// tslint:enable custom-no-magic-numbers
const tuple = [ const tuple = [
[new BigNumber(array[0])], [new BigNumber(array[0])],
[new BigNumber(array[1])], [new BigNumber(array[1])],