Fixed issue with decoding negative ints with width < 256

3 files changed, 246 insertions, 238 deletions

diff --git a/packages/utils/src/abi_encoder/data_type.ts b/packages/utils/src/abi_encoder/data_type.ts
index f5a8087ea..15de12a2f 100644
--- a/packages/utils/src/abi_encoder/data_type.ts
+++ b/packages/utils/src/abi_encoder/data_type.ts
@@ -41,7 +41,8 @@ export abstract class DataType {
     }
 
     public decode(calldata: string, rules?: DecodingRules): any {
-        const rawCalldata = new RawCalldata(calldata);
+        const rawCalldata = new RawCalldata(calldata, false);
+        console.log(`HERE DUDE ${JSON.stringify(rawCalldata)}`);
         const rules_ = rules ? rules : DataType.DEFAULT_DECODING_RULES;
         const value = this.generateValue(rawCalldata, rules_);
         return value;
@@ -277,6 +278,7 @@ export abstract class MemberDataType extends DataType {
             value = [];
             _.each(members, (member: DataType, idx: number) => {
                 let memberValue = member.generateValue(calldata, rules);
+                console.log(`MEMBER VALUE: ${memberValue}`);
                 (value as any[]).push(memberValue);
             });
         }
diff --git a/packages/utils/src/abi_encoder/evm_data_types.ts b/packages/utils/src/abi_encoder/evm_data_types.ts
index d024a9bfa..bfb2808da 100644
--- a/packages/utils/src/abi_encoder/evm_data_types.ts
+++ b/packages/utils/src/abi_encoder/evm_data_types.ts
@@ -154,9 +154,8 @@ abstract class Number extends PayloadDataType {
         if (this instanceof Int) {
             // Check if we're negative
             const binBase = 2;
-            const paddedValueBin = value.toString(binBase);
-            const valueBin = paddedValueBin.slice(paddedValueBin.length - this.width);
-            if (valueBin[0].startsWith('1')) {
+            const valueBin = value.toString(2);
+            if (valueBin.length === 256 && valueBin[0].startsWith('1')) {
                 // Negative
                 // Step 1/3: Invert binary value
                 let invertedValueBin = '';
diff --git a/packages/utils/test/abi_encoder_test.ts b/packages/utils/test/abi_encoder_test.ts
index 8add41af6..d2d7b9825 100644
--- a/packages/utils/test/abi_encoder_test.ts
+++ b/packages/utils/test/abi_encoder_test.ts
@@ -13,9 +13,9 @@ describe.only('ABI Encoder', () => {
 
     });
 
-    describe.only('ABI Tests at Method Level', () => {
+    describe('ABI Tests at Method Level', () => {
 
-        it.only('Should reuse duplicated strings in string array', async () => {
+        it('Should reuse duplicated strings in string array', async () => {
             const method = new AbiEncoder.Method(AbiSamples.GAbi);
 
             const args = [
@@ -723,237 +723,244 @@ describe.only('ABI Encoder', () => {
             expect(calldata).to.be.equal(expectedCalldata);
         });
     });
-    /*
-        describe('Array', () => {
-            it('sample', async () => {
-                const testDataItem = { name: 'testArray', type: 'int[2]' };
-                const dataType = new AbiEncoder.SolArray(testDataItem);
-                console.log(JSON.stringify(dataType, null, 4));
-                console.log('*'.repeat(60));
-                dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
-                console.log(JSON.stringify(dataType, null, 4));
-                const hexValue = dataType.getHexValue();
-                console.log('*'.repeat(60));
-                console.log(hexValue);
-            });
-    
-            it('sample undefined size', async () => {
-                const testDataItem = { name: 'testArray', type: 'int[]' };
-                const dataType = new AbiEncoder.SolArray(testDataItem);
-                console.log(JSON.stringify(dataType, null, 4));
-                console.log('*'.repeat(60));
-                dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
-                console.log(JSON.stringify(dataType, null, 4));
-                const hexValue = dataType.getHexValue();
-                console.log('*'.repeat(60));
-                console.log(hexValue);
-            });
-    
-            it('sample dynamic types', async () => {
-                const testDataItem = { name: 'testArray', type: 'string[]' };
-                const dataType = new AbiEncoder.SolArray(testDataItem);
-                console.log(JSON.stringify(dataType, null, 4));
-                console.log('*'.repeat(60));
-                dataType.assignValue(['five', 'six', 'seven']);
-                console.log(JSON.stringify(dataType, null, 4));
-                const hexValue = dataType.getHexValue();
-                console.log('*'.repeat(60));
-                console.log(hexValue);
-                const calldata = new AbiEncoder.Calldata('0x01020304', 1);
-                dataType.bind(calldata, AbiEncoder.CalldataSection.PARAMS);
-                console.log('*'.repeat(60));
-                console.log(calldata.getHexValue());
-            });
-        });
-    
-        describe('Address', () => {
-            const testAddressDataItem = { name: 'testAddress', type: 'address' };
-            it('Valid Address', async () => {
-                const addressDataType = new AbiEncoder.Address(testAddressDataItem);
-                addressDataType.assignValue('0xe41d2489571d322189246dafa5ebde1f4699f498');
-                const expectedAbiEncodedAddress = '0x000000000000000000000000e41d2489571d322189246dafa5ebde1f4699f498';
-    
-                console.log(addressDataType.getHexValue());
-                console.log(expectedAbiEncodedAddress);
-                expect(addressDataType.getHexValue()).to.be.equal(expectedAbiEncodedAddress);
-            });
-        });
-    
-        describe('Bool', () => {
-            const testBoolDataItem = { name: 'testBool', type: 'bool' };
-            it('True', async () => {
-                const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
-                boolDataType.assignValue(true);
-                const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000001';
-                expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
-            });
-    
-            it('False', async () => {
-                const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
-                boolDataType.assignValue(false);
-                const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000000';
-                expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
-            });
-        });
-    
-        describe('Integer', () => {
-            const testIntDataItem = { name: 'testInt', type: 'int' };
-            it('Positive - Base case', async () => {
-                const intDataType = new AbiEncoder.Int(testIntDataItem);
-                intDataType.assignValue(new BigNumber(1));
-                const expectedAbiEncodedInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
-                expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
-            });
-    
-            it('Positive', async () => {
-                const intDataType = new AbiEncoder.Int(testIntDataItem);
-                intDataType.assignValue(new BigNumber(437829473));
-                const expectedAbiEncodedInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
-                expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
-            });
-    
-            it('Negative - Base case', async () => {
-                const intDataType = new AbiEncoder.Int(testIntDataItem);
-                intDataType.assignValue(new BigNumber(-1));
-                const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
-                expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
-            });
-    
-            it('Negative', async () => {
-                const intDataType = new AbiEncoder.Int(testIntDataItem);
-                intDataType.assignValue(new BigNumber(-437829473));
-                const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffe5e7409f';
-                expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
-            });
-    
-            // TODO: Add bounds tests + tests for different widths
-        });
-    
-        describe('Unsigned Integer', () => {
-            const testIntDataItem = { name: 'testUInt', type: 'uint' };
-            it('Lower Bound', async () => {
-                const uintDataType = new AbiEncoder.UInt(testIntDataItem);
-                uintDataType.assignValue(new BigNumber(0));
-                const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000000';
-                expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
-            });
-    
-            it('Base Case', async () => {
-                const uintDataType = new AbiEncoder.UInt(testIntDataItem);
-                uintDataType.assignValue(new BigNumber(1));
-                const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
-                expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
-            });
-    
-            it('Random value', async () => {
-                const uintDataType = new AbiEncoder.UInt(testIntDataItem);
-                uintDataType.assignValue(new BigNumber(437829473));
-                const expectedAbiEncodedUInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
-                expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
-            });
-    
-            // TODO: Add bounds tests + tests for different widths
-        });
-    
-        describe('Static Bytes', () => {
-            it('Byte (padded)', async () => {
-                const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
-                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-                byteDataType.assignValue('0x05');
-                const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
-                expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
-            });
-    
-            it.skip('Byte (no padding)', async () => {
-                const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
-                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-    
-                // @TODO: This does not catch the Error
-                expect(byteDataType.assignValue('0x5')).to.throw();
-            });
-    
-            it('Bytes1', async () => {
-                const testByteDataItem = { name: 'testStaticBytes', type: 'bytes1' };
-                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-                byteDataType.assignValue('0x05');
-                const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
-                expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
-            });
-    
-            it('Bytes32 (padded)', async () => {
-                const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
-                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-                byteDataType.assignValue('0x0001020304050607080911121314151617181920212223242526272829303132');
-                const expectedAbiEncodedByte = '0x0001020304050607080911121314151617181920212223242526272829303132';
-                expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
-            });
-    
-            it('Bytes32 (unpadded)', async () => {
-                const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
-                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-                byteDataType.assignValue('0x1a18bf61');
-                const expectedAbiEncodedByte = '0x1a18bf6100000000000000000000000000000000000000000000000000000000';
-                expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
-            });
-    
-            it.skip('Bytes32 - Too long', async () => {
-                const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
-                const byteDataType = new AbiEncoder.Byte(testByteDataItem);
-    
-                // @TODO: This does not catch the Error
-                expect(
-                    byteDataType.assignValue('0x000102030405060708091112131415161718192021222324252627282930313233'),
-                ).to.throw(
-                    `Tried to assign 0x000102030405060708091112131415161718192021222324252627282930313233 (33 bytes), which exceeds max bytes that can be stored in a bytes32`,
-                );
-            });
-        });
-    
-        describe('Bytes (Dynamic)', () => {
-            const testBytesDataItem = { name: 'testBytes', type: 'bytes' };
-            it('Less than 32 bytes', async () => {
-                const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
-                bytesDataType.assignValue('0x010203');
-                const expectedAbiEncodedBytes =
-                    '0x00000000000000000000000000000000000000000000000000000000000000030102030000000000000000000000000000000000000000000000000000000000';
-    
-                expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
-            });
-    
-            it('Greater than 32 bytes', async () => {
-                const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
-                const testValue = '0x' + '61'.repeat(40);
-                bytesDataType.assignValue(testValue);
-                const expectedAbiEncodedBytes =
-                    '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
-                expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
-            });
-    
-            // @TODO: Add test for throw on half-byte
-            // @TODO: Test with no 0x prefix
-            // @TODO: Test with Buffer as input
-        });
-    
-        describe('String', () => {
-            const testStringDataItem = { name: 'testString', type: 'string' };
-            it('Less than 32 bytes', async () => {
-                const stringDataType = new AbiEncoder.SolString(testStringDataItem);
-                stringDataType.assignValue('five');
-                const expectedAbiEncodedString =
-                    '0x00000000000000000000000000000000000000000000000000000000000000046669766500000000000000000000000000000000000000000000000000000000';
-    
-                console.log(stringDataType.getHexValue());
-                console.log(expectedAbiEncodedString);
-                expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
-            });
-    
-            it('Greater than 32 bytes', async () => {
-                const stringDataType = new AbiEncoder.SolString(testStringDataItem);
-                const testValue = 'a'.repeat(40);
-                stringDataType.assignValue(testValue);
-                const expectedAbiEncodedString =
-                    '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
-                expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
-            });
+
+    describe.only('Array', () => {
+        it.only('sample', async () => {
+            // Create DataType object
+            const testDataItem = { name: 'testArray', type: 'int[2]' };
+            const dataType = new AbiEncoder.SolArray(testDataItem);
+            // Construct args to be encoded
+            const args = [new BigNumber(5), new BigNumber(6)];
+            // Encode Args and validate result
+            const encodedArgs = dataType.encode(args);
+            const expectedEncodedArgs = '0x00000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006';
+            expect(encodedArgs).to.be.equal(expectedEncodedArgs);
+            // Decode Encoded Args and validate result
+            const decodedArgs = dataType.decode(encodedArgs);
+            const decodedArgsAsJson = JSON.stringify(decodedArgs);
+            const argsAsJson = JSON.stringify(args);
+            expect(decodedArgsAsJson).to.be.equal(argsAsJson);
+        });
+
+        /*
+        it('sample undefined size', async () => {
+            const testDataItem = { name: 'testArray', type: 'int[]' };
+            const dataType = new AbiEncoder.SolArray(testDataItem);
+            console.log(JSON.stringify(dataType, null, 4));
+            console.log('*'.repeat(60));
+            dataType.assignValue([new BigNumber(5), new BigNumber(6)]);
+            console.log(JSON.stringify(dataType, null, 4));
+            const hexValue = dataType.getHexValue();
+            console.log('*'.repeat(60));
+            console.log(hexValue);
+        });
+
+        it('sample dynamic types', async () => {
+            const testDataItem = { name: 'testArray', type: 'string[]' };
+            const dataType = new AbiEncoder.SolArray(testDataItem);
+            console.log(JSON.stringify(dataType, null, 4));
+            console.log('*'.repeat(60));
+            dataType.assignValue(['five', 'six', 'seven']);
+            console.log(JSON.stringify(dataType, null, 4));
+            const hexValue = dataType.getHexValue();
+            console.log('*'.repeat(60));
+            console.log(hexValue);
+            const calldata = new AbiEncoder.Calldata('0x01020304', 1);
+            dataType.bind(calldata, AbiEncoder.CalldataSection.PARAMS);
+            console.log('*'.repeat(60));
+            console.log(calldata.getHexValue());
         });*/
+    });
+
+    /*
+    describe('Address', () => {
+        const testAddressDataItem = { name: 'testAddress', type: 'address' };
+        it('Valid Address', async () => {
+            const addressDataType = new AbiEncoder.Address(testAddressDataItem);
+            addressDataType.assignValue('0xe41d2489571d322189246dafa5ebde1f4699f498');
+            const expectedAbiEncodedAddress = '0x000000000000000000000000e41d2489571d322189246dafa5ebde1f4699f498';
+
+            console.log(addressDataType.getHexValue());
+            console.log(expectedAbiEncodedAddress);
+            expect(addressDataType.getHexValue()).to.be.equal(expectedAbiEncodedAddress);
+        });
+    });
+
+    describe('Bool', () => {
+        const testBoolDataItem = { name: 'testBool', type: 'bool' };
+        it('True', async () => {
+            const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
+            boolDataType.assignValue(true);
+            const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000001';
+            expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
+        });
+
+        it('False', async () => {
+            const boolDataType = new AbiEncoder.Bool(testBoolDataItem);
+            boolDataType.assignValue(false);
+            const expectedAbiEncodedBool = '0x0000000000000000000000000000000000000000000000000000000000000000';
+            expect(boolDataType.getHexValue()).to.be.equal(expectedAbiEncodedBool);
+        });
+    });
+
+    describe('Integer', () => {
+        const testIntDataItem = { name: 'testInt', type: 'int' };
+        it('Positive - Base case', async () => {
+            const intDataType = new AbiEncoder.Int(testIntDataItem);
+            intDataType.assignValue(new BigNumber(1));
+            const expectedAbiEncodedInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
+            expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+        });
+
+        it('Positive', async () => {
+            const intDataType = new AbiEncoder.Int(testIntDataItem);
+            intDataType.assignValue(new BigNumber(437829473));
+            const expectedAbiEncodedInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
+            expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+        });
+
+        it('Negative - Base case', async () => {
+            const intDataType = new AbiEncoder.Int(testIntDataItem);
+            intDataType.assignValue(new BigNumber(-1));
+            const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+            expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+        });
+
+        it('Negative', async () => {
+            const intDataType = new AbiEncoder.Int(testIntDataItem);
+            intDataType.assignValue(new BigNumber(-437829473));
+            const expectedAbiEncodedInt = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffe5e7409f';
+            expect(intDataType.getHexValue()).to.be.equal(expectedAbiEncodedInt);
+        });
+
+        // TODO: Add bounds tests + tests for different widths
+    });
+
+    describe('Unsigned Integer', () => {
+        const testIntDataItem = { name: 'testUInt', type: 'uint' };
+        it('Lower Bound', async () => {
+            const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+            uintDataType.assignValue(new BigNumber(0));
+            const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000000';
+            expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+        });
+
+        it('Base Case', async () => {
+            const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+            uintDataType.assignValue(new BigNumber(1));
+            const expectedAbiEncodedUInt = '0x0000000000000000000000000000000000000000000000000000000000000001';
+            expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+        });
+
+        it('Random value', async () => {
+            const uintDataType = new AbiEncoder.UInt(testIntDataItem);
+            uintDataType.assignValue(new BigNumber(437829473));
+            const expectedAbiEncodedUInt = '0x000000000000000000000000000000000000000000000000000000001a18bf61';
+            expect(uintDataType.getHexValue()).to.be.equal(expectedAbiEncodedUInt);
+        });
+
+        // TODO: Add bounds tests + tests for different widths
+    });
+
+    describe('Static Bytes', () => {
+        it('Byte (padded)', async () => {
+            const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
+            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+            byteDataType.assignValue('0x05');
+            const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
+            expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+        });
+
+        it.skip('Byte (no padding)', async () => {
+            const testByteDataItem = { name: 'testStaticBytes', type: 'byte' };
+            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+
+            // @TODO: This does not catch the Error
+            expect(byteDataType.assignValue('0x5')).to.throw();
+        });
+
+        it('Bytes1', async () => {
+            const testByteDataItem = { name: 'testStaticBytes', type: 'bytes1' };
+            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+            byteDataType.assignValue('0x05');
+            const expectedAbiEncodedByte = '0x0500000000000000000000000000000000000000000000000000000000000000';
+            expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+        });
+
+        it('Bytes32 (padded)', async () => {
+            const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+            byteDataType.assignValue('0x0001020304050607080911121314151617181920212223242526272829303132');
+            const expectedAbiEncodedByte = '0x0001020304050607080911121314151617181920212223242526272829303132';
+            expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+        });
+
+        it('Bytes32 (unpadded)', async () => {
+            const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+            byteDataType.assignValue('0x1a18bf61');
+            const expectedAbiEncodedByte = '0x1a18bf6100000000000000000000000000000000000000000000000000000000';
+            expect(byteDataType.getHexValue()).to.be.equal(expectedAbiEncodedByte);
+        });
+
+        it.skip('Bytes32 - Too long', async () => {
+            const testByteDataItem = { name: 'testStaticBytes', type: 'bytes32' };
+            const byteDataType = new AbiEncoder.Byte(testByteDataItem);
+
+            // @TODO: This does not catch the Error
+            expect(
+                byteDataType.assignValue('0x000102030405060708091112131415161718192021222324252627282930313233'),
+            ).to.throw(
+                `Tried to assign 0x000102030405060708091112131415161718192021222324252627282930313233 (33 bytes), which exceeds max bytes that can be stored in a bytes32`,
+            );
+        });
+    });
+
+    describe('Bytes (Dynamic)', () => {
+        const testBytesDataItem = { name: 'testBytes', type: 'bytes' };
+        it('Less than 32 bytes', async () => {
+            const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
+            bytesDataType.assignValue('0x010203');
+            const expectedAbiEncodedBytes =
+                '0x00000000000000000000000000000000000000000000000000000000000000030102030000000000000000000000000000000000000000000000000000000000';
+
+            expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
+        });
+
+        it('Greater than 32 bytes', async () => {
+            const bytesDataType = new AbiEncoder.Bytes(testBytesDataItem);
+            const testValue = '0x' + '61'.repeat(40);
+            bytesDataType.assignValue(testValue);
+            const expectedAbiEncodedBytes =
+                '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
+            expect(bytesDataType.getHexValue()).to.be.equal(expectedAbiEncodedBytes);
+        });
+
+        // @TODO: Add test for throw on half-byte
+        // @TODO: Test with no 0x prefix
+        // @TODO: Test with Buffer as input
+    });
+
+    describe('String', () => {
+        const testStringDataItem = { name: 'testString', type: 'string' };
+        it('Less than 32 bytes', async () => {
+            const stringDataType = new AbiEncoder.SolString(testStringDataItem);
+            stringDataType.assignValue('five');
+            const expectedAbiEncodedString =
+                '0x00000000000000000000000000000000000000000000000000000000000000046669766500000000000000000000000000000000000000000000000000000000';
+
+            console.log(stringDataType.getHexValue());
+            console.log(expectedAbiEncodedString);
+            expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
+        });
+
+        it('Greater than 32 bytes', async () => {
+            const stringDataType = new AbiEncoder.SolString(testStringDataItem);
+            const testValue = 'a'.repeat(40);
+            stringDataType.assignValue(testValue);
+            const expectedAbiEncodedString =
+                '0x000000000000000000000000000000000000000000000000000000000000002861616161616161616161616161616161616161616161616161616161616161616161616161616161000000000000000000000000000000000000000000000000';
+            expect(stringDataType.getHexValue()).to.be.equal(expectedAbiEncodedString);
+        });
+    });*/
 });