Merge pull request #179 from blockchain/bitcoinjs-2.1-again

Bitcoinjs 2.1 again

package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockchain-wallet-client",
-  "version": "3.10.0",
+  "version": "3.12.0",
   "description": "Blockchain.info JavaScript Wallet",
   "homepage": "https://github.com/blockchain/my-wallet-v3",
   "bugs": {
@@ -32,7 +32,7 @@
   "dependencies": {
     "bigi": "1.4.*",
     "bip39": "2.1.*",
-    "bitcoinjs-lib": "1.5.*",
+    "bitcoinjs-lib": "2.1.*",
     "bs58": "2.0.*",
     "es6-promise": "^3.0.2",
     "isomorphic-fetch": "^2.2.0",

src/address.js

@@ -156,12 +156,12 @@ Address.import = function (key, label){
       object.priv = null;
       break;
     case Helpers.isKey(key):
-      object.addr = key.pub.getAddress().toString();
+      object.addr = key.getAddress();
       object.priv = Base58.encode(key.d.toBuffer(32));
       break;
     case Helpers.isBitcoinPrivateKey(key):
-      key = Bitcoin.ECKey.fromWIF(key);
-      object.addr = key.pub.getAddress().toString();
+      key = Bitcoin.ECPair.fromWIF(key);
+      object.addr = key.getAddress();
       object.priv = Base58.encode(key.d.toBuffer(32));
       break;
     default:
@@ -188,7 +188,7 @@ Address.fromString = function (keyOrAddr, label, bipPass){
         if (bipPass == undefined || bipPass === '') {
           return reject('needsBip38');
         }
-        ImportExport.parseBIP38toECKey(keyOrAddr, bipPass,
+        ImportExport.parseBIP38toECPair(keyOrAddr, bipPass,
           function (key) { resolve(Address.import(key, label));},
           function ()    { reject('wrongBipPass'); },
           function ()    { reject('importError');}
@@ -204,8 +204,11 @@ Address.fromString = function (keyOrAddr, label, bipPass){
   return new Promise(asyncParse);
 };
 
-Address.new = function (label){
-  var key = Bitcoin.ECKey.makeRandom(true, RNG.run.bind(RNG));
+Address.new = function(label){
+  var key = Bitcoin.ECPair.makeRandom({
+    rng: RNG.run.bind(RNG),
+    compressed: true
+  });
   return Address.import(key, label);
 };
 

src/api.js

@@ -8,7 +8,6 @@ var WalletStore   = require('./wallet-store');
 var WalletCrypto  = require('./wallet-crypto');
 var MyWallet      = require('./wallet');
 var Bitcoin = require('bitcoinjs-lib');
-var ECKey         = Bitcoin.ECKey;
 ////////////////////////////////////////////////////////////////////////////////
 // API class
 function API (){
@@ -126,8 +125,8 @@ API.prototype.getBalanceForRedeemCode = function (privatekey){
   var format = Helpers.detectPrivateKeyFormat(privatekey);
   if(format == null) { return Promise.reject('Unknown private key format'); }
   var privateKeyToSweep = Helpers.privateKeyStringToKey(privatekey, format);
-  var aC = new ECKey(privateKeyToSweep.d, true).pub.getAddress().toString();
-  var aU = new ECKey(privateKeyToSweep.d, false).pub.getAddress().toString();
+  var aC = new ECPair(privateKeyToSweep.d, null, {compressed: true}).getAddress();
+  var aU = new ECPair(privateKeyToSweep.d, null, {compressed: false}).getAddress();
   var totalBalance = function (data) {
     return Object.keys(data)
                  .map(function (a){ return data[a].final_balance;})
@@ -227,12 +226,8 @@ API.prototype.securePostCallbacks = function (url, data, success, error) {
 
 
 //01000000013e095250cb35129c7dee081b8c89b4bff69f72222a25c45ba9747a704a6d0bcd010000006b4830450221009b4f6619b1499ea19494aec34c36fdeac9146b9f87f010b7ebf1eb8a1b590c6e02202f5d9b0cfa4107d586b5b370494b9932eba1411468af06e431001932c12bf245012103cf91e6b06d1a2432721559a010ee67e98f8ef0421b15cca66dc9717ac1af8d1effffffff0210270000000000001976a91402549a8a872fbe54721a899e5ac2a87daac2358088acf0ba0400000000001976a9148ee77b3dd0e33783c11a6c28473d16e9b63dc38588ac00000000
-API.prototype.pushTx = function (tx, note){
-  assert(tx, 'transaction required');
-
-  var txHex = tx.toHex();
-  var tx_hash = tx.getId();
-  var buffer = tx.toBuffer();
+API.prototype.pushTx = function (txHex, note){
+  assert(txHex, 'transaction required');
 
   var data = {
       tx : txHex
@@ -241,7 +236,7 @@ API.prototype.pushTx = function (tx, note){
 
   var responseTXHASH = function (responseText) {
     if (responseText.indexOf('Transaction Submitted') > -1)
-      { return tx_hash;}
+      { return true;}
     else
       { return responseText;}
   };

src/blockchain-wallet.js

@@ -823,5 +823,5 @@ Wallet.prototype._getPrivateKey = function (accountIndex, path, secondPassword)
     WalletCrypto.decryptSecretWithSecondPassword(
       maybeXpriv , secondPassword, this.sharedKey, this.pbkdf2_iterations) : maybeXpriv;
   var kr = new KeyRing(xpriv, null);
-  return kr.privateKeyFromPath(path).toWIF();
+  return kr.privateKeyFromPath(path).keyPair.toWIF();
 };

src/helpers.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var Bitcoin = require('bitcoinjs-lib');
-var ECKey = Bitcoin.ECKey;
 var BigInteger = require('bigi');
 var Buffer = require('buffer').Buffer;
 var Base58 = require('bs58');
@@ -16,22 +15,22 @@ Helpers.isString = function (str){
   return typeof str == 'string' || str instanceof String;
 };
 Helpers.isKey = function (bitcoinKey){
-  return Helpers.isInstanceOf(bitcoinKey, Bitcoin.ECKey);
+  return Helpers.isInstanceOf(bitcoinKey, Bitcoin.ECPair);
 };
 Helpers.isInstanceOf = function (object, theClass) {
   return object instanceof theClass;
 };
 Helpers.isBitcoinAddress = function (candidate) {
   try {
-    var d = Bitcoin.Address.fromBase58Check(candidate);
+    var d = Bitcoin.address.fromBase58Check(candidate);
     var n = Bitcoin.networks.bitcoin;
     return d.version === n.pubKeyHash || d.version === n.scriptHash
   }
   catch (e) { return false; };
 };
 Helpers.isBitcoinPrivateKey = function (candidate) {
   try {
-    Bitcoin.ECKey.fromWIF(candidate);
+    Bitcoin.ECPair.fromWIF(candidate);
     return true;
   }
   catch (e) { return false; };
@@ -318,7 +317,7 @@ Helpers.privateKeyStringToKey = function (value, format) {
     throw 'Unsupported Key Format';
   }
 
-  return new ECKey(new BigInteger.fromByteArrayUnsigned(key_bytes), (format !== 'sipa'));
+  return new Bitcoin.ECPair(new BigInteger.fromByteArrayUnsigned(key_bytes), null, {compressed: format !== 'sipa'});
 };
 
 Helpers.detectPrivateKeyFormat = function (key) {
@@ -366,7 +365,7 @@ Helpers.isValidPrivateKey = function (candidate) {
     var format = Helpers.detectPrivateKeyFormat(candidate);
     if(format == 'bip38') { return true }
     var key = Helpers.privateKeyStringToKey(candidate, format);
-    return key.pub.getAddress().toString();
+    return key.getAddress();
   } catch (e) {
     return false;
   }
@@ -380,7 +379,7 @@ Helpers.privateKeyCorrespondsToAddress = function (address, priv, bipPass) {
       if (bipPass == undefined || bipPass === '') {
         return reject('needsBip38');
       }
-      ImportExport.parseBIP38toECKey(priv, bipPass,
+      ImportExport.parseBIP38toECPair(priv, bipPass,
         function (key) { resolve(key);},
         function ()    { reject('wrongBipPass'); },
         function ()    { reject('importError');}
@@ -393,7 +392,7 @@ Helpers.privateKeyCorrespondsToAddress = function (address, priv, bipPass) {
     else { reject('unknown key format'); }
   }
   var predicate = function(key){
-    var a = key.pub.getAddress().toString();
+    var a = key.getAddress();
     return a === address? Base58.encode(key.d.toBuffer(32)) : null;
   }
   return new Promise(asyncParse).then(predicate);

src/import-export.js

@@ -11,7 +11,7 @@ var hash256 = Bitcoin.crypto.hash256;
 
 var ImportExport = new function () {
 
-  this.parseBIP38toECKey = function (base58Encrypted, passphrase, success, wrong_password, error) {
+  this.parseBIP38toECPair = function(base58Encrypted, passphrase, success, wrong_password, error) {
     var hex;
 
     // Unicode NFC normalization
@@ -68,18 +68,17 @@ var ImportExport = new function () {
     var decrypted;
     var AES_opts = { mode: WalletCrypto.AES.ECB, padding: WalletCrypto.pad.NoPadding };
 
-    var verifyHashAndReturn = function () {
-      var tmpkey = new Bitcoin.ECKey(decrypted, isCompPoint);
+    var verifyHashAndReturn = function() {
+      var tmpkey = new Bitcoin.ECPair(decrypted, null, {compressed: isCompPoint});
 
-      var base58Address = tmpkey.pub.getAddress().toBase58Check();
+      var base58Address = tmpkey.getAddress();
 
       checksum = hash256(base58Address);
 
       if (checksum[0] != hex[3] || checksum[1] != hex[4] || checksum[2] != hex[5] || checksum[3] != hex[6]) {
         wrong_password();
         return;
       }
-
       success(tmpkey, isCompPoint);
     };
 
@@ -112,9 +111,9 @@ var ImportExport = new function () {
           passfactor = hash256(prefactorB);
         }
 
-        var kp = new Bitcoin.ECKey(BigInteger.fromBuffer(passfactor));
+        var kp = new Bitcoin.ECPair(BigInteger.fromBuffer(passfactor));
 
-        var passpoint = kp.pub.toBuffer();
+        var passpoint = kp.getPublicKeyBuffer();
 
         var encryptedpart2 = Buffer(hex.slice(23, 23+16));
 

src/keychain.js

@@ -24,6 +24,14 @@ Object.defineProperties(KeyChain.prototype, {
   'xpub': {
     configurable: false,
     get: function () { return this._chainRoot ? this._chainRoot.neutered().toBase58() : null;}
+  },
+  'isNeutered': {
+    configurable: false,
+    get: function () {
+      // isNeutered() is not yet in 2.1.4
+      // return this._chainRoot ? this._chainRoot.isNeutered() : null;
+      return this._chainRoot ? !this._chainRoot.keyPair.d : null;
+    }
   }
 });
 
@@ -44,11 +52,11 @@ KeyChain.prototype.init = function (extendedKey, index, cache) {
 
 KeyChain.prototype.getAddress = function (index) {
   assert(Helpers.isPositiveInteger(index), 'Address index must be integer >= 0');
-  return this._getKey(index).getAddress().toString();
+  return this._getKey(index).getAddress();
 };
 
 KeyChain.prototype.getPrivateKey = function (index) {
   assert(Helpers.isPositiveInteger(index), 'private key index must be integer >= 0');
-  var key = this._getKey(index).privKey;
+  var key = this._getKey(index);
   return key ? key : null;
 };

src/keyring.js

@@ -37,12 +37,14 @@ KeyRing.prototype.init = function (extendedKey, cache){
   return this;
 };
 
+// "M/0/0" -> HDNode
 KeyRing.prototype.privateKeyFromPath = function (path) {
   var components = path.split('/');
   assert(components[0] === 'M', 'Invalid Path prefix');
   assert(components[1] === '0' || components[1] === '1'
     ,'Invalid Path: change/receive index out of bounds');
   assert(components.length === 3, 'Invalid Path length');
+  if(this._receiveChain.isNeutered) return null;
   var receiveOrChange = parseInt(components[1]);
   var index = parseInt(components[2]);
   return receiveOrChange === 0 ?

src/payment.js

@@ -259,11 +259,11 @@ Payment.from = function (origin) {
     // from PrivateKey
     case (pkFormat !== null):
       var key    = Helpers.privateKeyStringToKey(origin, pkFormat);
-      key.pub.compressed = false;
-      var addrUncomp = key.pub.getAddress().toString();
+      key.compressed = false;
+      var addrUncomp = key.getAddress();
       var uWIF = key.toWIF();
-      key.pub.compressed = true;
-      var addrComp = key.pub.getAddress().toString();
+      key.compressed = true;
+      var addrComp = key.getAddress();
       var cWIF = key.toWIF();
 
       var ukey = MyWallet.wallet.key(addrUncomp);
@@ -370,23 +370,24 @@ Payment.sign = function(password) {
 Payment.publish = function () {
   return function (payment) {
 
-    var success = function (tx_hash) {
-      console.log('published');
-      payment.txid = tx_hash;
+    var success = function () {
+      payment.txid = payment.transaction.getId();
       return payment;
     };
 
     var handleError = function (e) {
       throw e.message || e.responseText || e;
     };
 
-    var getValue = function (coin) {return coin.value;};
-    var isSmall = function (value) {return value < 500000;};
-    var anySmall = payment.transaction.outs.map(getValue).some(isSmall);
+    var getValue = function(coin) {return coin.value;};
+    var isSmall = function(value) {return value < 500000;};
+    var anySmall = payment.transaction.tx.outs.map(getValue).some(isSmall);
     if(anySmall && payment.note !== undefined && payment.note !== null)
       {throw 'There is an output too small to publish a note';}
 
-    return API.pushTx(payment.transaction, payment.note)
+    payment.transaction = payment.transaction.build();
+
+    return API.pushTx(payment.transaction.toHex(), payment.note)
       .then(success).catch(handleError);
   };
 };
@@ -435,10 +436,10 @@ function getUnspentCoins (addressList) {
 function getKey(priv, addr) {
   var format = Helpers.detectPrivateKeyFormat(priv);
   var key    = Helpers.privateKeyStringToKey(priv, format);
-  var ckey = new Bitcoin.ECKey(key.d, true);
-  var ukey = new Bitcoin.ECKey(key.d, false);
-  if (ckey.pub.getAddress().toString() === addr) {return ckey;}
-  else if (ukey.pub.getAddress().toString() === addr) {return ukey;}
+  var ckey = new Bitcoin.ECPair(key.d, null, {compressed: true});
+  var ukey = new Bitcoin.ECPair(key.d, null, {compressed: false});
+  if (ckey.getAddress() === addr) {return ckey;}
+  else if (ukey.getAddress() === addr) {return ukey;}
   return key;
 }
 
@@ -466,10 +467,10 @@ function getXPRIV (password, accountIndex) {
                                                   , MyWallet.wallet.pbkdf2_iterations);
 };
 ////////////////////////////////////////////////////////////////////////////////
-// getKeyForPath :: xpriv -> path -> [private key]
-function getKeyForPath (extendedPrivateKey, neededPrivateKeyPath) {
+// getKeyForPath :: xpriv -> path -> ECPair
+function getKeyForPath(extendedPrivateKey, neededPrivateKeyPath) {
   var keyring = new KeyRing(extendedPrivateKey);
-  return keyring.privateKeyFromPath(neededPrivateKeyPath);
+  return keyring.privateKeyFromPath(neededPrivateKeyPath).keyPair;
 };
 
 ////////////////////////////////////////////////////////////////////////////////