aboutsummaryrefslogtreecommitdiffstats
path: root/packages/utils/test/abi_encoder/signature_test.ts
diff options
context:
space:
mode:
Diffstat (limited to 'packages/utils/test/abi_encoder/signature_test.ts')
-rw-r--r--packages/utils/test/abi_encoder/signature_test.ts393
1 files changed, 393 insertions, 0 deletions
diff --git a/packages/utils/test/abi_encoder/signature_test.ts b/packages/utils/test/abi_encoder/signature_test.ts
new file mode 100644
index 000000000..cee6fa5e5
--- /dev/null
+++ b/packages/utils/test/abi_encoder/signature_test.ts
@@ -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);
+ });
+ });
+});