Merge pull request #1587 from 0xProject/fix/abiEncoder/DefaultTypesOnNullInput

Handle ABI decoding NULL for all data types

3 files changed, 374 insertions, 73 deletions

diff --git a/packages/utils/test/abi_encoder/abi_samples/return_value_abis.ts b/packages/utils/test/abi_encoder/abi_samples/return_value_abis.ts
index ac2124011..ad07b3d24 100644
--- a/packages/utils/test/abi_encoder/abi_samples/return_value_abis.ts
+++ b/packages/utils/test/abi_encoder/abi_samples/return_value_abis.ts
@@ -97,3 +97,28 @@ export const mixedStaticAndDynamicReturnValues: MethodAbi = {
     stateMutability: 'nonpayable',
     type: 'function',
 };
+
+export const structuredReturnValue: MethodAbi = {
+    constant: false,
+    inputs: [],
+    name: 'fillOrder',
+    outputs: [
+        {
+            components: [
+                {
+                    name: 'makerAssetFilledAmount',
+                    type: 'uint256',
+                },
+                {
+                    name: 'takerAssetFilledAmount',
+                    type: 'uint256',
+                },
+            ],
+            name: 'fillResults',
+            type: 'tuple',
+        },
+    ],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+};
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 c146890e0..c09c0d929 100644
--- a/packages/utils/test/abi_encoder/evm_data_types_test.ts
+++ b/packages/utils/test/abi_encoder/evm_data_types_test.ts
@@ -11,6 +11,7 @@ const expect = chai.expect;
 
 describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
     const encodingRules: AbiEncoder.EncodingRules = { shouldOptimize: false }; // optimizer is tested separately.
+    const nullEncodedArgs = '0x';
     describe('Array', () => {
         it('Fixed size; Static elements', async () => {
             // Create DataType object
@@ -207,6 +208,51 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
                 dataType.encode(args, encodingRules);
             }).to.throw('Tried to assign NaN value');
         });
+        it('Should decode NULL to default values (Fixed size; Static elements)', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'testArray', type: 'int[2]' };
+            const dataType = new AbiEncoder.Array(testDataItem);
+            const args = [new BigNumber(0), new BigNumber(0)];
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
+        it('Should decode NULL to default values (Dynamic size; Static elements)', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'testArray', type: 'int[]' };
+            const dataType = new AbiEncoder.Array(testDataItem);
+            const args: BigNumber[] = [];
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
+        it('Should decode NULL to default values (Fixed size; Dynamic elements)', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'testArray', type: 'string[2]' };
+            const dataType = new AbiEncoder.Array(testDataItem);
+            const args = ['', ''];
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
+        it('Should decode NULL to default values (Dynamic size; Dynamic elements)', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'testArray', type: 'string[]' };
+            const dataType = new AbiEncoder.Array(testDataItem);
+            const args: string[] = [];
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
+        it('Should decode NULL to default values (Dynamic Size; Multidimensional; Dynamic Elements)', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'testArray', type: 'bytes[][]' };
+            const dataType = new AbiEncoder.Array(testDataItem);
+            const args: string[][] = [];
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
     });
 
     describe('Tuple', () => {
@@ -407,6 +453,46 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
                 dataType.encode(args, encodingRules);
             }).to.throw('Could not assign tuple to object: missing key \'field_2\' in object {"field_1":"-5"}');
         });
+        it('Should decode NULL to default values (static elements only)', async () => {
+            // Create DataType object
+            const testDataItem = {
+                name: 'Tuple',
+                type: 'tuple',
+                components: [{ name: 'field_1', type: 'int32' }, { name: 'field_2', type: 'bool' }],
+            };
+            const dataType = new AbiEncoder.Tuple(testDataItem);
+            // Construct args to be encoded
+            const args = { field_1: new BigNumber(0), field_2: false };
+            // Decode Encoded Args and validate result
+            const decodingRules: AbiEncoder.DecodingRules = { shouldConvertStructsToObjects: true };
+            const decodedArgs = dataType.decode(nullEncodedArgs, decodingRules);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
+        it('Should decode NULL to default values (static and dynamic elements)', async () => {
+            // Create DataType object
+            const testDataItem = {
+                name: 'Tuple',
+                type: 'tuple',
+                components: [
+                    { name: 'field_1', type: 'int32' },
+                    { name: 'field_2', type: 'string' },
+                    { name: 'field_3', type: 'bool' },
+                    { name: 'field_4', type: 'bytes' },
+                ],
+            };
+            const dataType = new AbiEncoder.Tuple(testDataItem);
+            // Construct args to be encoded
+            const args = {
+                field_1: new BigNumber(0),
+                field_2: '',
+                field_3: false,
+                field_4: '0x',
+            };
+            // Decode Encoded Args and validate result
+            const decodingRules: AbiEncoder.DecodingRules = { shouldConvertStructsToObjects: true };
+            const decodedArgs = dataType.decode(nullEncodedArgs, decodingRules);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
     });
 
     describe('Address', () => {
@@ -450,6 +536,15 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
                 dataType.encode(args, encodingRules);
             }).to.throw(`Invalid address: '${args}'`);
         });
+        it('Should decode NULL to default value of address zero', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'Address', type: 'address' };
+            const dataType = new AbiEncoder.Address(testDataItem);
+            const args = '0x0000000000000000000000000000000000000000';
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
     });
 
     describe('Bool', () => {
@@ -489,23 +584,14 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
             const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
             expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
         });
-        it('Null should decode as False', async () => {
-            // Hack @hysz: there are some cases where `false` is encoded as 0x instead of 0x0.
+        it('Should decode NULL to default value of False', async () => {
             // Create DataType object
             const testDataItem = { name: 'Boolean', type: 'bool' };
             const dataType = new AbiEncoder.Bool(testDataItem);
-            // Construct args to be encoded
             const args = false;
-            // Encode Args and validate result
-            const encodedArgs = '0x';
-            const expectedEncodedArgs = '0x0000000000000000000000000000000000000000000000000000000000000000';
             // Decode Encoded Args and validate result
-            const decodedArgs = dataType.decode(encodedArgs);
+            const decodedArgs = dataType.decode(nullEncodedArgs);
             expect(decodedArgs).to.be.deep.equal(args);
-            // Validate signature
-            const dataTypeFromSignature = AbiEncoder.create(dataType.getSignature(true));
-            const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
-            expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
         });
     });
 
@@ -705,6 +791,15 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
                 dataType.encode(args, encodingRules);
             }).to.throw();
         });
+        it('Should decode NULL to default value of 0', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'Integer (256)', type: 'int' };
+            const dataType = new AbiEncoder.Int(testDataItem);
+            const args = new BigNumber(0);
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
     });
 
     describe('Unsigned Integer', () => {
@@ -867,6 +962,15 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
                 dataType.encode(args, encodingRules);
             }).to.throw();
         });
+        it('Should decode NULL to default value of 0', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'Unsigned Integer (256)', type: 'uint' };
+            const dataType = new AbiEncoder.UInt(testDataItem);
+            const args = new BigNumber(0);
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
     });
 
     describe('Static Bytes', () => {
@@ -1030,6 +1134,33 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
                 dataType.encode(args, encodingRules);
             }).to.throw('Tried to assign 0x010, which is contains a half-byte. Use full bytes only.');
         });
+        it('Should decode NULL to default value - Single Byte (byte)', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'Static Byte', type: 'byte' };
+            const dataType = new AbiEncoder.StaticBytes(testDataItem);
+            const args = '0x00';
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
+        it('Should decode NULL to default value - 4 Bytes (bytes4)', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'Static Bytes4', type: 'bytes4' };
+            const dataType = new AbiEncoder.StaticBytes(testDataItem);
+            const args = '0x00000000';
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
+        it('Should decode NULL to default value - 32 Bytes (bytes32)', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'Static Bytes32', type: 'bytes32' };
+            const dataType = new AbiEncoder.StaticBytes(testDataItem);
+            const args = '0x0000000000000000000000000000000000000000000000000000000000000000';
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
     });
 
     describe('Dynamic Bytes', () => {
@@ -1117,6 +1248,15 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
                 dataType.encode(args, encodingRules);
             }).to.throw('Tried to assign 0x010, which is contains a half-byte. Use full bytes only.');
         });
+        it('Should decode NULL to empty byte array', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'Dynamic Bytes', type: 'bytes' };
+            const dataType = new AbiEncoder.DynamicBytes(testDataItem);
+            const args = '0x';
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
     });
 
     describe('String', () => {
@@ -1182,5 +1322,14 @@ describe('ABI Encoder: EVM Data Type Encoding/Decoding', () => {
             const argsEncodedFromSignature = dataTypeFromSignature.encode(args);
             expect(argsEncodedFromSignature).to.be.deep.equal(expectedEncodedArgs);
         });
+        it('Should decode NULL to empty string', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'String', type: 'string' };
+            const dataType = new AbiEncoder.String(testDataItem);
+            // Decode Encoded Args and validate result
+            const args = '';
+            const decodedArgs = dataType.decode(nullEncodedArgs);
+            expect(decodedArgs).to.be.deep.equal(args);
+        });
     });
 });
diff --git a/packages/utils/test/abi_encoder/return_values_test.ts b/packages/utils/test/abi_encoder/return_values_test.ts
index 308d11ee5..ccdac510d 100644
--- a/packages/utils/test/abi_encoder/return_values_test.ts
+++ b/packages/utils/test/abi_encoder/return_values_test.ts
@@ -1,7 +1,7 @@
 import * as chai from 'chai';
 import 'mocha';
 
-import { AbiEncoder } from '../../src/';
+import { AbiEncoder, BigNumber } from '../../src/';
 import { chaiSetup } from '../utils/chai_setup';
 
 import * as ReturnValueAbis from './abi_samples/return_value_abis';
@@ -11,67 +11,194 @@ const expect = chai.expect;
 
 describe('ABI Encoder: Return Value Encoding/Decoding', () => {
     const encodingRules: AbiEncoder.EncodingRules = { shouldOptimize: false }; // optimizer is tested separately.
-    it('No Return Value', async () => {
-        // Decode return value
-        const method = new AbiEncoder.Method(ReturnValueAbis.noReturnValues);
-        const returnValue = '0x';
-        const decodedReturnValue = method.decodeReturnValues(returnValue, { shouldConvertStructsToObjects: false });
-        const expectedDecodedReturnValue: any[] = [];
-        expect(decodedReturnValue).to.be.deep.equal(expectedDecodedReturnValue);
-    });
-    it('Single static return value', async () => {
-        // Generate Return Value
-        const method = new AbiEncoder.Method(ReturnValueAbis.singleStaticReturnValue);
-        const returnValue = ['0x01020304'];
-        const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
-        const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
-            shouldConvertStructsToObjects: false,
-        });
-        // Validate decoded return value
-        expect(decodedReturnValue).to.be.deep.equal(returnValue);
-    });
-    it('Multiple static return values', async () => {
-        // Generate Return Value
-        const method = new AbiEncoder.Method(ReturnValueAbis.multipleStaticReturnValues);
-        const returnValue = ['0x01020304', '0x05060708'];
-        const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
-        const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
-            shouldConvertStructsToObjects: false,
-        });
-        // Validate decoded return value
-        expect(decodedReturnValue).to.be.deep.equal(returnValue);
-    });
-    it('Single dynamic return value', async () => {
-        // Generate Return Value
-        const method = new AbiEncoder.Method(ReturnValueAbis.singleDynamicReturnValue);
-        const returnValue = ['0x01020304'];
-        const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
-        const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
-            shouldConvertStructsToObjects: false,
-        });
-        // Validate decoded return value
-        expect(decodedReturnValue).to.be.deep.equal(returnValue);
-    });
-    it('Multiple dynamic return values', async () => {
-        // Generate Return Value
-        const method = new AbiEncoder.Method(ReturnValueAbis.multipleDynamicReturnValues);
-        const returnValue = ['0x01020304', '0x05060708'];
-        const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
-        const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
-            shouldConvertStructsToObjects: false,
-        });
-        // Validate decoded return value
-        expect(decodedReturnValue).to.be.deep.equal(returnValue);
+    const nullEncodedReturnValue = '0x';
+    describe('Standard encoding/decoding', () => {
+        it('No Return Value', async () => {
+            // Decode return value
+            const method = new AbiEncoder.Method(ReturnValueAbis.noReturnValues);
+            const returnValue = '0x';
+            const decodedReturnValue = method.decodeReturnValues(returnValue, { shouldConvertStructsToObjects: false });
+            const expectedDecodedReturnValue: any[] = [];
+            expect(decodedReturnValue).to.be.deep.equal(expectedDecodedReturnValue);
+        });
+        it('Single static return value', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.singleStaticReturnValue);
+            const returnValue = ['0x01020304'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
+                shouldConvertStructsToObjects: false,
+            });
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Multiple static return values', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.multipleStaticReturnValues);
+            const returnValue = ['0x01020304', '0x05060708'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
+                shouldConvertStructsToObjects: false,
+            });
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Single dynamic return value', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.singleDynamicReturnValue);
+            const returnValue = ['0x01020304'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
+                shouldConvertStructsToObjects: false,
+            });
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Multiple dynamic return values', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.multipleDynamicReturnValues);
+            const returnValue = ['0x01020304', '0x05060708'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
+                shouldConvertStructsToObjects: false,
+            });
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Mixed static/dynamic return values', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.mixedStaticAndDynamicReturnValues);
+            const returnValue = ['0x01020304', '0x05060708'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
+                shouldConvertStructsToObjects: false,
+            });
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Should decode NULL as default value (single; static)', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.singleStaticReturnValue);
+            const returnValue = ['0x00000000'];
+
+            const decodedReturnValue = method.decodeReturnValues(nullEncodedReturnValue, {
+                shouldConvertStructsToObjects: false,
+            });
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Should decode NULL as default value (multiple; static)', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.multipleStaticReturnValues);
+            const returnValue = ['0x00000000', '0x00000000'];
+            const decodedReturnValue = method.decodeReturnValues(nullEncodedReturnValue, {
+                shouldConvertStructsToObjects: false,
+            });
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Should decode NULL as default value (single; dynamic)', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.singleDynamicReturnValue);
+            const returnValue = ['0x'];
+            const decodedReturnValue = method.decodeReturnValues(nullEncodedReturnValue, {
+                shouldConvertStructsToObjects: false,
+            });
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
     });
-    it('Mixed static/dynamic return values', async () => {
-        // Generate Return Value
-        const method = new AbiEncoder.Method(ReturnValueAbis.mixedStaticAndDynamicReturnValues);
-        const returnValue = ['0x01020304', '0x05060708'];
-        const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
-        const decodedReturnValue = method.decodeReturnValues(encodedReturnValue, {
-            shouldConvertStructsToObjects: false,
-        });
-        // Validate decoded return value
-        expect(decodedReturnValue).to.be.deep.equal(returnValue);
+
+    describe('Strict encoding/decoding', () => {
+        it('No Return Value', async () => {
+            // Decode return value
+            const method = new AbiEncoder.Method(ReturnValueAbis.noReturnValues);
+            const returnValue = '0x';
+            const decodedReturnValue = method.strictDecodeReturnValue<void>(returnValue);
+            const expectedDecodedReturnValue = undefined;
+            expect(decodedReturnValue).to.be.deep.equal(expectedDecodedReturnValue);
+        });
+        it('Single static return value', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.singleStaticReturnValue);
+            const returnValue = ['0x01020304'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.strictDecodeReturnValue<string>(encodedReturnValue);
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue[0]);
+        });
+        it('Multiple static return values', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.multipleStaticReturnValues);
+            const returnValue = ['0x01020304', '0x05060708'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.strictDecodeReturnValue<[string, string]>(encodedReturnValue);
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Single dynamic return value', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.singleDynamicReturnValue);
+            const returnValue = ['0x01020304'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.strictDecodeReturnValue<string>(encodedReturnValue);
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue[0]);
+        });
+        it('Multiple dynamic return values', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.multipleDynamicReturnValues);
+            const returnValue = ['0x01020304', '0x05060708'];
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.strictDecodeReturnValue<[string, string]>(encodedReturnValue);
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Struct should include fields', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.structuredReturnValue);
+            const returnValue = {
+                fillResults: {
+                    makerAssetFilledAmount: new BigNumber(50),
+                    takerAssetFilledAmount: new BigNumber(40),
+                },
+            };
+            const encodedReturnValue = method.encodeReturnValues(returnValue, encodingRules);
+            const decodedReturnValue = method.strictDecodeReturnValue<{
+                makerAssetFilledAmount: BigNumber;
+                takerAssetFilledAmount: BigNumber;
+            }>(encodedReturnValue);
+            // Validate decoded return value
+            // Note that only the contents of `fillResults`, not the key itself, is decoded.
+            // This is by design, as only a struct's contents are encoded and returned by a funciton call.
+            expect(decodedReturnValue).to.be.deep.equal(returnValue.fillResults);
+        });
+        it('Should decode NULL as default value (single; static)', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.singleStaticReturnValue);
+            const returnValue = '0x00000000';
+            const encodedReturnValue = '0x';
+            const decodedReturnValue = method.strictDecodeReturnValue<string>(encodedReturnValue);
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Should decode NULL as default value (multiple; static)', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.multipleStaticReturnValues);
+            const returnValue = ['0x00000000', '0x00000000'];
+            const encodedReturnValue = '0x';
+            const decodedReturnValue = method.strictDecodeReturnValue<[string, string]>(encodedReturnValue);
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
+        it('Should decode NULL as default value (single; dynamic)', async () => {
+            // Generate Return Value
+            const method = new AbiEncoder.Method(ReturnValueAbis.singleDynamicReturnValue);
+            const returnValue = '0x';
+            const encodedReturnValue = '0x';
+            const decodedReturnValue = method.strictDecodeReturnValue<string>(encodedReturnValue);
+            // Validate decoded return value
+            expect(decodedReturnValue).to.be.deep.equal(returnValue);
+        });
     });
 });