diff --git a/abi.inputParser.js b/abi.inputParser.js
index 1d3a869e3..a488bb2e5 100644
--- a/abi.inputParser.js
+++ b/abi.inputParser.js
@@ -19,7 +19,7 @@ var description =  [{
     ]
 }];
 
-describe('abi', function() {
+describe('lib/solidity/abi', function() {
     describe('inputParser', function() {
         it('should parse input uint', function() {
 
diff --git a/abi.outputParser.js b/abi.outputParser.js
index 955c0d5f1..a57b84a83 100644
--- a/abi.outputParser.js
+++ b/abi.outputParser.js
@@ -19,7 +19,7 @@ var description =  [{
     ]
 }];
 
-describe('abi', function() {
+describe('lib/solidity/abi', function() {
     describe('outputParser', function() {
         it('should parse output fixed bytes type', function() {
 
diff --git a/contract.js b/contract.js
new file mode 100644
index 000000000..fec9fc314
--- /dev/null
+++ b/contract.js
@@ -0,0 +1,229 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+var utils = require('../lib/utils/utils');
+
+var desc = [{
+    "name": "balance(address)",
+    "type": "function",
+    "inputs": [{
+        "name": "who",
+        "type": "address"
+    }],
+    "constant": true,
+    "outputs": [{
+        "name": "value",
+        "type": "uint256"
+    }]
+}, {
+    "name": "send(address,uint256)",
+    "type": "function",
+    "inputs": [{
+        "name": "to",
+        "type": "address"
+    }, {
+        "name": "value",
+        "type": "uint256"
+    }],
+    "outputs": []
+}, {
+    "name":"Changed",
+    "type":"event",
+    "inputs": [
+        {"name":"from","type":"address","indexed":true},
+        {"name":"amount","type":"uint256","indexed":true},
+        {"name":"t1","type":"uint256","indexed":false},
+        {"name":"t2","type":"uint256","indexed":false}
+    ],
+}];
+
+var address = '0x1234567890123456789012345678901234567890';
+
+describe('web3.eth.contract', function () {
+    describe('event', function () {
+        it('should create event filter', function (done) {
+            var provider = new FakeHttpProvider();
+            web3.setProvider(provider);
+            web3.reset(); // reset different polls
+            var sha3 = '0x5131231231231231231231';
+            provider.injectResult(sha3);
+            var step = 0;
+            provider.injectValidation(function (payload) {
+                if (step === 0) {
+                    step = 1;
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, 'web3_sha3');
+                    assert.equal(payload.params[0], web3.fromAscii('Changed(address,uint256,uint256,uint256)'));
+                } else if (step === 1) {
+                    step = 2;
+                    provider.injectResult(3);
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, 'eth_newFilter');
+                    assert.deepEqual(payload.params[0], {
+                        topics: [
+                            sha3,
+                            '0x1234567890123456789012345678901234567890'
+                        ],
+                        address: '0x1234567890123456789012345678901234567890'
+                    });
+                } else if (step === 2 && utils.isArray(payload)) {
+                    provider.injectBatchResults([[{
+                        address: address,
+                        topics: [
+                            sha3,
+                            '0x0000000000000000000000001234567890123456789012345678901234567890',
+                            '0x0000000000000000000000000000000000000000000000000000000000000001'
+                        ],
+                        number: 2,
+                        data: '0x0000000000000000000000000000000000000000000000000000000000000001' +
+                                '0000000000000000000000000000000000000000000000000000000000000008' 
+                    }]]);
+                    var r = payload.filter(function (p) {
+                        return p.jsonrpc === '2.0' && p.method === 'eth_getFilterChanges' && p.params[0] === 3;
+                    });
+                    assert.equal(r.length > 0, true);
+                }
+            });
+
+            var Contract = web3.eth.contract(desc);
+            var contract = new Contract(address);
+
+            contract.Changed({from: address}).watch(function(err, result) {
+                assert.equal(result.args.from, address); 
+                assert.equal(result.args.amount, 1);
+                assert.equal(result.args.t1, 1);
+                assert.equal(result.args.t2, 8);
+                done();
+            });
+        });
+
+        it('should call constant function', function () {
+            var provider = new FakeHttpProvider();
+            web3.setProvider(provider);
+            web3.reset();
+            var sha3 = '0x5131231231231231231231';
+            var address = '0x1234567890123456789012345678901234567890';
+            provider.injectResult(sha3);
+            var step = 0;
+            provider.injectValidation(function (payload) {
+                if (step === 0) {
+                    step = 1;
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, 'web3_sha3');
+                    assert.equal(payload.params[0], web3.fromAscii('balance(address)'));
+                } else if (step === 1) {
+                    assert.equal(payload.method, 'eth_call');
+                    assert.deepEqual(payload.params, [{
+                        data: sha3.slice(0, 10) + '0000000000000000000000001234567890123456789012345678901234567890',
+                        to: address
+                    }, 'latest']);
+                }
+            });
+
+            var Contract = web3.eth.contract(desc);
+            var contract = new Contract(address);
+
+            contract.balance(address);
+        });
+
+        it('should sendTransaction to contract function', function () {
+            var provider = new FakeHttpProvider();
+            web3.setProvider(provider);
+            web3.reset();
+            var sha3 = '0x5131231231231231231231';
+            var address = '0x1234567890123456789012345678901234567890';
+            provider.injectResult(sha3);
+            var step = 0;
+            provider.injectValidation(function (payload) {
+                if (step === 0) {
+                    step = 1;
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, 'web3_sha3');
+                    assert.equal(payload.params[0], web3.fromAscii('send(address,uint256)'));
+                } else if (step === 1) {
+                    assert.equal(payload.method, 'eth_sendTransaction');
+                    assert.deepEqual(payload.params, [{
+                        data: sha3.slice(0, 10) + 
+                            '0000000000000000000000001234567890123456789012345678901234567890' + 
+                            '0000000000000000000000000000000000000000000000000000000000000011' ,
+                        to: address
+                    }]);
+                }
+            });
+
+            var Contract = web3.eth.contract(desc);
+            var contract = new Contract(address);
+
+            contract.send(address, 17);
+        });
+
+        it('should make a call with optional params', function () {
+           
+            var provider = new FakeHttpProvider();
+            web3.setProvider(provider);
+            web3.reset();
+            var sha3 = '0x5131231231231231231231';
+            var address = '0x1234567890123456789012345678901234567890';
+            provider.injectResult(sha3);
+            var step = 0;
+            provider.injectValidation(function (payload) {
+                if (step === 0) {
+                    step = 1;
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, 'web3_sha3');
+                    assert.equal(payload.params[0], web3.fromAscii('balance(address)'));
+                } else if (step === 1) {
+                    assert.equal(payload.method, 'eth_call');
+                    assert.deepEqual(payload.params, [{
+                        data: sha3.slice(0, 10) + '0000000000000000000000001234567890123456789012345678901234567890',
+                        to: address,
+                        from: address,
+                        gas: '0xc350'
+                    }, 'latest']);
+                }
+            });
+
+            var Contract = web3.eth.contract(desc);
+            var contract = new Contract(address);
+
+            contract.call({from: address, gas: 50000}).balance(address);
+
+        });
+
+        it('should sendTransaction with optional params', function () {
+            var provider = new FakeHttpProvider();
+            web3.setProvider(provider);
+            web3.reset();
+            var sha3 = '0x5131231231231231231231';
+            var address = '0x1234567890123456789012345678901234567890';
+            provider.injectResult(sha3);
+            var step = 0;
+            provider.injectValidation(function (payload) {
+                if (step === 0) {
+                    step = 1;
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, 'web3_sha3');
+                    assert.equal(payload.params[0], web3.fromAscii('send(address,uint256)'));
+                } else if (step === 1) {
+                    assert.equal(payload.method, 'eth_sendTransaction');
+                    assert.deepEqual(payload.params, [{
+                        data: sha3.slice(0, 10) + 
+                            '0000000000000000000000001234567890123456789012345678901234567890' + 
+                            '0000000000000000000000000000000000000000000000000000000000000011' ,
+                        to: address,
+                        from: address,
+                        gas: '0xc350',
+                        gasPrice: '0xbb8',
+                        value: '0x2710'
+                    }]);
+                }
+            });
+
+            var Contract = web3.eth.contract(desc);
+            var contract = new Contract(address);
+
+            contract.sendTransaction({from: address, gas: 50000, gasPrice: 3000, value: 10000}).send(address, 17);
+        });
+    });
+});
diff --git a/event.inputParser.js b/event.inputParser.js
index a2ce27112..15e0b6d2a 100644
--- a/event.inputParser.js
+++ b/event.inputParser.js
@@ -2,7 +2,7 @@ var assert = require('assert');
 var event = require('../lib/web3/event.js');
 var f = require('../lib/solidity/formatters.js');
 
-describe('event', function () {
+describe('lib/web3/event', function () {
     describe('inputParser', function () {
         it('should create basic filter input object', function () {
             
@@ -33,8 +33,6 @@ describe('event', function () {
             var options = {
                 fromBlock: 1,
                 toBlock: 2,
-                offset: 3,
-                limit: 4
             };
             var e = {
                 name: 'Event',
@@ -51,8 +49,6 @@ describe('event', function () {
             assert.equal(result.topics[0], signature);
             assert.equal(result.fromBlock, options.fromBlock);
             assert.equal(result.toBlock, options.toBlock);
-            assert.equal(result.offset, options.offset);
-            assert.equal(result.limit, options.limit);
         
         });
 
@@ -63,9 +59,7 @@ describe('event', function () {
             var signature = '0x987654';
             var options = {
                 fromBlock: 1,
-                toBlock: 2,
-                offset: 3,
-                limit: 4
+                toBlock: 2
             };
             var e = {
                 name: 'Event',
@@ -80,11 +74,9 @@ describe('event', function () {
             assert.equal(result.address, address);
             assert.equal(result.topics.length, 2);
             assert.equal(result.topics[0], signature);
-            assert.equal(result.topics[1], f.formatInputInt(4));
+            assert.equal(result.topics[1], '0x' + f.formatInputInt(4));
             assert.equal(result.fromBlock, options.fromBlock);
             assert.equal(result.toBlock, options.toBlock);
-            assert.equal(result.offset, options.offset);
-            assert.equal(result.limit, options.limit);
 
         });
 
@@ -94,10 +86,8 @@ describe('event', function () {
             var address = '0x012345';
             var signature = '0x987654';
             var options = {
-                earliest: 1,
-                latest: 2,
-                offset: 3,
-                max: 4
+                fromBlock: 1,
+                toBlock: 2,
             };
             var e = {
                 name: 'Event',
@@ -114,10 +104,8 @@ describe('event', function () {
             assert.equal(result.topics[0], signature);
             assert.equal(result.topics[1][0], f.formatInputInt(4));
             assert.equal(result.topics[1][1], f.formatInputInt(69));
-            assert.equal(result.earliest, options.earliest);
-            assert.equal(result.latest, options.latest);
-            assert.equal(result.offset, options.offset);
-            assert.equal(result.max, options.max);
+            assert.equal(result.fromBlock, options.fromBlock);
+            assert.equal(result.toBlock, options.toBlock);
 
         });
     });
diff --git a/event.outputParser.js b/event.outputParser.js
index 93b50ff2f..d31e49fa8 100644
--- a/event.outputParser.js
+++ b/event.outputParser.js
@@ -1,7 +1,7 @@
 var assert = require('assert');
 var event = require('../lib/web3/event.js');
 
-describe('event', function () {
+describe('lib/web3/event', function () {
     describe('outputParser', function () {
         it('should parse basic event output object', function () {
             
@@ -10,7 +10,7 @@ describe('event', function () {
                 "address":"0x78dfc5983baecf65f73e3de3a96cee24e6b7981e",
                 "data":"0x000000000000000000000000000000000000000000000000000000000000004b",
                 "number":2,
-                "topic":[
+                "topics":[
                     "0x6e61ef44ac2747ff8b84d353a908eb8bd5c3fb118334d57698c5cfc7041196ad",
                     "0x0000000000000000000000000000000000000000000000000000000000000001"
                 ]
@@ -43,7 +43,7 @@ describe('event', function () {
                     "000000000000000000000000000000000000000000000000000000000000004c" +
                     "0000000000000000000000000000000000000000000000000000000000000001",
                 "number":3,
-                "topic":[
+                "topics":[
                     "0x6e61ef44ac2747ff8b84d353a908eb8bd5c3fb118334d57698c5cfc7041196ad",
                     "0x0000000000000000000000000000000000000000000000000000000000000001",
                     "0x0000000000000000000000000000000000000000000000000000000000000005"
diff --git a/filter.methods.js b/filter.methods.js
deleted file mode 100644
index d039ec9bb..000000000
--- a/filter.methods.js
+++ /dev/null
@@ -1,24 +0,0 @@
-var assert = require('assert');
-var filter = require('../lib/web3/filter');
-var u = require('./test.utils.js');
-
-var empty = function () {};
-var implementation = {
-    newFilter: empty,
-    getLogs: empty,
-    uninstallFilter: empty,
-    startPolling: empty,
-    stopPolling: empty,
-};
-
-describe('web3', function () {
-    describe('eth', function () {
-        describe('filter', function () {
-            var f = filter({}, implementation);
-
-            u.methodExists(f, 'watch');
-            u.methodExists(f, 'stopWatching');
-            u.methodExists(f, 'get');
-        });
-    });
-});
diff --git a/formatters.inputDefaultBlockFormatter.js b/formatters.inputDefaultBlockFormatter.js
new file mode 100644
index 000000000..8ae5ea268
--- /dev/null
+++ b/formatters.inputDefaultBlockFormatter.js
@@ -0,0 +1,24 @@
+var chai = require('chai');
+var assert = chai.assert;
+var formatters = require('../lib/web3/formatters');
+
+var tests = [
+    { value: 'latest', expected: 'latest' },
+    { value: 'pending', expected: 'pending' },
+    { value: 'earliest', expected: 'earliest' },
+    { value: 1, expected: '0x1' },
+    { value: '0x1', expected: '0x1' }
+];
+
+describe('lib/web3/formatters', function () {
+    describe('inputDefaultBlockNumberFormatter', function () {
+        tests.forEach(function (test) {
+            it('should turn ' + test.value + ' to ' + test.expected, function () {
+                assert.strictEqual(formatters.inputDefaultBlockNumberFormatter(test.value), test.expected);
+            });
+        });
+    });
+});
+
+
+
diff --git a/formatters.inputPostFormatter.js b/formatters.inputPostFormatter.js
index 0995d6d79..7f0ce5298 100644
--- a/formatters.inputPostFormatter.js
+++ b/formatters.inputPostFormatter.js
@@ -1,6 +1,6 @@
 var chai = require('chai');
-var formatters = require('../lib/web3/formatters.js');
 var assert = chai.assert;
+var formatters = require('../lib/web3/formatters.js');
 
 describe('formatters', function () {
     describe('inputPostFormatter', function () {
@@ -26,3 +26,4 @@ describe('formatters', function () {
         });
     });
 });
+
diff --git a/formatters.inputTransactionFormatter.js b/formatters.inputTransactionFormatter.js
index 5ff0526e1..2f7f8c2e5 100644
--- a/formatters.inputTransactionFormatter.js
+++ b/formatters.inputTransactionFormatter.js
@@ -1,4 +1,5 @@
-var assert = require('assert');
+var chai = require('chai');
+var assert = chai.assert;
 var formatters = require('../lib/web3/formatters.js');
 var BigNumber = require('bignumber.js');
 
@@ -7,19 +8,19 @@ describe('formatters', function () {
         it('should return the correct value', function () {
             
             assert.deepEqual(formatters.inputTransactionFormatter({
-                data: '0x34234kjh23kj4234',
+                data: '0x34234bf23bf4234',
                 value: new BigNumber(100),
                 from: '0x00000',
                 to: '0x00000',
                 gas: 1000,
-                gasPrice: new BigNumber(1000),
+                gasPrice: new BigNumber(1000)
             }), {
-                data: '0x34234kjh23kj4234',
+                data: '0x34234bf23bf4234',
                 value: '0x64',
                 from: '0x00000',
                 to: '0x00000',
                 gas: '0x3e8',
-                gasPrice: '0x3e8',
+                gasPrice: '0x3e8'
             });
         });
     });
diff --git a/formatters.outputTransactionFormatter.js b/formatters.outputTransactionFormatter.js
index f42ed8495..b1eaff52d 100644
--- a/formatters.outputTransactionFormatter.js
+++ b/formatters.outputTransactionFormatter.js
@@ -12,7 +12,10 @@ describe('formatters', function () {
                 to: '0x00000',
                 value: '0x3e8',
                 gas: '0x3e8',
-                gasPrice: '0x3e8'
+                gasPrice: '0x3e8',
+                transactionIndex: '0x1',
+                blockNumber: '0x3e8',
+                blockHash: '0x34234bf23bf4234'
             }), {
                 input: '0x34234kjh23kj4234',
                 from: '0x00000',
@@ -20,6 +23,9 @@ describe('formatters', function () {
                 value: new BigNumber(1000),
                 gas: 1000,
                 gasPrice: new BigNumber(1000),
+                blockNumber: 1000,
+                blockHash: '0x34234bf23bf4234',
+                transactionIndex: 1
             });
         });
     });
diff --git a/helpers/FakeHttpProvider.js b/helpers/FakeHttpProvider.js
new file mode 100644
index 000000000..20d1f2580
--- /dev/null
+++ b/helpers/FakeHttpProvider.js
@@ -0,0 +1,68 @@
+var chai = require('chai');
+var assert = require('assert');
+var utils = require('../../lib/utils/utils');
+
+var getResponseStub = function () {
+    return {
+        jsonrpc: '2.0',
+        id: 1,
+        result: 0
+    };
+};
+
+var FakeHttpProvider = function () {
+    this.response = getResponseStub();
+    this.error = null;
+    this.validation = null;
+};
+
+FakeHttpProvider.prototype.send = function (payload) {
+    assert.equal(utils.isArray(payload) || utils.isObject(payload), true);
+    // TODO: validate jsonrpc request
+    if (this.error) {
+        throw this.error;
+    } 
+    if (this.validation) {
+        // imitate plain json object
+        this.validation(JSON.parse(JSON.stringify(payload)));
+    }
+    return this.response;
+};
+
+FakeHttpProvider.prototype.sendAsync = function (payload, callback) {
+    assert.equal(utils.isArray(payload) || utils.isObject(payload), true);
+    assert.equal(utils.isFunction(callback), true);
+    if (this.validation) {
+        // imitate plain json object
+        this.validation(JSON.parse(JSON.stringify(payload)), callback);
+    }
+    callback(this.error, this.response);
+};
+
+FakeHttpProvider.prototype.injectResponse = function (response) {
+    this.response = response;
+};
+
+FakeHttpProvider.prototype.injectResult = function (result) {
+    this.response = getResponseStub();
+    this.response.result = result;
+};
+
+FakeHttpProvider.prototype.injectBatchResults = function (results) {
+    this.response = results.map(function (r) {
+        var response = getResponseStub();
+        response.result = r;
+        return response;
+    }); 
+};
+
+FakeHttpProvider.prototype.injectError = function (error) {
+    this.error = error;
+};
+
+FakeHttpProvider.prototype.injectValidation = function (callback) {
+    this.validation = callback;
+};
+
+module.exports = FakeHttpProvider;
+
diff --git a/helpers/FakeQtNavigator.js b/helpers/FakeQtNavigator.js
new file mode 100644
index 000000000..fb251d239
--- /dev/null
+++ b/helpers/FakeQtNavigator.js
@@ -0,0 +1,11 @@
+
+var navigator = {
+    qt: {
+        callMethod: function (payload) {
+            return "{}";
+        }
+    }
+};
+
+module.exports = navigator;
+
diff --git a/helpers/FakeXMLHttpRequest.js b/helpers/FakeXMLHttpRequest.js
new file mode 100644
index 000000000..a67d7f74a
--- /dev/null
+++ b/helpers/FakeXMLHttpRequest.js
@@ -0,0 +1,31 @@
+var chai = require('chai');
+var assert = chai.assert;
+
+var FakeXMLHttpRequest = function () {
+    this.responseText = "{}";
+    this.readyState = 4;
+    this.onreadystatechange = null;
+    this.async = false;
+};
+
+FakeXMLHttpRequest.prototype.open = function (method, host, async) {
+    assert.equal(method, 'POST');
+    assert.notEqual(host, null);
+    assert.equal(async === false || async === true, true);
+    this.async = async;
+};
+
+FakeXMLHttpRequest.prototype.send = function (payload) {
+    assert.equal(typeof payload, 'string');
+    if (this.async) {
+        assert.equal(typeof this.onreadystatechange, 'function');
+        this.onreadystatechange();
+        return;
+    }
+    return this.responseText;
+};
+
+module.exports = { 
+    XMLHttpRequest: FakeXMLHttpRequest
+};
+
diff --git a/helpers/test.method.js b/helpers/test.method.js
new file mode 100644
index 000000000..8de318d8c
--- /dev/null
+++ b/helpers/test.method.js
@@ -0,0 +1,68 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../../index');
+var FakeHttpProvider = require('./FakeHttpProvider');
+
+var runTests = function (obj, method, tests) {
+
+    var testName = obj ? 'web3.' + obj : 'web';
+
+    describe(testName, function () {
+        describe(method, function () {
+            tests.forEach(function (test, index) {
+                it('sync test: ' + index, function () {
+                    
+                    // given
+                    var provider = new FakeHttpProvider();
+                    web3.setProvider(provider);
+                    provider.injectResult(test.result);
+                    provider.injectValidation(function (payload) {
+                        assert.equal(payload.jsonrpc, '2.0');
+                        assert.equal(payload.method, test.call);
+                        assert.deepEqual(payload.params, test.formattedArgs);
+                    });
+
+                    // when
+                    var result = (obj)
+                        ? web3[obj][method].apply(null, test.args.slice(0))
+                        : web3[method].apply(null, test.args.slice(0));
+                    
+                    // then 
+                    assert.deepEqual(test.formattedResult, result);
+                });
+                
+                it('async test: ' + index, function (done) {
+                    
+                    // given
+                    var provider = new FakeHttpProvider();
+                    web3.setProvider(provider);
+                    provider.injectResult(test.result);
+                    provider.injectValidation(function (payload) {
+                        assert.equal(payload.jsonrpc, '2.0');
+                        assert.equal(payload.method, test.call);
+                        assert.deepEqual(payload.params, test.formattedArgs);
+                    });
+
+                    var args = test.args.slice(0);
+                    // add callback
+                    args.push(function (err, result) {
+                        assert.deepEqual(test.formattedResult, result);
+                        done();
+                    });
+
+                    // when
+                    if(obj)
+                        web3[obj][method].apply(null, args);
+                    else
+                        web3[method].apply(null, args);
+                });
+            });
+        });
+    });
+
+};
+
+module.exports = {
+    runTests: runTests
+}
+
diff --git a/test.utils.js b/helpers/test.utils.js
similarity index 67%
rename from test.utils.js
rename to helpers/test.utils.js
index 8a1e9a0b6..ea710fdca 100644
--- a/test.utils.js
+++ b/helpers/test.utils.js
@@ -1,13 +1,20 @@
-var assert = require('assert');
+var chai = require('chai');
+var assert = chai.assert; 
+var web3 = require('../../index');
+
+var FakeHttpProvider = require('./FakeHttpProvider');
 
 var methodExists = function (object, method) {
     it('should have method ' + method + ' implemented', function() {
+        web3.setProvider(null);
         assert.equal('function', typeof object[method], 'method ' + method + ' is not implemented');
     });
 };
 
 var propertyExists = function (object, property) {
     it('should have property ' + property + ' implemented', function() {
+        // set dummy providor, to prevent error
+        web3.setProvider(new FakeHttpProvider());
         assert.notEqual('undefined', typeof object[property], 'property ' + property + ' is not implemented');
     });
 };
diff --git a/httpprovider.js b/httpprovider.js
new file mode 100644
index 000000000..6205a16d2
--- /dev/null
+++ b/httpprovider.js
@@ -0,0 +1,33 @@
+var chai = require('chai');
+var assert = chai.assert;
+var SandboxedModule = require('sandboxed-module');
+
+SandboxedModule.registerBuiltInSourceTransformer('istanbul');
+var HttpProvider = SandboxedModule.require('../lib/web3/httpprovider', {
+    requires: {
+        'xmlhttprequest': require('./helpers/FakeXMLHttpRequest')
+    }
+});
+
+describe('lib/web3/httpprovider', function () {
+    describe('send', function () {
+        it('should send basic request', function () {
+            var provider = new HttpProvider();
+            var result = provider.send({});
+
+            assert.equal(typeof result, 'object');
+        });
+    });
+
+    describe('sendAsync', function () {
+        it('should send basic async request', function (done) {
+            var provider = new HttpProvider();
+
+            provider.sendAsync({}, function (err, result) {
+                assert.equal(typeof result, 'object');
+                done();
+            });
+        }); 
+    });
+});
+
diff --git a/jsonrpc.id.js b/jsonrpc.id.js
new file mode 100644
index 000000000..07ede281e
--- /dev/null
+++ b/jsonrpc.id.js
@@ -0,0 +1,23 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Jsonrpc = require('../lib/web3/jsonrpc');
+
+describe('lib/web3/jsonrpc', function () {
+    describe('id', function () {
+        it('should increment the id', function () {
+            
+            // given
+            var a = Jsonrpc.getInstance();
+            var b = Jsonrpc.getInstance();
+            var method = 'm';
+
+            // when
+            var p1 = a.toPayload(method);
+            var p2 = b.toPayload(method);
+
+            // then
+            assert.equal(p2.id, p1.id + 1); 
+        });
+    });
+});
+
diff --git a/jsonrpc.isValidResponse.js b/jsonrpc.isValidResponse.js
index 78388a443..fc42f505d 100644
--- a/jsonrpc.isValidResponse.js
+++ b/jsonrpc.isValidResponse.js
@@ -1,5 +1,6 @@
 var assert = require('assert');
 var jsonrpc = require('../lib/web3/jsonrpc');
+jsonrpc = new jsonrpc();
 
 describe('jsonrpc', function () {
     describe('isValidResponse', function () {
diff --git a/jsonrpc.toBatchPayload.js b/jsonrpc.toBatchPayload.js
index c9a1e51e0..b1b523f4e 100644
--- a/jsonrpc.toBatchPayload.js
+++ b/jsonrpc.toBatchPayload.js
@@ -1,5 +1,6 @@
 var assert = require('assert');
 var jsonrpc = require('../lib/web3/jsonrpc');
+jsonrpc = new jsonrpc();
 
 describe('jsonrpc', function () {
     describe('toBatchPayload', function () {
diff --git a/jsonrpc.toPayload.js b/jsonrpc.toPayload.js
index a79501d73..dbec9afd1 100644
--- a/jsonrpc.toPayload.js
+++ b/jsonrpc.toPayload.js
@@ -1,5 +1,7 @@
-var assert = require('assert');
+var chai = require('chai');
+var assert = chai.assert; 
 var jsonrpc = require('../lib/web3/jsonrpc');
+jsonrpc = new jsonrpc();
 
 describe('jsonrpc', function () {
     describe('toPayload', function () {
diff --git a/method.attachToObject.js b/method.attachToObject.js
new file mode 100644
index 000000000..a27a3e821
--- /dev/null
+++ b/method.attachToObject.js
@@ -0,0 +1,44 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Method = require('../lib/web3/method');
+var utils = require('../lib/utils/utils');
+
+describe('lib/web3/method', function () {
+    describe('attachToObject', function () {
+        //it('attach simple function to an object', function () {
+            
+            //// given
+            //var method = new Method({
+                //name: 'hello'
+            //});
+            //var object = {};
+            //var func = function () { return 1; };
+
+            //// when
+            //method.attachToObject(object, func);
+            
+            //// then
+            //assert.equal(utils.isFunction(object.hello), true);
+            //assert.equal(object.hello(), 1);
+        //});
+
+        //it('attach nested function to an object', function () {
+            
+            //// given
+            //var method = new Method({
+                //name: 'hello.world'
+            //});
+            //var object = {};
+            //var func = function () { return 1; };
+
+            //// when
+            //method.attachToObject(object, func);
+            
+            //// then
+            //assert.equal(utils.isObject(object.hello), true);
+            //assert.equal(utils.isFunction(object.hello.world), true);
+            //assert.equal(object.hello.world(), 1);
+        //});
+    });
+});
+
diff --git a/method.extractCallback.js b/method.extractCallback.js
new file mode 100644
index 000000000..34e480c32
--- /dev/null
+++ b/method.extractCallback.js
@@ -0,0 +1,52 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Method = require('../lib/web3/method');
+
+describe('lib/web3/method', function () {
+    describe('extractCallback', function () {
+        it('should extract callback', function () {
+            
+            // given
+            var method = new Method({});
+            var callback = function () { };
+            var args = [1, callback]
+
+            // when
+            var result = method.extractCallback(args);
+
+            // then
+            assert.equal(args.length, 1);
+            assert.equal(callback, result);
+        });
+        
+        it('should extract callback created using newFunction', function () {
+            
+            // given
+            var method = new Method({});
+            var callback = new Function ();
+            var args = [1, callback]
+
+            // when
+            var result = method.extractCallback(args);
+
+            // then
+            assert.equal(args.length, 1);
+            assert.equal(callback, result);
+        });
+
+        it('should not extract the callback', function () {
+            
+            // given
+            var method = new Method({});
+            var args = [1, 2]
+
+            // when
+            var result = method.extractCallback(args);
+
+            // then
+            assert.equal(args.length, 2);
+            assert.equal(result, null);
+        });
+    });
+});
+
diff --git a/method.formatInput.js b/method.formatInput.js
new file mode 100644
index 000000000..c778f1059
--- /dev/null
+++ b/method.formatInput.js
@@ -0,0 +1,41 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Method = require('../lib/web3/method');
+
+describe('lib/web3/method', function () {
+    describe('formatInput', function () {
+        it('should format plain input', function () {
+            
+            // given
+            var star = function (arg) {
+                return arg + '*';
+            };
+            
+            var method = new Method({
+                inputFormatter: [star, star, star]
+            });
+            var args = ['1','2','3'];
+            var expectedArgs = ['1*', '2*', '3*'];
+
+            // when
+            var result = method.formatInput(args);
+
+            // then
+            assert.deepEqual(result, expectedArgs);
+        });
+
+        it('should do nothing if there is no formatter', function () {
+
+            // given
+            var method = new Method({});
+            var args = [1,2,3];
+
+            // when
+            var result = method.formatInput(args);
+            
+            // then
+            assert.deepEqual(result, args);
+        });
+    });
+});
+
diff --git a/method.formatOutput.js b/method.formatOutput.js
new file mode 100644
index 000000000..4d88e2dae
--- /dev/null
+++ b/method.formatOutput.js
@@ -0,0 +1,43 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Method = require('../lib/web3/method');
+
+describe('lib/web3/method', function () {
+    describe('formatOutput', function () {
+        it('should format plain output', function () {
+            
+            // given
+            var formatter = function (args) {
+                return args.map(function (arg) {
+                    return arg + '*';
+                });
+            };
+            
+            var method = new Method({
+                outputFormatter: formatter
+            });
+            var args = ['1','2','3'];
+            var expectedArgs = ['1*', '2*', '3*'];
+
+            // when
+            var result = method.formatOutput(args);
+
+            // then
+            assert.deepEqual(result, expectedArgs);
+        });
+        
+        it('should do nothing if there is no formatter', function () {
+
+            // given
+            var method = new Method({});
+            var args = [1,2,3];
+
+            // when
+            var result = method.formatOutput(args);
+            
+            // then
+            assert.deepEqual(result, args);
+        });
+    });
+});
+
diff --git a/method.getCall.js b/method.getCall.js
new file mode 100644
index 000000000..398de325e
--- /dev/null
+++ b/method.getCall.js
@@ -0,0 +1,46 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Method = require('../lib/web3/method');
+
+describe('lib/web3/method', function () {
+    describe('getCall', function () {
+        it('should return call name', function () {
+            
+            // given
+            var call = 'hello_call_world';
+            var method = new Method({
+                call: call
+            });
+
+            // when
+            var result = method.getCall();
+
+            // then
+            assert.equal(call, result);
+        });
+
+        it('should return call based on args', function () {
+            
+            // given
+            var call = function (args) {
+                return args ? args.length.toString() : '0';
+            };
+            
+            var method = new Method({
+                call: call
+            });
+            
+            // when
+            var r0 = method.getCall();
+            var r1 = method.getCall([1]);
+            var r2 = method.getCall([1, 2]);
+
+            // then
+            assert.equal(r0, '0');
+            assert.equal(r1, '1');
+            assert.equal(r2, '2');
+            
+        });
+    });
+});
+
diff --git a/method.validateArgs.js b/method.validateArgs.js
new file mode 100644
index 000000000..5cb16e1e0
--- /dev/null
+++ b/method.validateArgs.js
@@ -0,0 +1,47 @@
+var chai = require('chai');
+var assert = chai.assert;
+var Method = require('../lib/web3/method');
+var errors = require('../lib/web3/errors');
+
+describe('lib/web3/method', function () {
+    describe('validateArgs', function () {
+        it('should pass', function () {
+            
+            // given
+            var method = new Method({
+                params: 1
+            });
+
+            var args = [1];
+            var args2 = ['heloas'];
+
+            // when
+            var test = function () { method.validateArgs(args); };
+            var test2 = function () { method.validateArgs(args2); };
+
+            // then
+            assert.doesNotThrow(test);
+            assert.doesNotThrow(test2);
+        });
+
+        it('should return call based on args', function () {
+        
+            // given
+            var method = new Method({
+                params: 2
+            });
+
+            var args = [1];
+            var args2 = ['heloas', '12', 3];
+
+            // when
+            var test = function () { method.validateArgs(args); };
+            var test2 = function () { method.validateArgs(args2); };
+            
+            // then
+            assert.throws(test, errors.InvalidNumberOfParams);
+            assert.throws(test2, errors.InvalidNumberOfParams);
+        });
+    });
+});
+
diff --git a/mocha.opts b/mocha.opts
index c4a633d64..5ada47be1 100644
--- a/mocha.opts
+++ b/mocha.opts
@@ -1,2 +1 @@
---reporter spec 
-
+--reporter spec
diff --git a/net.methods.js b/net.methods.js
deleted file mode 100644
index 26d9c224d..000000000
--- a/net.methods.js
+++ /dev/null
@@ -1,10 +0,0 @@
-var assert = require('assert');
-var web3 = require('../index.js');
-var u = require('./test.utils.js');
-
-describe('web3', function() {
-    describe('net', function() {
-        u.propertyExists(web3.net, 'listening');
-        u.propertyExists(web3.net, 'peerCount');
-    });
-});
\ No newline at end of file
diff --git a/node/app.js b/node/app.js
new file mode 100644
index 000000000..c3fd489a0
--- /dev/null
+++ b/node/app.js
@@ -0,0 +1,5 @@
+var web3 = require('ethereum.js');
+
+console.log(web3.version.api);
+
+
diff --git a/node/package.json b/node/package.json
new file mode 100644
index 000000000..4c56b2c10
--- /dev/null
+++ b/node/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "node",
+  "version": "1.0.0",
+  "description": "",
+  "main": "app.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "ethereum.js": "ethereum/ethereum.js#master"
+  }
+}
diff --git a/polling.js b/polling.js
new file mode 100644
index 000000000..ea7dd9829
--- /dev/null
+++ b/polling.js
@@ -0,0 +1,69 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+var utils = require('../lib/utils/utils');
+
+var tests = [{
+    protocol: 'eth',
+    args: ['pending'],
+    firstResult: 1,
+    firstPayload: {
+        method: "eth_newBlockFilter",
+        params: [
+            "pending"
+        ]
+    },
+    secondResult: [null],
+    secondPayload: {
+        method: "eth_getFilterChanges"
+    }
+}];
+
+
+var testPolling = function (tests) {
+    
+    describe('web3.eth.filter.polling', function () {
+        tests.forEach(function (test, index) {
+            it('should create && successfully poll filter', function (done) {
+
+                // given
+                var provider = new FakeHttpProvider(); 
+                web3.setProvider(provider);
+                web3.reset();
+                provider.injectResult(test.firstResult);
+                var step = 0;
+                provider.injectValidation(function (payload) {
+                    if (step === 0) {
+                        step = 1;
+                        assert.equal(payload.jsonrpc, '2.0');
+                        assert.equal(payload.method, test.firstPayload.method);
+                        assert.deepEqual(payload.params, test.firstPayload.params);
+                    } else if (step === 1 && utils.isArray(payload)) {
+                        var r = payload.filter(function (p) {
+                            return p.jsonrpc === '2.0' && p.method === test.secondPayload.method && p.params[0] === test.firstResult;
+                        });
+                        assert.equal(r.length > 0, true);
+                    }
+
+                });
+
+                // when
+                var filter = web3[test.protocol].filter.apply(null, test.args);
+                provider.injectBatchResults([test.secondResult]);
+                filter.watch(function (err, result) {
+                    if (test.err) {
+                        // todo
+                    } else {
+                        assert.equal(result, test.secondResult[0]);
+                    }
+                    done();
+
+                });
+            });
+        }); 
+    });
+};
+
+testPolling(tests);
+
diff --git a/qtsyncprovider.js b/qtsyncprovider.js
new file mode 100644
index 000000000..ce0064414
--- /dev/null
+++ b/qtsyncprovider.js
@@ -0,0 +1,22 @@
+var chai = require('chai');
+var assert = chai.assert;
+var SandboxedModule = require('sandboxed-module');
+
+SandboxedModule.registerBuiltInSourceTransformer('istanbul');
+var QtSyncProvider = SandboxedModule.require('../lib/web3/qtsync', {
+    globals: {
+        navigator: require('./helpers/FakeQtNavigator')
+    }
+});
+
+describe('/lib/web3/qtsyncprovider', function () {
+    describe('send', function () {
+        it('should send basic request', function () {
+            var provider = new QtSyncProvider();
+            var result = provider.send({});
+
+            assert.equal(typeof result, 'object');
+        });
+    });
+});
+
diff --git a/requestmanager.js b/requestmanager.js
new file mode 100644
index 000000000..5c951ded3
--- /dev/null
+++ b/requestmanager.js
@@ -0,0 +1,44 @@
+var chai = require('chai');
+var assert = chai.assert;
+var RequestManager = require('../lib/web3/requestmanager');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+// TODO: handling errors!
+// TODO: validation of params!
+
+describe('lib/web3/requestmanager', function () {
+    describe('send', function () {
+        it('should return expected result synchronously', function () {
+            var provider = new FakeHttpProvider();
+            var manager = RequestManager.getInstance();
+            manager.setProvider(provider);
+            var expected = 'hello_world';
+            provider.injectResult(expected);
+            
+            var result = manager.send({
+                method: 'test',
+                params: [1,2,3]
+            });
+
+            assert.equal(expected, result);
+        });
+
+        it('should return expected result asynchronously', function (done) {
+            var provider = new FakeHttpProvider();
+            var manager = RequestManager.getInstance();
+            manager.setProvider(provider);
+            var expected = 'hello_world';
+            provider.injectResult(expected);
+            
+            manager.sendAsync({
+                method: 'test',
+                params: [1,2,3]
+            }, function (error, result) {
+                assert.equal(error, null);
+                assert.equal(expected, result);
+                done();
+            });
+        });
+    });
+});
+
diff --git a/shh.filter.js b/shh.filter.js
new file mode 100644
index 000000000..57df4d0c5
--- /dev/null
+++ b/shh.filter.js
@@ -0,0 +1,45 @@
+var chai = require('chai');
+var web3 = require('../index');
+var assert = chai.assert;
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+var method = 'filter';
+
+var tests = [{
+    args: [{
+        to: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
+        topics: ['0x324f5435', '0x564b4566f3453']
+    }],
+    formattedArgs: [{
+        to: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
+        topics: ['0x324f5435', '0x564b4566f3453']
+    }],
+    result: '0xf',
+    formattedResult: '0xf',
+    call: 'shh_newFilter'
+}];
+
+describe('shh', function () {
+    describe(method, function () {
+        tests.forEach(function (test, index) {
+            it('property test: ' + index, function () {
+                
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, test.call);
+                    assert.deepEqual(payload.params, test.formattedArgs);
+                });
+
+                // call
+                web3.shh[method].apply(null, test.args);
+                
+            });
+        });
+    });
+});
+
+
diff --git a/shh.hasIdentity.js b/shh.hasIdentity.js
new file mode 100644
index 000000000..569247a88
--- /dev/null
+++ b/shh.hasIdentity.js
@@ -0,0 +1,16 @@
+var chai = require('chai');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'hasIdentity';
+
+var tests = [{
+    args: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855'],
+    formattedArgs: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855'],
+    result: true,
+    formattedResult: true,
+    call: 'shh_'+ method
+}];
+
+testMethod.runTests('shh', method, tests);
+
diff --git a/signature.js b/signature.js
new file mode 100644
index 000000000..709f662fd
--- /dev/null
+++ b/signature.js
@@ -0,0 +1,48 @@
+var chai = require('chai');
+var assert = chai.assert;
+var utils = require('../lib/utils/utils');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+var signature = require('../lib/web3/signature');
+var web3 = require('../index');
+
+var tests = [{
+    method: 'functionSignatureFromAscii',
+    call: 'web3_sha3',
+    request: 'multiply',
+    formattedRequest: utils.fromAscii('multiply'),
+    result: '0x255d31552d29a21e93334e96055c6dca7cd329f5420ae74ec166d0c47f9f9843',
+    formattedResult: '0x255d3155'
+},{
+    method: 'eventSignatureFromAscii',
+    call: 'web3_sha3',
+    request: 'multiply',
+    formattedRequest:  utils.fromAscii('multiply'),
+    result: '0x255d31552d29a21e93334e96055c6dca7cd329f5420ae74ec166d0c47f9f9843',
+    formattedResult: '0x255d31552d29a21e93334e96055c6dca7cd329f5420ae74ec166d0c47f9f9843'
+}];
+
+describe('lib/web3/signature', function () {
+    tests.forEach(function (test, index) {
+        describe(test.method, function () {
+            it('should properly format and return signature of solidity functioni ' + index, function () {
+
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.method, test.call);
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.params[0], test.formattedRequest);
+                });
+
+                // when
+                var result = signature[test.method].call(null, test.request);
+
+                // then
+                assert.equal(result, test.formattedResult);
+            });
+        });
+    });
+});
+
diff --git a/utils.extractDisplayName.js b/utils.extractDisplayName.js
index c401b7e60..d3faef8da 100644
--- a/utils.extractDisplayName.js
+++ b/utils.extractDisplayName.js
@@ -1,7 +1,7 @@
 var assert = require('assert');
 var utils = require('../lib/utils/utils.js');
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('extractDisplayName', function () {
         it('should extract display name from method with no params', function () {
             
diff --git a/utils.extractTypeName.js b/utils.extractTypeName.js
index 7211ff613..41099787d 100644
--- a/utils.extractTypeName.js
+++ b/utils.extractTypeName.js
@@ -1,7 +1,7 @@
 var assert = require('assert');
 var utils = require('../lib/utils/utils.js');
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('extractTypeName', function () {
         it('should extract type name from method with no params', function () {
             
diff --git a/utils.filters.js b/utils.filters.js
index 4629e4fe8..5e6870efa 100644
--- a/utils.filters.js
+++ b/utils.filters.js
@@ -1,7 +1,7 @@
 var assert = require('assert');
 var utils = require('../lib/utils/utils.js');
 
-describe('utils', function() {
+describe('lib/utils/utils', function() {
     it('should filter functions and events from input array properly', function () {
 
         // given
diff --git a/utils.fromDecimal.js b/utils.fromDecimal.js
index 4dc774c74..c0e5ed62f 100644
--- a/utils.fromDecimal.js
+++ b/utils.fromDecimal.js
@@ -31,7 +31,7 @@ var tests = [
     { value: '-0x0', expected: '0x0'}
 ];
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('fromDecimal', function () {
         tests.forEach(function (test) {
             it('should turn ' + test.value + ' to ' + test.expected, function () {
diff --git a/utils.fromWei.js b/utils.fromWei.js
index 735575c68..e8691eb2a 100644
--- a/utils.fromWei.js
+++ b/utils.fromWei.js
@@ -1,7 +1,7 @@
 var assert = require('assert');
 var utils = require('../lib/utils/utils.js');
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('fromWei', function () {
         it('should return the correct value', function () {
             
diff --git a/utils.isAddress.js b/utils.isAddress.js
index d2d087ffd..3ebbce837 100644
--- a/utils.isAddress.js
+++ b/utils.isAddress.js
@@ -8,10 +8,10 @@ var tests = [
     { value: 'function', is: false},
     { value: {}, is: false},
     { value: '0xc6d9d2cd449a754c494264e1809c50e34d64562b', is: true },
-    { value: 'c6d9d2cd449a754c494264e1809c50e34d64562b', is: true }
+    { value: 'c6d9d2cd449a754c494264e1809c50e34d64562b', is: false }
 ];
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('isAddress', function () {
         tests.forEach(function (test) {
             it('shoud test if value ' + test.value + ' is address: ' + test.is, function () {
diff --git a/utils.isBigNumber.js b/utils.isBigNumber.js
index a3de36916..d78739b8a 100644
--- a/utils.isBigNumber.js
+++ b/utils.isBigNumber.js
@@ -15,7 +15,7 @@ var tests = [
 
 ];
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('isBigNumber', function () {
         tests.forEach(function (test) {
             it('shoud test if value ' + test.func + ' is BigNumber: ' + test.is, function () {
diff --git a/utils.isFunction.js b/utils.isFunction.js
index c113bc334..05882b2c0 100644
--- a/utils.isFunction.js
+++ b/utils.isFunction.js
@@ -9,7 +9,7 @@ var tests = [
     { func: {}, is: false}
 ];
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('isFunction', function () {
         tests.forEach(function (test) {
             it('shoud test if value ' + test.func + ' is function: ' + test.is, function () {
diff --git a/utils.isJson.js b/utils.isJson.js
new file mode 100644
index 000000000..73d86d833
--- /dev/null
+++ b/utils.isJson.js
@@ -0,0 +1,26 @@
+var chai = require('chai');
+var utils = require('../lib/utils/utils.js');
+var assert = chai.assert;
+
+var tests = [
+    { obj: function () {}, is: false},
+    { obj: new Function(), is: false},
+    { obj: 'function', is: false},
+    { obj: {}, is: false},
+    { obj: '[]', is: true},
+    { obj: '[1, 2]', is: true},
+    { obj: '{}', is: true},
+    { obj: '{"a": 123, "b" :3,}', is: false},
+    { obj: '{"c" : 2}', is: true}
+];
+
+describe('lib/utils/utils', function () {
+    describe('isJson', function () {
+        tests.forEach(function (test) {
+            it('shoud test if value ' + test.obj + ' is json: ' + test.is, function () {
+                assert.equal(utils.isJson(test.obj), test.is);
+            });
+        });   
+    });
+});
+
diff --git a/utils.isString.js b/utils.isString.js
index bb36ccd67..73b95d22b 100644
--- a/utils.isString.js
+++ b/utils.isString.js
@@ -10,7 +10,7 @@ var tests = [
     { value: new String('hello'), is: true}
 ];
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('isString', function () {
         tests.forEach(function (test) {
             it('shoud test if value ' + test.func + ' is string: ' + test.is, function () {
diff --git a/utils.toBigNumber.js b/utils.toBigNumber.js
index 2d293c12a..efe3fa714 100644
--- a/utils.toBigNumber.js
+++ b/utils.toBigNumber.js
@@ -34,7 +34,7 @@ var tests = [
     { value: new BigNumber(0), expected: '0'}
 ];
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('toBigNumber', function () {
         tests.forEach(function (test) {
             it('should turn ' + test.value + ' to ' + test.expected, function () {
diff --git a/utils.toDecimal.js b/utils.toDecimal.js
index d785b0444..74352f324 100644
--- a/utils.toDecimal.js
+++ b/utils.toDecimal.js
@@ -1,7 +1,7 @@
 var assert = require('assert');
 var utils = require('../lib/utils/utils.js');
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('toDecimal', function () {
         it('should return the correct value', function () {
             
diff --git a/utils.toHex.js b/utils.toHex.js
index 2e9c59cb5..0a328e345 100644
--- a/utils.toHex.js
+++ b/utils.toHex.js
@@ -27,14 +27,16 @@ var tests = [
     { value: {test: 'test'}, expected: '0x7b2274657374223a2274657374227d'},
     { value: '{"test": "test"}', expected: '0x7b2274657374223a202274657374227d'},
     { value: 'myString', expected: '0x6d79537472696e67'},
-    { value: new BigNumber(15), expected: '0xf'}
+    { value: new BigNumber(15), expected: '0xf'},
+    { value: true, expected: '0x1'},
+    { value: false, expected: '0x0'}
 ];
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('toHex', function () {
         tests.forEach(function (test) {
             it('should turn ' + test.value + ' to ' + test.expected, function () {
-                assert.equal(utils.toHex(test.value), test.expected);
+                assert.strictEqual(utils.toHex(test.value), test.expected);
             });
         });
     });
diff --git a/utils.toWei.js b/utils.toWei.js
index 33e03ffc3..3bb0997c6 100644
--- a/utils.toWei.js
+++ b/utils.toWei.js
@@ -2,7 +2,7 @@ var chai = require('chai');
 var utils = require('../lib/utils/utils');
 var assert = chai.assert;
 
-describe('utils', function () {
+describe('lib/utils/utils', function () {
     describe('toWei', function () {
         it('should return the correct value', function () {
             
diff --git a/web3.db.getHex.js b/web3.db.getHex.js
new file mode 100644
index 000000000..7e17d0c51
--- /dev/null
+++ b/web3.db.getHex.js
@@ -0,0 +1,14 @@
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getHex';
+
+var tests = [{
+    args: ['myDB', 'myKey'],
+    formattedArgs: ['myDB', 'myKey'],
+    result: '0xf',
+    formattedResult: '0xf',
+    call: 'db_'+ method
+}];
+
+testMethod.runTests('db', method, tests);
+
diff --git a/web3.db.getString.js b/web3.db.getString.js
new file mode 100644
index 000000000..f9aadffa3
--- /dev/null
+++ b/web3.db.getString.js
@@ -0,0 +1,16 @@
+var chai = require('chai');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getString';
+
+var tests = [{
+    args: ['myDB', 'myKey'],
+    formattedArgs: ['myDB', 'myKey'],
+    result: 'myValue',
+    formattedResult: 'myValue',
+    call: 'db_'+ method
+}];
+
+testMethod.runTests('db', method, tests);
+
diff --git a/db.methods.js b/web3.db.methods.js
similarity index 57%
rename from db.methods.js
rename to web3.db.methods.js
index aac8981d2..246ecfd0b 100644
--- a/db.methods.js
+++ b/web3.db.methods.js
@@ -1,10 +1,10 @@
-
-var assert = require('assert');
+var chai = require('chai');
+var assert = chai.assert; 
 var web3 = require('../index.js');
-var u = require('./test.utils.js');
+var u = require('./helpers/test.utils.js');
 
-describe('web3', function() {
-    describe('db', function() {
+describe('web3.db', function() {
+    describe('methods', function() {
         u.methodExists(web3.db, 'putHex');
         u.methodExists(web3.db, 'getHex');
         u.methodExists(web3.db, 'putString');
diff --git a/web3.db.putHex.js b/web3.db.putHex.js
new file mode 100644
index 000000000..306abaec4
--- /dev/null
+++ b/web3.db.putHex.js
@@ -0,0 +1,16 @@
+var chai = require('chai');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'putHex';
+
+var tests = [{
+    args: ['myDB', 'myKey', '0xb'],
+    formattedArgs: ['myDB', 'myKey', '0xb'],
+    result: true,
+    formattedResult: true,
+    call: 'db_'+ method
+}];
+
+testMethod.runTests('db', method, tests);
+
diff --git a/web3.db.putString.js b/web3.db.putString.js
new file mode 100644
index 000000000..ddd32874f
--- /dev/null
+++ b/web3.db.putString.js
@@ -0,0 +1,16 @@
+var chai = require('chai');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'putString';
+
+var tests = [{
+    args: ['myDB', 'myKey', 'myValue'],
+    formattedArgs: ['myDB', 'myKey', 'myValue'],
+    result: true,
+    formattedResult: true,
+    call: 'db_'+ method
+}];
+
+testMethod.runTests('db', method, tests);
+
diff --git a/web3.eth.accounts.js b/web3.eth.accounts.js
new file mode 100644
index 000000000..da7da1a96
--- /dev/null
+++ b/web3.eth.accounts.js
@@ -0,0 +1,38 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+var method = 'accounts';
+
+var tests = [{
+    result: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
+    formattedResult: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
+    call: 'eth_'+ method
+}];
+
+describe('web3.eth', function () {
+    describe(method, function () {
+        tests.forEach(function (test, index) {
+            it('property test: ' + index, function () {
+                
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, test.call);
+                    assert.deepEqual(payload.params, []);
+                });
+
+                // when 
+                var result = web3.eth[method];
+                
+                // then
+                assert.deepEqual(test.formattedResult, result);
+            });
+        });
+    });
+});
+
diff --git a/web3.eth.blockNumber.js b/web3.eth.blockNumber.js
new file mode 100644
index 000000000..dfd73f57e
--- /dev/null
+++ b/web3.eth.blockNumber.js
@@ -0,0 +1,38 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+var method = 'blockNumber';
+
+var tests = [{
+    result: '0xb',
+    formattedResult: 11,
+    call: 'eth_'+ method
+}];
+
+describe('web3.eth', function () {
+    describe(method, function () {
+        tests.forEach(function (test, index) {
+            it('property test: ' + index, function () {
+                
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, test.call);
+                    assert.deepEqual(payload.params, []);
+                });
+
+                // when 
+                var result = web3.eth[method];
+                
+                // then
+                assert.strictEqual(test.formattedResult, result);
+            });
+        });
+    });
+});
+
diff --git a/web3.eth.coinbase.js b/web3.eth.coinbase.js
new file mode 100644
index 000000000..f34c53588
--- /dev/null
+++ b/web3.eth.coinbase.js
@@ -0,0 +1,38 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+var method = 'coinbase';
+
+var tests = [{
+    result: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
+    formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
+    call: 'eth_'+ method
+}];
+
+describe('web3.eth', function () {
+    describe(method, function () {
+        tests.forEach(function (test, index) {
+            it('property test: ' + index, function () {
+                
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, test.call);
+                    assert.deepEqual(payload.params, []);
+                });
+
+                // when 
+                var result = web3.eth[method];
+                
+                // then
+                assert.deepEqual(test.formattedResult, result);
+            });
+        });
+    });
+});
+
diff --git a/eth.contract.js b/web3.eth.contract.js
similarity index 99%
rename from eth.contract.js
rename to web3.eth.contract.js
index 59ad51b29..0f2fd8640 100644
--- a/eth.contract.js
+++ b/web3.eth.contract.js
@@ -1,7 +1,7 @@
 var assert = require('assert');
 var contract = require('../lib/web3/contract.js');
 
-describe('contract', function() {
+describe('web3.eth.contract', function() {
     it('should create simple contract with one method from abi with explicit type name', function () {
         
         // given
diff --git a/web3.eth.defaultBlock.js b/web3.eth.defaultBlock.js
new file mode 100644
index 000000000..5fc60df47
--- /dev/null
+++ b/web3.eth.defaultBlock.js
@@ -0,0 +1,12 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+
+describe('web3.eth', function () {
+    describe('defaultBlock', function () {
+        it('should check if defaultBlock is set to proper value', function () {
+            assert.equal(web3.eth.defaultBlock, 'latest');
+        });
+    });
+});
+
diff --git a/web3.eth.filter.js b/web3.eth.filter.js
new file mode 100644
index 000000000..d8b37311a
--- /dev/null
+++ b/web3.eth.filter.js
@@ -0,0 +1,55 @@
+var chai = require('chai');
+var web3 = require('../index');
+var assert = chai.assert;
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+var method = 'filter';
+
+
+var tests = [{
+    args: [{
+        fromBlock: 0,
+        toBlock: 10,
+        address: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'
+    }],
+    formattedArgs: [{
+        fromBlock: '0x0',
+        toBlock: '0xa',
+        address: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
+        topics: []
+    }],
+    result: '0xf',
+    formattedResult: '0xf',
+    call: 'eth_newFilter'
+},{
+    args: ['pending'],
+    formattedArgs: ['pending'],
+    result: '0xf',
+    formattedResult: '0xf',
+    call: 'eth_newBlockFilter'
+}];
+
+describe('web3.eth', function () {
+    describe(method, function () {
+        tests.forEach(function (test, index) {
+            it('property test: ' + index, function () {
+                
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, test.call);
+                    assert.deepEqual(payload.params, test.formattedArgs);
+                });
+
+                // call
+                web3.eth[method].apply(null, test.args);
+                
+            });
+        });
+    });
+});
+
+
diff --git a/web3.eth.filter.methods.js b/web3.eth.filter.methods.js
new file mode 100644
index 000000000..f40f3d0ac
--- /dev/null
+++ b/web3.eth.filter.methods.js
@@ -0,0 +1,23 @@
+var chai = require('chai');
+var assert = chai.assert;
+var filter = require('../lib/web3/filter');
+var u = require('./helpers/test.utils.js');
+
+var empty = function () {};
+var implementation = {
+    newFilter: empty,
+    getLogs: empty,
+    uninstallFilter: empty,
+    startPolling: empty,
+    stopPolling: empty,
+};
+
+describe('web3.eth.filter', function () {
+    describe('methods', function () {
+        //var f = filter({}, implementation);
+
+        //u.methodExists(f, 'watch');
+        //u.methodExists(f, 'stopWatching');
+        //u.methodExists(f, 'get');
+    });
+});
diff --git a/web3.eth.getBalance.js b/web3.eth.getBalance.js
new file mode 100644
index 000000000..e1eb73707
--- /dev/null
+++ b/web3.eth.getBalance.js
@@ -0,0 +1,64 @@
+var BigNumber = require('bignumber.js');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getBalance';
+
+var tests = [{
+    args: [301, 2],
+    formattedArgs: ['0x000000000000000000000000000000000000012d', '0x2'],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+},{
+    args: ['0x12d', '0x1'],
+    formattedArgs: ['0x000000000000000000000000000000000000012d', '0x1'],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+}, {
+    args: [0x12d, 0x1],
+    formattedArgs: ['0x000000000000000000000000000000000000012d', '0x1'],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+}, {
+    args: [0x12d],
+    formattedArgs: ['0x000000000000000000000000000000000000012d', web3.eth.defaultBlock],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+}, {
+    args: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', 0x1],
+    formattedArgs: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', '0x1'],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+}, {
+    args: ['dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', 0x1],
+    formattedArgs: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', '0x1'],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+}, {
+    args: ['1255171934823351805979544608257289442498956485798', 0x1],
+    formattedArgs: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', '0x1'],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+}, {
+    args: ['1255171934823351805979544608257289442498956485798'],
+    formattedArgs: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', 'latest'],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+}, {
+    args: ['0x00000000000000000000aaaaaaaaaaaaaaaaaaa'],
+    formattedArgs: ['0x000000000000000000000aaaaaaaaaaaaaaaaaaa', 'latest'],
+    result: '0x31981',
+    formattedResult: new BigNumber('0x31981', 16),
+    call: 'eth_'+ method
+}];
+
+testMethod.runTests('eth', method, tests);
+
diff --git a/web3.eth.getBlock.js b/web3.eth.getBlock.js
new file mode 100644
index 000000000..539e433a6
--- /dev/null
+++ b/web3.eth.getBlock.js
@@ -0,0 +1,139 @@
+var web3 = require('../index');
+var BigNumber = require('bignumber.js');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getBlock';
+
+var blockResult = {
+    "number": "0x1b4",
+    "hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
+    "nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
+    "miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
+    "difficulty": "0x027f07",
+    "totalDifficulty":  "0x027f07",
+    "size":  "0x027f07",
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": "0x9f759",
+    "minGasPrice": "0x9f759",
+    "gasUsed": "0x9f759",
+    "timestamp": "0x54e34e8e",
+    "transactions": ['0x460cfb8472af2c5fd05b5a2','0x460cfb8472af2c5fd05b5a2'],
+    "uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
+};
+var formattedBlockResult = {
+    "number": 436,
+    "hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
+    "nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
+    "miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
+    "difficulty": new BigNumber(163591),
+    "totalDifficulty":  new BigNumber(163591),
+    "size":  163591,
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": 653145,
+    "minGasPrice": new BigNumber(653145),
+    "gasUsed": 653145,
+    "timestamp": 1424182926,
+    "transactions": ['0x460cfb8472af2c5fd05b5a2','0x460cfb8472af2c5fd05b5a2'],
+    "uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
+};
+var blockResultWithTx = {
+    "number": "0x1b4",
+    "hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
+    "nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
+    "miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
+    "difficulty": "0x027f07",
+    "totalDifficulty":  "0x027f07",
+    "size":  "0x027f07",
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": "0x9f759",
+    "minGasPrice": "0x9f759",
+    "gasUsed": "0x9f759",
+    "timestamp": "0x54e34e8e",
+    "transactions": [{
+        "status": "mined",
+        "hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
+        "nonce":"0x",
+        "blockHash": "0x6fd9e2a26ab",
+        "blockNumber": "0x15df",
+        "transactionIndex":  "0x1",
+        "from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+        "to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
+        "value":"0x7f110",
+        "gas": "0x7f110",
+        "gasPrice":"0x09184e72a000",
+        "input":"0x603880600c6000396000f30060",
+    }],
+    "uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
+};
+var formattedBlockResultWithTx = {
+    "number": 436,
+    "hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
+    "nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
+    "miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
+    "difficulty": new BigNumber(163591),
+    "totalDifficulty":  new BigNumber(163591),
+    "size":  163591,
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": 653145,
+    "minGasPrice": new BigNumber(653145),
+    "gasUsed": 653145,
+    "timestamp": 1424182926,
+    "transactions": [{
+        "status": "mined",
+        "hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
+        "nonce":"0x",
+        "blockHash": "0x6fd9e2a26ab",
+        "blockNumber": 5599,
+        "transactionIndex":  1,
+        "from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+        "to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
+        "value": new BigNumber(520464),
+        "gas": 520464,
+        "gasPrice": new BigNumber(10000000000000),
+        "input":"0x603880600c6000396000f30060",
+    }],
+    "uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
+};
+
+var tests = [{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', false],
+    result: blockResult,
+    formattedResult: formattedBlockResult,
+    call: 'eth_'+ method + 'ByHash'
+},{
+    args: [436],
+    formattedArgs: ['0x1b4', false],
+    result: blockResult,
+    formattedResult: formattedBlockResult,
+    call: 'eth_'+ method + 'ByNumber'
+},{
+    args: [436, true],
+    formattedArgs: ['0x1b4', true],
+    result: blockResultWithTx,
+    formattedResult: formattedBlockResultWithTx,
+    call: 'eth_'+ method + 'ByNumber'
+}];
+
+testMethod.runTests('eth', method, tests);
+
diff --git a/web3.eth.getBlockTransactionCount.js b/web3.eth.getBlockTransactionCount.js
new file mode 100644
index 000000000..009b25ec5
--- /dev/null
+++ b/web3.eth.getBlockTransactionCount.js
@@ -0,0 +1,29 @@
+var chai = require('chai');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getBlockTransactionCount';
+
+
+var tests = [{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
+    result: '0xb',
+    formattedResult: 11,
+    call: 'eth_getBlockTransactionCountByHash'
+},{
+    args: [436],
+    formattedArgs: ['0x1b4'],
+    result: '0xb',
+    formattedResult: 11,
+    call: 'eth_getBlockTransactionCountByNumber'
+},{
+    args: ['pending'],
+    formattedArgs: ['pending'],
+    result: '0xb',
+    formattedResult: 11,
+    call: 'eth_getBlockTransactionCountByNumber'
+}];
+
+testMethod.runTests('eth', method, tests);
+
diff --git a/web3.eth.getBlockUncleCount.js b/web3.eth.getBlockUncleCount.js
new file mode 100644
index 000000000..f8193b712
--- /dev/null
+++ b/web3.eth.getBlockUncleCount.js
@@ -0,0 +1,27 @@
+var chai = require('chai');
+var web3 = require('../index');
+var method = 'getBlockUncleCount';
+var testMethod = require('./helpers/test.method.js');
+
+
+var tests = [{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
+    result: '0xb',
+    formattedResult: 11,
+    call: 'eth_getUncleCountByBlockHash'
+},{
+    args: [436],
+    formattedArgs: ['0x1b4'],
+    result: '0xb',
+    formattedResult: 11,
+    call: 'eth_getUncleCountByBlockNumber'
+},{
+    args: ['pending'],
+    formattedArgs: ['pending'],
+    result: '0xb',
+    formattedResult: 11,
+    call: 'eth_getUncleCountByBlockNumber'
+}];
+
+testMethod.runTests('eth', method, tests);
diff --git a/web3.eth.getCode.js b/web3.eth.getCode.js
new file mode 100644
index 000000000..fc4f5b864
--- /dev/null
+++ b/web3.eth.getCode.js
@@ -0,0 +1,23 @@
+var chai = require('chai');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getCode';
+
+
+var tests = [{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', web3.eth.defaultBlock],
+    result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    call: 'eth_'+ method
+},{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 2],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0x2'],
+    result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    call: 'eth_'+ method
+}];
+
+testMethod.runTests('eth', method, tests);
+
diff --git a/web3.eth.getCompilers.js b/web3.eth.getCompilers.js
new file mode 100644
index 000000000..ab426b228
--- /dev/null
+++ b/web3.eth.getCompilers.js
@@ -0,0 +1,23 @@
+var chai = require('chai');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getCompilers';
+
+
+var tests = [{
+    args: [],
+    formattedArgs: [],
+    result: ['solidity'],
+    formattedResult: ['solidity'],
+    call: 'eth_'+ method
+},{
+    args: [],
+    formattedArgs: [],
+    result: ['solidity'],
+    formattedResult: ['solidity'],
+    call: 'eth_'+ method
+}];
+
+testMethod.runTests('eth', method, tests);
+
diff --git a/web3.eth.getStorageAt.js b/web3.eth.getStorageAt.js
new file mode 100644
index 000000000..8973772e7
--- /dev/null
+++ b/web3.eth.getStorageAt.js
@@ -0,0 +1,35 @@
+var chai = require('chai');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getStorageAt';
+
+
+var tests = [{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 2],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0x2', web3.eth.defaultBlock],
+    result: '0x47d33b2',
+    formattedResult: '0x47d33b2',
+    call: 'eth_'+ method
+},{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 2, 0],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0x2', '0x0'],
+    result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    call: 'eth_'+ method
+},{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 0xb, 0x0],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0xb', '0x0'],
+    result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    call: 'eth_'+ method
+}, {
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 0xb, 'latest'],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0xb', 'latest'],
+    result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
+    call: 'eth_'+ method
+}];
+
+testMethod.runTests('eth', method, tests);
+
diff --git a/web3.eth.getTransaction.js b/web3.eth.getTransaction.js
new file mode 100644
index 000000000..fb833edf3
--- /dev/null
+++ b/web3.eth.getTransaction.js
@@ -0,0 +1,46 @@
+var chai = require('chai');
+var web3 = require('../index');
+var BigNumber = require('bignumber.js');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getTransaction';
+
+var txResult = {
+    "status": "mined",
+    "hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
+    "nonce":"0x",
+    "blockHash": "0x6fd9e2a26ab",
+    "blockNumber": "0x15df",
+    "transactionIndex":  "0x1",
+    "from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+    "to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
+    "value":"0x7f110",
+    "gas": "0x7f110",
+    "gasPrice":"0x09184e72a000",
+    "input":"0x603880600c6000396000f30060"
+};
+var formattedTxResult = {
+    "status": "mined",
+    "hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
+    "nonce":"0x",
+    "blockHash": "0x6fd9e2a26ab",
+    "blockNumber": 5599,
+    "transactionIndex":  1,
+    "from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+    "to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
+    "value": new BigNumber(520464),
+    "gas": 520464,
+    "gasPrice": new BigNumber(10000000000000),
+    "input":"0x603880600c6000396000f30060"
+};
+
+var tests = [{
+    args: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855'],
+    formattedArgs: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855'],
+    result: txResult,
+    formattedResult: formattedTxResult,
+    call: 'eth_'+ method + 'ByHash'
+}];
+
+testMethod.runTests('eth', method, tests);
+
diff --git a/web3.eth.getTransactionFromBlock.js b/web3.eth.getTransactionFromBlock.js
new file mode 100644
index 000000000..7b59a3ba1
--- /dev/null
+++ b/web3.eth.getTransactionFromBlock.js
@@ -0,0 +1,52 @@
+var chai = require('chai');
+var web3 = require('../index');
+var BigNumber = require('bignumber.js');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getTransactionFromBlock';
+
+var txResult = {
+    "status": "mined",
+    "hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
+    "nonce":"0x",
+    "blockHash": "0x6fd9e2a26ab",
+    "blockNumber": "0x15df",
+    "transactionIndex":  "0x1",
+    "from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+    "to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
+    "value":"0x7f110",
+    "gas": "0x7f110",
+    "gasPrice":"0x09184e72a000",
+    "input":"0x603880600c6000396000f30060"
+};
+var formattedTxResult = {
+    "status": "mined",
+    "hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
+    "nonce":"0x",
+    "blockHash": "0x6fd9e2a26ab",
+    "blockNumber": 5599,
+    "transactionIndex":  1,
+    "from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+    "to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
+    "value": new BigNumber(520464),
+    "gas": 520464,
+    "gasPrice": new BigNumber(10000000000000),
+    "input":"0x603880600c6000396000f30060"
+};
+
+var tests = [{
+    args: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855', 2],
+    formattedArgs: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855', '0x2'],
+    result: txResult,
+    formattedResult: formattedTxResult,
+    call: 'eth_getTransactionByBlockHashAndIndex'
+},{
+    args: [436, 11],
+    formattedArgs: ['0x1b4', '0xb'],
+    result: txResult,
+    formattedResult: formattedTxResult,
+    call: 'eth_getTransactionByBlockNumberAndIndex'
+}];
+
+testMethod.runTests('eth', method, tests);
+
diff --git a/web3.eth.getUncle.js b/web3.eth.getUncle.js
new file mode 100644
index 000000000..111865355
--- /dev/null
+++ b/web3.eth.getUncle.js
@@ -0,0 +1,139 @@
+var chai = require('chai');
+var web3 = require('../index');
+var BigNumber = require('bignumber.js');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'getUncle';
+
+var blockResult = {
+    "number": "0x1b4",
+    "hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
+    "nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
+    "miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
+    "difficulty": "0x027f07",
+    "totalDifficulty":  "0x027f07",
+    "size":  "0x027f07",
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": "0x9f759",
+    "minGasPrice": "0x9f759",
+    "gasUsed": "0x9f759",
+    "timestamp": "0x54e34e8e",
+    "transactions": ['0x460cfb8472af2c5fd05b5a2','0x460cfb8472af2c5fd05b5a2'],
+    "uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
+};
+var formattedBlockResult = {
+    "number": 436,
+    "hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
+    "nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
+    "miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
+    "difficulty": new BigNumber(163591),
+    "totalDifficulty":  new BigNumber(163591),
+    "size":  163591,
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": 653145,
+    "minGasPrice": new BigNumber(653145),
+    "gasUsed": 653145,
+    "timestamp": 1424182926,
+    "transactions": ['0x460cfb8472af2c5fd05b5a2','0x460cfb8472af2c5fd05b5a2'],
+    "uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
+};
+var blockResultWithTx = {
+    "number": "0x1b4",
+    "hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
+    "nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
+    "miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
+    "difficulty": "0x027f07",
+    "totalDifficulty":  "0x027f07",
+    "size":  "0x027f07",
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": "0x9f759",
+    "minGasPrice": "0x9f759",
+    "gasUsed": "0x9f759",
+    "timestamp": "0x54e34e8e",
+    "transactions": [{
+        "status": "mined",
+        "hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
+        "nonce":"0x",
+        "blockHash": "0x6fd9e2a26ab",
+        "blockNumber": "0x15df",
+        "transactionIndex":  "0x1",
+        "from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+        "to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
+        "value":"0x7f110",
+        "gas": "0x7f110",
+        "gasPrice":"0x09184e72a000",
+        "input":"0x603880600c6000396000f30060",
+    }],
+    "uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
+};
+var formattedBlockResultWithTx = {
+    "number": 436,
+    "hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
+    "nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
+    "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    "logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
+    "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+    "stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
+    "miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
+    "difficulty": new BigNumber(163591),
+    "totalDifficulty":  new BigNumber(163591),
+    "size":  163591,
+    "extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "gasLimit": 653145,
+    "minGasPrice": new BigNumber(653145),
+    "gasUsed": 653145,
+    "timestamp": 1424182926,
+    "transactions": [{
+        "status": "mined",
+        "hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
+        "nonce":"0x",
+        "blockHash": "0x6fd9e2a26ab",
+        "blockNumber": 5599,
+        "transactionIndex":  1,
+        "from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+        "to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
+        "value": new BigNumber(520464),
+        "gas": 520464,
+        "gasPrice": new BigNumber(10000000000000),
+        "input":"0x603880600c6000396000f30060",
+    }],
+    "uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
+};
+
+var tests = [{
+    args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 2],
+    formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0x2', false],
+    result: blockResult,
+    formattedResult: formattedBlockResult,
+    call: 'eth_getUncleByBlockHashAndIndex'
+},{
+    args: [436, 1],
+    formattedArgs: ['0x1b4', '0x1', false],
+    result: blockResult,
+    formattedResult: formattedBlockResult,
+    call: 'eth_getUncleByBlockNumberAndIndex'
+},{
+    args: [436, 1, true],
+    formattedArgs: ['0x1b4', '0x1', true],
+    result: blockResultWithTx,
+    formattedResult: formattedBlockResultWithTx,
+    call: 'eth_getUncleByBlockNumberAndIndex'
+}];
+
+testMethod.runTests('eth', method, tests);
diff --git a/eth.methods.js b/web3.eth.methods.js
similarity index 54%
rename from eth.methods.js
rename to web3.eth.methods.js
index e1eea1ec4..8f9396866 100644
--- a/eth.methods.js
+++ b/web3.eth.methods.js
@@ -1,14 +1,14 @@
-var assert = require('assert');
+var chai = require('chai');
+var assert = chai.assert; 
 var web3 = require('../index.js');
-var u = require('./test.utils.js');
+var u = require('./helpers/test.utils.js');
 
-describe('web3', function() {
-    describe('eth', function() {
+describe('web3.eth', function() {
+    describe('methods', function() {
         u.methodExists(web3.eth, 'getBalance');
         u.methodExists(web3.eth, 'getStorageAt');
-        u.methodExists(web3.eth, 'getStorage');
         u.methodExists(web3.eth, 'getTransactionCount');
-        u.methodExists(web3.eth, 'getData');
+        u.methodExists(web3.eth, 'getCode');
         u.methodExists(web3.eth, 'sendTransaction');
         u.methodExists(web3.eth, 'call');
         u.methodExists(web3.eth, 'getBlock');
@@ -30,30 +30,5 @@ describe('web3', function() {
         u.propertyExists(web3.eth, 'defaultBlock');
         u.propertyExists(web3.eth, 'blockNumber');
     });
-
-    // Fail at the moment
-    // describe('eth', function(){
-    //     it('should be a positive balance', function() {
-    //         // when
-    //         var testAddress = '0x50f4ed0e83f9da907017bcfb444e3e25407f59bb';
-    //         var balance = web3.eth.balanceAt(testAddress);
-    //         // then
-    //         assert(balance > 0, 'Balance is ' + balance);
-    //     });
-
-    //     it('should return a block', function() {
-    //         // when
-    //         var block = web3.eth.block(0);
-            
-    //         // then
-    //         assert.notEqual(block, null);
-    //         assert.equal(block.number, 0);
-    //         assert(web3.toDecimal(block.difficulty) > 0);
-    //     });
-    // });
 });
 
-
-
-
-
diff --git a/web3.eth.mining.js b/web3.eth.mining.js
new file mode 100644
index 000000000..2c111542c
--- /dev/null
+++ b/web3.eth.mining.js
@@ -0,0 +1,38 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+var method = 'mining';
+
+var tests = [{
+    result: true,
+    formattedResult: true,
+    call: 'eth_'+ method
+}];
+
+describe('web3.eth', function () {
+    describe(method, function () {
+        tests.forEach(function (test, index) {
+            it('property test: ' + index, function () {
+                
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, test.call);
+                    assert.deepEqual(payload.params, []);
+                });
+
+                // when 
+                var result = web3.eth[method];
+                
+                // then
+                assert.deepEqual(test.formattedResult, result);
+            });
+        });
+    });
+});
+
diff --git a/web3.methods.js b/web3.methods.js
index 92d4e1604..d37277f40 100644
--- a/web3.methods.js
+++ b/web3.methods.js
@@ -1,24 +1,24 @@
-var assert = require('assert');
 var web3 = require('../index.js');
-var u = require('./test.utils.js');
+var u = require('./helpers/test.utils.js');
 
 describe('web3', function() {
-    u.methodExists(web3, 'sha3');
-    u.methodExists(web3, 'toAscii');
-    u.methodExists(web3, 'fromAscii');
-    u.methodExists(web3, 'toDecimal');
-    u.methodExists(web3, 'fromDecimal');
-    u.methodExists(web3, 'fromWei');
-    u.methodExists(web3, 'toWei');
-    u.methodExists(web3, 'toBigNumber');
-    u.methodExists(web3, 'isAddress');
-    u.methodExists(web3, 'setProvider');
-    u.methodExists(web3, 'reset');
+    describe('methods', function () {
+        u.methodExists(web3, 'sha3');
+        u.methodExists(web3, 'toAscii');
+        u.methodExists(web3, 'fromAscii');
+        u.methodExists(web3, 'toDecimal');
+        u.methodExists(web3, 'fromDecimal');
+        u.methodExists(web3, 'fromWei');
+        u.methodExists(web3, 'toWei');
+        u.methodExists(web3, 'toBigNumber');
+        u.methodExists(web3, 'isAddress');
+        u.methodExists(web3, 'setProvider');
+        u.methodExists(web3, 'reset');
 
-    u.propertyExists(web3, 'manager');
-    u.propertyExists(web3, 'providers');
-    u.propertyExists(web3, 'eth');
-    u.propertyExists(web3, 'db');
-    u.propertyExists(web3, 'shh');
+        u.propertyExists(web3, 'providers');
+        u.propertyExists(web3, 'eth');
+        u.propertyExists(web3, 'db');
+        u.propertyExists(web3, 'shh');
+    });
 });
 
diff --git a/web3.net.listening.js b/web3.net.listening.js
new file mode 100644
index 000000000..38b2c8763
--- /dev/null
+++ b/web3.net.listening.js
@@ -0,0 +1,38 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+var method = 'listening';
+
+var tests = [{
+    result: true,
+    formattedResult: true,
+    call: 'net_'+ method
+}];
+
+describe('web3.net', function () {
+    describe(method, function () {
+        tests.forEach(function (test, index) {
+            it('property test: ' + index, function () {
+                
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, test.call);
+                    assert.deepEqual(payload.params, []);
+                });
+
+                // when 
+                var result = web3.net[method];
+                
+                // then
+                assert.deepEqual(test.formattedResult, result);
+            });
+        });
+    });
+});
+
diff --git a/web3.net.methods.js b/web3.net.methods.js
new file mode 100644
index 000000000..97fddaa12
--- /dev/null
+++ b/web3.net.methods.js
@@ -0,0 +1,11 @@
+var chai = require('chai');
+var assert = chai.assert; 
+var web3 = require('../index.js');
+var u = require('./helpers/test.utils.js');
+
+describe('web3.net', function() {
+    describe('methods', function() {
+        u.propertyExists(web3.net, 'listening');
+        u.propertyExists(web3.net, 'peerCount');
+    });
+});
diff --git a/web3.net.peerCount.js b/web3.net.peerCount.js
new file mode 100644
index 000000000..eb226892a
--- /dev/null
+++ b/web3.net.peerCount.js
@@ -0,0 +1,38 @@
+var chai = require('chai');
+var assert = chai.assert;
+var web3 = require('../index');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+
+var method = 'peerCount';
+
+var tests = [{
+    result: '0xf',
+    formattedResult: 15,
+    call: 'net_'+ method
+}];
+
+describe('web3.net', function () {
+    describe(method, function () {
+        tests.forEach(function (test, index) {
+            it('property test: ' + index, function () {
+                
+                // given
+                var provider = new FakeHttpProvider();
+                web3.setProvider(provider);
+                provider.injectResult(test.result);
+                provider.injectValidation(function (payload) {
+                    assert.equal(payload.jsonrpc, '2.0');
+                    assert.equal(payload.method, test.call);
+                    assert.deepEqual(payload.params, []);
+                });
+
+                // when 
+                var result = web3.net[method];
+                
+                // then
+                assert.deepEqual(test.formattedResult, result);
+            });
+        });
+    });
+});
+
diff --git a/web3.sha3.js b/web3.sha3.js
new file mode 100644
index 000000000..0ae104962
--- /dev/null
+++ b/web3.sha3.js
@@ -0,0 +1,16 @@
+var BigNumber = require('bignumber.js');
+var web3 = require('../index');
+var testMethod = require('./helpers/test.method.js');
+
+var method = 'sha3';
+
+var tests = [{
+    args: ['myString'],
+    formattedArgs: ['myString'],
+    result: '0x319319f831983198319881',
+    formattedResult: '0x319319f831983198319881',
+    call: 'web3_'+ method
+}];
+
+testMethod.runTests(null, method, tests);
+
diff --git a/shh.methods.js b/web3.shh.methods.js
similarity index 65%
rename from shh.methods.js
rename to web3.shh.methods.js
index f8501d527..fc20e1d1c 100644
--- a/shh.methods.js
+++ b/web3.shh.methods.js
@@ -1,9 +1,10 @@
-var assert = require('assert');
+var chai = require('chai');
+var assert = chai.assert; 
 var web3 = require('../index.js');
-var u = require('./test.utils.js');
+var u = require('./helpers/test.utils.js');
 
-describe('web3', function() {
-    describe('shh', function() {
+describe('web3.shh', function() {
+    describe('methods', function() {
         u.methodExists(web3.shh, 'post');
         u.methodExists(web3.shh, 'newIdentity');
         u.methodExists(web3.shh, 'hasIdentity');