Updated ethereum.js

cmd/mist/assets/ext/ethereum.js/dist/ethereum.js

@@ -22,7 +22,6 @@ require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof requ
  * @date 2014
  */
 
-var web3 = require('./web3'); 
 var utils = require('./utils');
 var types = require('./types');
 var c = require('./const');
@@ -41,11 +40,11 @@ var arrayType = function (type) {
 var dynamicTypeBytes = function (type, value) {
     // TODO: decide what to do with array of strings
     if (arrayType(type) || type === 'string')    // only string itself that is dynamic; stringX is static length.
-        return f.formatInputInt(value.length); 
+        return f.formatInputInt(value.length);
     return "";
 };
 
-var inputTypes = types.inputTypes(); 
+var inputTypes = types.inputTypes();
 
 /// Formats input params to bytes
 /// @param abi contract method inputs
@@ -53,13 +52,16 @@ var inputTypes = types.inputTypes();
 /// @returns bytes representation of input params
 var formatInput = function (inputs, params) {
     var bytes = "";
+    var toAppendConstant = "";
+    var toAppendArrayContent = "";
 
-    /// first we iterate in search for dynamic 
+    /// first we iterate in search for dynamic
     inputs.forEach(function (input, index) {
         bytes += dynamicTypeBytes(input.type, params[index]);
     });
 
     inputs.forEach(function (input, i) {
+        /*jshint maxcomplexity:5 */
         var typeMatch = false;
         for (var j = 0; j < inputTypes.length && !typeMatch; j++) {
             typeMatch = inputTypes[j].type(inputs[i].type, params[i]);
@@ -69,17 +71,19 @@ var formatInput = function (inputs, params) {
         }
 
         var formatter = inputTypes[j - 1].format;
-        var toAppend = "";
 
         if (arrayType(inputs[i].type))
-            toAppend = params[i].reduce(function (acc, curr) {
+            toAppendArrayContent += params[i].reduce(function (acc, curr) {
                 return acc + formatter(curr);
             }, "");
+        else if (inputs[i].type === 'string')
+            toAppendArrayContent += formatter(params[i]);
         else
-            toAppend = formatter(params[i]);
-
-        bytes += toAppend; 
+            toAppendConstant += formatter(params[i]);
     });
+
+    bytes += toAppendConstant + toAppendArrayContent;
+
     return bytes;
 };
 
@@ -89,14 +93,14 @@ var dynamicBytesLength = function (type) {
     return 0;
 };
 
-var outputTypes = types.outputTypes(); 
+var outputTypes = types.outputTypes();
 
 /// Formats output bytes back to param list
 /// @param contract abi method outputs
-/// @param bytes representtion of output 
-/// @returns array of output params 
+/// @param bytes representtion of output
+/// @returns array of output params
 var formatOutput = function (outs, output) {
-    
+
     output = output.slice(2);
     var result = [];
     var padding = c.ETH_PADDING * 2;
@@ -104,7 +108,7 @@ var formatOutput = function (outs, output) {
     var dynamicPartLength = outs.reduce(function (acc, curr) {
         return acc + dynamicBytesLength(curr.type);
     }, 0);
-    
+
     var dynamicPart = output.slice(0, dynamicPartLength);
     output = output.slice(dynamicPartLength);
 
@@ -125,13 +129,13 @@ var formatOutput = function (outs, output) {
             dynamicPart = dynamicPart.slice(padding);
             var array = [];
             for (var k = 0; k < size; k++) {
-                array.push(formatter(output.slice(0, padding))); 
+                array.push(formatter(output.slice(0, padding)));
                 output = output.slice(padding);
             }
             result.push(array);
         }
         else if (types.prefixedType('string')(outs[i].type)) {
-            dynamicPart = dynamicPart.slice(padding); 
+            dynamicPart = dynamicPart.slice(padding);
             result.push(formatter(output.slice(0, padding)));
             output = output.slice(padding);
         } else {
@@ -149,14 +153,14 @@ var formatOutput = function (outs, output) {
 var inputParser = function (json) {
     var parser = {};
     json.forEach(function (method) {
-        var displayName = utils.extractDisplayName(method.name); 
+        var displayName = utils.extractDisplayName(method.name);
         var typeName = utils.extractTypeName(method.name);
 
         var impl = function () {
             var params = Array.prototype.slice.call(arguments);
             return formatInput(method.inputs, params);
         };
-       
+
         if (parser[displayName] === undefined) {
             parser[displayName] = impl;
         }
@@ -173,7 +177,7 @@ var outputParser = function (json) {
     var parser = {};
     json.forEach(function (method) {
 
-        var displayName = utils.extractDisplayName(method.name); 
+        var displayName = utils.extractDisplayName(method.name);
         var typeName = utils.extractTypeName(method.name);
 
         var impl = function (output) {
@@ -190,27 +194,14 @@ var outputParser = function (json) {
     return parser;
 };
 
-/// @param function/event name for which we want to get signature
-/// @returns signature of function/event with given name
-var signatureFromAscii = function (name) {
-    return web3.sha3(web3.fromAscii(name)).slice(0, 2 + c.ETH_SIGNATURE_LENGTH * 2);
-};
-
-var eventSignatureFromAscii = function (name) {
-    return web3.sha3(web3.fromAscii(name));
-};
-
 module.exports = {
     inputParser: inputParser,
     outputParser: outputParser,
     formatInput: formatInput,
-    formatOutput: formatOutput,
-    signatureFromAscii: signatureFromAscii,
-    eventSignatureFromAscii: eventSignatureFromAscii
+    formatOutput: formatOutput
 };
 
-
-},{"./const":2,"./formatters":8,"./types":14,"./utils":15,"./web3":17}],2:[function(require,module,exports){
+},{"./const":2,"./formatters":8,"./types":15,"./utils":16}],2:[function(require,module,exports){
 /*
     This file is part of ethereum.js.
 
@@ -296,6 +287,7 @@ var web3 = require('./web3');
 var abi = require('./abi');
 var utils = require('./utils');
 var eventImpl = require('./event');
+var signature = require('./signature');
 
 var exportNatspecGlobals = function (vars) {
     // it's used byt natspec.js
@@ -309,16 +301,24 @@ var exportNatspecGlobals = function (vars) {
 var addFunctionRelatedPropertiesToContract = function (contract) {
     
     contract.call = function (options) {
-        contract._isTransact = false;
+        contract._isTransaction = false;
         contract._options = options;
         return contract;
     };
 
-    contract.transact = function (options) {
-        contract._isTransact = true;
+
+    contract.sendTransaction = function (options) {
+        contract._isTransaction = true;
         contract._options = options;
         return contract;
     };
+    // DEPRECATED
+    contract.transact = function (options) {
+
+        console.warn('myContract.transact() is deprecated please use myContract.sendTransaction() instead.');
+
+        return contract.sendTransaction(options);
+    };
 
     contract._options = {};
     ['gas', 'gasPrice', 'value', 'from'].forEach(function(p) {
@@ -343,21 +343,21 @@ var addFunctionsToContract = function (contract, desc, address) {
         var impl = function () {
             /*jshint maxcomplexity:7 */
             var params = Array.prototype.slice.call(arguments);
-            var signature = abi.signatureFromAscii(method.name);
+            var sign = signature.functionSignatureFromAscii(method.name);
             var parsed = inputParser[displayName][typeName].apply(null, params);
 
             var options = contract._options || {};
             options.to = address;
-            options.data = signature + parsed;
+            options.data = sign + parsed;
             
-            var isTransact = contract._isTransact === true || (contract._isTransact !== false && !method.constant);
+            var isTransaction = contract._isTransaction === true || (contract._isTransaction !== false && !method.constant);
             var collapse = options.collapse !== false;
             
             // reset
             contract._options = {};
-            contract._isTransact = null;
+            contract._isTransaction = null;
 
-            if (isTransact) {
+            if (isTransaction) {
                 
                 exportNatspecGlobals({
                     abi: desc,
@@ -367,7 +367,7 @@ var addFunctionsToContract = function (contract, desc, address) {
                 });
 
                 // transactions do not have any output, cause we do not know, when they will be processed
-                web3.eth.transact(options);
+                web3.eth.sendTransaction(options);
                 return;
             }
             
@@ -402,7 +402,7 @@ var addEventRelatedPropertiesToContract = function (contract, desc, address) {
     Object.defineProperty(contract, 'topic', {
         get: function() {
             return utils.filterEvents(desc).map(function (e) {
-                return abi.eventSignatureFromAscii(e.name);
+                return signature.eventSignatureFromAscii(e.name);
             });
         }
     });
@@ -415,14 +415,14 @@ var addEventsToContract = function (contract, desc, address) {
 
         var impl = function () {
             var params = Array.prototype.slice.call(arguments);
-            var signature = abi.eventSignatureFromAscii(e.name);
-            var event = eventImpl.inputParser(address, signature, e);
+            var sign = signature.eventSignatureFromAscii(e.name);
+            var event = eventImpl.inputParser(address, sign, e);
             var o = event.apply(null, params);
             var outputFormatter = function (data) {
                 var parser = eventImpl.outputParser(e);
                 return parser(data);
             };
-            return web3.eth.watch(o, undefined, undefined, outputFormatter);
+            return web3.eth.filter(o, undefined, undefined, outputFormatter);
         };
         
         // this property should be used by eth.filter to check if object is an event
@@ -452,24 +452,40 @@ var addEventsToContract = function (contract, desc, address) {
  *      outputs: [{name: 'd', type: 'string' }]
  * }];  // contract abi
  *
- * var myContract = web3.eth.contract('0x0123123121', abi); // creation of contract object
+ * var MyContract = web3.eth.contract(abi); // creation of contract prototype
+ *
+ * var contractInstance = new MyContract('0x0123123121');
  *
- * myContract.myMethod('this is test string param for call'); // myMethod call (implicit, default)
- * myContract.call().myMethod('this is test string param for call'); // myMethod call (explicit)
- * myContract.transact().myMethod('this is test string param for transact'); // myMethod transact
+ * contractInstance.myMethod('this is test string param for call'); // myMethod call (implicit, default)
+ * contractInstance.call().myMethod('this is test string param for call'); // myMethod call (explicit)
+ * contractInstance.sendTransaction().myMethod('this is test string param for transact'); // myMethod sendTransaction
  *
- * @param address - address of the contract, which should be called
- * @param desc - abi json description of the contract, which is being created
+ * @param abi - abi json description of the contract, which is being created
  * @returns contract object
  */
+var contract = function (abi) {
+
+    // return prototype
+    if(abi instanceof Array && arguments.length === 1) {
+        return Contract.bind(null, abi);
+
+    // deprecated: auto initiate contract
+    } else {
+
+        console.warn('Initiating a contract like this is deprecated please use var MyContract = eth.contract(abi); new MyContract(address); instead.');
+
+        return new Contract(arguments[1], arguments[0]);
+    }
+
+};
 
-var contract = function (address, desc) {
+function Contract(abi, address) {
 
     // workaround for invalid assumption that method.name is the full anonymous prototype of the method.
     // it's not. it's just the name. the rest of the code assumes it's actually the anonymous
     // prototype, so we make it so as a workaround.
     // TODO: we may not want to modify input params, maybe use copy instead?
-    desc.forEach(function (method) {
+    abi.forEach(function (method) {
         if (method.name.indexOf('(') === -1) {
             var displayName = method.name;
             var typeName = method.inputs.map(function(i){return i.type; }).join();
@@ -479,17 +495,17 @@ var contract = function (address, desc) {
 
     var result = {};
     addFunctionRelatedPropertiesToContract(result);
-    addFunctionsToContract(result, desc, address);
-    addEventRelatedPropertiesToContract(result, desc, address);
-    addEventsToContract(result, desc, address);
+    addFunctionsToContract(result, abi, address);
+    addEventRelatedPropertiesToContract(result, abi, address);
+    addEventsToContract(result, abi, address);
 
     return result;
-};
+}
 
 module.exports = contract;
 
 
-},{"./abi":1,"./event":6,"./utils":15,"./web3":17}],4:[function(require,module,exports){
+},{"./abi":1,"./event":6,"./signature":14,"./utils":16,"./web3":18}],4:[function(require,module,exports){
 /*
     This file is part of ethereum.js.
 
@@ -549,63 +565,83 @@ module.exports = {
  * @date 2015
  */
 
-/// @returns an array of objects describing web3.eth api methods
-var methods = function () {
-    var blockCall = function (args) {
-        return typeof args[0] === "string" ? "eth_blockByHash" : "eth_blockByNumber";
-    };
+var formatters = require('./formatters');
 
-    var transactionCall = function (args) {
-        return typeof args[0] === "string" ? 'eth_transactionByHash' : 'eth_transactionByNumber';
-    };
 
-    var uncleCall = function (args) {
-        return typeof args[0] === "string" ? 'eth_uncleByHash' : 'eth_uncleByNumber';
-    };
+var blockCall = function (args) {
+    return typeof args[0] === "string" ? "eth_blockByHash" : "eth_blockByNumber";
+};
 
-    var transactionCountCall = function (args) {
-        return typeof args[0] === "string" ? 'eth_transactionCountByHash' : 'eth_transactionCountByNumber';
-    };
+var transactionCall = function (args) {
+    return typeof args[0] === "string" ? 'eth_transactionByHash' : 'eth_transactionByNumber';
+};
 
-    var uncleCountCall = function (args) {
-        return typeof args[0] === "string" ? 'eth_uncleCountByHash' : 'eth_uncleCountByNumber';
-    };
+var uncleCall = function (args) {
+    return typeof args[0] === "string" ? 'eth_uncleByHash' : 'eth_uncleByNumber';
+};
 
-    return [
-    { name: 'balanceAt', call: 'eth_balanceAt' },
-    { name: 'stateAt', call: 'eth_stateAt' },
-    { name: 'storageAt', call: 'eth_storageAt' },
-    { name: 'countAt', call: 'eth_countAt'},
-    { name: 'codeAt', call: 'eth_codeAt' },
-    { name: 'transact', call: 'eth_transact' },
+var transactionCountCall = function (args) {
+    return typeof args[0] === "string" ? 'eth_transactionCountByHash' : 'eth_transactionCountByNumber';
+};
+
+var uncleCountCall = function (args) {
+    return typeof args[0] === "string" ? 'eth_uncleCountByHash' : 'eth_uncleCountByNumber';
+};
+
+/// @returns an array of objects describing web3.eth api methods
+var methods = [
+    { name: 'getBalance', call: 'eth_balanceAt', outputFormatter: formatters.convertToBigNumber},
+    { name: 'getState', call: 'eth_stateAt' },
+    { name: 'getStorage', call: 'eth_storageAt' },
+    { name: 'getData', call: 'eth_codeAt' },
+    { name: 'getBlock', call: blockCall, outputFormatter: formatters.outputBlockFormatter},
+    { name: 'getUncle', call: uncleCall, outputFormatter: formatters.outputBlockFormatter},
+    { name: 'getCompilers', call: 'eth_compilers' },
+    { name: 'getBlockTransactionCount', call: transactionCountCall },
+    { name: 'getBlockUncleCount', call: uncleCountCall },
+    { name: 'getTransaction', call: transactionCall, outputFormatter: formatters.outputTransactionFormatter },
+    { name: 'getTransactionCount', call: 'eth_countAt'},
+    { name: 'sendTransaction', call: 'eth_transact', inputFormatter: formatters.inputTransactionFormatter },
     { name: 'call', call: 'eth_call' },
-    { name: 'block', call: blockCall },
-    { name: 'transaction', call: transactionCall },
-    { name: 'uncle', call: uncleCall },
-    { name: 'compilers', call: 'eth_compilers' },
+    { name: 'compile.solidity', call: 'eth_solidity' },
+    { name: 'compile.lll', call: 'eth_lll' },
+    { name: 'compile.serpent', call: 'eth_serpent' },
     { name: 'flush', call: 'eth_flush' },
-    { name: 'lll', call: 'eth_lll' },
-    { name: 'solidity', call: 'eth_solidity' },
-    { name: 'serpent', call: 'eth_serpent' },
-    { name: 'logs', call: 'eth_logs' },
-    { name: 'transactionCount', call: transactionCountCall },
-    { name: 'uncleCount', call: uncleCountCall }
-    ];
-};
+
+    // deprecated methods
+    { name: 'balanceAt', call: 'eth_balanceAt', newMethod: 'getBalance' },
+    { name: 'stateAt', call: 'eth_stateAt', newMethod: 'getState' },
+    { name: 'storageAt', call: 'eth_storageAt', newMethod: 'getStorage' },
+    { name: 'countAt', call: 'eth_countAt', newMethod: 'getTransactionCount' },
+    { name: 'codeAt', call: 'eth_codeAt', newMethod: 'getData' },
+    { name: 'transact', call: 'eth_transact', newMethod: 'sendTransaction' },
+    { name: 'block', call: blockCall, newMethod: 'getBlock' },
+    { name: 'transaction', call: transactionCall, newMethod: 'getTransaction' },
+    { name: 'uncle', call: uncleCall, newMethod: 'getUncle' },
+    { name: 'compilers', call: 'eth_compilers', newMethod: 'getCompilers' },
+    { name: 'solidity', call: 'eth_solidity', newMethod: 'compile.solidity' },
+    { name: 'lll', call: 'eth_lll', newMethod: 'compile.lll' },
+    { name: 'serpent', call: 'eth_serpent', newMethod: 'compile.serpent' },
+    { name: 'transactionCount', call: transactionCountCall, newMethod: 'getBlockTransactionCount' },
+    { name: 'uncleCount', call: uncleCountCall, newMethod: 'getBlockUncleCount' },
+    { name: 'logs', call: 'eth_logs' }
+];
 
 /// @returns an array of objects describing web3.eth api properties
-var properties = function () {
-    return [
+var properties = [
     { name: 'coinbase', getter: 'eth_coinbase', setter: 'eth_setCoinbase' },
     { name: 'listening', getter: 'eth_listening', setter: 'eth_setListening' },
     { name: 'mining', getter: 'eth_mining', setter: 'eth_setMining' },
-    { name: 'gasPrice', getter: 'eth_gasPrice' },
+    { name: 'gasPrice', getter: 'eth_gasPrice', outputFormatter: formatters.convertToBigNumber},
     { name: 'accounts', getter: 'eth_accounts' },
     { name: 'peerCount', getter: 'eth_peerCount' },
     { name: 'defaultBlock', getter: 'eth_defaultBlock', setter: 'eth_setDefaultBlock' },
-    { name: 'number', getter: 'eth_number'}
-    ];
-};
+    { name: 'blockNumber', getter: 'eth_number'},
+
+    // deprecated properties
+    { name: 'number', getter: 'eth_number', newProperty: 'blockNumber'}
+];
+
 
 module.exports = {
     methods: methods,
@@ -613,7 +649,7 @@ module.exports = {
 };
 
 
-},{}],6:[function(require,module,exports){
+},{"./formatters":8}],6:[function(require,module,exports){
 /*
     This file is part of ethereum.js.
 
@@ -638,6 +674,7 @@ module.exports = {
 
 var abi = require('./abi');
 var utils = require('./utils');
+var signature = require('./signature');
 
 /// filter inputs array && returns only indexed (or not) inputs
 /// @param inputs array
@@ -676,14 +713,14 @@ var indexedParamsToTopics = function (event, indexed) {
     });
 };
 
-var inputParser = function (address, signature, event) {
+var inputParser = function (address, sign, event) {
     
-    // valid options are 'earliest', 'latest', 'offset' and 'max', as defined for 'eth.watch'
+    // valid options are 'earliest', 'latest', 'offset' and 'max', as defined for 'eth.filter'
     return function (indexed, options) {
         var o = options || {};
         o.address = address;
         o.topic = [];
-        o.topic.push(signature);
+        o.topic.push(sign);
         if (indexed) {
             o.topic = o.topic.concat(indexedParamsToTopics(event, indexed));
         }
@@ -712,6 +749,7 @@ var outputParser = function (event) {
         var result = {
             event: utils.extractDisplayName(event.name),
             number: output.number,
+            hash: output.hash,
             args: {}
         };
 
@@ -735,8 +773,8 @@ var outputParser = function (event) {
 
 var getMatchingEvent = function (events, payload) {
     for (var i = 0; i < events.length; i++) {
-        var signature = abi.eventSignatureFromAscii(events[i].name); 
-        if (signature === payload.topic[0]) {
+        var sign = signature.eventSignatureFromAscii(events[i].name); 
+        if (sign === payload.topic[0]) {
             return events[i];
         }
     }
@@ -751,7 +789,7 @@ module.exports = {
 };
 
 
-},{"./abi":1,"./utils":15}],7:[function(require,module,exports){
+},{"./abi":1,"./signature":14,"./utils":16}],7:[function(require,module,exports){
 /*
     This file is part of ethereum.js.
 
@@ -782,7 +820,7 @@ module.exports = {
 var implementationIsValid = function (i) {
     return !!i && 
         typeof i.newFilter === 'function' && 
-        typeof i.getMessages === 'function' && 
+        typeof i.getLogs === 'function' && 
         typeof i.uninstallFilter === 'function' &&
         typeof i.startPolling === 'function' &&
         typeof i.stopPolling === 'function';
@@ -839,27 +877,50 @@ var filter = function(options, implementation, formatter) {
 
     implementation.startPolling(filterId, onMessages, implementation.uninstallFilter);
 
-    var changed = function (callback) {
+    var watch = function(callback) {
         callbacks.push(callback);
     };
 
-    var messages = function () {
-        return implementation.getMessages(filterId);
-    };
-    
-    var uninstall = function () {
+    var stopWatching = function() {
         implementation.stopPolling(filterId);
         implementation.uninstallFilter(filterId);
         callbacks = [];
     };
 
+    var get = function () {
+        return implementation.getLogs(filterId);
+    };
+    
     return {
-        changed: changed,
-        arrived: changed,
-        happened: changed,
-        messages: messages,
-        logs: messages,
-        uninstall: uninstall
+        watch: watch,
+        stopWatching: stopWatching,
+        get: get,
+
+        // DEPRECATED methods
+        changed:  function(){
+            console.warn('watch().changed() is deprecated please use filter().watch() instead.');
+            return watch.apply(this, arguments);
+        },
+        arrived:  function(){
+            console.warn('watch().arrived() is deprecated please use filter().watch() instead.');
+            return watch.apply(this, arguments);
+        },
+        happened:  function(){
+            console.warn('watch().happened() is deprecated please use filter().watch() instead.');
+            return watch.apply(this, arguments);
+        },
+        uninstall: function(){
+            console.warn('watch().uninstall() is deprecated please use filter().stopWatching() instead.');
+            return stopWatching.apply(this, arguments);
+        },
+        messages: function(){
+            console.warn('watch().messages() is deprecated please use filter().get() instead.');
+            return get.apply(this, arguments);
+        },
+        logs: function(){
+            console.warn('watch().logs() is deprecated please use filter().get() instead.');
+            return get.apply(this, arguments);
+        }
     };
 };
 
@@ -911,7 +972,7 @@ var padLeft = function (string, chars, sign) {
 var formatInputInt = function (value) {
     /*jshint maxcomplexity:7 */
     var padding = c.ETH_PADDING * 2;
-    if (value instanceof BigNumber || typeof value === 'number') {
+    if (utils.isBigNumber(value) || typeof value === 'number') {
         if (typeof value === 'number')
             value = new BigNumber(value);
         BigNumber.config(c.ETH_BIGNUMBER_ROUNDING_MODE);
@@ -921,10 +982,13 @@ var formatInputInt = function (value) {
             value = new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).plus(value).plus(1);
         value = value.toString(16);
     }
-    else if (value.indexOf('0x') === 0)
-        value = value.substr(2);
-    else if (typeof value === 'string')
-        value = formatInputInt(new BigNumber(value));
+    else if (typeof value === 'string') {
+        if (value.indexOf('0x') === 0) {
+            value = value.substr(2);
+        } else {
+            value = formatInputInt(new BigNumber(value));
+        }
+    }
     else
         value = (+value).toString(16);
     return padLeft(value, padding);
@@ -960,7 +1024,9 @@ var signedIsNegative = function (value) {
 /// Formats input right-aligned input bytes to int
 /// @returns right-aligned input bytes formatted to int
 var formatOutputInt = function (value) {
+
     value = value || "0";
+
     // check if it's negative number
     // it it is, return two's complement
     if (signedIsNegative(value)) {
@@ -969,6 +1035,7 @@ var formatOutputInt = function (value) {
     return new BigNumber(value, 16);
 };
 
+
 /// Formats big right-aligned input bytes to uint
 /// @returns right-aligned input bytes formatted to uint
 var formatOutputUInt = function (value) {
@@ -1007,6 +1074,138 @@ var formatOutputAddress = function (value) {
 };
 
 
+/// Formats the input to a big number
+/// @returns a BigNumber object
+var convertToBigNumber = function (value) {
+
+    // remove the leading 0x
+    if(typeof value === 'string')
+        value = value.replace('0x', '');
+
+    value = value || "0";
+
+    return new BigNumber(value, 16);
+};
+
+
+/**
+Formats the input of a transaction and converts all values to HEX
+
+@returns object
+*/
+var inputTransactionFormatter = function(options){
+
+    // make code -> data
+    if(options.code) {
+        options.data = options.code;
+        delete options.code;
+    }
+
+    // make endowment -> value
+    if(options.endowment) {
+        options.value = options.endowment;
+        delete options.endowment;
+    }
+
+
+    // format the following options
+    /*jshint maxcomplexity:5 */
+    ['gasPrice', 'value'].forEach(function(key){
+
+        // if hex or string integer
+        if(typeof options[key] === 'string') {
+
+            // if not hex assume its a number string
+            if(options[key].indexOf('0x') === -1)
+                options[key] = utils.fromDecimal(options[key]);
+
+        // if number
+        } else if(typeof options[key] === 'number') {
+            options[key] = utils.fromDecimal(options[key]);
+
+        // if bignumber
+        } else if(options[key] instanceof BigNumber) {
+            options[key] = '0x'+ options[key].toString(16);
+        }
+    });
+
+    // format gas to number
+    options.gas = Number(options.gas);
+
+
+    return options;
+};
+
+/**
+Formats the output of a transaction to its proper values
+
+@returns object
+*/
+var outputTransactionFormatter = function(tx){
+    // transform to number
+    tx.gas = Number(tx.gas);
+
+    // gasPrice to bignumber
+    if(typeof tx.gasPrice === 'string' && tx.gasPrice.indexOf('0x') === 0)
+        tx.gasPrice = new BigNumber(tx.gasPrice, 16);
+    else
+        tx.gasPrice = new BigNumber(tx.gasPrice.toString(10), 10);
+
+    // value to bignumber
+    if(typeof tx.value === 'string' && tx.value.indexOf('0x') === 0)
+        tx.value = new BigNumber(tx.value, 16);
+    else
+        tx.value = new BigNumber(tx.value.toString(10), 10);
+
+    return tx;
+};
+
+
+/**
+Formats the output of a block to its proper values
+
+@returns object
+*/
+var outputBlockFormatter = function(block){
+    /*jshint maxcomplexity:7 */
+
+    // transform to number
+    block.gasLimit = Number(block.gasLimit);
+    block.gasUsed = Number(block.gasUsed);
+    block.size = Number(block.size);
+    block.timestamp = Number(block.timestamp);
+    block.number = Number(block.number);
+
+    // minGasPrice to bignumber
+    if(block.minGasPrice) {
+        if(typeof block.minGasPrice === 'string' && block.minGasPrice.indexOf('0x') === 0)
+            block.minGasPrice = new BigNumber(block.minGasPrice, 16);
+        else
+            block.minGasPrice = new BigNumber(block.minGasPrice.toString(10), 10);
+    }
+
+
+    // difficulty to bignumber
+    if(block.difficulty) {
+        if(typeof block.difficulty === 'string' && block.difficulty.indexOf('0x') === 0)
+            block.difficulty = new BigNumber(block.difficulty, 16);
+        else
+            block.difficulty = new BigNumber(block.difficulty.toString(10), 10);
+    }
+
+
+    // difficulty to bignumber
+    if(block.totalDifficulty) {
+        if(typeof block.totalDifficulty === 'string' && block.totalDifficulty.indexOf('0x') === 0)
+            block.totalDifficulty = new BigNumber(block.totalDifficulty, 16);
+        else
+            block.totalDifficulty = new BigNumber(block.totalDifficulty.toString(10), 10);
+    }
+
+    return block;
+};
+
+
 module.exports = {
     formatInputInt: formatInputInt,
     formatInputString: formatInputString,
@@ -1019,11 +1218,15 @@ module.exports = {
     formatOutputHash: formatOutputHash,
     formatOutputBool: formatOutputBool,
     formatOutputString: formatOutputString,
-    formatOutputAddress: formatOutputAddress
+    formatOutputAddress: formatOutputAddress,
+    convertToBigNumber: convertToBigNumber,
+    inputTransactionFormatter: inputTransactionFormatter,
+    outputTransactionFormatter: outputTransactionFormatter,
+    outputBlockFormatter: outputBlockFormatter
 };
 
 
-},{"./const":2,"./utils":15}],9:[function(require,module,exports){
+},{"./const":2,"./utils":16}],9:[function(require,module,exports){
 /*
     This file is part of ethereum.js.
 
@@ -1215,6 +1418,15 @@ var requestManager = function() {
     var provider;
 
     var send = function (data) {
+        /*jshint maxcomplexity: 6 */
+
+        // format the input before sending
+        if(typeof data.inputFormatter === 'function') {
+            data.params = Array.prototype.map.call(data.params, function(item){
+                return data.inputFormatter(item);
+            });
+        }
+
         var payload = jsonrpc.toPayload(data.method, data.params);
         
         if (!provider) {
@@ -1226,10 +1438,13 @@ var requestManager = function() {
 
         if (!jsonrpc.isValidResponse(result)) {
             console.log(result);
+            if(typeof result === 'object' && result.error && result.error.message)
+                console.error(result.error.message);
             return null;
         }
         
-        return result.result;
+        // format the output
+        return (typeof data.outputFormatter === 'function') ? data.outputFormatter(result.result) : result.result;
     };
 
     var setProvider = function (p) {
@@ -1317,9 +1532,12 @@ var methods = function () {
     return [
     { name: 'post', call: 'shh_post' },
     { name: 'newIdentity', call: 'shh_newIdentity' },
-    { name: 'haveIdentity', call: 'shh_haveIdentity' },
+    { name: 'hasIdentity', call: 'shh_haveIdentity' },
     { name: 'newGroup', call: 'shh_newGroup' },
-    { name: 'addToGroup', call: 'shh_addToGroup' }
+    { name: 'addToGroup', call: 'shh_addToGroup' },
+
+    // deprecated
+    { name: 'haveIdentity', call: 'shh_haveIdentity', newMethod: 'hasIdentity' },
     ];
 };
 
@@ -1345,6 +1563,50 @@ module.exports = {
     You should have received a copy of the GNU Lesser General Public License
     along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
 */
+/** @file signature.js
+ * @authors:
+ *   Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+var web3 = require('./web3'); 
+var c = require('./const');
+
+/// @param function name for which we want to get signature
+/// @returns signature of function with given name
+var functionSignatureFromAscii = function (name) {
+    return web3.sha3(web3.fromAscii(name)).slice(0, 2 + c.ETH_SIGNATURE_LENGTH * 2);
+};
+
+/// @param event name for which we want to get signature
+/// @returns signature of event with given name
+var eventSignatureFromAscii = function (name) {
+    return web3.sha3(web3.fromAscii(name));
+};
+
+module.exports = {
+    functionSignatureFromAscii: functionSignatureFromAscii,
+    eventSignatureFromAscii: eventSignatureFromAscii
+};
+
+
+},{"./const":2,"./web3":18}],15:[function(require,module,exports){
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    ethereum.js is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
 /** @file types.js
  * @authors:
  *   Marek Kotewicz <marek@ethdev.com>
@@ -1409,7 +1671,7 @@ module.exports = {
 };
 
 
-},{"./formatters":8}],15:[function(require,module,exports){
+},{"./formatters":8}],16:[function(require,module,exports){
 /*
     This file is part of ethereum.js.
 
@@ -1434,6 +1696,30 @@ module.exports = {
 
 var c = require('./const');
 
+if ("build" !== 'build') {/*
+    var BigNumber = require('bignumber.js'); // jshint ignore:line
+*/}
+
+var unitMap = {
+    'wei':      '1',
+    'kwei':     '1000',
+    'ada':      '1000',
+    'mwei':     '1000000',
+    'babbage':  '1000000',
+    'gwei':     '1000000000',
+    'shannon':  '1000000000',
+    'szabo':    '1000000000000',
+    'finney':   '1000000000000000',
+    'ether':    '1000000000000000000',
+    'kether':   '1000000000000000000000',
+    'grand':    '1000000000000000000000',
+    'einstein': '1000000000000000000000',
+    'mether':   '1000000000000000000000000',
+    'gether':   '1000000000000000000000000000',
+    'tether':   '1000000000000000000000000000000'
+};
+
+
 /// Finds first index of array element matching pattern
 /// @param array
 /// @param callback pattern
@@ -1519,8 +1805,11 @@ var filterEvents = function (json) {
 /// TODO: use BigNumber.js to parse int
 /// TODO: add tests for it!
 var toEth = function (str) {
+
+    console.warn('This method is deprecated please use eth.fromWei(BigNumberOrNumber, unit) instead.');
+
      /*jshint maxcomplexity:7 */
-    var val = typeof str === "string" ? str.indexOf('0x') === 0 ? parseInt(str.substr(2), 16) : parseInt(str) : str;
+    var val = typeof str === "string" ? str.indexOf('0x') === 0 ? parseInt(str.substr(2), 16) : parseInt(str.replace(/,/g,'').replace(/ /g,'')) : str;
     var unit = 0;
     var units = c.ETH_UNITS;
     while (val > 3000 && unit < units.length - 1)
@@ -1542,19 +1831,161 @@ var toEth = function (str) {
     return s + ' ' + units[unit];
 };
 
+
+var toDecimal = function (val) {
+    // remove 0x and place 0, if it's required
+    val = val.length > 2 ? val.substring(2) : "0";
+    return (new BigNumber(val, 16).toString(10));
+};
+
+var fromDecimal = function (val) {
+    return "0x" + (new BigNumber(val).toString(16));
+};
+
+
+/**
+Takes a number of wei and converts it to any other ether unit.
+
+Possible units are:
+
+    - kwei/ada
+    - mwei/babbage
+    - gwei/shannon
+    - szabo
+    - finney
+    - ether
+    - kether/grand/einstein
+    - mether
+    - gether
+    - tether
+
+@method fromWei
+@param {Number|String} number can be a number, number string or a HEX of a decimal
+@param {String} unit the unit to convert to
+@return {String|Object} When given a BigNumber object it returns one as well, otherwise a number
+*/
+var fromWei = function(number, unit) {
+    /*jshint maxcomplexity: 6 */
+    unit = unit.toLowerCase();
+
+    var isBigNumber = true;
+
+    if(!unitMap[unit]) {
+        console.warn('This unit doesn\'t exists, please use the one of the following units' , unitMap);
+        return number;
+    }
+
+    if(!number)
+        return number;
+
+    if(typeof number === 'string' && number.indexOf('0x') === 0) {
+        isBigNumber = false;
+        number = new BigNumber(number, 16);
+    }
+    
+    if(!(number instanceof BigNumber)) {
+        isBigNumber = false;
+        number = new BigNumber(number.toString(10), 10); // toString to prevent errors, the user have to handle giving correct bignums themselves
+    }
+
+    number = number.dividedBy(new BigNumber(unitMap[unit], 10));
+
+    return (isBigNumber) ? number : number.toString(10);
+};
+
+/**
+Takes a number of a unit and converts it to wei.
+
+Possible units are:
+
+    - kwei/ada
+    - mwei/babbage
+    - gwei/shannon
+    - szabo
+    - finney
+    - ether
+    - kether/grand/einstein
+    - mether
+    - gether
+    - tether
+
+@method toWei
+@param {Number|String|BigNumber} number can be a number, number string or a HEX of a decimal
+@param {String} unit the unit to convert to
+@return {String|Object} When given a BigNumber object it returns one as well, otherwise a number
+*/
+var toWei = function(number, unit) {
+    /*jshint maxcomplexity: 6 */
+    unit = unit.toLowerCase();
+
+    var isBigNumber = true;
+
+    if(!unitMap[unit]) {
+        console.warn('This unit doesn\'t exists, please use the one of the following units' , unitMap);
+        return number;
+    }
+
+    if(!number)
+        return number;
+
+    if(typeof number === 'string' && number.indexOf('0x') === 0) {
+        isBigNumber = false;
+        number = new BigNumber(number, 16);
+    }
+
+    if(!(number instanceof BigNumber)) {
+        isBigNumber = false;
+        number = new BigNumber(number.toString(10), 10);// toString to prevent errors, the user have to handle giving correct bignums themselves
+    }
+
+
+    number = number.times(new BigNumber(unitMap[unit], 10));
+
+    return (isBigNumber) ? number : number.toString(10);
+};
+
+
+/**
+Checks if the given string is a valid ethereum HEX address.
+
+@method isAddress
+@param {String} address the given HEX adress
+@return {Boolean}
+*/
+var isAddress = function(address) {
+    if(address.indexOf('0x') === 0 && address.length !== 42)
+        return false;
+    if(address.indexOf('0x') === -1 && address.length !== 40)
+        return false;
+
+    return /^\w+$/.test(address);
+};
+
+var isBigNumber = function (value) {
+    return value instanceof BigNumber ||
+        (value && value.constructor && value.constructor.name === 'BigNumber');
+};
+
+
 module.exports = {
     findIndex: findIndex,
+    toDecimal: toDecimal,
+    fromDecimal: fromDecimal,
     toAscii: toAscii,
     fromAscii: fromAscii,
     extractDisplayName: extractDisplayName,
     extractTypeName: extractTypeName,
     filterFunctions: filterFunctions,
     filterEvents: filterEvents,
-    toEth: toEth
+    toEth: toEth,
+    toWei: toWei,
+    fromWei: fromWei,
+    isAddress: isAddress,
+    isBigNumber: isBigNumber
 };
 
 
-},{"./const":2}],16:[function(require,module,exports){
+},{"./const":2}],17:[function(require,module,exports){
 /*
     This file is part of ethereum.js.
 
@@ -1577,7 +2008,7 @@ module.exports = {
  * @date 2015
  */
 
-/// @returns an array of objects describing web3.eth.watch api methods
+/// @returns an array of objects describing web3.eth.filter api methods
 var eth = function () {
     var newFilter = function (args) {
         return typeof args[0] === 'string' ? 'eth_newFilterString' : 'eth_newFilter';
@@ -1586,7 +2017,7 @@ var eth = function () {
     return [
     { name: 'newFilter', call: newFilter },
     { name: 'uninstallFilter', call: 'eth_uninstallFilter' },
-    { name: 'getMessages', call: 'eth_filterLogs' }
+    { name: 'getLogs', call: 'eth_filterLogs' }
     ];
 };
 
@@ -1595,7 +2026,7 @@ var shh = function () {
     return [
     { name: 'newFilter', call: 'shh_newFilter' },
     { name: 'uninstallFilter', call: 'shh_uninstallFilter' },
-    { name: 'getMessages', call: 'shh_getMessages' }
+    { name: 'getLogs', call: 'shh_getMessages' }
     ];
 };
 
@@ -1605,7 +2036,7 @@ module.exports = {
 };
 
 
-},{}],17:[function(require,module,exports){
+},{}],18:[function(require,module,exports){
 /*
     This file is part of ethereum.js.
 
@@ -1631,9 +2062,9 @@ module.exports = {
  * @date 2014
  */
 
-if ("build" !== 'build') {/*
-    var BigNumber = require('bignumber.js');
-*/}
+// if (process.env.NODE_ENV !== 'build') {
+//     var BigNumber = require('bignumber.js');
+// }
 
 var eth = require('./eth');
 var db = require('./db');
@@ -1654,14 +2085,35 @@ var web3Methods = function () {
 /// setups api calls for these methods
 var setupMethods = function (obj, methods) {
     methods.forEach(function (method) {
-        obj[method.name] = function () {
-            var args = Array.prototype.slice.call(arguments);
-            var call = typeof method.call === 'function' ? method.call(args) : method.call;
-            return web3.manager.send({
-                method: call,
-                params: args
-            });
-        };
+        // allow for object methods 'myObject.method'
+        var objectMethods = method.name.split('.'),
+            callFunction = function () {
+                var args = Array.prototype.slice.call(arguments);
+                var call = typeof method.call === 'function' ? method.call(args) : method.call;
+
+                // show deprecated warning
+                if(method.newMethod)
+                    console.warn('This method is deprecated please use eth.'+ method.newMethod +'() instead.');
+
+                return web3.manager.send({
+                    method: call,
+                    params: args,
+                    outputFormatter: method.outputFormatter,
+                    inputFormatter: method.inputFormatter
+                });
+            };
+
+        if(objectMethods.length > 1) {
+            if(!obj[objectMethods[0]])
+                obj[objectMethods[0]] = {};
+
+            obj[objectMethods[0]][objectMethods[1]] = callFunction;
+        
+        } else {
+
+            obj[objectMethods[0]] = callFunction;
+        }
+
     });
 };
 
@@ -1671,20 +2123,36 @@ var setupProperties = function (obj, properties) {
     properties.forEach(function (property) {
         var proto = {};
         proto.get = function () {
+
+            // show deprecated warning
+            if(property.newProperty)
+                console.warn('This property is deprecated please use eth.'+ property.newProperty +' instead.');
+
+
             return web3.manager.send({
-                method: property.getter
+                method: property.getter,
+                outputFormatter: property.outputFormatter
             });
         };
 
         if (property.setter) {
             proto.set = function (val) {
+
+                // show deprecated warning
+                if(property.newProperty)
+                    console.warn('This property is deprecated please use eth.'+ property.newProperty +' instead.');
+
                 return web3.manager.send({
                     method: property.setter,
-                    params: [val]
+                    params: [val],
+                    inputFormatter: property.inputFormatter
                 });
             };
         }
+
+        proto.enumerable = !property.newProperty;
         Object.defineProperty(obj, property.name, proto);
+
     });
 };
 
@@ -1716,6 +2184,16 @@ var web3 = {
     manager: requestManager(),
     providers: {},
 
+    setProvider: function (provider) {
+        web3.manager.setProvider(provider);
+    },
+    
+    /// Should be called to reset state of web3 object
+    /// Resets everything except manager
+    reset: function () {
+        web3.manager.reset(); 
+    },
+
     /// @returns ascii string representation of hex value prefixed with 0x
     toAscii: utils.toAscii,
 
@@ -1723,23 +2201,25 @@ var web3 = {
     fromAscii: utils.fromAscii,
 
     /// @returns decimal representaton of hex value prefixed by 0x
-    toDecimal: function (val) {
-        // remove 0x and place 0, if it's required
-        val = val.length > 2 ? val.substring(2) : "0";
-        return (new BigNumber(val, 16).toString(10));
-    },
+    toDecimal: utils.toDecimal,
 
     /// @returns hex representation (prefixed by 0x) of decimal value
-    fromDecimal: function (val) {
-        return "0x" + (new BigNumber(val).toString(16));
-    },
+    fromDecimal: utils.fromDecimal,
 
     /// used to transform value/string to eth string
     toEth: utils.toEth,
 
+    toWei: utils.toWei,
+    fromWei: utils.fromWei,
+    isAddress: utils.isAddress,
+
+
     /// eth object prototype
     eth: {
+        // DEPRECATED
         contractFromAbi: function (abi) {
+            console.warn('Initiating a contract like this is deprecated please use var MyContract = eth.contract(abi); new MyContract(address); instead.');
+
             return function(addr) {
                 // Default to address of Config. TODO: rremove prior to genesis.
                 addr = addr || '0xc6d9d2cd449a754c494264e1809c50e34d64562b';
@@ -1750,15 +2230,22 @@ var web3 = {
         },
 
         /// @param filter may be a string, object or event
-        /// @param indexed is optional, this is an object with optional event indexed params
+        /// @param eventParams is optional, this is an object with optional event eventParams params
         /// @param options is optional, this is an object with optional event options ('max'...)
         /// TODO: fix it, 4 params? no way
         /*jshint maxparams:4 */
-        watch: function (fil, indexed, options, formatter) {
-            if (fil._isEvent) {
-                return fil(indexed, options);
-            }
+        filter: function (fil, eventParams, options, formatter) {
+
+            // if its event, treat it differently
+            if (fil._isEvent)
+                return fil(eventParams, options);
+
             return filter(fil, ethWatch, formatter);
+        },
+        // DEPRECATED
+        watch: function (fil, eventParams, options, formatter) {
+            console.warn('eth.watch() is deprecated please use eth.filter() instead.');
+            return this.filter(fil, eventParams, options, formatter);
         }
         /*jshint maxparams:3 */
     },
@@ -1769,25 +2256,21 @@ var web3 = {
     /// shh object prototype
     shh: {
         /// @param filter may be a string, object or event
-        watch: function (fil) {
+        filter: function (fil) {
             return filter(fil, shhWatch);
+        },
+        // DEPRECATED
+        watch: function (fil) {
+            console.warn('shh.watch() is deprecated please use shh.filter() instead.');
+            return this.filter(fil);
         }
-    },
-    setProvider: function (provider) {
-        web3.manager.setProvider(provider);
-    },
-    
-    /// Should be called to reset state of web3 object
-    /// Resets everything except manager
-    reset: function () {
-        web3.manager.reset(); 
     }
 };
 
 /// setups all api methods
 setupMethods(web3, web3Methods());
-setupMethods(web3.eth, eth.methods());
-setupProperties(web3.eth, eth.properties());
+setupMethods(web3.eth, eth.methods);
+setupProperties(web3.eth, eth.properties);
 setupMethods(web3.db, db.methods());
 setupMethods(web3.shh, shh.methods());
 setupMethods(ethWatch, watches.eth());
@@ -1796,7 +2279,7 @@ setupMethods(shhWatch, watches.shh());
 module.exports = web3;
 
 
-},{"./db":4,"./eth":5,"./filter":7,"./requestmanager":12,"./shh":13,"./utils":15,"./watches":16}],"web3":[function(require,module,exports){
+},{"./db":4,"./eth":5,"./filter":7,"./requestmanager":12,"./shh":13,"./utils":16,"./watches":17}],"web3":[function(require,module,exports){
 var web3 = require('./lib/web3');
 web3.providers.HttpSyncProvider = require('./lib/httpsync');
 web3.providers.QtSyncProvider = require('./lib/qtsync');
@@ -1805,7 +2288,7 @@ web3.abi = require('./lib/abi');
 
 module.exports = web3;
 
-},{"./lib/abi":1,"./lib/contract":3,"./lib/httpsync":9,"./lib/qtsync":11,"./lib/web3":17}]},{},["web3"])
+},{"./lib/abi":1,"./lib/contract":3,"./lib/httpsync":9,"./lib/qtsync":11,"./lib/web3":18}]},{},["web3"])
 
 
 //# sourceMappingURL=ethereum.js.map