Squashed 'libjsqrc/ethereumjs/' changes from ab745d3..ec74fc0

ec74fc0 gulp
46b932c negative integers support
f85f77f fixed typos
6a4b4f3 fixed readme
d0473d6 gulp
70bf1a5 fixed typos
bacc5aa methodExists and propertyExists are now separated tests
472ad43 more comments
603c790 next part of abi.js parsers tests and fixes
b0a9bbf next part of abi.js docs
6b2ec23 formatting bool tests and fixes
ed1cb9e simplifid abi.js methods
17f2f12 gulp
12bdb5f providers documentation
8d1f96c few comments
422dc05 ProviderManager separated to providermanager.js file
9a8f45e Filter separated to filter.js file
8b7d4b0 beginning of comments in web3
ee167e5 test for parsing multiple methods description
4056c04 tests...
1428dce web3.contract -> web3.eth.contract
f3b71a7 removed unused line
380d986 tests in progress, fixed utf characters conversion in toAscii
9e0de57 mocha test reporter
f6ff1f1 mocha reporter name starts with lower case letter
7595a5d removed padding calculation from ethereum.js, padding is always 32
9a9987a Merge commit 'a1023a5dffee7c06e8b75a21f5c9b8826e820942' into develop
5582901 Various fixes to ethereum.js and client web API stuff.
ded221f Merge commit 'ab745d3b0eb89d67db1ed953020c665be3d072ed' into develop

git-subtree-dir: libjsqrc/ethereumjs
git-subtree-split: ec74fc05d438806ece64fe34b0f28c8f45f5167e

7 files changed, 576 insertions, 72 deletions

diff --git a/abi.parsers.js b/abi.parsers.js
index 06a77fb8..92532446 100644
--- a/abi.parsers.js
+++ b/abi.parsers.js
@@ -1,37 +1,547 @@
 var assert = require('assert');
 var abi = require('../lib/abi.js');
+var clone = function (object) { return JSON.parse(JSON.stringify(object)); };
+
+var description =  [{
+    "name": "test",
+    "inputs": [{
+        "name": "a",
+        "type": "uint256"
+    }
+    ],
+    "outputs": [
+    {
+        "name": "d",
+        "type": "uint256"
+    }
+    ]
+}];
 
 describe('abi', function() {
     describe('inputParser', function() {
-        it('should parse ...', function() {
-
-            var desc =  [{
-                "name": "multiply",
-                "inputs": [
-                {
-                    "name": "a",
-                    "type": "uint256"
-                }
-                ],
-                "outputs": [
-                {
-                    "name": "d",
-                    "type": "uint256"
-                }
-                ]
+        it('should parse input uint', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "uint" }
+            ];
+            
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+
+        });
+
+        it('should parse input uint128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "uint128" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+
+        });
+        
+        it('should parse input uint256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "uint256" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            
+        });
+
+        it('should parse input int', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "int" }
+            ];
+            
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
+            assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
+
+        });
+
+        it('should parse input int128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "int128" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
+            assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
+
+        });
+
+        it('should parse input int256', function() {
+        
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "int256" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(10), "000000000000000000000000000000000000000000000000000000000000000a");
+            assert.equal(parser.test(-1), "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            assert.equal(parser.test(-2), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
+            assert.equal(parser.test(-16), "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0");
+            
+        });
+
+        it('should parse input bool', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: 'bool' }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test(true), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test(false), "0000000000000000000000000000000000000000000000000000000000000000");
+
+        });
+
+        it('should parse input hash', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "hash" }
+            ];
+            
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
+
+        }); 
+
+        it('should parse input hash256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "hash256" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
+
+        });
+
+
+        it('should parse input hash160', function() {
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "hash160" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+            
+            // then
+            assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
+        });
+
+        it('should parse input address', function () {
+
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "address" }
+            ];
+            
+            // when
+            var parser = abi.inputParser(d)
+            
+            // then
+            assert.equal(parser.test("0x407d73d8a49eeb85d32cf465507dd71d507100c1"), "000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1");
+
+        });
+
+        it('should parse input string', function () {
+            
+            // given
+            var d = clone(description);
+
+            d[0].inputs = [
+                { type: "string" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.test('hello'), "68656c6c6f000000000000000000000000000000000000000000000000000000");
+            assert.equal(parser.test('world'), "776f726c64000000000000000000000000000000000000000000000000000000");
+        });
+
+        it('should use proper method name', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].name = 'helloworld';
+            d[0].inputs = [
+                { type: "int" }
+            ];
+
+            // when
+            var parser = abi.inputParser(d);
+
+            // then
+            assert.equal(parser.helloworld(1), "0000000000000000000000000000000000000000000000000000000000000001");
+
+        });
+        
+        it('should parse multiple methods', function () {
+            
+            // given
+            var d =  [{
+                name: "test",
+                inputs: [{ type: "int" }],
+                outputs: [{ type: "int" }]
+            },{
+                name: "test2",
+                inputs: [{ type: "string" }],
+                outputs: [{ type: "string" }]
             }];
 
-            var iParser = abi.inputParser(desc);
-            assert.equal(iParser.multiply(1), "0x000000000000000000000000000000000000000000000000000000000000000001");
+            // when
+            var parser = abi.inputParser(d);
+
+            //then
+            assert.equal(parser.test(1), "0000000000000000000000000000000000000000000000000000000000000001");
+            assert.equal(parser.test2('hello'), "68656c6c6f000000000000000000000000000000000000000000000000000000");
 
         });
     });
 
-
     describe('outputParser', function() {
-        it('parse ...', function() {
+        it('should parse output string', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: "string" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+            
+            // then
+            assert.equal(parser.test("0x68656c6c6f000000000000000000000000000000000000000000000000000000")[0], 'hello');
+            assert.equal(parser.test("0x776f726c64000000000000000000000000000000000000000000000000000000")[0], 'world');
 
         });
+
+        it('should parse output uint', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+        });
+        
+        it('should parse output uint256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+        });
+
+        it('should parse output uint128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'uint128' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+        });
+
+        it('should parse output int', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+        });
+        
+        it('should parse output int256', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+        });
+
+        it('should parse output int128', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'int128' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10);
+        });
+
+        it('should parse output hash', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")
+        });
+        
+        it('should parse output hash256', function() {
+        
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash256' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")
+        });
+
+        it('should parse output hash160', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'hash160' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], "0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")
+            // TODO shouldnt' the expected hash be shorter?
+        });
+
+        it('should parse output address', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'address' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], "0x407d73d8a49eeb85d32cf465507dd71d507100c1")
+        });
+
+        it('should parse output bool', function() {
+            
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: 'bool' }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("000000000000000000000000000000000000000000000000000000000000000001")[0], true);
+            assert.equal(parser.test("000000000000000000000000000000000000000000000000000000000000000000")[0], false);
+            
+
+        });
+
+        it('should parse multiple output strings', function() {
+
+            // given
+            var d = clone(description);
+
+            d[0].outputs = [
+                { type: "string" },
+                { type: "string" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.test("0x68656c6c6f000000000000000000000000000000000000000000000000000000776f726c64000000000000000000000000000000000000000000000000000000")[0], 'hello');
+            assert.equal(parser.test("0x68656c6c6f000000000000000000000000000000000000000000000000000000776f726c64000000000000000000000000000000000000000000000000000000")[1], 'world');
+
+        });
+        
+        it('should use proper method name', function () {
+        
+            // given
+            var d = clone(description);
+            d[0].name = 'helloworld';
+            d[0].outputs = [
+                { type: "int" }
+            ];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            // then
+            assert.equal(parser.helloworld("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+
+        });
+
+
+        it('should parse multiple methods', function () {
+            
+            // given
+            var d =  [{
+                name: "test",
+                inputs: [{ type: "int" }],
+                outputs: [{ type: "int" }]
+            },{
+                name: "test2",
+                inputs: [{ type: "string" }],
+                outputs: [{ type: "string" }]
+            }];
+
+            // when
+            var parser = abi.outputParser(d);
+
+            //then
+            assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1);
+            assert.equal(parser.test2("0x68656c6c6f000000000000000000000000000000000000000000000000000000")[0], "hello");
+
+        });
+
     });
 });
 
diff --git a/db.methods.js b/db.methods.js
index b4abfc4d..662f4e7c 100644
--- a/db.methods.js
+++ b/db.methods.js
@@ -7,12 +7,10 @@ web3.setProvider(new web3.providers.WebSocketProvider('http://localhost:8080'));
 
 describe('web3', function() {
     describe('db', function() {
-        it('should have all methods implemented', function() {
-            u.methodExists(web3.db, 'put');
-            u.methodExists(web3.db, 'get');
-            u.methodExists(web3.db, 'putString');
-            u.methodExists(web3.db, 'getString');
-        });
+        u.methodExists(web3.db, 'put');
+        u.methodExists(web3.db, 'get');
+        u.methodExists(web3.db, 'putString');
+        u.methodExists(web3.db, 'getString');
     });
 });
 
diff --git a/eth.methods.js b/eth.methods.js
index 7190b27d..892db0d8 100644
--- a/eth.methods.js
+++ b/eth.methods.js
@@ -7,35 +7,31 @@ web3.setProvider(new web3.providers.WebSocketProvider('http://localhost:8080'));
 
 describe('web3', function() {
     describe('eth', function() {
-        it('should have all methods implemented', function() {
-            u.methodExists(web3.eth, 'balanceAt');
-            u.methodExists(web3.eth, 'stateAt');
-            u.methodExists(web3.eth, 'storageAt');
-            u.methodExists(web3.eth, 'countAt');
-            u.methodExists(web3.eth, 'codeAt');
-            u.methodExists(web3.eth, 'transact');
-            u.methodExists(web3.eth, 'call');
-            u.methodExists(web3.eth, 'block');
-            u.methodExists(web3.eth, 'transaction');
-            u.methodExists(web3.eth, 'uncle');
-            u.methodExists(web3.eth, 'compilers');
-            u.methodExists(web3.eth, 'lll');
-            u.methodExists(web3.eth, 'solidity');
-            u.methodExists(web3.eth, 'serpent');
-            u.methodExists(web3.eth, 'logs');
-        });
+        u.methodExists(web3.eth, 'balanceAt');
+        u.methodExists(web3.eth, 'stateAt');
+        u.methodExists(web3.eth, 'storageAt');
+        u.methodExists(web3.eth, 'countAt');
+        u.methodExists(web3.eth, 'codeAt');
+        u.methodExists(web3.eth, 'transact');
+        u.methodExists(web3.eth, 'call');
+        u.methodExists(web3.eth, 'block');
+        u.methodExists(web3.eth, 'transaction');
+        u.methodExists(web3.eth, 'uncle');
+        u.methodExists(web3.eth, 'compilers');
+        u.methodExists(web3.eth, 'lll');
+        u.methodExists(web3.eth, 'solidity');
+        u.methodExists(web3.eth, 'serpent');
+        u.methodExists(web3.eth, 'logs');
 
-        it('should have all properties implemented', function () {
-            u.propertyExists(web3.eth, 'coinbase');
-            u.propertyExists(web3.eth, 'listening');
-            u.propertyExists(web3.eth, 'mining');
-            u.propertyExists(web3.eth, 'gasPrice');
-            u.propertyExists(web3.eth, 'account');
-            u.propertyExists(web3.eth, 'accounts');
-            u.propertyExists(web3.eth, 'peerCount');
-            u.propertyExists(web3.eth, 'defaultBlock');
-            u.propertyExists(web3.eth, 'number');
-        });
+        u.propertyExists(web3.eth, 'coinbase');
+        u.propertyExists(web3.eth, 'listening');
+        u.propertyExists(web3.eth, 'mining');
+        u.propertyExists(web3.eth, 'gasPrice');
+        u.propertyExists(web3.eth, 'account');
+        u.propertyExists(web3.eth, 'accounts');
+        u.propertyExists(web3.eth, 'peerCount');
+        u.propertyExists(web3.eth, 'defaultBlock');
+        u.propertyExists(web3.eth, 'number');
     });
 });
 
diff --git a/mocha.opts b/mocha.opts
index b2db8d5a..c4a633d6 100644
--- a/mocha.opts
+++ b/mocha.opts
@@ -1,2 +1,2 @@
---reporter Spec
+--reporter spec 
 
diff --git a/shh.methods.js b/shh.methods.js
index 08f573a3..f2f56edb 100644
--- a/shh.methods.js
+++ b/shh.methods.js
@@ -7,13 +7,11 @@ web3.setProvider(new web3.providers.WebSocketProvider('http://localhost:8080'));
 
 describe('web3', function() {
     describe('shh', function() {
-        it('should have all methods implemented', function() {
-            u.methodExists(web3.shh, 'post');
-            u.methodExists(web3.shh, 'newIdentity');
-            u.methodExists(web3.shh, 'haveIdentity');
-            u.methodExists(web3.shh, 'newGroup');
-            u.methodExists(web3.shh, 'addToGroup');
-        });
+        u.methodExists(web3.shh, 'post');
+        u.methodExists(web3.shh, 'newIdentity');
+        u.methodExists(web3.shh, 'haveIdentity');
+        u.methodExists(web3.shh, 'newGroup');
+        u.methodExists(web3.shh, 'addToGroup');
     });
 });
 
diff --git a/utils.js b/utils.js
index 4c508da6..8617348e 100644
--- a/utils.js
+++ b/utils.js
@@ -1,11 +1,15 @@
 var assert = require('assert');
 
 var methodExists = function (object, method) {
-    assert.equal('function', typeof object[method], 'method ' + method + ' is not implemented');
+    it('should have method ' + method + ' implemented', function() {
+        assert.equal('function', typeof object[method], 'method ' + method + ' is not implemented');
+    });
 };
 
 var propertyExists = function (object, property) {
-    assert.equal('object', typeof object[property], 'property ' + property + ' is not implemented');
+    it('should have property ' + property + ' implemented', function() {
+        assert.equal('object', typeof object[property], 'property ' + property + ' is not implemented');
+    });
 };
 
 module.exports = {
diff --git a/web3.methods.js b/web3.methods.js
index a7e02097..5c30177e 100644
--- a/web3.methods.js
+++ b/web3.methods.js
@@ -6,13 +6,11 @@ var u = require('./utils.js');
 web3.setProvider(new web3.providers.WebSocketProvider('http://localhost:8080')); // TODO: create some mock provider
 
 describe('web3', function() {
-    it('should have all methods implemented', function() {
-        u.methodExists(web3, 'sha3');
-        u.methodExists(web3, 'toAscii');
-        u.methodExists(web3, 'fromAscii');
-        u.methodExists(web3, 'toFixed');
-        u.methodExists(web3, 'fromFixed');
-        u.methodExists(web3, 'offset');
-    });
+    u.methodExists(web3, 'sha3');
+    u.methodExists(web3, 'toAscii');
+    u.methodExists(web3, 'fromAscii');
+    u.methodExists(web3, 'toFixed');
+    u.methodExists(web3, 'fromFixed');
+    u.methodExists(web3, 'offset');
 });