aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--packages/utils/src/abi_encoder/evm_data_type_factory.ts23
-rw-r--r--packages/utils/src/abi_encoder/index.ts3
-rw-r--r--packages/utils/src/abi_encoder/utils/signatureParser.ts63
-rw-r--r--packages/utils/test/abi_encoder/evm_data_types_test.ts264
4 files changed, 166 insertions, 187 deletions
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 4cc124e0a..5ff7366d6 100644
--- a/packages/utils/src/abi_encoder/evm_data_type_factory.ts
+++ b/packages/utils/src/abi_encoder/evm_data_type_factory.ts
@@ -2,6 +2,8 @@
import { DataItem, MethodAbi } from 'ethereum-types';
import * as _ from 'lodash';
+import { generateDataItemsFromSignature } from './utils/signatureParser';
+
import { DataType } from './abstract_data_types/data_type';
import { DataTypeFactory } from './abstract_data_types/interfaces';
import { AddressDataType } from './evm_data_types/address';
@@ -129,4 +131,25 @@ export class EvmDataTypeFactory implements DataTypeFactory {
private constructor() {}
}
+
+// Convenience function
+export function create(input: DataItem | DataItem[] | string): DataType {
+ // Handle different types of input
+ let dataItems: DataItem[] = [];
+ if (typeof(input) === 'string') {
+ dataItems = generateDataItemsFromSignature(input);
+ } else if(input instanceof Array) {
+ dataItems = input as DataItem[];
+ } else {
+ dataItems = [input as DataItem];
+ }
+ // Create single data item from input
+ let dataItem: DataItem = dataItems.length === 1 ? dataItems[0] : {
+ name: '',
+ type: 'tuple',
+ components: dataItems
+ };
+ // Create data type
+ return EvmDataTypeFactory.getInstance().create(dataItem);
+}
/* tslint:enable no-construct */
diff --git a/packages/utils/src/abi_encoder/index.ts b/packages/utils/src/abi_encoder/index.ts
index 23422dd8b..f7f1ceedc 100644
--- a/packages/utils/src/abi_encoder/index.ts
+++ b/packages/utils/src/abi_encoder/index.ts
@@ -11,5 +11,6 @@ export {
String,
Tuple,
UInt,
+ create,
} from './evm_data_type_factory';
-export { fromSignature } from './utils/signatureParser';
+//export { fromSignature } from './utils/signatureParser';
diff --git a/packages/utils/src/abi_encoder/utils/signatureParser.ts b/packages/utils/src/abi_encoder/utils/signatureParser.ts
index fe5127032..9c1a59c82 100644
--- a/packages/utils/src/abi_encoder/utils/signatureParser.ts
+++ b/packages/utils/src/abi_encoder/utils/signatureParser.ts
@@ -1,67 +1,22 @@
import * as _ from 'lodash';
-import { DataType } from '../abstract_data_types/data_type';
import { DataItem } from 'ethereum-protocol';
-import { MethodAbi } from 'ethereum-types';
-import * as EvmDataTypes from '../evm_data_type_factory';
-// Valid signatures:
-// functionName(param1, param2, ...): (output1, output2, ...)
-// functionName(param1, param2, ...)
-// (param1, param2, ...)
/*
-export function fromSignature(signature: string): DataType {
- const maxSignatureIndex = signature.length - 1;
- // Function name
- const isFunction = signature.startsWith('function ');
- // Output components
- const outputComponentsBeginIndex = signature.indexOf(':');
- const outputComponentsEndIndex = outputComponentsBeginIndex >= 0 ? maxSignatureIndex : 0;
- const hasOutputComponents = outputComponentsBeginIndex >= 0;
- const outputComponentsSignature = hasOutputComponents ? signature.substring(outputComponentsBeginIndex, outputComponentsEndIndex + 1) : "";
- // Input components
- const inputComponentsBeginIndex = signature.indexOf('(');
- const inputComponentsEndIndex = hasOutputComponents ? outputComponentsBeginIndex : maxSignatureIndex;
- const inputComponentsSignature = signature.substring(inputComponentsBeginIndex, inputComponentsEndIndex + 1);
- // Function anme
- const functionName = signature.substr(0, inputComponentsBeginIndex);
- const isFunction = !_.isEmpty(functionName);
-
- console.log(`sig - ` + inputComponentsSignature);
- // Create data type
- let dataType: DataType;
- if (isFunction) {
- const methodAbi = {
- type: 'function',
- name: functionName,
- inputs: generateDataItems(inputComponentsSignature),
- outputs: !_.isEmpty(outputComponentsSignature) ? generateDataItems(outputComponentsSignature) : [],
- } as MethodAbi;
- dataType = new EvmDataTypes.Method(methodAbi);
- } else if(hasOutputComponents) {
- throw new Error(`Invalid signature: Contains outputs but no function name.`);
- } else {
- const inputDataItem = generateDataItem(inputComponentsSignature);
- console.log(JSON.stringify(inputDataItem));
- dataType = EvmDataTypes.EvmDataTypeFactory.getInstance().create(inputDataItem);
- }
- return dataType;
-}*/
-
-export function fromSignature(signature: string): DataType {
- const dataItems = generateDataItems(signature);
+export function generateDataItemFromSignature(signature: string): DataItem {
+ const dataItems = generateDataItemsFromSignature(signature);
if (dataItems.length === 1) {
- return EvmDataTypes.EvmDataTypeFactory.getInstance().create(dataItems[0]);
+ return dataItems[0];
}
- // this is a tuple
- return EvmDataTypes.EvmDataTypeFactory.getInstance().create({
+ // signature represents a tuple
+ return {
name: '',
type: 'tuple',
components: dataItems
- });
-}
+ };
+}*/
-function generateDataItems(signature: string): DataItem[] {
+export function generateDataItemsFromSignature(signature: string): DataItem[] {
let trimmedSignature = signature;
if (signature.startsWith('(')) {
if(!signature.endsWith(')')) {
@@ -116,7 +71,7 @@ function generateDataItems(signature: string): DataItem[] {
case ',':
if (parenCount === 0) {
//throw new Error(`Generating Data Items`);
- const components = currToken.startsWith('(') ? generateDataItems(currToken) : [];
+ const components = currToken.startsWith('(') ? generateDataItemsFromSignature(currToken) : [];
const isTuple = !_.isEmpty(components);
const isArray = currTokenIsArray;
let dataItem: DataItem = {name: currTokenName, type: ''};
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 4faa5a21f..919b71c55 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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args, encodingRules);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args, encodingRules);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).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 dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Missing Key', async () => {
// Create DataType object
@@ -439,9 +439,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Invalid Address - input is not valid hex', async () => {
// Create DataType object
@@ -482,9 +482,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('False', async () => {
// Create DataType object
@@ -500,9 +500,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
});
@@ -528,9 +528,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Int256 - Negative Base Case', async () => {
// Create DataType object
@@ -546,9 +546,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Int256 - Positive Value', async () => {
// Create DataType object
@@ -564,9 +564,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Int256 - Negative Value', async () => {
// Create DataType object
@@ -582,9 +582,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Int256 - Value too large', async () => {
// Create DataType object
@@ -622,9 +622,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Int32 - Negative Base Case', async () => {
// Create DataType object
@@ -640,9 +640,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Int32 - Positive Value', async () => {
// Create DataType object
@@ -658,9 +658,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Int32 - Negative Value', async () => {
// Create DataType object
@@ -676,9 +676,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Int32 - Value too large', async () => {
// Create DataType object
@@ -726,9 +726,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('UInt256 - Positive Value', async () => {
// Create DataType object
@@ -744,9 +744,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('UInt256 - Zero Value', async () => {
// Create DataType object
@@ -762,9 +762,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('UInt256 - Value too large', async () => {
// Create DataType object
@@ -802,9 +802,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('UInt32 - Positive Value', async () => {
// Create DataType object
@@ -820,9 +820,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('UInt32 - Zero Value', async () => {
// Create DataType object
@@ -838,9 +838,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('UInt32 - Value too large', async () => {
// Create DataType object
@@ -881,9 +881,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Single Byte (bytes1)', async () => {
// Create DataType object
@@ -899,9 +899,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('4 Bytes (bytes4)', async () => {
// Create DataType object
@@ -917,9 +917,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('4 Bytes (bytes4); Encoder must pad input', async () => {
// Create DataType object
@@ -937,9 +937,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const paddedArgs = '0x1a180000';
expect(decodedArgs).to.be.deep.equal(paddedArgs);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('32 Bytes (bytes32)', async () => {
// Create DataType object
@@ -955,9 +955,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('32 Bytes (bytes32); Encoder must pad input', async () => {
// Create DataType object
@@ -975,9 +975,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const paddedArgs = '0x1a18bf6100000000000000000000000000000000000000000000000000000000';
expect(decodedArgs).to.be.deep.equal(paddedArgs);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Should throw when pass in too many bytes (bytes4)', async () => {
// Create DataType object
@@ -1046,9 +1046,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Spans multiple EVM words', async () => {
// Create DataType object
@@ -1067,9 +1067,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Input as Buffer', async () => {
// Create DataType object
@@ -1088,9 +1088,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Should throw when pass in bad hex (no 0x prefix)', async () => {
// Create DataType object
@@ -1133,9 +1133,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('Spans multiple EVM words', async () => {
// Create DataType object
@@ -1154,9 +1154,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
it('String that begins with 0x prefix', async () => {
// Create DataType object
@@ -1175,9 +1175,9 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
const decodedArgs = dataType.decode(encodedArgs);
expect(decodedArgs).to.be.deep.equal(args);
// Validate signature
- const dataTypeFromSignature = AbiEncoder.fromSignature(dataType.getSignature(true));
- const encodedArgsFromSignature = dataTypeFromSignature.encode(args);
- expect(encodedArgsFromSignature).to.be.deep.equal(expectedEncodedArgs);
+ const dataTypecreate = AbiEncoder.create(dataType.getSignature(true));
+ const encodedArgscreate = dataTypecreate.encode(args);
+ expect(encodedArgscreate).to.be.deep.equal(expectedEncodedArgs);
});
});
});