2014-04-04 13:16:10 -07:00
|
|
|
|
2014-03-26 11:26:31 -07:00
|
|
|
'use strict';
|
2014-04-04 13:16:10 -07:00
|
|
|
|
|
|
|
|
2014-03-26 21:18:29 -07:00
|
|
|
var imports = require('soop').imports();
|
|
|
|
var bitcore = require('bitcore');
|
|
|
|
var BIP32 = bitcore.BIP32;
|
|
|
|
var Address = bitcore.Address;
|
|
|
|
var Script = bitcore.Script;
|
|
|
|
var coinUtil = bitcore.util;
|
2014-04-28 11:02:24 -07:00
|
|
|
var Transaction = bitcore.Transaction
|
2014-04-18 14:25:51 -07:00
|
|
|
var util = bitcore.util;
|
2014-03-26 11:26:31 -07:00
|
|
|
|
2014-04-14 11:31:10 -07:00
|
|
|
var Storage = imports.Storage || require('../storage/Base.js');
|
2014-03-26 21:18:29 -07:00
|
|
|
var storage = Storage.default();
|
2014-03-26 11:26:31 -07:00
|
|
|
|
|
|
|
|
2014-04-04 11:57:28 -07:00
|
|
|
function PublicKeyRing(opts) {
|
2014-03-26 11:26:31 -07:00
|
|
|
opts = opts || {};
|
|
|
|
|
2014-04-15 08:17:28 -07:00
|
|
|
this.walletId = opts.walletId;
|
|
|
|
|
2014-04-07 20:54:38 -07:00
|
|
|
this.network = opts.networkName === 'livenet' ?
|
2014-03-26 11:26:31 -07:00
|
|
|
bitcore.networks.livenet : bitcore.networks.testnet;
|
|
|
|
|
2014-04-04 11:57:28 -07:00
|
|
|
this.requiredCopayers = opts.requiredCopayers || 3;
|
|
|
|
this.totalCopayers = opts.totalCopayers || 5;
|
2014-03-26 11:26:31 -07:00
|
|
|
|
2014-04-17 14:06:55 -07:00
|
|
|
this.copayersBIP32 = opts.copayersBIP32 || [];
|
2014-03-26 18:00:42 -07:00
|
|
|
|
2014-04-17 14:06:55 -07:00
|
|
|
this.changeAddressIndex= opts.changeAddressIndex || 0;
|
|
|
|
this.addressIndex= opts.addressIndex || 0;
|
|
|
|
|
|
|
|
this.publicKeysCache = opts.publicKeysCache || {};
|
2014-03-26 11:26:31 -07:00
|
|
|
}
|
|
|
|
|
2014-04-09 13:28:35 -07:00
|
|
|
/*
|
|
|
|
* This follow Electrum convetion, as described in
|
|
|
|
* https://bitcointalk.org/index.php?topic=274182.0
|
|
|
|
*
|
|
|
|
* We should probably adopt the next standard once it's ready, as discussed in:
|
|
|
|
* http://sourceforge.net/p/bitcoin/mailman/message/32148600/
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2014-04-17 13:01:31 -07:00
|
|
|
PublicKeyRing.Branch = function (index, isChange) {
|
2014-04-23 18:43:17 -07:00
|
|
|
// first 0 is for future use: could be copayerId.
|
|
|
|
return 'm/0/'+(isChange?1:0)+'/'+index;
|
2014-04-09 13:28:35 -07:00
|
|
|
};
|
2014-03-26 11:26:31 -07:00
|
|
|
|
2014-04-28 11:02:24 -07:00
|
|
|
PublicKeyRing.ID_BRANCH = 'm/100/0/0';
|
2014-04-23 18:43:17 -07:00
|
|
|
|
2014-04-08 22:20:28 -07:00
|
|
|
PublicKeyRing.fromObj = function (data) {
|
2014-04-17 14:06:55 -07:00
|
|
|
if (data instanceof PublicKeyRing) {
|
2014-04-11 09:26:36 -07:00
|
|
|
throw new Error('bad data format: Did you use .toObj()?');
|
|
|
|
}
|
2014-04-17 14:06:55 -07:00
|
|
|
data.copayersBIP32 = data.copayersExtPubKeys.map(function(pk) {
|
2014-04-04 13:16:10 -07:00
|
|
|
return new BIP32(pk);
|
2014-03-26 13:55:02 -07:00
|
|
|
});
|
2014-04-17 14:06:55 -07:00
|
|
|
return new PublicKeyRing(data);
|
2014-03-26 13:55:02 -07:00
|
|
|
};
|
|
|
|
|
2014-04-07 07:46:45 -07:00
|
|
|
PublicKeyRing.prototype.toObj = function() {
|
2014-04-04 16:16:15 -07:00
|
|
|
return {
|
2014-04-15 08:17:28 -07:00
|
|
|
walletId: this.walletId,
|
2014-04-07 07:46:45 -07:00
|
|
|
networkName: this.network.name,
|
|
|
|
requiredCopayers: this.requiredCopayers,
|
2014-04-04 11:57:28 -07:00
|
|
|
totalCopayers: this.totalCopayers,
|
2014-04-07 07:46:45 -07:00
|
|
|
|
2014-04-04 16:16:15 -07:00
|
|
|
changeAddressIndex: this.changeAddressIndex,
|
|
|
|
addressIndex: this.addressIndex,
|
2014-04-04 13:16:10 -07:00
|
|
|
copayersExtPubKeys: this.copayersBIP32.map( function (b) {
|
|
|
|
return b.extendedPublicKeyString();
|
2014-03-26 13:55:02 -07:00
|
|
|
}),
|
2014-04-17 14:06:55 -07:00
|
|
|
publicKeysCache: this.publicKeysCache
|
2014-04-04 16:16:15 -07:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
PublicKeyRing.prototype.serialize = function () {
|
2014-04-07 07:46:45 -07:00
|
|
|
return JSON.stringify(this.toObj());
|
2014-03-26 13:55:02 -07:00
|
|
|
};
|
|
|
|
|
2014-04-23 18:43:17 -07:00
|
|
|
PublicKeyRing.prototype.getCopayerId = function(i) {
|
|
|
|
this.copayerIds = this.copayerIds || [];
|
|
|
|
|
|
|
|
if (!this.copayerIds[i]) {
|
2014-04-28 11:02:24 -07:00
|
|
|
var path = PublicKeyRing.ID_BRANCH;
|
2014-04-23 18:43:17 -07:00
|
|
|
var bip32 = this.copayersBIP32[i].derive(path);
|
|
|
|
this.copayerIds[i]= bip32.eckey.public.toString('hex');
|
2014-04-18 14:25:51 -07:00
|
|
|
}
|
2014-04-23 18:43:17 -07:00
|
|
|
|
|
|
|
return this.copayerIds[i];
|
2014-04-20 08:41:28 -07:00
|
|
|
};
|
2014-04-18 14:25:51 -07:00
|
|
|
|
2014-04-04 11:57:28 -07:00
|
|
|
PublicKeyRing.prototype.registeredCopayers = function () {
|
2014-04-04 13:16:10 -07:00
|
|
|
return this.copayersBIP32.length;
|
2014-03-26 11:26:31 -07:00
|
|
|
};
|
|
|
|
|
2014-04-09 10:30:12 -07:00
|
|
|
PublicKeyRing.prototype.isComplete = function () {
|
2014-04-24 19:13:55 -07:00
|
|
|
return this.registeredCopayers() === this.totalCopayers;
|
|
|
|
};
|
|
|
|
|
|
|
|
PublicKeyRing.prototype.getAllCopayerIds = function() {
|
|
|
|
var ret = [];
|
|
|
|
var l = this.registeredCopayers();
|
|
|
|
for(var i=0; i<l; i++) {
|
|
|
|
ret.push(this.getCopayerId(i));
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
PublicKeyRing.prototype.myCopayerId = function(i) {
|
|
|
|
return this.getCopayerId(0);
|
2014-03-26 18:00:42 -07:00
|
|
|
};
|
|
|
|
|
2014-04-04 11:57:28 -07:00
|
|
|
PublicKeyRing.prototype._checkKeys = function() {
|
2014-03-26 18:00:42 -07:00
|
|
|
|
2014-04-09 10:30:12 -07:00
|
|
|
if (!this.isComplete())
|
2014-03-26 18:00:42 -07:00
|
|
|
throw new Error('dont have required keys yet');
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2014-04-04 13:16:10 -07:00
|
|
|
PublicKeyRing.prototype._newExtendedPublicKey = function () {
|
|
|
|
return new BIP32(this.network.name)
|
|
|
|
.extendedPublicKeyString();
|
|
|
|
};
|
|
|
|
|
|
|
|
PublicKeyRing.prototype.addCopayer = function (newEpk) {
|
2014-03-26 11:26:31 -07:00
|
|
|
|
2014-04-09 10:30:12 -07:00
|
|
|
if (this.isComplete())
|
2014-04-04 11:57:28 -07:00
|
|
|
throw new Error('already have all required key:' + this.totalCopayers);
|
2014-03-26 11:26:31 -07:00
|
|
|
|
2014-04-04 13:16:10 -07:00
|
|
|
if (!newEpk) {
|
|
|
|
newEpk = this._newExtendedPublicKey();
|
|
|
|
}
|
2014-03-26 11:26:31 -07:00
|
|
|
|
2014-04-04 13:16:10 -07:00
|
|
|
this.copayersBIP32.forEach(function(b){
|
|
|
|
if (b.extendedPublicKeyString() === newEpk)
|
2014-03-26 11:26:31 -07:00
|
|
|
throw new Error('already have that key');
|
|
|
|
});
|
|
|
|
|
2014-04-04 13:16:10 -07:00
|
|
|
this.copayersBIP32.push(new BIP32(newEpk));
|
|
|
|
return newEpk;
|
2014-03-26 11:26:31 -07:00
|
|
|
};
|
|
|
|
|
2014-04-09 10:30:12 -07:00
|
|
|
PublicKeyRing.prototype.getPubKeys = function (index, isChange) {
|
2014-03-26 18:00:42 -07:00
|
|
|
this._checkKeys();
|
2014-03-26 11:26:31 -07:00
|
|
|
|
2014-04-17 14:06:55 -07:00
|
|
|
var path = PublicKeyRing.Branch(index, isChange);
|
|
|
|
var pubKeys = this.publicKeysCache[path];
|
|
|
|
if (!pubKeys) {
|
|
|
|
pubKeys = [];
|
|
|
|
var l = this.copayersBIP32.length;
|
|
|
|
for(var i=0; i<l; i++) {
|
|
|
|
var bip32 = this.copayersBIP32[i].derive(path);
|
|
|
|
pubKeys[i] = bip32.eckey.public;
|
|
|
|
}
|
2014-04-22 18:07:18 -07:00
|
|
|
this.publicKeysCache[path] = pubKeys.map(function(pk){return pk.toString('hex');});
|
2014-04-17 14:06:55 -07:00
|
|
|
} else {
|
2014-04-28 11:02:24 -07:00
|
|
|
pubKeys = pubKeys.map(function(s){return new Buffer(s,'hex')});
|
2014-04-30 08:25:33 -07:00
|
|
|
//console.log('public keys cache HIT');
|
2014-03-26 18:00:42 -07:00
|
|
|
}
|
|
|
|
|
2014-03-26 19:55:46 -07:00
|
|
|
return pubKeys;
|
|
|
|
};
|
|
|
|
|
2014-04-04 13:16:10 -07:00
|
|
|
PublicKeyRing.prototype._checkIndexRange = function (index, isChange) {
|
|
|
|
if ( (isChange && index > this.changeAddressIndex) ||
|
|
|
|
(!isChange && index > this.addressIndex)) {
|
2014-04-07 11:31:41 -07:00
|
|
|
console.log('Out of bounds at getAddress: Index %d isChange: %d', index, isChange);
|
2014-03-26 21:18:29 -07:00
|
|
|
throw new Error('index out of bound');
|
|
|
|
}
|
2014-04-04 13:16:10 -07:00
|
|
|
};
|
|
|
|
|
2014-04-22 18:07:18 -07:00
|
|
|
// TODO this could be cached
|
2014-04-04 13:16:10 -07:00
|
|
|
PublicKeyRing.prototype.getRedeemScript = function (index, isChange) {
|
|
|
|
this._checkIndexRange(index, isChange);
|
2014-03-26 21:18:29 -07:00
|
|
|
|
2014-04-09 10:30:12 -07:00
|
|
|
var pubKeys = this.getPubKeys(index, isChange);
|
2014-04-04 11:57:28 -07:00
|
|
|
var script = Script.createMultisig(this.requiredCopayers, pubKeys);
|
2014-04-04 13:16:10 -07:00
|
|
|
return script;
|
|
|
|
};
|
|
|
|
|
2014-04-22 18:07:18 -07:00
|
|
|
// TODO this could be cached
|
2014-04-04 13:16:10 -07:00
|
|
|
PublicKeyRing.prototype.getAddress = function (index, isChange) {
|
|
|
|
var script = this.getRedeemScript(index,isChange);
|
2014-04-17 11:04:39 -07:00
|
|
|
return Address.fromScript(script, this.network.name);
|
2014-03-26 11:26:31 -07:00
|
|
|
};
|
|
|
|
|
2014-04-22 18:07:18 -07:00
|
|
|
// TODO this could be cached
|
2014-04-10 21:09:42 -07:00
|
|
|
PublicKeyRing.prototype.getScriptPubKeyHex = function (index, isChange) {
|
|
|
|
var addr = this.getAddress(index,isChange);
|
|
|
|
return Script.createP2SH(addr.payload()).getBuffer().toString('hex');
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2014-04-04 11:57:28 -07:00
|
|
|
//generate a new address, update index.
|
|
|
|
PublicKeyRing.prototype.generateAddress = function(isChange) {
|
2014-03-26 18:00:42 -07:00
|
|
|
|
|
|
|
var ret =
|
|
|
|
this.getAddress(isChange ? this.changeAddressIndex : this.addressIndex, isChange);
|
2014-04-17 11:04:39 -07:00
|
|
|
if (isChange) {
|
2014-03-26 18:00:42 -07:00
|
|
|
this.changeAddressIndex++;
|
2014-04-17 11:04:39 -07:00
|
|
|
} else {
|
2014-04-04 15:59:00 -07:00
|
|
|
this.addressIndex++;
|
2014-04-17 11:04:39 -07:00
|
|
|
}
|
2014-03-26 18:00:42 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
};
|
2014-03-26 21:18:29 -07:00
|
|
|
|
2014-04-30 08:25:33 -07:00
|
|
|
PublicKeyRing.prototype.getAddresses = function(excludeChange) {
|
2014-03-26 21:18:29 -07:00
|
|
|
var ret = [];
|
|
|
|
|
|
|
|
for (var i=0; i<this.addressIndex; i++) {
|
2014-04-24 19:23:40 -07:00
|
|
|
ret.unshift(this.getAddress(i,false));
|
2014-03-26 21:18:29 -07:00
|
|
|
}
|
2014-04-17 13:22:50 -07:00
|
|
|
|
2014-04-30 08:25:33 -07:00
|
|
|
if (!excludeChange) {
|
2014-04-17 13:22:50 -07:00
|
|
|
for (var i=0; i<this.changeAddressIndex; i++) {
|
2014-04-24 19:23:40 -07:00
|
|
|
ret.unshift(this.getAddress(i,true));
|
2014-04-17 13:22:50 -07:00
|
|
|
}
|
|
|
|
}
|
2014-03-26 21:18:29 -07:00
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
2014-04-30 08:25:33 -07:00
|
|
|
// TODO this could be cached
|
|
|
|
PublicKeyRing.prototype._addScriptMap = function (map, index, isChange) {
|
|
|
|
var script = this.getRedeemScript(index,isChange);
|
|
|
|
map[Address.fromScript(script, this.network.name).toString()] = script.getBuffer().toString('hex');
|
|
|
|
};
|
|
|
|
|
2014-04-09 13:28:35 -07:00
|
|
|
PublicKeyRing.prototype.getRedeemScriptMap = function () {
|
|
|
|
var ret = {};
|
|
|
|
|
|
|
|
for (var i=0; i<this.changeAddressIndex; i++) {
|
2014-04-22 18:07:18 -07:00
|
|
|
this._addScriptMap(ret,i,true);
|
2014-04-09 13:28:35 -07:00
|
|
|
}
|
|
|
|
for (var i=0; i<this.addressIndex; i++) {
|
2014-04-22 18:07:18 -07:00
|
|
|
this._addScriptMap(ret,i,false);
|
2014-04-09 13:28:35 -07:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-04-07 20:54:38 -07:00
|
|
|
PublicKeyRing.prototype._checkInPRK = function(inPKR, ignoreId) {
|
|
|
|
|
2014-04-15 08:17:28 -07:00
|
|
|
if (!ignoreId && this.walletId !== inPKR.walletId) {
|
|
|
|
throw new Error('inPRK walletId mismatch');
|
2014-04-07 20:54:38 -07:00
|
|
|
}
|
2014-04-07 07:46:45 -07:00
|
|
|
|
2014-04-11 09:26:36 -07:00
|
|
|
if (this.network.name !== inPKR.network.name)
|
2014-04-07 07:46:45 -07:00
|
|
|
throw new Error('inPRK network mismatch');
|
|
|
|
|
|
|
|
if (
|
|
|
|
this.requiredCopayers && inPKR.requiredCopayers &&
|
|
|
|
(this.requiredCopayers !== inPKR.requiredCopayers))
|
2014-04-18 14:25:51 -07:00
|
|
|
throw new Error('inPRK requiredCopayers mismatch '+this.requiredCopayers+'!='+inPKR.requiredCopayers);
|
2014-04-07 07:46:45 -07:00
|
|
|
|
|
|
|
if (
|
|
|
|
this.totalCopayers && inPKR.totalCopayers &&
|
|
|
|
(this.totalCopayers !== inPKR.totalCopayers))
|
2014-04-18 14:25:51 -07:00
|
|
|
throw new Error('inPRK totalCopayers mismatch'+this.totalCopayers+'!='+inPKR.requiredCopayers);
|
2014-04-07 07:46:45 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
PublicKeyRing.prototype._mergeIndexes = function(inPKR) {
|
|
|
|
var hasChanged = false;
|
|
|
|
|
|
|
|
// Indexes
|
|
|
|
if (inPKR.changeAddressIndex > this.changeAddressIndex) {
|
|
|
|
this.changeAddressIndex = inPKR.changeAddressIndex;
|
|
|
|
hasChanged = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inPKR.addressIndex > this.addressIndex) {
|
|
|
|
this.addressIndex = inPKR.addressIndex;
|
|
|
|
hasChanged = true;
|
|
|
|
}
|
|
|
|
return hasChanged;
|
|
|
|
};
|
|
|
|
|
|
|
|
PublicKeyRing.prototype._mergePubkeys = function(inPKR) {
|
|
|
|
var self = this;
|
2014-04-11 09:26:36 -07:00
|
|
|
var hasChanged = false;
|
|
|
|
var l= self.copayersBIP32.length;
|
2014-04-22 22:01:54 -07:00
|
|
|
if (self.isComplete())
|
|
|
|
return;
|
2014-04-07 07:46:45 -07:00
|
|
|
|
2014-04-11 09:26:36 -07:00
|
|
|
inPKR.copayersBIP32.forEach( function(b) {
|
2014-04-07 07:46:45 -07:00
|
|
|
var haveIt = false;
|
2014-04-11 09:26:36 -07:00
|
|
|
var epk = b.extendedPublicKeyString();
|
2014-04-07 07:46:45 -07:00
|
|
|
for(var j=0; j<l; j++) {
|
|
|
|
if (self.copayersBIP32[j].extendedPublicKeyString() === epk) {
|
|
|
|
haveIt=true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!haveIt) {
|
2014-04-11 09:26:36 -07:00
|
|
|
if (self.isComplete()) {
|
|
|
|
throw new Error('trying to add more pubkeys, when PKR isComplete at merge');
|
|
|
|
}
|
2014-04-07 07:46:45 -07:00
|
|
|
self.copayersBIP32.push(new BIP32(epk));
|
|
|
|
hasChanged=true;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
return hasChanged;
|
|
|
|
};
|
|
|
|
|
2014-04-07 20:54:38 -07:00
|
|
|
PublicKeyRing.prototype.merge = function(inPKR, ignoreId) {
|
2014-04-07 07:46:45 -07:00
|
|
|
var hasChanged = false;
|
|
|
|
|
2014-04-07 20:54:38 -07:00
|
|
|
this._checkInPRK(inPKR, ignoreId);
|
2014-04-07 07:46:45 -07:00
|
|
|
|
|
|
|
if (this._mergeIndexes(inPKR))
|
|
|
|
hasChanged = true;
|
|
|
|
|
|
|
|
if (this._mergePubkeys(inPKR))
|
|
|
|
hasChanged = true;
|
|
|
|
|
|
|
|
return hasChanged;
|
|
|
|
};
|
|
|
|
|
2014-04-04 11:57:28 -07:00
|
|
|
module.exports = require('soop')(PublicKeyRing);
|