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

Signature parsing tests

Browse Source
This commit is contained in:
Greg Hysen 2019-02-06 11:56:58 -08:00
parent 4079563f5d
commit eb5f7e36e9
3 changed files with 394 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -28,7 +28,7 @@ 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.create(dataType.getSignature(true));
const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(false));
const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
});

393
packages/utils/test/abi_encoder/signature_test.ts Normal file
View File

@ -0,0 +1,393 @@
import * as chai from 'chai';
import 'mocha';
import { AbiEncoder } from '../../src';
import { chaiSetup } from '../utils/chai_setup';
chaiSetup.configure();
const expect = chai.expect;
describe('ABI Encoder: Signatures', () => {
describe('Single type', () => {
it('Elementary', async () => {
const signature = 'uint256';
const dataType = AbiEncoder.create(signature);
const dataTypeId = dataType.getDataItem().type;
expect(dataTypeId).to.be.equal('uint256');
expect(dataType.getSignature()).to.be.equal(signature);
});
it('Array', async () => {
const signature = 'string[]';
const dataType = AbiEncoder.create(signature);
const dataItem = dataType.getDataItem();
const expectedDataItem = {
name: '',
type: 'string[]',
};
expect(dataItem).to.be.deep.equal(expectedDataItem);
expect(dataType.getSignature()).to.be.equal(signature);
});
it('Multidimensional Array', async () => {
// Decode return value
const signature = 'uint256[4][][5]';
const dataType = AbiEncoder.create(signature);
const dataTypeId = dataType.getDataItem().type;
expect(dataTypeId).to.be.equal(signature);
expect(dataType.getSignature()).to.be.equal(signature);
});
it('Tuple with single element', async () => {
const signature = '(uint256)';
const dataType = AbiEncoder.create(signature);
const dataItem = dataType.getDataItem();
const expectedDataItem = {
name: '',
type: 'tuple',
components: [
{
name: '',
type: 'uint256',
},
],
};
expect(dataItem).to.be.deep.equal(expectedDataItem);
expect(dataType.getSignature()).to.be.equal(signature);
});
it('Tuple with multiple elements', async () => {
const signature = '(uint256,string,bytes4)';
const dataType = AbiEncoder.create(signature);
const dataItem = dataType.getDataItem();
const expectedDataItem = {
name: '',
type: 'tuple',
components: [
{
name: '',
type: 'uint256',
},
{
name: '',
type: 'string',
},
{
name: '',
type: 'bytes4',
},
],
};
expect(dataItem).to.be.deep.equal(expectedDataItem);
expect(dataType.getSignature()).to.be.equal(signature);
});
it('Tuple with nested array and nested tuple', async () => {
const signature = '(uint256[],(bytes),string[4],bytes4)';
const dataType = AbiEncoder.create(signature);
const dataItem = dataType.getDataItem();
const expectedDataItem = {
name: '',
type: 'tuple',
components: [
{
name: '',
type: 'uint256[]',
},
{
name: '',
type: 'tuple',
components: [
{
name: '',
type: 'bytes',
},
],
},
{
name: '',
type: 'string[4]',
},
{
name: '',
type: 'bytes4',
},
],
};
expect(dataItem).to.be.deep.equal(expectedDataItem);
expect(dataType.getSignature()).to.be.equal(signature);
});
it('Array of complex tuples', async () => {
const signature = '(uint256[],(bytes),string[4],bytes4)[5][4][]';
const dataType = AbiEncoder.create(signature);
const dataItem = dataType.getDataItem();
const expectedDataItem = {
name: '',
type: 'tuple[5][4][]',
components: [
{
name: '',
type: 'uint256[]',
},
{
name: '',
type: 'tuple',
components: [
{
name: '',
type: 'bytes',
},
],
},
{
name: '',
type: 'string[4]',
},
{
name: '',
type: 'bytes4',
},
],
};
expect(dataItem).to.be.deep.equal(expectedDataItem);
expect(dataType.getSignature()).to.be.equal(signature);
});
});
describe('Function', () => {
it('No inputs and no outputs', async () => {
// create encoder
const functionName = 'foo';
const dataType = AbiEncoder.createMethod(functionName);
// create expected values
const expectedSignature = 'foo()';
const expectedInputDataItem = {
name: 'foo',
type: 'method',
components: [],
};
const expectedOutputDataItem = {
name: 'foo',
type: 'tuple',
components: [],
};
// check expected values
expect(dataType.getSignature()).to.be.equal(expectedSignature);
expect(dataType.getDataItem()).to.be.deep.equal(expectedInputDataItem);
expect(dataType.getReturnValueDataItem()).to.be.deep.equal(expectedOutputDataItem);
});
it('No inputs and no outputs (empty arrays as input)', async () => {
// create encoder
const functionName = 'foo';
const dataType = AbiEncoder.createMethod(functionName, [], []);
// create expected values
const expectedSignature = 'foo()';
const expectedInputDataItem = {
name: 'foo',
type: 'method',
components: [],
};
const expectedOutputDataItem = {
name: 'foo',
type: 'tuple',
components: [],
};
// check expected values
expect(dataType.getSignature()).to.be.equal(expectedSignature);
expect(dataType.getDataItem()).to.be.deep.equal(expectedInputDataItem);
expect(dataType.getReturnValueDataItem()).to.be.deep.equal(expectedOutputDataItem);
});
it('Single DataItem input and single DataItem output', async () => {
// create encoder
const functionName = 'foo';
const inputDataItem = {
name: 'input',
type: 'uint256',
};
const outputDataItem = {
name: 'output',
type: 'string',
};
const dataType = AbiEncoder.createMethod(functionName, inputDataItem, outputDataItem);
// create expected values
const expectedSignature = 'foo(uint256)';
const expectedInputDataItem = {
name: 'foo',
type: 'method',
components: [inputDataItem],
};
const expectedOutputDataItem = {
name: 'foo',
type: 'tuple',
components: [outputDataItem],
};
// check expected values
expect(dataType.getSignature()).to.be.equal(expectedSignature);
expect(dataType.getDataItem()).to.be.deep.equal(expectedInputDataItem);
expect(dataType.getReturnValueDataItem()).to.be.deep.equal(expectedOutputDataItem);
});
it('Single signature input and single signature output', async () => {
// create encoder
const functionName = 'foo';
const inputSignature = 'uint256';
const outputSignature = 'string';
const dataType = AbiEncoder.createMethod(functionName, inputSignature, outputSignature);
// create expected values
const expectedSignature = 'foo(uint256)';
const expectedInputDataItem = {
name: 'foo',
type: 'method',
components: [
{
name: '',
type: 'uint256',
},
],
};
const expectedOutputDataItem = {
name: 'foo',
type: 'tuple',
components: [
{
name: '',
type: 'string',
},
],
};
// check expected values
expect(dataType.getSignature()).to.be.equal(expectedSignature);
expect(dataType.getDataItem()).to.be.deep.equal(expectedInputDataItem);
expect(dataType.getReturnValueDataItem()).to.be.deep.equal(expectedOutputDataItem);
});
it('Single signature tuple input and single signature tuple output', async () => {
// create encoder
const functionName = 'foo';
const inputSignature = '(uint256,bytes[][4])';
const outputSignature = '(string,uint32)';
const dataType = AbiEncoder.createMethod(functionName, inputSignature, outputSignature);
// create expected values
const expectedSignature = 'foo((uint256,bytes[][4]))';
const expectedInputDataItem = {
name: 'foo',
type: 'method',
components: [
{
name: '',
type: 'tuple',
components: [
{
name: '',
type: 'uint256',
},
{
name: '',
type: 'bytes[][4]',
},
],
},
],
};
const expectedOutputDataItem = {
name: 'foo',
type: 'tuple',
components: [
{
name: '',
type: 'tuple',
components: [
{
name: '',
type: 'string',
},
{
name: '',
type: 'uint32',
},
],
},
],
};
// check expected values
expect(dataType.getSignature()).to.be.equal(expectedSignature);
expect(dataType.getDataItem()).to.be.deep.equal(expectedInputDataItem);
expect(dataType.getReturnValueDataItem()).to.be.deep.equal(expectedOutputDataItem);
});
it('Mutiple DataItem input and multiple DataItem output', async () => {
// create encoder
const functionName = 'foo';
const inputDataItems = [
{
name: '',
type: 'uint256',
},
{
name: '',
type: 'bytes[][4]',
},
];
const outputDataItems = [
{
name: '',
type: 'string',
},
{
name: '',
type: 'uint32',
},
];
const dataType = AbiEncoder.createMethod(functionName, inputDataItems, outputDataItems);
// create expected values
const expectedSignature = 'foo(uint256,bytes[][4])';
const expectedInputDataItem = {
name: 'foo',
type: 'method',
components: inputDataItems,
};
const expectedOutputDataItem = {
name: 'foo',
type: 'tuple',
components: outputDataItems,
};
// check expected values
expect(dataType.getSignature()).to.be.equal(expectedSignature);
expect(dataType.getDataItem()).to.be.deep.equal(expectedInputDataItem);
expect(dataType.getReturnValueDataItem()).to.be.deep.equal(expectedOutputDataItem);
});
it('Multiple signature input and multiple signature output', async () => {
// create encoder
const functionName = 'foo';
const inputSignatures = ['uint256', 'bytes[][4]'];
const outputSignatures = ['string', 'uint32'];
const dataType = AbiEncoder.createMethod(functionName, inputSignatures, outputSignatures);
// create expected values
const expectedSignature = 'foo(uint256,bytes[][4])';
const expectedInputDataItem = {
name: 'foo',
type: 'method',
components: [
{
name: '',
type: 'uint256',
},
{
name: '',
type: 'bytes[][4]',
},
],
};
const expectedOutputDataItem = {
name: 'foo',
type: 'tuple',
components: [
{
name: '',
type: 'string',
},
{
name: '',
type: 'uint32',
},
],
};
// check expected values
expect(dataType.getSignature()).to.be.equal(expectedSignature);
expect(dataType.getDataItem()).to.be.deep.equal(expectedInputDataItem);
expect(dataType.getReturnValueDataItem()).to.be.deep.equal(expectedOutputDataItem);
});
});
});

0
packages/utils/test/abi_encoder/signature_tests.ts
View File