From f6400610f194c0b5088ef1a6b23d8a83b87f875a Mon Sep 17 00:00:00 2001
From: "David A. Carley" <dacarley@gmail.com>
Date: Tue, 24 Oct 2017 02:01:31 -0700
Subject: [PATCH] Fix for Bug #1123 (#1135)

* Fix for Bug #1123

* Trigger travis

* Removed a bogus test for `bytes64`
---
 packages/web3-eth-abi/src/formatters.js |   4 +
 test/abi.encodeParameter.js             |   4 -
 test/contract.encodeABI.js              | 108 ++++++++++++++++++++++++
 3 files changed, 112 insertions(+), 4 deletions(-)
 create mode 100644 test/contract.encodeABI.js

diff --git a/packages/web3-eth-abi/src/formatters.js b/packages/web3-eth-abi/src/formatters.js
index 2f52726ba41..08baac7e9f5 100644
--- a/packages/web3-eth-abi/src/formatters.js
+++ b/packages/web3-eth-abi/src/formatters.js
@@ -62,6 +62,10 @@ var formatInputBytes = function (value) {
         throw new Error('Given parameter bytes has an invalid length: "'+ value + '"');
     }
 
+    if (result.length > 64) {
+        throw new Error('Given parameter bytes is too long: "' + value + '"');
+    }
+
     var l = Math.floor((result.length + 63) / 64);
     result = utils.padRight(result, l * 64);
     return new SolidityParam(result);
diff --git a/test/abi.encodeParameter.js b/test/abi.encodeParameter.js
index 12690b88ad5..8476643afdf 100644
--- a/test/abi.encodeParameter.js
+++ b/test/abi.encodeParameter.js
@@ -133,10 +133,6 @@ describe('lib/solidity/coder', function () {
                                                               'c3a40000c3a40000000000000000000000000000000000000000000000000000'});
         test({ type: 'bytes32', value: '0xc3a40000c3a4',
                                                     expected: 'c3a40000c3a40000000000000000000000000000000000000000000000000000'});
-        test({ type: 'bytes64', value: '0xc3a40000c3a40000000000000000000000000000000000000000000000000000' +
-                                         'c3a40000c3a40000000000000000000000000000000000000000000000000000',
-                                                    expected: 'c3a40000c3a40000000000000000000000000000000000000000000000000000' +
-                                                              'c3a40000c3a40000000000000000000000000000000000000000000000000000'});
         test({ type: 'string', value: 'ää',
                                                     expected: '0000000000000000000000000000000000000000000000000000000000000020' +
                                                               '0000000000000000000000000000000000000000000000000000000000000008' +
diff --git a/test/contract.encodeABI.js b/test/contract.encodeABI.js
new file mode 100644
index 00000000000..20e7bcfa781
--- /dev/null
+++ b/test/contract.encodeABI.js
@@ -0,0 +1,108 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Eth = require('../packages/web3-eth');
+var sha3 = require('../packages/web3-utils').sha3;
+var FakeIpcProvider = require('./helpers/FakeIpcProvider');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+var Promise = require('bluebird');
+
+var abi = [
+    {
+        constant: true,
+        inputs: [
+            {
+                name: "a",
+                type: "bytes32"
+            },
+            {
+                name: "b",
+                type: "bytes32"
+            }
+        ],
+        name: "takesTwoBytes32",
+        outputs: [
+            {
+                name: "",
+                type: "bytes32"
+            }
+        ],
+        payable: false,
+        type: "function",
+        stateMutability: "view"
+    }
+];
+
+describe('contract', function () {
+    describe('method.encodeABI', function () {
+        it('should handle bytes32 arrays that only contain 1 byte', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var result = contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(2)), '0x'.concat('b'.repeat(2))).encodeABI();
+
+            assert.equal(result, [
+                '0x1323517e',
+                'aa00000000000000000000000000000000000000000000000000000000000000',
+                'bb00000000000000000000000000000000000000000000000000000000000000'
+            ].join(''));
+        });
+
+        it('should handle bytes32 arrays that are short 1 byte', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var result = contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(62)), '0x'.concat('b'.repeat(62))).encodeABI();
+
+            assert.equal(result, [
+                '0x1323517e',
+                'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00',
+                'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00'
+            ].join(''));
+        });
+
+        it('should throw an exception on bytes32 arrays that have an invalid length', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var test = function () {
+                contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(63)), '0x'.concat('b'.repeat(63))).encodeABI();
+            }
+
+            assert.throws(test, 'Given parameter bytes has an invalid length: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
+        });
+
+        it('should handle bytes32 arrays that are full', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var result = contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(64)), '0x'.concat('b'.repeat(64))).encodeABI();
+
+            assert.equal(result, [
+                '0x1323517e',
+                'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+            ].join(''));
+        });
+
+        it('should throw an exception on bytes32 arrays that are too long', function () {
+            var provider = new FakeIpcProvider();
+            var eth = new Eth(provider);
+
+            var contract = new eth.Contract(abi);
+
+            var test = function() {
+                contract.methods.takesTwoBytes32('0x'.concat('a'.repeat(66)), '0x'.concat('b'.repeat(66))).encodeABI();
+            }
+
+            assert.throws(test, 'Given parameter bytes is too long: "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
+        });
+    });
+});