mirror of https://github.com/BTCPrivate/copay.git
2847 lines
77 KiB
JavaScript
2847 lines
77 KiB
JavaScript
'use strict';
|
|
|
|
var _ = require('lodash');
|
|
var preconditions = require('preconditions').singleton();
|
|
var inherits = require('inherits');
|
|
var events = require('events');
|
|
var async = require('async');
|
|
|
|
var bitcore = require('bitcore');
|
|
var BIP21 = bitcore.BIP21;
|
|
var bignum = bitcore.Bignum;
|
|
var coinUtil = bitcore.util;
|
|
var buffertools = bitcore.buffertools;
|
|
var Builder = bitcore.TransactionBuilder;
|
|
var SecureRandom = bitcore.SecureRandom;
|
|
var Base58Check = bitcore.Base58.base58Check;
|
|
var Address = bitcore.Address;
|
|
var PayPro = bitcore.PayPro;
|
|
var Transaction = bitcore.Transaction;
|
|
|
|
var log = require('../util/log');
|
|
var cryptoUtil = require('../util/crypto');
|
|
var httpUtil = require('../util/HTTP');
|
|
var HDParams = require('./HDParams');
|
|
var PublicKeyRing = require('./PublicKeyRing');
|
|
var TxProposal = require('./TxProposal');
|
|
var TxProposals = require('./TxProposals');
|
|
var PrivateKey = require('./PrivateKey');
|
|
var Async = require('./Async');
|
|
var Insight = module.exports.Insight = require('./Insight');
|
|
var copayConfig = require('../../config');
|
|
|
|
var TX_MAX_INS = 70;
|
|
|
|
|
|
/**
|
|
* @desc
|
|
* Wallet manages a private key for Copay, network and blockchain information.
|
|
*
|
|
* @TODO: Split this leviathan.
|
|
*
|
|
* @param {Object} opts
|
|
* @param {Network} opts.network - used to send and retrieve messages from
|
|
* copayers
|
|
* @param {Blockchain} opts.blockchain - source of truth for what happens in
|
|
* the blockchain (utxos, balances)
|
|
* @param {number} opts.requiredCopayers - number of required copayers to
|
|
* release funds
|
|
* @param {number} opts.totalCopayers - number of copayers in the wallet
|
|
* @param {boolean} opts.spendUnconfirmed - whether it's safe to spend
|
|
* unconfirmed outputs or not
|
|
* @param {PublicKeyRing} opts.publicKeyRing - an instance of {@link PublicKeyRing}
|
|
* @param {TxProposals} opts.txProposals - an instance of {@link TxProposals}
|
|
* @param {PrivateKey} opts.privateKey - an instance of {@link PrivateKey}
|
|
* @param {string} opts.version - the version of copay where this wallet was
|
|
* created
|
|
* @TODO: figure out if reconnectDelay is set in milliseconds
|
|
* @param {number} opts.reconnectDelay - amount of seconds to wait before
|
|
* attempting to reconnect
|
|
* @constructor
|
|
*/
|
|
function Wallet(opts) {
|
|
var self = this;
|
|
preconditions.checkArgument(opts);
|
|
|
|
opts.reconnectDelay = opts.reconnectDelay || 500;
|
|
|
|
var networkName = Wallet.obtainNetworkName(opts);
|
|
preconditions.checkState((opts.network && opts.blockchain) || networkName);
|
|
|
|
opts.network = opts.network || Wallet._newAsync(opts.networkOpts[networkName]);
|
|
opts.blockchain = opts.blockchain || Wallet._newInsight(opts.blockchainOpts[networkName]);;
|
|
this.httpUtil = opts.httpUtil || httpUtil;
|
|
|
|
//required params
|
|
['network', 'blockchain',
|
|
'requiredCopayers', 'totalCopayers', 'spendUnconfirmed',
|
|
'publicKeyRing', 'txProposals', 'privateKey', 'version',
|
|
'reconnectDelay'
|
|
].forEach(function(k) {
|
|
preconditions.checkArgument(!_.isUndefined(opts[k]), 'MISSOPT: missing required option for Wallet: ' + k);
|
|
self[k] = opts[k];
|
|
});
|
|
|
|
|
|
this.id = opts.id || Wallet.getRandomId();
|
|
this.secretNumber = opts.secretNumber || Wallet.getRandomSecretNumber();
|
|
// TODO
|
|
// this.lock = new WalletLock(this.storage, this.id, opts.lockTimeOutMin);
|
|
this.settings = opts.settings || copayConfig.wallet.settings;
|
|
this.name = opts.name;
|
|
|
|
this.publicKeyRing.walletId = this.id;
|
|
this.txProposals.walletId = this.id;
|
|
this.registeredPeerIds = [];
|
|
this.addressBook = opts.addressBook || {};
|
|
this.publicKey = this.privateKey.publicHex;
|
|
this.syncedTimestamp = opts.syncedTimestamp || 0;
|
|
this.lastMessageFrom = {};
|
|
|
|
|
|
var networkName = Wallet.obtainNetworkName(opts);
|
|
|
|
preconditions.checkArgument(this.network.setHexNonce, 'Incorrect network parameter');
|
|
preconditions.checkArgument(this.blockchain.getTransaction, 'Incorrect blockchain parameter');
|
|
|
|
|
|
this.network.maxPeers = this.totalCopayers;
|
|
this.network.secretNumber = this.secretNumber;
|
|
|
|
//network nonces are 8 byte buffers, representing a big endian number
|
|
//one nonce for oneself, and then one nonce for each copayer
|
|
this.network.setHexNonce(opts.networkNonce);
|
|
this.network.setHexNonces(opts.networkNonces);
|
|
|
|
this.cache = {
|
|
paymentRequests: {},
|
|
};
|
|
}
|
|
|
|
inherits(Wallet, events.EventEmitter);
|
|
|
|
|
|
Wallet.TX_NEW = 'txNew';
|
|
Wallet.TX_PURGED = 'txPurged';
|
|
Wallet.TX_ALL_PURGED = 'txAllPurged';
|
|
Wallet.TX_REJECTED = 'txRejected';
|
|
Wallet.TX_BROADCASTED = 'txBroadcasted';
|
|
Wallet.TX_PROPOSAL_SENT = 'txProposalSent';
|
|
Wallet.TX_SIGNED = 'txSigned';
|
|
Wallet.TX_SIGNED_AND_BROADCASTED = 'txSignedAndBroadcasted';
|
|
|
|
Wallet.prototype.emitAndKeepAlive = function(args) {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
log.debug('Wallet:' + this.getName() + ' Emitting:', args);
|
|
this.keepAlive();
|
|
this.emit.apply(this, arguments);
|
|
};
|
|
|
|
/**
|
|
* @desc Fixed & Forced TransactionBuilder options, for genererating transactions.
|
|
*
|
|
* @static
|
|
* @property lockTime null
|
|
* @property signhash SIGHASH
|
|
* @property fee null (automatic)
|
|
* @property feeSat null
|
|
*/
|
|
Wallet.builderOpts = {
|
|
lockTime: null,
|
|
signhash: bitcore.Transaction.SIGHASH_ALL,
|
|
fee: undefined,
|
|
feeSat: undefined,
|
|
};
|
|
|
|
/**
|
|
* @desc static list with persisted properties of a wallet.
|
|
* These are the properties that get stored/read from localstorage
|
|
*/
|
|
Wallet.PERSISTED_PROPERTIES = [
|
|
'opts',
|
|
'settings',
|
|
'publicKeyRing',
|
|
'txProposals',
|
|
'privateKey',
|
|
'addressBook',
|
|
'syncedTimestamp',
|
|
'secretNumber',
|
|
];
|
|
|
|
/* For compressed keys, m*73 + n*34 <= 496 */
|
|
Wallet.COPAYER_PAIR_LIMITS = {
|
|
1: 1,
|
|
2: 2,
|
|
3: 3,
|
|
4: 4,
|
|
5: 4,
|
|
6: 4,
|
|
7: 3,
|
|
8: 3,
|
|
9: 2,
|
|
10: 2,
|
|
11: 1,
|
|
12: 1,
|
|
};
|
|
|
|
Wallet.getStoragePrefix = function() {
|
|
return 'wallet::';
|
|
};
|
|
|
|
Wallet.getStorageKey = function(str) {
|
|
return Wallet.getStoragePrefix() + str;
|
|
};
|
|
|
|
Wallet.prototype.getStorageKey = function() {
|
|
return Wallet.getStorageKey(this.getId());
|
|
};
|
|
|
|
/* for stubbing */
|
|
Wallet._newInsight = function(opts) {
|
|
return new Insight(opts);
|
|
};
|
|
|
|
/* for stubbing */
|
|
Wallet._newAsync = function(opts) {
|
|
return new Async(opts);
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieve a random id for the wallet
|
|
* @TODO: Discuss changing to a UUID
|
|
* @return {string} 8 bytes, hexa encoded
|
|
*/
|
|
Wallet.getRandomId = function() {
|
|
var r = bitcore.SecureRandom.getPseudoRandomBuffer(8).toString('hex');
|
|
return r;
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieve a random secret number to secure wallet secret
|
|
* @return {string} 5 bytes, hexa encoded
|
|
*/
|
|
Wallet.getRandomSecretNumber = function() {
|
|
var r = bitcore.SecureRandom.getPseudoRandomBuffer(5).toString('hex')
|
|
return r;
|
|
};
|
|
|
|
/**
|
|
* @desc
|
|
* Get the maximum allowed number of required copayers.
|
|
* This is a limit imposed by the maximum allowed size of the scriptSig.
|
|
* @param {number} totalCopayers - the total number of copayers
|
|
* @return {number}
|
|
*/
|
|
Wallet.getMaxRequiredCopayers = function(totalCopayers) {
|
|
return Wallet.COPAYER_PAIR_LIMITS[totalCopayers];
|
|
};
|
|
|
|
/**
|
|
* @desc obtain network name from serialized wallet
|
|
* @param {Object} wallet object
|
|
* @return {string} network name
|
|
*/
|
|
Wallet.obtainNetworkName = function(obj) {
|
|
return obj.networkName ||
|
|
(obj.opts ? obj.opts.networkName : null) ||
|
|
(obj.publicKeyRing ? (obj.publicKeyRing.networkName || obj.publicKeyRing.network.name) : null) ||
|
|
(obj.privateKey ? obj.privateKey.networkName : null);
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* @desc Set the copayer id for the owner of this wallet
|
|
* @param {string} pubkey - the pubkey to set to the {@link Wallet#seededCopayerId} property
|
|
*/
|
|
Wallet.prototype.seedCopayer = function(pubKey) {
|
|
this.seededCopayerId = pubKey;
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Handles an 'indexes' message.
|
|
*
|
|
* Processes the data using {@link HDParams#fromList} and merges it with the
|
|
* {@link Wallet#publicKeyRing}.
|
|
*
|
|
* @param {Object} data - the data received, {@see HDParams#fromList}
|
|
*/
|
|
Wallet.prototype._doOnIndexes = function(indexes, fromTxProposal) {
|
|
preconditions.checkArgument(indexes);
|
|
var inIndexes = HDParams.fromList(indexes);
|
|
var hasChanged = this.publicKeyRing.mergeIndexes(inIndexes);
|
|
if (hasChanged) {
|
|
|
|
// If the new indexes come from TX proposals (change address)
|
|
// that addresses should be new. No need to clean cache.
|
|
if (!fromTxProposal)
|
|
this.clearUnspentCache();
|
|
|
|
this.subscribeToAddresses();
|
|
this.emitAndKeepAlive('newAddresses');
|
|
}
|
|
};
|
|
|
|
|
|
Wallet.prototype._onIndexes = function(senderId, data) {
|
|
return this._doOnIndexes(data.indexes);
|
|
};
|
|
|
|
/**
|
|
* @desc
|
|
* Changes wallet settings. The settings format is:
|
|
*
|
|
* var settings = {
|
|
* unitName: 'bits',
|
|
* unitToSatoshi: 100,
|
|
* alternativeName: 'US Dollar',
|
|
* alternativeIsoCode: 'USD',
|
|
* };
|
|
*/
|
|
Wallet.prototype.changeSettings = function(settings) {
|
|
this.settings = settings;
|
|
this.emitAndKeepAlive('settingsUpdated');
|
|
};
|
|
|
|
/**
|
|
* @desc Locks other sessions from connecting to the wallet
|
|
* @see Async#lockIncommingConnections
|
|
*/
|
|
Wallet.prototype._lockIncomming = function() {
|
|
this.network.lockIncommingConnections(this.publicKeyRing.getAllCopayerIds());
|
|
};
|
|
|
|
/**
|
|
* @desc
|
|
* Handles a 'PUBLICKEYRING' message from <tt>senderId</tt>.
|
|
*
|
|
* <tt>data.publicKeyRing</tt> is expected to be processed correctly by
|
|
* {@link PublicKeyRing#fromObj}.
|
|
*
|
|
* After successful deserialization, {@link Wallet#publicKeyRing} is merged
|
|
* with the received data, a call to {@link Wallet#store} is performed if the
|
|
* internal state has changed.
|
|
*
|
|
* This locks new incoming connections in case the public key ring is completed
|
|
*
|
|
* @param {string} senderId - the sender id
|
|
* @param {Object} data - the data recived, {@see HDParams#fromList}
|
|
* @param {Object} data.publicKeyRing - data to be deserialized into a {@link PublicKeyRing}
|
|
* using {@link PublicKeyRing#fromObj}
|
|
* @emits connectionError
|
|
*/
|
|
Wallet.prototype._onPublicKeyRing = function(senderId, data) {
|
|
log.debug('Wallet:' + this.id + ' RECV PUBLICKEYRING:', data);
|
|
|
|
var inPKR = PublicKeyRing.fromUntrustedObj(data.publicKeyRing);
|
|
var wasIncomplete = !this.publicKeyRing.isComplete();
|
|
var hasChanged;
|
|
|
|
try {
|
|
hasChanged = this.publicKeyRing.merge(inPKR, true);
|
|
} catch (e) {
|
|
log.warn('Wallet:' + this.id, e);
|
|
return;
|
|
}
|
|
if (hasChanged) {
|
|
|
|
if (wasIncomplete) {
|
|
this.sendPublicKeyRing();
|
|
}
|
|
if (this.publicKeyRing.isComplete()) {
|
|
this._lockIncomming();
|
|
this.subscribeToAddresses();
|
|
this.emitAndKeepAlive('ready');
|
|
} else {
|
|
this.emitAndKeepAlive('publicKeyRingUpdated');
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @desc
|
|
* Retrieves a keymap from a transaction proposal set extracts a maps from
|
|
* public key to cosignerId for each signed input of the transaction proposal.
|
|
*
|
|
* @param {TxProposals} txp - the transaction proposals
|
|
* @return {Object} [pubkey] -> copayerId
|
|
*/
|
|
Wallet.prototype._getPubkeyToCopayerMap = function(txp) {
|
|
preconditions.checkArgument(txp);
|
|
var inSig0, keyMapAll = {},
|
|
self = this;
|
|
|
|
var signersPubKeys = txp.getSignersPubKeys();
|
|
_.each(signersPubKeys, function(inputSignersPubKey, i) {
|
|
var keyMap = self.publicKeyRing.copayersForPubkeys(inputSignersPubKey, txp.inputChainPaths);
|
|
|
|
if (_.size(keyMap) !== _.size(inputSignersPubKey))
|
|
throw new Error('Signature does not match known copayers');
|
|
|
|
_.extend(keyMapAll, keyMap);
|
|
|
|
// From here -> only to check that all inputs have the same sigs
|
|
var inSigArr = _.values(keyMap);
|
|
var inSig = JSON.stringify(inSigArr.sort());
|
|
|
|
if (!inSig0) {
|
|
inSig0 = inSig;
|
|
} else {
|
|
if (inSig !== inSig0)
|
|
throw new Error('found inputs with different signatures');
|
|
}
|
|
});
|
|
return keyMapAll;
|
|
};
|
|
|
|
/**
|
|
* @callback transactionCallback
|
|
* @param {error} error
|
|
* @param {number} transaction ID (if sent)
|
|
*/
|
|
|
|
/**
|
|
* @desc
|
|
* Asynchronously check with the blockchain if a given transaction was sent.
|
|
*
|
|
* @param {string} ntxid - the transaction proposal
|
|
* @param {transactionCallback} cb
|
|
*/
|
|
Wallet.prototype._checkIfTxIsSent = function(ntxid, cb) {
|
|
var txp = this.txProposals.get(ntxid);
|
|
var tx = txp.builder.build();
|
|
|
|
//not used anymore
|
|
//var txHex = tx.serialize().toString('hex');
|
|
|
|
|
|
//Use calcHash NOT getHash which could be cached.
|
|
var txid = bitcore.util.formatHashFull(tx.calcHash());
|
|
|
|
log.debug('Checking if transactions was broadcasted... ID:' + txid);
|
|
|
|
this.blockchain.getTransaction(txid, function(err, tx) {
|
|
return cb(err, !err ? txid : null);
|
|
});
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @desc Set Incomming Transaction Proposal seen status
|
|
* and send `seen` messages to peers if aplicable.
|
|
* @param ntxid
|
|
*/
|
|
Wallet.prototype._setTxProposalSeen = function(txp) {
|
|
if (!txp.getSeen(this.getMyCopayerId())) {
|
|
txp.setSeen(this.getMyCopayerId());
|
|
this.sendSeen(txp.getId());
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* @desc updates Tx Proposal Sent status by checking the blockchain
|
|
*
|
|
* @param ntxid
|
|
* @param {transactionCallback} cb
|
|
*/
|
|
Wallet.prototype._updateTxProposalSent = function(txp, cb) {
|
|
var self = this;
|
|
this._checkIfTxIsSent(txp.getId(), function(err, txid) {
|
|
if (err) return cb(err);
|
|
|
|
if (txid) {
|
|
txp.setSent(txid);
|
|
}
|
|
if (cb)
|
|
return cb(null, txid, txid ? Wallet.TX_BROADCASTED : null);
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* _processTxProposalPayPro
|
|
*
|
|
* @desc Process and incoming PayPro TX Proposal. Fetchs the payment request
|
|
* from the merchant.
|
|
*
|
|
* @param mergeInfo Proposals merge information, as returned by TxProposals.merge
|
|
* @return {fetchPaymentRequestCallback}
|
|
*/
|
|
Wallet.prototype._processTxProposalPayPro = function(txp, cb) {
|
|
var self = this;
|
|
|
|
if (!txp.paymentProtocolURL)
|
|
return cb();
|
|
|
|
log.info('Received a Payment Protocol TX Proposal');
|
|
self.fetchPaymentRequest({
|
|
url: txp.paymentProtocolURL
|
|
}, function(err, merchantData) {
|
|
if (err) return cb(err);
|
|
|
|
// This will verify current TXP data vs. merchantData (e.g., out addresses)
|
|
try {
|
|
txp.addMerchantData(merchantData);
|
|
} catch (e) {
|
|
log.error(e);
|
|
err = 'BADPAYPRO: ' + e.toString();
|
|
}
|
|
return cb(err);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Process an NEW incoming transaction proposal. Runs safety and sanity checks on it.
|
|
*
|
|
* @param mergeInfo Proposals merge information, as returned by TxProposals.merge
|
|
* @return {errCallback}
|
|
*/
|
|
Wallet.prototype._processIncomingNewTxProposal = function(txp, cb) {
|
|
var self = this;
|
|
|
|
var ntxid = txp.getId();
|
|
self._processTxProposalPayPro(txp, function(err) {
|
|
if (err) return cb(err);
|
|
|
|
// Disabled, not been shown on the UX now.
|
|
//self._setTxProposalSeen(txp);
|
|
|
|
var tx = txp.builder.build();
|
|
if (tx.isComplete() && !txp.getSent())
|
|
self._updateTxProposalSent(txp);
|
|
return cb();
|
|
});
|
|
};
|
|
|
|
|
|
/* only for stubbing */
|
|
Wallet.prototype._txProposalFromUntrustedObj = function(data, opts) {
|
|
return TxProposal.fromUntrustedObj(data, opts);
|
|
};
|
|
|
|
/**
|
|
* @desc
|
|
* Handles a NEW 'TXPROPOSAL' network message
|
|
*
|
|
* @param {string} senderId - the id of the sender
|
|
* @param {Object} data - the data received
|
|
* @param {Object} data.txProposal - first parameter for {@link TxProposals#merge}
|
|
* @emits txProposalEvent
|
|
*/
|
|
Wallet.prototype._onTxProposal = function(senderId, data) {
|
|
preconditions.checkArgument(data.txProposal);
|
|
var self = this;
|
|
|
|
if (data.indexes) {
|
|
this._doOnIndexes(data.indexes, true);
|
|
}
|
|
|
|
try {
|
|
var incomingTx = self._txProposalFromUntrustedObj(data.txProposal, Wallet.builderOpts);
|
|
var incomingNtxid = incomingTx.getId();
|
|
} catch (e) {
|
|
log.warn(e);
|
|
return;
|
|
}
|
|
|
|
if (this.txProposals.exist(incomingNtxid)) {
|
|
log.warn('Ignoring existing tx Proposal:' + incomingNtxid);
|
|
return;
|
|
}
|
|
|
|
self._processIncomingNewTxProposal(incomingTx, function(err) {
|
|
if (err) {
|
|
log.warn('Corrupt TX proposal received from:', senderId, err.toString());
|
|
return;
|
|
}
|
|
|
|
|
|
var pubkeyToCopayerMap = self._getPubkeyToCopayerMap(incomingTx);
|
|
incomingTx.setCopayers(pubkeyToCopayerMap);
|
|
|
|
self.txProposals.add(incomingTx);
|
|
self.emitAndKeepAlive('txProposalEvent', {
|
|
type: Wallet.TX_NEW,
|
|
cId: senderId,
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
Wallet.prototype._onSignature = function(senderId, data) {
|
|
var self = this;
|
|
try {
|
|
var localTx = this.txProposals.get(data.ntxid);
|
|
} catch (e) {
|
|
log.info('Ignoring signature for unknown tx Proposal:' + data.ntxid);
|
|
return;
|
|
};
|
|
localTx.addSignature(senderId, data.signatures);
|
|
self.emitAndKeepAlive('txProposalEvent', {
|
|
type: Wallet.TX_SIGNED,
|
|
cId: senderId,
|
|
});
|
|
self.issueTxIfComplete(data.ntxid, function(err, txid) {});
|
|
};
|
|
|
|
/**
|
|
* @desc
|
|
* Handle a REJECT message received
|
|
*
|
|
* @param {string} senderId
|
|
* @param {Object} data
|
|
* @param {string} data.ntxid
|
|
* @emits txProposalEvent
|
|
*/
|
|
Wallet.prototype._onReject = function(senderId, data) {
|
|
preconditions.checkState(data.ntxid);
|
|
log.debug('Wallet:' + this.id + ' RECV REJECT:', data);
|
|
|
|
try {
|
|
var txp = this.txProposals.get(data.ntxid);
|
|
} catch (e) {
|
|
log.info(e);
|
|
};
|
|
|
|
if (txp) {
|
|
if (txp.signedBy[senderId])
|
|
throw new Error('Received Reject for an already signed TX from:' + senderId);
|
|
|
|
txp.setRejected(senderId);
|
|
this.emitAndKeepAlive('txProposalEvent', {
|
|
type: Wallet.TX_REJECTED,
|
|
cId: senderId,
|
|
txId: data.ntxid
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @desc
|
|
* Handle a SEEN message received
|
|
*
|
|
* @param {string} senderId
|
|
* @param {Object} data
|
|
* @param {string} data.ntxid
|
|
* @emits txProposalEvent
|
|
*/
|
|
Wallet.prototype._onSeen = function(senderId, data) {
|
|
preconditions.checkState(data.ntxid);
|
|
try {
|
|
var txp = this.txProposals.get(data.ntxid);
|
|
} catch (e) {};
|
|
if (txp) {
|
|
txp.setSeen(senderId);
|
|
this.emitAndKeepAlive('txProposalEvent', {
|
|
type: Wallet.TX_SEEN,
|
|
cId: senderId,
|
|
txId: data.ntxid
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @desc
|
|
* Handle a ADDRESSBOOK message received
|
|
*
|
|
* @param {string} senderId
|
|
* @param {Object} data
|
|
* @param {Object} data.addressBook
|
|
* @emits addressBookUpdated
|
|
* @emits txProposalEvent
|
|
*/
|
|
Wallet.prototype._onAddressBook = function(senderId, data) {
|
|
if (!data.addressBook || !_.isObject(data.addressBook))
|
|
return;
|
|
|
|
var self = this,
|
|
hasChange;
|
|
_.each(data.addressBook, function(value, key) {
|
|
if (key && !self.addressBook[key] && _.isString(key) && Address.validate(key)) {
|
|
|
|
self.addressBook[key] = _.pick(value, ['createdTs', 'label']);
|
|
|
|
// Force author to senderId.
|
|
self.addressBook[key].copayerId = senderId;
|
|
|
|
hasChange = true;
|
|
}
|
|
});
|
|
|
|
if (hasChange) {
|
|
this.emitAndKeepAlive('addressBookUpdated');
|
|
}
|
|
};
|
|
|
|
Wallet.prototype.updateSyncedTimestamp = function(ts) {
|
|
preconditions.checkArgument(ts);
|
|
preconditions.checkArgument(_.isNumber(ts));
|
|
preconditions.checkArgument(ts > 2999999999999, 'use microseconds');
|
|
this.syncedTimestamp = ts;
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Called when there are no messages in the server
|
|
* Triggers a call to {@link Wallet#sendWalletReady}
|
|
*/
|
|
Wallet.prototype._onNoMessages = function() {
|
|
if (this.isComplete()) {
|
|
log.debug('Wallet:' + this.getName() + ' No messages at the server. Requesting peer sync from: ' + (this.syncedTimestamp + 1));
|
|
this.sendWalletReady(null, parseInt((this.syncedTimestamp + 1) / 1000000));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @desc Demultiplexes a new message received through the wire
|
|
*
|
|
* @param {string} senderId - the sender id
|
|
* @param {Object} data - the received object
|
|
* @param {number} ts - the timestamp when this object was received
|
|
*
|
|
* @emits corrupt
|
|
*/
|
|
Wallet.prototype._onData = function(senderId, data, ts) {
|
|
preconditions.checkArgument(senderId);
|
|
preconditions.checkArgument(data);
|
|
preconditions.checkArgument(data.type);
|
|
preconditions.checkArgument(ts);
|
|
preconditions.checkArgument(_.isNumber(ts));
|
|
|
|
log.debug('Wallet:' + this.getName() + ' RECV:', data.type, data, senderId);
|
|
|
|
this.updateSyncedTimestamp(ts);
|
|
|
|
if (data.type !== 'walletId' && this.id !== data.walletId) {
|
|
log.debug('Wallet:' + this.id + ' Received corrupt message:', data)
|
|
this.emitAndKeepAlive('corrupt', senderId);
|
|
return;
|
|
}
|
|
|
|
switch (data.type) {
|
|
// This handler is repeaded on WalletFactory (#join). TODO
|
|
case 'walletId':
|
|
this.sendWalletReady(senderId);
|
|
break;
|
|
case 'walletReady':
|
|
if (this.lastMessageFrom[senderId] !== 'walletReady') {
|
|
log.debug('Wallet:' + this.id + ' peer Sync received. since: ' + (data.sinceTs || 0));
|
|
this.sendPublicKeyRing(senderId);
|
|
this.sendAddressBook(senderId);
|
|
this.sendAllTxProposals(senderId, data.sinceTs); // send old txps
|
|
}
|
|
break;
|
|
case 'publicKeyRing':
|
|
this._onPublicKeyRing(senderId, data);
|
|
break;
|
|
case 'reject':
|
|
this._onReject(senderId, data);
|
|
break;
|
|
case 'seen':
|
|
this._onSeen(senderId, data);
|
|
break;
|
|
case 'txProposal':
|
|
this._onTxProposal(senderId, data);
|
|
break;
|
|
case 'signature':
|
|
this._onSignature(senderId, data);
|
|
break;
|
|
case 'indexes':
|
|
this._onIndexes(senderId, data);
|
|
break;
|
|
case 'addressbook':
|
|
this._onAddressBook(senderId, data);
|
|
break;
|
|
// unused messages
|
|
case 'disconnect':
|
|
//case 'an other unused message':
|
|
break;
|
|
default:
|
|
throw new Error('unknown message type received: ' + data.type + ' from: ' + senderId)
|
|
}
|
|
this.lastMessageFrom[senderId] = data.type;
|
|
|
|
};
|
|
|
|
/**
|
|
* @desc Handles a connect message
|
|
* @param {string} newCopayerId - the new copayer in the wallet
|
|
* @emits connect
|
|
*/
|
|
Wallet.prototype._onConnect = function(newCopayerId) {
|
|
if (newCopayerId) {
|
|
log.debug('Wallet:' + this.id + '#### Setting new COPAYER:', newCopayerId);
|
|
this.sendWalletId(newCopayerId);
|
|
}
|
|
|
|
var peerID = this.network.peerFromCopayer(newCopayerId);
|
|
this.emitAndKeepAlive('connect', peerID);
|
|
};
|
|
|
|
/**
|
|
* @desc Returns the network name for this wallet ('testnet' or 'livenet')
|
|
* @return {string}
|
|
*/
|
|
Wallet.prototype.getNetworkName = function() {
|
|
return this.publicKeyRing.network.name;
|
|
};
|
|
|
|
/**
|
|
* @return {bool}
|
|
*/
|
|
Wallet.prototype.isTestnet = function() {
|
|
return this.publicKeyRing.network.name === 'testnet';
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* @desc Serialize options into an object
|
|
* @return {Object} with keys <tt>id</tt>, <tt>spendUnconfirmed</tt>,
|
|
* <tt>requiredCopayers</tt>, <tt>totalCopayers</tt>, <tt>name</tt>,
|
|
* <tt>version</tt>
|
|
*/
|
|
Wallet.prototype._optsToObj = function() {
|
|
var obj = {
|
|
id: this.id,
|
|
spendUnconfirmed: this.spendUnconfirmed,
|
|
requiredCopayers: this.requiredCopayers,
|
|
totalCopayers: this.totalCopayers,
|
|
name: this.name,
|
|
version: this.version,
|
|
networkName: this.getNetworkName(),
|
|
};
|
|
|
|
return obj;
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieve the copayerId pubkey for a given index
|
|
* @param {number=} index - the index of the copayer, ours by default
|
|
* @return {string} hex-encoded pubkey
|
|
*/
|
|
Wallet.prototype.getCopayerId = function(index) {
|
|
return this.publicKeyRing.getCopayerId(index || 0);
|
|
};
|
|
|
|
/**
|
|
* @desc Get my own pubkey
|
|
* @return {string} hex-encoded pubkey
|
|
*/
|
|
Wallet.prototype.getMyCopayerId = function() {
|
|
|
|
if (!this._myId)
|
|
this._myId = this.getCopayerId(0);
|
|
|
|
return this._myId; //copayer id is hex of a public key
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieve my private key
|
|
* @return {string} hex-encoded private key
|
|
*/
|
|
Wallet.prototype.getMyCopayerIdPriv = function() {
|
|
return this.privateKey.getIdPriv(); //copayer idpriv is hex of a private key
|
|
};
|
|
|
|
/**
|
|
* @desc Get my own nickname
|
|
* @return {string} copayer nickname
|
|
*/
|
|
Wallet.prototype.getMyCopayerNickname = function() {
|
|
return this.publicKeyRing.nicknameForCopayer(this.getMyCopayerId());
|
|
};
|
|
|
|
/**
|
|
* @desc Returns the secret value for other users to join this wallet
|
|
* @return {string} my own pubkey, base58 encoded
|
|
*/
|
|
Wallet.prototype.getSecretNumber = function() {
|
|
return this.secretNumber;
|
|
};
|
|
|
|
/**
|
|
* @desc Returns the secret number used to prevent MitM attacks from Insight
|
|
* @return {string}
|
|
*/
|
|
Wallet.prototype.getSecret = function() {
|
|
var buf = new Buffer(
|
|
this.getMyCopayerId() +
|
|
this.getSecretNumber() +
|
|
(this.getNetworkName() === 'livenet' ? '00' : '01'),
|
|
'hex');
|
|
var str = Base58Check.encode(buf);
|
|
return str;
|
|
};
|
|
|
|
/**
|
|
* @desc Returns an object with a <tt>pubKey</tt> value, an hex representation
|
|
* of a public key
|
|
* @param {string} secretB - the secret to be base58-decoded
|
|
* @return {Object}
|
|
*/
|
|
Wallet.decodeSecret = function(secretB) {
|
|
try {
|
|
var secret = Base58Check.decode(secretB);
|
|
var pubKeyBuf = secret.slice(0, 33);
|
|
var secretNumber = secret.slice(33, 38);
|
|
var networkName = secret.slice(38, 39).toString('hex') === '00' ? 'livenet' : 'testnet';
|
|
return {
|
|
pubKey: pubKeyBuf.toString('hex'),
|
|
secretNumber: secretNumber.toString('hex'),
|
|
networkName: networkName,
|
|
}
|
|
} catch (e) {
|
|
log.debug(e.message);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
Wallet.prototype._setupBlockchainHandlers = function() {
|
|
|
|
var self = this;
|
|
self.blockchain.removeAllListeners();
|
|
self.subscribeToAddresses();
|
|
|
|
log.debug('Setting Blockchain listeners for', this.getName());
|
|
self.blockchain.on('reconnect', function(attempts) {
|
|
log.debug('Wallet:' + self.id + 'blockchain reconnect event');
|
|
self.clearUnspentCache();
|
|
self.emitAndKeepAlive('insightReconnected');
|
|
});
|
|
|
|
self.blockchain.on('disconnect', function() {
|
|
log.debug('Wallet:' + self.id + 'blockchain disconnect event');
|
|
self.emitAndKeepAlive('insightError');
|
|
});
|
|
|
|
self.blockchain.on('tx', function(tx) {
|
|
log.debug('Wallet:' + self.id + ' blockchain tx event');
|
|
var addresses = self.getAddresses();
|
|
// This should always be >=0
|
|
if (_.indexOf(addresses, tx.address) >= 0) {
|
|
self.clearUnspentCache();
|
|
self.emitAndKeepAlive('tx', tx.address, self.addressIsChange(tx.address));
|
|
}
|
|
});
|
|
|
|
if (!self.spendUnconfirmed) {
|
|
|
|
// TODO HERE should only clean utxos if there are some wallet
|
|
// transactions waiting for confirmation (ie confirmation < min confirmation)
|
|
self.clearUnspentCache();
|
|
|
|
self.blockchain.on('block', self.emitAndKeepAlive.bind(self, 'balanceUpdated'));
|
|
}
|
|
}
|
|
|
|
Wallet.prototype._setupNetworkHandlers = function() {
|
|
var self = this;
|
|
|
|
var net = this.network;
|
|
net.removeAllListeners();
|
|
net.on('connect', self._onConnect.bind(self));
|
|
net.on('data', self._onData.bind(self));
|
|
net.on('no_messages', self._onNoMessages.bind(self));
|
|
net.on('connect_error', function() {
|
|
self.emitAndKeepAlive('connectionError');
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Sets up the networking with other peers.
|
|
*
|
|
* @emits connect
|
|
* @emits data
|
|
*
|
|
* @emits ready
|
|
*
|
|
*/
|
|
Wallet.prototype.netStart = function() {
|
|
var self = this;
|
|
|
|
if (self.netStarted)
|
|
return;
|
|
|
|
|
|
self._setupBlockchainHandlers();
|
|
self.netStarted = true;
|
|
|
|
if (!this.isShared()) {
|
|
self.emitAndKeepAlive('ready');
|
|
return;
|
|
}
|
|
|
|
self._setupNetworkHandlers();
|
|
|
|
var myId = self.getMyCopayerId();
|
|
var myIdPriv = self.getMyCopayerIdPriv();
|
|
var startOpts = {
|
|
copayerId: myId,
|
|
privkey: myIdPriv,
|
|
maxPeers: self.totalCopayers,
|
|
syncedTimestamp: this.syncedTimestamp || 0,
|
|
secretNumber: self.secretNumber,
|
|
};
|
|
|
|
var wasIncomplete;
|
|
if (this.publicKeyRing.isComplete()) {
|
|
this._lockIncomming(this.publicKeyRing.getAllCopayerIds());
|
|
} else {
|
|
//Partially complete wallet.
|
|
if (this.publicKeyRing.getAllCopayerIds().length > 1) {
|
|
this.network.setCopayers(this.publicKeyRing.getAllCopayerIds());
|
|
wasIncomplete = true;
|
|
}
|
|
}
|
|
|
|
log.debug('Wallet:' + self.id + ' Starting network.');
|
|
this.network.start(startOpts, function() {
|
|
//Partially complete wallet.
|
|
if (wasIncomplete) {
|
|
log.debug('Incomplete wallet opened:' + self.getName() + '. forced peer sync from 0');
|
|
self.sendWalletReady(null, 0);
|
|
}
|
|
self.emitAndKeepAlive(self.isComplete() ? 'ready' : 'waitingCopayers');
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieves the public keys of all the copayers in the ring
|
|
* @return {string[]} hex-encoded public keys of copayers
|
|
*/
|
|
Wallet.prototype.getRegisteredCopayerIds = function() {
|
|
var l = this.publicKeyRing.registeredCopayers();
|
|
var copayers = [];
|
|
for (var i = 0; i < l; i++) {
|
|
var cid = this.getCopayerId(i);
|
|
copayers.push(cid);
|
|
}
|
|
return copayers;
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieves the public keys of all the peers in the network
|
|
* @TODO: Isn't this deprecated? Now that we don't use peerjs
|
|
*
|
|
* @return {string[]} hex-encoded public keys of copayers
|
|
*/
|
|
Wallet.prototype.getRegisteredPeerIds = function() {
|
|
var l = this.publicKeyRing.registeredCopayers();
|
|
if (this.registeredPeerIds.length !== l) {
|
|
this.registeredPeerIds = [];
|
|
var copayers = this.getRegisteredCopayerIds();
|
|
for (var i = 0; i < l; i++) {
|
|
var cid = copayers[i];
|
|
var pid = this.network.peerFromCopayer(cid);
|
|
this.registeredPeerIds.push({
|
|
peerId: pid,
|
|
copayerId: cid,
|
|
nick: this.publicKeyRing.nicknameForCopayer(cid),
|
|
index: i,
|
|
});
|
|
}
|
|
}
|
|
return this.registeredPeerIds;
|
|
};
|
|
|
|
/**
|
|
* @TODO: Review design of this call
|
|
* @desc Send a keepalive to this wallet's {@link WalletLock} instance.
|
|
*
|
|
* @emits locked - in case the wallet is opened in another instance
|
|
*/
|
|
Wallet.prototype.keepAlive = function() {
|
|
var self = this;
|
|
|
|
|
|
// this.lock.keepAlive(function(err) {
|
|
// if (err) {
|
|
// log.debug(err);
|
|
// self.emitAndKeepAlive('locked', null, 'Wallet appears to be openned on other browser instance. Closing this one.');
|
|
// }
|
|
// });
|
|
};
|
|
|
|
|
|
|
|
Wallet.prototype.getId = function() {
|
|
return this.id;
|
|
};
|
|
|
|
/**
|
|
* @desc Serialize the wallet into a plain object.
|
|
* @return {Object}
|
|
*/
|
|
Wallet.prototype.toObj = function() {
|
|
var optsObj = this._optsToObj();
|
|
|
|
var walletObj = {
|
|
opts: optsObj,
|
|
settings: this.settings,
|
|
networkNonce: this.network.getHexNonce(), //yours
|
|
networkNonces: this.network.getHexNonces(), //copayers
|
|
publicKeyRing: this.publicKeyRing.toObj(),
|
|
txProposals: this.txProposals.toObj(),
|
|
privateKey: this.privateKey ? this.privateKey.toObj() : undefined,
|
|
addressBook: this.addressBook,
|
|
syncedTimestamp: this.syncedTimestamp || 0,
|
|
secretNumber: this.secretNumber,
|
|
};
|
|
|
|
return walletObj;
|
|
};
|
|
|
|
/**
|
|
* @desc: returns the sizes, by component, of a wallet, in bytes.
|
|
*
|
|
* @return {object} sizes by component name and 'total' for the total wallet size.
|
|
*/
|
|
Wallet.prototype.sizes = function() {
|
|
var obj = this.toObj();
|
|
var sizes = {},
|
|
total = 0;
|
|
_.each(obj, function(val, key) {
|
|
var s = JSON.stringify(val).length;
|
|
sizes[key] = s;
|
|
total += s;
|
|
});
|
|
sizes.total = total;
|
|
return sizes;
|
|
};
|
|
|
|
Wallet.fromUntrustedObj = function(obj, readOpts) {
|
|
obj = _.clone(obj);
|
|
var o = {};
|
|
_.each(Wallet.PERSISTED_PROPERTIES, function(p) {
|
|
o[p] = obj[p];
|
|
});
|
|
|
|
return Wallet.fromObj(o, readOpts);
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieve the wallet state from a trusted object
|
|
*
|
|
* @param {Object} o
|
|
* @param {Object[]} o.addressBook - Stores known associations of bitcoin addresses to names
|
|
* @param {Object} o.privateKey - Private key to be deserialized by {@link PrivateKey#fromObj}
|
|
* @param {string} o.networkName - 'livenet' or 'testnet'
|
|
* @param {Object} o.publicKeyRing - PublicKeyRing to be deserialized by {@link PublicKeyRing#fromObj}
|
|
* @param {number} o.syncedTimestamp - ts of the last synced message with insifht (in microseconds, as insight returns ts)
|
|
* @param {Object} o.txProposals - TxProposals to be deserialized by {@link TxProposals#fromObj}
|
|
* @param {string} o.nickname - user's nickname
|
|
*
|
|
* @param readOpts.network
|
|
* @param readOpts.blockchain
|
|
* @param readOpts.{string[]} skipFields - parameters to ignore when importing
|
|
*/
|
|
Wallet.fromObj = function(o, readOpts) {
|
|
|
|
preconditions.checkArgument(readOpts.networkOpts);
|
|
preconditions.checkArgument(readOpts.blockchainOpts);
|
|
|
|
var networkOpts = readOpts.networkOpts;
|
|
var blockchainOpts = readOpts.blockchainOpts;
|
|
var skipFields = readOpts.skipFields || [];
|
|
|
|
|
|
if (skipFields) {
|
|
_.each(skipFields, function(k) {
|
|
if (o[k]) {
|
|
delete o[k];
|
|
} else {
|
|
throw new Error('unknown field:' + k);
|
|
}
|
|
});
|
|
}
|
|
|
|
var networkName = Wallet.obtainNetworkName(o);
|
|
|
|
|
|
// TODO Why moving everything to opts. This needs refactoring.
|
|
//
|
|
// clone opts
|
|
|
|
if (!o.opts) {
|
|
return null;
|
|
}
|
|
|
|
var opts = JSON.parse(JSON.stringify(o.opts));
|
|
opts.addressBook = o.addressBook;
|
|
opts.settings = o.settings;
|
|
|
|
|
|
if (o.privateKey) {
|
|
opts.privateKey = PrivateKey.fromObj(o.privateKey);
|
|
} else {
|
|
opts.privateKey = new PrivateKey({
|
|
networkName: networkName
|
|
});
|
|
}
|
|
|
|
opts.secretNumber = o.secretNumber;
|
|
|
|
if (o.publicKeyRing) {
|
|
opts.publicKeyRing = PublicKeyRing.fromObj(o.publicKeyRing);
|
|
} else {
|
|
opts.publicKeyRing = new PublicKeyRing({
|
|
networkName: networkName,
|
|
requiredCopayers: opts.requiredCopayers,
|
|
totalCopayers: opts.totalCopayers,
|
|
});
|
|
opts.publicKeyRing.addCopayer(
|
|
opts.privateKey.deriveBIP45Branch().extendedPublicKeyString(),
|
|
opts.nickname
|
|
);
|
|
}
|
|
|
|
if (o.txProposals) {
|
|
opts.txProposals = TxProposals.fromObj(o.txProposals, Wallet.builderOpts);
|
|
} else {
|
|
opts.txProposals = new TxProposals({
|
|
networkName: networkName,
|
|
});
|
|
}
|
|
|
|
opts.syncedTimestamp = opts.publicKeyRing.isComplete() ? o.syncedTimestamp || 0 : 0;
|
|
opts.blockchainOpts = readOpts.blockchainOpts;
|
|
opts.networkOpts = readOpts.networkOpts;
|
|
|
|
return new Wallet(opts);
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc sends a message to peers
|
|
* @param {string[]} recipients - the pubkey of the recipients of the message. Null for sending to all peers.
|
|
* @param {Object} obj - the data to be sent to them.
|
|
* @param {String} obj.type - Type of the message to be send
|
|
*/
|
|
Wallet.prototype._sendToPeers = function(recipients, obj) {
|
|
if (!this.isShared()) return;
|
|
log.info('Wallet:' + this.getName() + ' ### Sending ' + obj.type);
|
|
log.debug('Sending:', recipients, obj);
|
|
|
|
this.network.send(recipients, obj);
|
|
};
|
|
|
|
/**
|
|
* @desc Send the set of TxProposals to peers
|
|
* @param {string[]} recipients - the pubkeys of the recipients
|
|
*/
|
|
Wallet.prototype.sendAllTxProposals = function(recipients, sinceTs) {
|
|
var ntxids = sinceTs ? this.txProposals.getNtxidsSince(sinceTs) : this.txProposals.getNtxids();
|
|
var self = this;
|
|
_.each(ntxids, function(ntxid, key) {
|
|
self.sendTxProposal(ntxid, recipients);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Send a TxProposal identified by transaction id to a set of recipients
|
|
* @param {string} ntxid - the transaction proposal id
|
|
* @param {string[]} [recipients] - the pubkeys of the recipients
|
|
*/
|
|
Wallet.prototype.sendTxProposal = function(ntxid, recipients) {
|
|
preconditions.checkArgument(ntxid);
|
|
var indexes = HDParams.serialize(this.publicKeyRing.indexes);
|
|
this._sendToPeers(recipients, {
|
|
type: 'txProposal',
|
|
txProposal: this.txProposals.get(ntxid).toObjTrim(),
|
|
walletId: this.id,
|
|
indexes: indexes,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Notifies other peers that a transaction proposal was seen
|
|
* @param {string} ntxid
|
|
*/
|
|
Wallet.prototype.sendSeen = function(ntxid) {
|
|
preconditions.checkArgument(ntxid);
|
|
this._sendToPeers(null, {
|
|
type: 'seen',
|
|
ntxid: ntxid,
|
|
walletId: this.id,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Notifies other peers that a transaction proposal was rejected
|
|
* @param {string} ntxid
|
|
*/
|
|
Wallet.prototype.sendReject = function(ntxid) {
|
|
preconditions.checkArgument(ntxid);
|
|
|
|
this._sendToPeers(null, {
|
|
type: 'reject',
|
|
ntxid: ntxid,
|
|
walletId: this.id,
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Send a signature for a TX Proposal
|
|
* @param {string} ntxid
|
|
*/
|
|
Wallet.prototype.sendSignature = function(ntxid) {
|
|
preconditions.checkArgument(ntxid);
|
|
|
|
var txp = this.txProposals.get(ntxid);
|
|
var signatures = txp.getMySignatures();
|
|
preconditions.checkState(signatures && signatures.length);
|
|
|
|
this._sendToPeers(null, {
|
|
type: 'signature',
|
|
ntxid: ntxid,
|
|
signatures: signatures,
|
|
walletId: this.id,
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Notify other peers that a wallet has been backed up and it's ready to be used
|
|
* @param {string[]} [recipients] - the pubkeys of the recipients
|
|
*/
|
|
Wallet.prototype.sendWalletReady = function(recipients, sinceTs) {
|
|
this._sendToPeers(recipients, {
|
|
type: 'walletReady',
|
|
walletId: this.id,
|
|
sinceTs: sinceTs
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Notify other peers of the walletId
|
|
* @TODO: Why is this needed? Can't everybody just calculate the walletId?
|
|
* @param {string[]} [recipients] - the pubkeys of the recipients
|
|
*/
|
|
Wallet.prototype.sendWalletId = function(recipients) {
|
|
this._sendToPeers(recipients, {
|
|
type: 'walletId',
|
|
walletId: this.id,
|
|
opts: this._optsToObj(),
|
|
networkName: this.getNetworkName(),
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Send the current PublicKeyRing to other recipients
|
|
* @param {string[]} [recipients] - the pubkeys of the recipients
|
|
*/
|
|
Wallet.prototype.sendPublicKeyRing = function(recipients) {
|
|
var publicKeyRingObj = this.publicKeyRing.toTrimmedObj();
|
|
|
|
this._sendToPeers(recipients, {
|
|
type: 'publicKeyRing',
|
|
publicKeyRing: publicKeyRingObj,
|
|
walletId: this.id,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Send the current indexes of our public key ring to other peers
|
|
* @param {string[]} recipients - the pubkeys of the recipients
|
|
*/
|
|
Wallet.prototype.sendIndexes = function(recipients) {
|
|
var indexes = HDParams.serialize(this.publicKeyRing.indexes);
|
|
this._sendToPeers(recipients, {
|
|
type: 'indexes',
|
|
indexes: indexes,
|
|
walletId: this.id,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* sendAddressBook
|
|
* @desc Send our addressBook to other recipients
|
|
*
|
|
* @param {string[]} recipients - the pubkeys of the recipients
|
|
* @param onlyKey
|
|
* @return {undefined}
|
|
*/
|
|
Wallet.prototype.sendAddressBook = function(recipients, onlyKey) {
|
|
var toSend = [],
|
|
myId = this.getMyCopayerId();
|
|
|
|
if (onlyKey && this.addressBook[onlyKey]) {
|
|
toSend = {};
|
|
toSend[onlyKey] = this.addressBook[onlyKey];
|
|
} else {
|
|
toSend = _.filter(this.addressBook, function(entry) {
|
|
return entry.copayerId === myId;
|
|
});
|
|
}
|
|
if (_.isEmpty(toSend)) return;
|
|
|
|
this._sendToPeers(recipients, {
|
|
type: 'addressbook',
|
|
addressBook: toSend,
|
|
walletId: this.id,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieve this wallet's name
|
|
* @return {string}
|
|
*/
|
|
Wallet.prototype.getName = function() {
|
|
return this.name || this.id;
|
|
};
|
|
|
|
/**
|
|
* @desc Generate a new address
|
|
* @param {boolean} isChange - whether to generate a change address or a receive address
|
|
* @return {string[]} a list of all the addresses generated so far for the wallet
|
|
*/
|
|
Wallet.prototype._doGenerateAddress = function(isChange) {
|
|
var addr = this.publicKeyRing.generateAddress(isChange, this.publicKey);
|
|
this.subscribeToAddresses();
|
|
this.emitAndKeepAlive('newAddresses');
|
|
return addr;
|
|
};
|
|
|
|
/**
|
|
* @desc Generate a new address
|
|
* @param {boolean} isChange - whether to generate a change address or a receive address
|
|
* @return {string[]} a list of all the addresses generated so far for the wallet
|
|
*/
|
|
Wallet.prototype.generateAddress = function(isChange) {
|
|
var addr = this._doGenerateAddress(isChange);
|
|
this.sendIndexes();
|
|
return addr;
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc get list of actions (see {@link getPendingTxProposals})
|
|
*/
|
|
Wallet.prototype._getActionList = function(txp) {
|
|
preconditions.checkArgument(txp);
|
|
|
|
var self = this;
|
|
var peers = [];
|
|
|
|
_.each(self.getRegisteredCopayerIds(), function(copayerId) {
|
|
var actions = {
|
|
rejected: txp.rejectedBy[copayerId],
|
|
sign: txp.signedBy[copayerId],
|
|
seen: txp.seenBy[copayerId],
|
|
create: (txp.creator === copayerId) ? txp.createdTs : null,
|
|
};
|
|
peers.push({
|
|
cId: copayerId,
|
|
actions: actions,
|
|
});
|
|
});
|
|
return peers;
|
|
};
|
|
|
|
/**
|
|
* @desc Retrieve Pendings Transaction proposals (see {@link TxProposals})
|
|
* @return {Object[]} each object returned represents a transaction proposal
|
|
*/
|
|
Wallet.prototype.getPendingTxProposalsCount = function() {
|
|
var self = this;
|
|
var txps = this.txProposals.txps;
|
|
var maxRejectCount = this.maxRejectCount();
|
|
var myId = this.getMyCopayerId();
|
|
var pending = 0,
|
|
pendingForUs = 0;
|
|
|
|
_.each(txps, function(inTxp, ntxid) {
|
|
if (!inTxp.isPending(maxRejectCount))
|
|
return;
|
|
// TODO: are the uxtos availables?
|
|
//
|
|
pending++;
|
|
|
|
if (!inTxp.signedBy[myId] && !inTxp.rejectedBy[myId])
|
|
pendingForUs++
|
|
});
|
|
|
|
|
|
return {
|
|
pending: pending,
|
|
pendingForUs: pendingForUs,
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Retrieve Pendings Transaction proposals (see {@link TxProposals})
|
|
* @return {Object[]} each object returned represents a transaction proposal
|
|
*/
|
|
Wallet.prototype.getPendingTxProposals = function() {
|
|
var self = this;
|
|
var ret = [];
|
|
var txps = this.txProposals.txps;
|
|
var maxRejectCount = this.maxRejectCount();
|
|
var satToUnit = 1 / this.settings.unitToSatoshi;
|
|
|
|
_.each(txps, function(inTxp, ntxid) {
|
|
if (!inTxp.isPending(maxRejectCount) || (inTxp.sentTs && inTxp.isFullySigned()))
|
|
return;
|
|
|
|
var txp = _.clone(inTxp);
|
|
txp.ntxid = ntxid;
|
|
|
|
var addresses = {};
|
|
var outs = JSON.parse(txp.builder.vanilla.outs);
|
|
outs.forEach(function(o) {
|
|
if (!addresses[o.address]) addresses[o.address] = 0;
|
|
addresses[o.address] += (o.amountSatStr || Math.round(o.amount * bitcore.util.COIN));
|
|
});
|
|
txp.outs = [];
|
|
_.each(addresses, function(value, address) {
|
|
txp.outs.push({
|
|
address: address,
|
|
value: value * satToUnit
|
|
});
|
|
});
|
|
// extra fields
|
|
txp.fee = txp.builder.feeSat * satToUnit;
|
|
txp.missingSignatures = txp.builder.build().countInputMissingSignatures(0);
|
|
txp.actionList = self._getActionList(txp);
|
|
ret.push(txp);
|
|
});
|
|
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* @desc Removes old transactions
|
|
* @param {boolean} deleteAll - if true, remove all the transactions
|
|
* @return {number} the number of deleted proposals
|
|
*/
|
|
Wallet.prototype.purgeTxProposals = function(deleteAll) {
|
|
var deleted = this.txProposals.purge(deleteAll, this.maxRejectCount());
|
|
if (deleted) {
|
|
this.emitAndKeepAlive('txProposalEvent', {
|
|
type: deleteAll ? Wallet.TX_PURGED : Wallet.TX_ALL_PURGED,
|
|
cId: this.getMyCopayerId(),
|
|
});
|
|
}
|
|
return deleted;
|
|
};
|
|
|
|
/**
|
|
* @desc Reject a proposal
|
|
* @param {string} ntxid the id of the transaction proposal to reject
|
|
* @emits txProposalsEvent
|
|
*/
|
|
Wallet.prototype.reject = function(ntxid, cb) {
|
|
var txp = this.txProposals.get(ntxid);
|
|
txp.setRejected(this.getMyCopayerId());
|
|
this.sendReject(ntxid);
|
|
|
|
this.emitAndKeepAlive('txProposalEvent', {
|
|
type: Wallet.TX_REJECTED,
|
|
cId: this.getMyCopayerId(),
|
|
});
|
|
|
|
// TODO this callback should be triggered by sendRejected, which is trully async
|
|
if (cb)
|
|
cb(null, Wallet.TX_REJECTED);
|
|
};
|
|
|
|
/**
|
|
* @callback signCallback
|
|
* @param {Error} error if any
|
|
* @param {number} Transaction ID or Transaction Proposal ID
|
|
* @param {status} Wallet.TX_* Status
|
|
*/
|
|
|
|
|
|
/**
|
|
* @desc Signs a transaction proposal
|
|
* @param {string} ntxid the id of the transaction proposal to sign
|
|
* @throws {Error} Could not sign proposal
|
|
* @throws {Error} Bad payment request
|
|
* @return {boolean} true if signing actually incremented the number of signatures
|
|
*/
|
|
Wallet.prototype.sign = function(ntxid) {
|
|
preconditions.checkState(!_.isUndefined(this.getMyCopayerId()));
|
|
|
|
var txp = this.txProposals.get(ntxid);
|
|
var keys = this.privateKey.getForPaths(txp.inputChainPaths);
|
|
var signaturesAdded = txp.sign(keys, this.getMyCopayerId());
|
|
if (!signaturesAdded)
|
|
return false;
|
|
|
|
return true;
|
|
};
|
|
|
|
Wallet.prototype.issueTxIfComplete = function(ntxid, cb) {
|
|
var txp = this.txProposals.get(ntxid);
|
|
var tx = txp.builder.build();
|
|
if (tx.isComplete()) {
|
|
this.issueTx(ntxid, cb);
|
|
} else {
|
|
return cb();
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
*
|
|
* @desc signs and send or broadcast a transaction.
|
|
* In m-n wallets,
|
|
* if m==1 it will broadcast it to the Bitcoin Network
|
|
* if n>1 it will send the proposal to the peers
|
|
*
|
|
* @param ntxid Transaction Proposal Id
|
|
* @param {signCallback} cb
|
|
* @throws {Error} Could not sign proposal
|
|
* @emits txProposalEvent
|
|
*/
|
|
Wallet.prototype.signAndSend = function(ntxid, cb) {
|
|
var self = this;
|
|
|
|
if (this.sign(ntxid)) {
|
|
|
|
this.sendSignature(ntxid);
|
|
this.issueTxIfComplete(ntxid, function(err, txid, status) {
|
|
|
|
// We did not broadcast the TX, only signed it.
|
|
if (!txid) {
|
|
self.emitAndKeepAlive('txProposalEvent', {
|
|
type: Wallet.TX_SIGNED,
|
|
cId: self.getMyCopayerId(),
|
|
});
|
|
}
|
|
|
|
return cb(err, txid, status ? status : Wallet.TX_SIGNED);
|
|
});
|
|
} else {
|
|
return cb(new Error('Could not sign the proposal'));
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Broadcast a tx proposal. In case of failure, check if the resulting
|
|
* transactions is already on the blockchain.
|
|
*
|
|
* @param ntxid
|
|
* @param cb
|
|
* @return {undefined}
|
|
*/
|
|
Wallet.prototype.broadcastToBitcoinNetwork = function(ntxid, cb) {
|
|
var self = this;
|
|
var txp = this.txProposals.get(ntxid);
|
|
|
|
var tx = txp.builder.build();
|
|
preconditions.checkState(tx.isComplete(), 'tx is not complete');
|
|
|
|
var txHex = tx.serialize().toString('hex');
|
|
|
|
log.info('Wallet:' + this.id + ' Broadcasting Transaction ntxid:' + ntxid);
|
|
log.debug('\tRaw transaction: ', txHex);
|
|
|
|
this.blockchain.broadcast(txHex, function(err, txid) {
|
|
if (err || !txid) {
|
|
log.debug('Wallet:' + self.getName() + ' Send failed:' + err);
|
|
|
|
self._checkIfTxIsSent(ntxid, function(err, txid) {
|
|
self.emitAndKeepAlive('balanceUpdated');
|
|
return cb(err, txid);
|
|
});
|
|
} else {
|
|
log.info('Wallet:' + self.getName() + ' broadcasted a TX! TXID:', txid);
|
|
return cb(null, txid);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Broadcasts a transaction to the blockchain, updates tx transactions
|
|
* sent status. If the tx proposal is a payment protocol request,it will also
|
|
* send the payment message to the server,and process the response.
|
|
*
|
|
* @param {string} ntxid - the transaction proposal id
|
|
* @param {string} txid - the transaction id on the blockchain
|
|
* @param {signCallback} cb
|
|
*/
|
|
Wallet.prototype.issueTx = function(ntxid, cb) {
|
|
var self = this;
|
|
|
|
self.broadcastToBitcoinNetwork(ntxid, function(err, txid) {
|
|
if (err) return cb(err);
|
|
preconditions.checkState(txid);
|
|
|
|
var txp = self.txProposals.get(ntxid);
|
|
txp.setSent(txid);
|
|
self.emitAndKeepAlive('txProposalEvent', {
|
|
type: Wallet.TX_BROADCASTED,
|
|
cId: self.getMyCopayerId(),
|
|
});
|
|
|
|
// PAYPRO: Payment message is optional, only if payment_url is set
|
|
// This is async. and will notify and update txp async.
|
|
if (txp.merchant && txp.merchant.pr.pd.payment_url) {
|
|
var data = self.createPayProPayment(txp);
|
|
self.sendPayProPayment(txp, data, function(err, data) {
|
|
if (err) return cb(err);
|
|
self.onPayProPaymentAck(ntxid, data);
|
|
});
|
|
}
|
|
return cb(null, txid, Wallet.TX_BROADCASTED);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @callback {fetchPaymentRequestCallback}
|
|
* @param {string=} err - an error, if any
|
|
* @param {Object} merchantData - object representing the payment request. Add described on BIP70 merchant_data
|
|
*/
|
|
|
|
/**
|
|
* @desc Creates a Payment Protocol transaction
|
|
* @param {Object|string} options - if it's a string, parse it as the url
|
|
* @param {string} options.url the url for the transaction
|
|
* @return {fetchPaymentRequestCallback} cb
|
|
*/
|
|
Wallet.prototype.fetchPaymentRequest = function(options, cb) {
|
|
preconditions.checkArgument(_.isObject(options));
|
|
preconditions.checkArgument(options.url);
|
|
preconditions.checkArgument(options.url.indexOf('http') == 0, 'Bad PayPro URL given:' + options.url);
|
|
var self = this;
|
|
|
|
if (self.cache.paymentRequests[options.url])
|
|
return cb(null, self.cache.paymentRequests[options.url]);
|
|
|
|
this.httpUtil.request({
|
|
method: 'GET',
|
|
url: options.url,
|
|
headers: {
|
|
'Accept': PayPro.PAYMENT_REQUEST_CONTENT_TYPE
|
|
},
|
|
responseType: 'arraybuffer'
|
|
})
|
|
.success(function(rawData) {
|
|
log.info('PayPro Request done successfully. Parsing response')
|
|
|
|
var merchantData, err;
|
|
try {
|
|
merchantData = self.parsePaymentRequest(options, rawData);
|
|
} catch (e) {
|
|
err = e
|
|
};
|
|
|
|
log.debug('PayPro request data', merchantData);
|
|
|
|
self.cache.paymentRequests[options.url] = merchantData;
|
|
return cb(err, merchantData);
|
|
})
|
|
.error(function(data, status) {
|
|
log.debug('Server did not return PaymentRequest.\nXHR status: ' + status);
|
|
return cb(new Error('Status: ' + status));
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* _addOutputsToMerchantData
|
|
*
|
|
* @desc parses merchant_data internal output representation and stores
|
|
* the result in merchant_data.outs = [{address: xx, amountSatStr: xx}],
|
|
* to be compatible with TransactionBuilder.
|
|
*`
|
|
* @param merchantData BIP70 merchant_data (from the payment request)
|
|
* @throws {Error} PayPro: Unsupported inputs
|
|
* @return {undefined}
|
|
*/
|
|
Wallet.prototype._addOutputsToMerchantData = function(merchantData) {
|
|
|
|
var total = bignum(0);
|
|
var outs = {};
|
|
|
|
_.each(merchantData.pr.pd.outputs, function(output) {
|
|
var amount = output.amount;
|
|
|
|
// big endian
|
|
var v = new Buffer(8);
|
|
v[0] = (amount.high >> 24) & 0xff;
|
|
v[1] = (amount.high >> 16) & 0xff;
|
|
v[2] = (amount.high >> 8) & 0xff;
|
|
v[3] = (amount.high >> 0) & 0xff;
|
|
v[4] = (amount.low >> 24) & 0xff;
|
|
v[5] = (amount.low >> 16) & 0xff;
|
|
v[6] = (amount.low >> 8) & 0xff;
|
|
v[7] = (amount.low >> 0) & 0xff;
|
|
|
|
var script = {
|
|
offset: output.script.offset,
|
|
limit: output.script.limit,
|
|
buffer: new Buffer(output.script.buffer, 'hex')
|
|
};
|
|
var s = script.buffer.slice(script.offset, script.limit);
|
|
var network = merchantData.pr.pd.network === 'main' ? 'livenet' : 'testnet';
|
|
var addr = bitcore.Address.fromScriptPubKey(new bitcore.Script(s), network);
|
|
|
|
var a = addr[0].toString();
|
|
outs[a] = bignum.fromBuffer(v, {
|
|
endian: 'big',
|
|
size: 1
|
|
}).add(outs[a] || bignum(0));
|
|
|
|
total = total.add(bignum.fromBuffer(v, {
|
|
endian: 'big',
|
|
size: 1
|
|
}));
|
|
});
|
|
|
|
// for now we only support PayPro with 1 output.
|
|
if (_.size(outs) !== 1)
|
|
throw new Error('PayPro: Unsupported outputs');
|
|
|
|
var out = _.pairs(outs)[0];
|
|
|
|
merchantData.outs = [{
|
|
address: out[0],
|
|
amountSatStr: out[1].toString(10),
|
|
}];
|
|
merchantData.total = total.toString(10);
|
|
|
|
// If user is granted the privilege of choosing
|
|
// their own amount, add it to the tx.
|
|
if (merchantData.total == "0" && options.amount) {
|
|
merchant.outs[0].amountSatStr = merchantData.total = options.amount;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @desc Analyzes a payment request and generate merchantData
|
|
* @param {Object} options
|
|
* @param {string} options.url url where the pay request was acquired
|
|
* @param {string} options.amount Only used if pay requesst allow user to set the amount
|
|
* @param {PayProRequest} rawData
|
|
*/
|
|
Wallet.prototype.parsePaymentRequest = function(options, rawData) {
|
|
var self = this;
|
|
|
|
var data = PayPro.PaymentRequest.decode(rawData);
|
|
var paypro = new PayPro();
|
|
var pr = paypro.makePaymentRequest(data);
|
|
var ver = pr.get('payment_details_version');
|
|
var pki_type = pr.get('pki_type');
|
|
var pki_data = pr.get('pki_data');
|
|
var details = pr.get('serialized_payment_details');
|
|
var sig = pr.get('signature');
|
|
|
|
var certs = PayPro.X509Certificates.decode(pki_data);
|
|
certs = certs.certificate;
|
|
|
|
// Verify Signature
|
|
var trust = pr.verify(true);
|
|
|
|
if (!trust.verified) {
|
|
throw new Error('Server sent a bad signature.');
|
|
}
|
|
|
|
details = PayPro.PaymentDetails.decode(details);
|
|
var pd = new PayPro();
|
|
pd = pd.makePaymentDetails(details);
|
|
|
|
var network = pd.get('network');
|
|
var outputs = pd.get('outputs');
|
|
var time = pd.get('time');
|
|
var expires = pd.get('expires');
|
|
var memo = pd.get('memo');
|
|
var payment_url = pd.get('payment_url');
|
|
var merchant_data = pd.get('merchant_data');
|
|
|
|
var total = bignum('0', 10).toString(10);
|
|
var merchantData = {
|
|
pr: {
|
|
payment_details_version: ver,
|
|
pki_type: pki_type,
|
|
pki_data: certs,
|
|
pd: {
|
|
network: network,
|
|
outputs: outputs.map(function(output) {
|
|
return {
|
|
amount: output.get('amount'),
|
|
script: {
|
|
offset: output.get('script').offset,
|
|
limit: output.get('script').limit,
|
|
// NOTE: For some reason output.script.buffer
|
|
// is only an ArrayBuffer
|
|
buffer: new Buffer(new Uint8Array(
|
|
output.get('script').buffer)).toString('hex')
|
|
}
|
|
};
|
|
}),
|
|
time: time,
|
|
expires: expires,
|
|
memo: memo || 'This server would like some BTC from you.',
|
|
payment_url: payment_url,
|
|
merchant_data: merchant_data ? merchant_data.toString('hex') : null
|
|
},
|
|
signature: sig.toString('hex'),
|
|
ca: trust.caName,
|
|
untrusted: !trust.caTrusted,
|
|
selfSigned: trust.selfSigned
|
|
},
|
|
expires: expires,
|
|
request_url: options.url,
|
|
domain: /^(?:https?)?:\/\/([^\/:]+).*$/.exec(options.url)[1],
|
|
total: total,
|
|
expirationDate: expires ? new Date(expires * 1000) : null,
|
|
};
|
|
|
|
this._addOutputsToMerchantData(merchantData, options.amount);
|
|
|
|
return merchantData;
|
|
};
|
|
|
|
/**
|
|
* _getPayProRefundOutputs
|
|
* Create refund outputs for a PayPro Payment Message
|
|
* Uses current transaction's change address.
|
|
*
|
|
* @param txp
|
|
* @return {undefined}
|
|
*/
|
|
Wallet.prototype._getPayProRefundOutputs = function(txp) {
|
|
var pkr = this.publicKeyRing;
|
|
var amount = +txp.merchant.total.toString(10);
|
|
|
|
var output = new PayPro.Output();
|
|
var opts = JSON.parse(txp.builder.vanilla.opts);
|
|
if (!opts.remainderOut) {
|
|
log.warn('no remainder set. Not setting refund in PayPro');
|
|
return;
|
|
}
|
|
var addrStr = opts.remainderOut.address;
|
|
var addr = new bitcore.Address(addrStr);
|
|
var script = bitcore.Script.createP2SH(addr.payload()).getBuffer();
|
|
log.debug('PayPro refund address set to:' + addrStr);
|
|
|
|
output.set('script', script);
|
|
output.set('amount', amount);
|
|
return [output];
|
|
};
|
|
|
|
|
|
/**
|
|
*
|
|
* @desc Creates a Payment Protocol Payment message for the given TX Proposal
|
|
* @param txp Transaction Proposal
|
|
* @param txHex
|
|
* @return {undefined}
|
|
*/
|
|
Wallet.prototype.createPayProPayment = function(txp) {
|
|
|
|
var tx = txp.builder.build();
|
|
var txBuf = tx.serialize();
|
|
|
|
|
|
// We send this to the serve after receiving a PaymentRequest
|
|
var pay = new PayPro();
|
|
pay = pay.makePayment();
|
|
|
|
var merchant_data = txp.merchant.pr.pd.merchant_data;
|
|
if (merchant_data) {
|
|
merchant_data = new Buffer(merchant_data, 'hex');
|
|
pay.set('merchant_data', merchant_data);
|
|
}
|
|
pay.set('transactions', [txBuf]);
|
|
|
|
var refund_outputs = this._getPayProRefundOutputs(txp);
|
|
if (refund_outputs)
|
|
pay.set('refund_to', refund_outputs);
|
|
|
|
// Unused for now
|
|
// options.memo = '';
|
|
// pay.set('memo', options.memo);
|
|
|
|
pay = pay.serialize();
|
|
var buf = new ArrayBuffer(pay.length);
|
|
var view = new Uint8Array(buf);
|
|
for (var i = 0; i < pay.length; i++) {
|
|
view[i] = pay[i];
|
|
}
|
|
|
|
return view;
|
|
};
|
|
|
|
|
|
/**
|
|
* onPayProPaymentAck
|
|
*
|
|
* @desc parse and process a Payment Protocol Payment Ack. Updates
|
|
* given TX Proposal with merchant's memo and send it to copayers
|
|
*
|
|
* @param ntxid ID of the Transaction Proposal
|
|
* @param rawData of the Payment Ack
|
|
* @emits paymentACK - (merchants's memo)
|
|
*/
|
|
Wallet.prototype.onPayProPaymentAck = function(ntxid, rawData) {
|
|
var data = PayPro.PaymentACK.decode(rawData);
|
|
var paypro = new PayPro();
|
|
var ack = paypro.makePaymentACK(data);
|
|
var memo = ack.get('memo');
|
|
log.debug('Payment Acknowledged!: %s', memo);
|
|
|
|
var txp = this.txProposals.get(ntxid);
|
|
txp.paymentAckMemo = memo;
|
|
this.sendTxProposal(ntxid);
|
|
this.emitAndKeepAlive('paymentACK', memo);
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Send a payment transaction to a merchant, complying with BIP70
|
|
* on Acknoledge, updates the TX Proposal with server's memo and send it
|
|
* to peers
|
|
*
|
|
* @param {string} ntxid - the transaction proposal ID for with the
|
|
*
|
|
*/
|
|
Wallet.prototype.sendPayProPayment = function(txp, data, cb) {
|
|
var self = this;
|
|
|
|
log.debug('Sending Payment Message to merchant server');
|
|
var postInfo = {
|
|
method: 'POST',
|
|
url: txp.merchant.pr.pd.payment_url,
|
|
headers: {
|
|
// BIP-71
|
|
'Accept': PayPro.PAYMENT_ACK_CONTENT_TYPE,
|
|
'Content-Type': PayPro.PAYMENT_CONTENT_TYPE
|
|
// XHR does not allow these:
|
|
// 'Content-Length': (pay.byteLength || pay.length) + '',
|
|
// 'Content-Transfer-Encoding': 'binary'
|
|
},
|
|
// Technically how this should be done via XHR (used to
|
|
// be the ArrayBuffer, now you send the View instead).
|
|
data: data,
|
|
responseType: 'arraybuffer'
|
|
};
|
|
|
|
this.httpUtil.request(postInfo)
|
|
.success(function(rawData) {
|
|
return cb(null, rawData);
|
|
})
|
|
.error(function(data, status) {
|
|
log.error('Sending payment notification: XHR status: ' + status);
|
|
return cb(new Error(status));
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Mark that a user has seen a given TxProposal
|
|
* @return {boolean} true if the internal state has changed
|
|
*/
|
|
Wallet.prototype.addSeenToTxProposals = function() {
|
|
var ret = false;
|
|
var myId = this.getMyCopayerId();
|
|
|
|
for (var k in this.txProposals.txps) {
|
|
var txp = this.txProposals.txps[k];
|
|
if (!txp.seenBy[myId]) {
|
|
|
|
txp.seenBy[myId] = Date.now();
|
|
ret = true;
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* @desc Alias for {@link PublicKeyRing#getAddresses}
|
|
* @return {Buffer[]}
|
|
*/
|
|
Wallet.prototype.getAddresses = function() {
|
|
return this.publicKeyRing.getAddresses();
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc gets the list of addresses, ordered for the caller:
|
|
* 1) himselfs first
|
|
* 2) receive address first
|
|
* 3) last created first
|
|
*/
|
|
Wallet.prototype.getAddressesOrdered = function() {
|
|
return this.publicKeyRing.getAddressesOrdered(this.publicKey);
|
|
};
|
|
|
|
/**
|
|
* @desc Alias for {@link PublicKeyRing#getAddresses}
|
|
* @return {Buffer[]}
|
|
*/
|
|
Wallet.prototype.getReceiveAddresses = function() {
|
|
return this.publicKeyRing.getReceiveAddresses();
|
|
};
|
|
|
|
|
|
Wallet.prototype.subscribeToAddresses = function() {
|
|
if (!this.publicKeyRing.isComplete()) return;
|
|
|
|
var addresses = this.getAddresses();
|
|
this.blockchain.subscribe(addresses);
|
|
log.debug('Wallet:' + this.getName() + ' Subscribed to:' + addresses.length + ' addresses');
|
|
};
|
|
|
|
/**
|
|
* @desc Returns true if a given address was generated by deriving our master public key
|
|
* @return {boolean}
|
|
*/
|
|
Wallet.prototype.addressIsOwn = function(addrStr) {
|
|
return this.publicKeyRing.addressIsOwn(addrStr);
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Returns true if a given address is a change address (remainder)
|
|
* @param addrStr
|
|
* @return {boolean}
|
|
*/
|
|
Wallet.prototype.addressIsChange = function(addrStr) {
|
|
return this.publicKeyRing.addressIsChange(addrStr);
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* Estimate a tx fee in satoshis given its input count
|
|
* (only used when spending all wallet funds)
|
|
*/
|
|
Wallet.estimatedFee = function(unspentCount) {
|
|
preconditions.checkArgument(_.isNumber(unspentCount));
|
|
var estimatedSizeKb = Math.ceil((500 + unspentCount * 250) / 1024);
|
|
return parseInt(estimatedSizeKb * bitcore.TransactionBuilder.FEE_PER_1000B_SAT);
|
|
};
|
|
|
|
|
|
/**
|
|
* @callback {getBalanceCallback}
|
|
* @param {string=} err - an error, if any
|
|
* @param {number} balance - total number of satoshis for all addresses
|
|
* @param {Object} balanceByAddr - maps string addresses to satoshis
|
|
* @param {number} safeBalance - total number of satoshis in UTXOs that are not part of any TxProposal
|
|
* @param {number} safeUnspentCount - total number of safe unspent Outputs that make this balance.
|
|
*/
|
|
|
|
/**
|
|
* computeBalance
|
|
*
|
|
* @param safeUnspent
|
|
* @param unspent
|
|
* @param {getBalanceCallback} cb
|
|
*/
|
|
Wallet.prototype.computeBalance = function(safeUnspent, unspent, cb) {
|
|
var balance = 0;
|
|
var safeBalance = 0;
|
|
var balanceByAddr = {};
|
|
var COIN = coinUtil.COIN;
|
|
|
|
for (var i = 0; i < unspent.length; i++) {
|
|
var u = unspent[i];
|
|
var amt = u.amount * COIN;
|
|
balance += amt;
|
|
balanceByAddr[u.address] = (balanceByAddr[u.address] || 0) + amt;
|
|
}
|
|
|
|
// we multiply and divide by BIT to avoid rounding errors when adding
|
|
for (var a in balanceByAddr) {
|
|
balanceByAddr[a] = parseInt(balanceByAddr[a].toFixed(0), 10);
|
|
}
|
|
|
|
balance = parseInt(balance.toFixed(0), 10);
|
|
|
|
var safeUnspentCount = safeUnspent.length;
|
|
|
|
for (var i = 0; i < safeUnspentCount; i++) {
|
|
var u = safeUnspent[i];
|
|
var amt = u.amount * COIN;
|
|
safeBalance += amt;
|
|
}
|
|
|
|
safeBalance = parseInt(safeBalance.toFixed(0), 10);
|
|
return cb(null, balance, balanceByAddr, safeBalance, safeUnspentCount);
|
|
};
|
|
|
|
/**
|
|
* @desc Returns the balances for all addresses in Satoshis
|
|
* @param {getBalanceCallback} cb
|
|
*/
|
|
Wallet.prototype.getBalance = function(cb) {
|
|
var self = this;
|
|
|
|
this.getUnspent(function(err, safeUnspent, unspent) {
|
|
if (err) {
|
|
return cb(err);
|
|
}
|
|
self.computeBalance(safeUnspent, unspent, cb);
|
|
});
|
|
};
|
|
|
|
|
|
// See
|
|
// https://github.com/bitpay/copay/issues/1056
|
|
//
|
|
// maxRejectCount should equal requiredCopayers
|
|
// strictly.
|
|
/**
|
|
* @desc Get the number of copayers that need to reject a transaction so it can't be signed
|
|
* @return {number}
|
|
*/
|
|
Wallet.prototype.maxRejectCount = function() {
|
|
return this.totalCopayers - this.requiredCopayers;
|
|
};
|
|
|
|
|
|
Wallet.prototype.clearUnspentCache = function() {
|
|
log.debug('Cleaning unspent cache');
|
|
this.cache.unspent = null;
|
|
};
|
|
|
|
/**
|
|
* @callback getUnspentCallback
|
|
* @desc Get a list of unspent transaction outputs
|
|
* @param {string} error
|
|
* @param {Object[]} safeUnspendList
|
|
* @param {Object[]} unspentList
|
|
* @param {getUnspentCallback} cb
|
|
*/
|
|
|
|
Wallet.prototype.getUnspent = function(cb) {
|
|
var self = this;
|
|
|
|
|
|
if (self.cache.unspent != null) {
|
|
log.debug('Wallet ' + this.getName() + ': Get unspent cache hit');
|
|
return self.computeUnspent(self.cache.unspent, cb);
|
|
}
|
|
|
|
var addresses = this.getAddresses();
|
|
log.debug('Wallet ' + this.getName() + ': Getting unspents from ' + addresses.length + ' addresses');
|
|
this.blockchain.getUnspent(addresses, function(err, unspentList) {
|
|
if (err)
|
|
return cb(err);
|
|
|
|
self.cache.unspent = unspentList;
|
|
return self.computeUnspent(self.cache.unspent, cb);
|
|
});
|
|
};
|
|
|
|
/**
|
|
*
|
|
* @callback getUnspentCallback
|
|
* @param {string} error
|
|
* @param {Object[]} safeUnspendList
|
|
* @param {Object[]} unspentList
|
|
*/
|
|
/**
|
|
* computeUnspent
|
|
*
|
|
* @param unspentList List of unprocessed utxos.
|
|
* @param {getUnspentCallback} cb
|
|
*/
|
|
Wallet.prototype.computeUnspent = function(unspentList, cb) {
|
|
var self = this;
|
|
|
|
var safeUnspendList = [];
|
|
var uu = this.txProposals.getUsedUnspent(this.maxRejectCount());
|
|
|
|
_.each(unspentList, function(u) {
|
|
var name = u.txid + ',' + u.vout;
|
|
if (!uu[name] && (self.spendUnconfirmed || u.confirmations >= 1))
|
|
safeUnspendList.push(u);
|
|
});
|
|
|
|
return cb(null, safeUnspendList, unspentList);
|
|
};
|
|
|
|
/**
|
|
* spend
|
|
*
|
|
* @desc Spends coins from the wallet
|
|
* Create a Transaction Proposal and send it
|
|
* to copayers (broadcast it in a 1-x wallet)
|
|
* @param {object} opts
|
|
* @param {string} opts.toAddress address to send coins
|
|
* @param {number} opts.amountSat amount in satoshis
|
|
* @param {string} opts.comment optional transaction proposal private comment (for copayers)
|
|
* @param {string} opts.url optional (payment protocol URL). If this is given, toAddress will be ignored, and amount could be ignored or not, depending on the payment protocol request.
|
|
* @param {signCallback} cb
|
|
*/
|
|
Wallet.prototype.spend = function(opts, cb) {
|
|
preconditions.checkArgument(_.isObject(opts));
|
|
log.debug('create Options', opts);
|
|
|
|
var self = this;
|
|
var toAddress = opts.toAddress;
|
|
var amountSat = opts.amountSat;
|
|
var comment = opts.comment;
|
|
var merchantData = opts.merchantData;
|
|
|
|
|
|
// PayPro? With given merchant data
|
|
if (opts.merchantData && !opts.toAddress) {
|
|
if (!merchantData.outs[0].address)
|
|
return cb(new Error('BADPAYPRO'));
|
|
|
|
opts.toAddress = merchantData.outs[0].address;
|
|
opts.amountSat = parseInt(merchantData.outs[0].amountSatStr);
|
|
return self.spend(opts, cb);
|
|
}
|
|
|
|
// PayPro? Fetch payment data and recurse
|
|
var url = opts.url;
|
|
if (url && !opts.merchantData) {
|
|
return self.fetchPaymentRequest({
|
|
url: url,
|
|
memo: comment,
|
|
amount: amountSat,
|
|
}, function(err, merchantData) {
|
|
if (err) return cb(err);
|
|
opts.merchantData = merchantData;
|
|
return self.spend(opts, cb);
|
|
});
|
|
}
|
|
|
|
preconditions.checkArgument(amountSat, 'no amount');
|
|
preconditions.checkArgument(toAddress, 'no address');
|
|
|
|
this.getUnspent(function(err, safeUnspent) {
|
|
if (err) {
|
|
log.info(err);
|
|
return cb(new Error('Spend: Could not get list of UTXOs'));
|
|
}
|
|
|
|
var ntxid, txp;
|
|
try {
|
|
txp = self._createTxProposal(toAddress,
|
|
amountSat, comment, safeUnspent, opts.builderOpts);
|
|
|
|
if (opts.merchantData) {
|
|
txp.addMerchantData(opts.merchantData);
|
|
}
|
|
} catch (e) {
|
|
log.warn(e);
|
|
return cb(e);
|
|
}
|
|
|
|
var ntxid = self.txProposals.add(txp);
|
|
if (!ntxid) {
|
|
return cb(new Error('Error creating the transaction'));
|
|
}
|
|
|
|
log.debug('TXP Added: ', ntxid);
|
|
// Needs only one signature? Broadcast it!
|
|
if (!self.requiresMultipleSignatures())
|
|
return self.issueTx(ntxid, cb);
|
|
|
|
self.sendTxProposal(ntxid);
|
|
self.emitAndKeepAlive('txProposalEvent', {
|
|
type: Wallet.TX_PROPOSAL_SENT,
|
|
cId: self.getMyCopayerId(),
|
|
});
|
|
return cb(null, ntxid, Wallet.TX_PROPOSAL_SENT);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* _getAddress
|
|
* Returns an Address object from an address string or a BIP21 URL.*
|
|
* @param address
|
|
* @return { bitcore.Address }
|
|
*/
|
|
|
|
Wallet._getAddress = function(address) {
|
|
if (/ ^ bitcoin: /g.test(address)) {
|
|
return new BIP21(address).address;
|
|
}
|
|
return new Address(address);
|
|
};
|
|
|
|
|
|
Wallet.prototype._getBuilder = function(opts) {
|
|
opts = opts || {};
|
|
|
|
if (!opts.remainderOut) {
|
|
opts.remainderOut = {
|
|
address: this._doGenerateAddress(true).toString()
|
|
};
|
|
}
|
|
if (_.isUndefined(opts.spendUnconfirmed)) {
|
|
opts.spendUnconfirmed = this.spendUnconfirmed;
|
|
}
|
|
|
|
for (var k in Wallet.builderOpts) {
|
|
opts[k] = Wallet.builderOpts[k];
|
|
}
|
|
|
|
return new Builder(opts);
|
|
};
|
|
|
|
|
|
/*
|
|
* _createTxProposal
|
|
* Creates a transaction proposal and run many sanity checks
|
|
*
|
|
* @param toAddress
|
|
* @param amountSat
|
|
* @param comment (optional)
|
|
* @param utxos
|
|
* @param builderOpts bitcore.TransactionBuilder options(like spendUnconfirmed)
|
|
* @return {TxProposal} The newly created transaction proposal.*
|
|
* Throws errors on unexpected inputs.
|
|
*/
|
|
|
|
Wallet.prototype._createTxProposal = function(toAddress, amountSat, comment, utxos, builderOpts) {
|
|
preconditions.checkArgument(toAddress);
|
|
preconditions.checkArgument(amountSat);
|
|
preconditions.checkArgument(_.isArray(utxos));
|
|
preconditions.checkArgument(!comment || comment.length <= 100, 'Comment too long');
|
|
|
|
var pkr = this.publicKeyRing;
|
|
var priv = this.privateKey;
|
|
var addr = Wallet._getAddress(toAddress);
|
|
|
|
preconditions.checkState(addr && addr.data && addr.isValid(), 'Bad address:' + addr.toString());
|
|
|
|
preconditions.checkArgument(addr.network().name === this.getNetworkName(), 'networkname mismatch');
|
|
preconditions.checkState(pkr.isComplete(), 'pubkey ring incomplete');
|
|
preconditions.checkState(priv, 'no private key');
|
|
|
|
var b = this._getBuilder(builderOpts);
|
|
|
|
b.setUnspent(utxos)
|
|
.setOutputs([{
|
|
address: addr.data,
|
|
amountSatStr: amountSat,
|
|
}]);
|
|
|
|
var selectedUtxos = b.getSelectedUnspent();
|
|
|
|
if (selectedUtxos.length > TX_MAX_INS)
|
|
throw new Error('BIG: Resulting TX is too big:' + selectedUtxos.length +
|
|
' inputs. Aborting');
|
|
|
|
|
|
var inputChainPaths = selectedUtxos.map(function(utxo) {
|
|
return pkr.pathForAddress(utxo.address);
|
|
});
|
|
b.setHashToScriptMap(pkr.getRedeemScriptMap(inputChainPaths));
|
|
|
|
|
|
var tx = b.build();
|
|
var myId = this.getMyCopayerId();
|
|
var keys = priv.getForPaths(inputChainPaths);
|
|
return new TxProposal({
|
|
inputChainPaths: inputChainPaths,
|
|
comment: comment,
|
|
builder: b,
|
|
creator: myId,
|
|
signWith: keys,
|
|
});
|
|
|
|
return txp;
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Updates all the indexes for the current publicKeyRing. This scans
|
|
* the blockchain looking for transactions on derived addresses.
|
|
*
|
|
* @param {Function} callback - called when all indexes have been updated. Receives an error, if any, as first argument
|
|
*/
|
|
Wallet.prototype.updateIndexes = function(callback) {
|
|
var self = this;
|
|
if (!self.isComplete())
|
|
return callback();
|
|
log.debug('Wallet:' + this.id + ' Updating indexes...');
|
|
var tasks = this.publicKeyRing.indexes.map(function(index) {
|
|
return function(callback) {
|
|
self.updateIndex(index, callback);
|
|
};
|
|
});
|
|
|
|
async.parallel(tasks, function(err) {
|
|
if (err) callback(err);
|
|
log.debug('Wallet:' + self.id + ' Indexes updated');
|
|
self.clearUnspentCache();
|
|
self.subscribeToAddresses();
|
|
self.emitAndKeepAlive('newAddresses');
|
|
callback();
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Updates the lastly used index
|
|
* @param {Object} index - an index, as used by {@link PublicKeyRing}
|
|
* @param {Function} callback - called with no arguments when done updating
|
|
*/
|
|
Wallet.prototype.updateIndex = function(index, callback) {
|
|
var self = this;
|
|
var SCANN_WINDOW = 20;
|
|
self.indexDiscovery(index.changeIndex, true, index.copayerIndex, SCANN_WINDOW, function(err, changeIndex) {
|
|
if (err) return callback(err);
|
|
if (changeIndex != -1)
|
|
index.changeIndex = changeIndex + 1;
|
|
|
|
self.indexDiscovery(index.receiveIndex, false, index.copayerIndex, SCANN_WINDOW, function(err, receiveIndex) {
|
|
if (err) return callback(err);
|
|
if (receiveIndex != -1)
|
|
index.receiveIndex = receiveIndex + 1;
|
|
callback();
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @desc Derive addresses using the given parameters
|
|
*
|
|
* @param {number} index - the index to start with
|
|
* @param {number} amount - number of addresses to derive
|
|
* @param {boolean} isChange - derive change addresses or receive addresses
|
|
* @param {number} copayerIndex - the index of the copayer for whom to derive addresses
|
|
* @return {string[]} the result of calling {@link PublicKeyRing#getAddress}
|
|
*/
|
|
Wallet.prototype.deriveAddresses = function(index, amount, isChange, copayerIndex) {
|
|
preconditions.checkArgument(amount);
|
|
preconditions.shouldBeDefined(copayerIndex);
|
|
|
|
var ret = new Array(amount);
|
|
for (var i = 0; i < amount; i++) {
|
|
// TODO
|
|
ret[i] = this.publicKeyRing._getAddress(index + i, isChange, copayerIndex).toString();
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* @callback {indexDiscoveryCallback}
|
|
* @param {?} err
|
|
* @param {number} lastActivityIndex
|
|
*/
|
|
/**
|
|
* @desc Scans the block chain for the last index with activity for a copayer
|
|
*
|
|
* This function scans the publicKeyRing branch starting at index @start and reports the index with last activity,
|
|
* using a scan window of @gap. The argument @change defines the branch to scan: internal or external.
|
|
* Returns -1 if no activity is found in range.
|
|
* @param {number} start - the number for which to start scanning
|
|
* @param {boolean} change - whether to search for in the change branch or the receive branch
|
|
* @param {number} copayerIndex - the index of the copayer
|
|
* @param {number} gap - the maximum number of addresses to scan after the last active address
|
|
* @param {indexDiscoveryCallback} cb - callback
|
|
* @return {number} -1 if there's no activity in the range provided
|
|
*/
|
|
Wallet.prototype.indexDiscovery = function(start, change, copayerIndex, gap, cb) {
|
|
preconditions.shouldBeDefined(copayerIndex);
|
|
preconditions.checkArgument(gap);
|
|
var scanIndex = start;
|
|
var lastActive = -1;
|
|
var hasActivity = false;
|
|
|
|
var self = this;
|
|
async.doWhilst(
|
|
function _do(next) {
|
|
// Optimize window to minimize the derivations.
|
|
var scanWindow = (lastActive == -1) ? gap : gap - (scanIndex - lastActive) + 1;
|
|
var addresses = self.deriveAddresses(scanIndex, scanWindow, change, copayerIndex);
|
|
self.blockchain.getActivity(addresses, function(err, actives) {
|
|
if (err) throw err;
|
|
|
|
// Check for new activities in the newlly scanned addresses
|
|
var recentActive = actives.reduce(function(r, e, i) {
|
|
return e ? scanIndex + i : r;
|
|
}, lastActive);
|
|
hasActivity = lastActive != recentActive;
|
|
lastActive = recentActive;
|
|
scanIndex += scanWindow;
|
|
next();
|
|
});
|
|
},
|
|
function _while() {
|
|
return hasActivity;
|
|
},
|
|
function _finally(err) {
|
|
if (err) return cb(err);
|
|
cb(null, lastActive);
|
|
}
|
|
);
|
|
};
|
|
|
|
/**
|
|
* @desc Closes the wallet and disconnects all services
|
|
*/
|
|
Wallet.prototype.close = function(cb) {
|
|
log.debug('## CLOSING Wallet: ' + this.id);
|
|
this.network.removeAllListeners();
|
|
this.network.cleanUp();
|
|
this.blockchain.removeAllListeners();
|
|
this.blockchain.destroy();
|
|
|
|
// TODO
|
|
// this.lock.release(function() {
|
|
if (cb) return cb();
|
|
// });
|
|
};
|
|
|
|
/**
|
|
* @desc Returns the name of the network ('livenet' or 'testnet')
|
|
* @return {string}
|
|
*/
|
|
Wallet.prototype.getNetwork = function() {
|
|
return this.network;
|
|
};
|
|
|
|
/**
|
|
* @desc Throws an error if an address already exists in the address book
|
|
* @private
|
|
*/
|
|
Wallet.prototype._checkAddressBook = function(key) {
|
|
if (this.addressBook[key] && this.addressBook[key].copayerId != -1) {
|
|
throw new Error('This address already exists in your Address Book');
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @desc Add an entry to the address book
|
|
*
|
|
* @param {string} key - the address to be added
|
|
* @param {string} label - a name for the address
|
|
*/
|
|
Wallet.prototype.setAddressBook = function(key, label) {
|
|
this._checkAddressBook(key);
|
|
var copayerId = this.getMyCopayerId();
|
|
var ts = Date.now();
|
|
var newEntry = {
|
|
hidden: false,
|
|
createdTs: ts,
|
|
copayerId: copayerId,
|
|
label: label,
|
|
};
|
|
this.addressBook[key] = newEntry;
|
|
this.sendAddressBook(null, key);
|
|
this.emitAndKeepAlive('addressBookUpdated');
|
|
};
|
|
|
|
/**
|
|
* @desc Hides or unhides an address book entry
|
|
* @param {string} key - the address in the addressbook
|
|
*/
|
|
Wallet.prototype.toggleAddressBookEntry = function(key) {
|
|
if (!key) throw new Error('Key is required');
|
|
this.addressBook[key].hidden = !this.addressBook[key].hidden;
|
|
this.emitAndKeepAlive('addressBookUpdated', true);
|
|
};
|
|
|
|
/**
|
|
* @desc Returns true if there are more than one cosigners
|
|
* @return {boolean}
|
|
*/
|
|
Wallet.prototype.isShared = function() {
|
|
return this.totalCopayers > 1;
|
|
};
|
|
|
|
/**
|
|
* @desc Returns true if more than one signature is required
|
|
* @return {boolean}
|
|
*/
|
|
Wallet.prototype.requiresMultipleSignatures = function() {
|
|
return this.requiredCopayers > 1;
|
|
};
|
|
|
|
/**
|
|
* @desc Returns true if the keyring is complete
|
|
* @return {boolean}
|
|
*/
|
|
Wallet.prototype.isComplete = function() {
|
|
return this.publicKeyRing.isComplete();
|
|
};
|
|
|
|
|
|
/**
|
|
* @desc Sets the version of this wallet object
|
|
*
|
|
* @param {string} version - the new version for the wallet
|
|
*/
|
|
Wallet.prototype.setVersion = function(version) {
|
|
this.version = version;
|
|
if (this.opts) {
|
|
this.opts.version = version;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @desc Return a list of past transactions
|
|
*
|
|
* @param {number} opts.currentPage - the desired page in the dataset
|
|
* @param {number} opts.itemsPerPage - number of items per page
|
|
* @return {Object} the list of transactions
|
|
*/
|
|
Wallet.prototype.getTransactionHistory = function(opts, cb) {
|
|
var self = this;
|
|
|
|
if (_.isFunction(opts)) {
|
|
cb = opts;
|
|
opts = {};
|
|
}
|
|
opts = opts || {};
|
|
|
|
var addresses = self.getAddresses();
|
|
var proposals = self.txProposals.txps;
|
|
var satToUnit = 1 / self.settings.unitToSatoshi;
|
|
|
|
var indexedProposals = _.indexBy(proposals, 'sentTxid');
|
|
|
|
|
|
function extractInsOuts(tx) {
|
|
// Inputs
|
|
var inputs = _.map(tx.vin, function(item) {
|
|
return {
|
|
type: 'in',
|
|
address: item.addr,
|
|
isMine: self.addressIsOwn(item.addr),
|
|
isChange: self.addressIsChange(item.addr),
|
|
amountSat: item.valueSat,
|
|
}
|
|
});
|
|
var outputs = _.map(tx.vout, function(item) {
|
|
var itemAddr;
|
|
// If classic multisig, ignore
|
|
if (item.scriptPubKey && item.scriptPubKey.addresses.length == 1) {
|
|
itemAddr = item.scriptPubKey.addresses[0];
|
|
}
|
|
|
|
return {
|
|
type: 'out',
|
|
address: itemAddr,
|
|
isMine: self.addressIsOwn(itemAddr),
|
|
isChange: self.addressIsChange(itemAddr),
|
|
label: self.addressBook[itemAddr] ? self.addressBook[itemAddr].label : undefined,
|
|
amountSat: parseInt((item.value * bitcore.util.COIN).toFixed(0)),
|
|
}
|
|
});
|
|
|
|
return inputs.concat(outputs);
|
|
};
|
|
|
|
function sum(items, filter) {
|
|
return _.reduce(_.where(items, filter),
|
|
function(memo, item) {
|
|
return memo + item.amountSat;
|
|
}, 0);
|
|
};
|
|
|
|
function decorateTx(tx) {
|
|
var items = extractInsOuts(tx);
|
|
|
|
var amountIn = sum(items, {
|
|
type: 'in',
|
|
isMine: true
|
|
});
|
|
|
|
var amountOut = sum(items, {
|
|
type: 'out',
|
|
isMine: true,
|
|
isChange: false,
|
|
});
|
|
|
|
var amountOutChange = sum(items, {
|
|
type: 'out',
|
|
isMine: true,
|
|
isChange: true,
|
|
});
|
|
|
|
var fees = parseInt((tx.fees * bitcore.util.COIN).toFixed(0));
|
|
var amount;
|
|
|
|
|
|
if (amountIn == (amountOut + amountOutChange + (amountIn > 0 ? fees : 0))) {
|
|
tx.action = 'moved';
|
|
amount = amountOut;
|
|
} else {
|
|
amount = amountIn - amountOut - amountOutChange - (amountIn > 0 ? fees : 0);
|
|
tx.action = amount > 0 ? 'sent' : 'received';
|
|
}
|
|
|
|
if (tx.action == 'sent' || tx.action == 'moved') {
|
|
var firstOut = _.findWhere(items, {
|
|
type: 'out'
|
|
});
|
|
if (firstOut) {
|
|
tx.labelTo = firstOut.label;
|
|
tx.addressTo = firstOut.address;
|
|
}
|
|
};
|
|
|
|
tx.amountSat = Math.abs(amount);
|
|
tx.amount = tx.amountSat * satToUnit;
|
|
tx.minedTs = !_.isNaN(tx.time) ? tx.time * 1000 : undefined;
|
|
|
|
var proposal = indexedProposals[tx.txid];
|
|
if (proposal) {
|
|
tx.comment = proposal.comment;
|
|
tx.sentTs = proposal.sentTs;
|
|
tx.merchant = proposal.merchant;
|
|
tx.peerActions = proposal.peerActions;
|
|
tx.paymentAckMemo = proposal.paymentAckMemo;
|
|
tx.actionList = self._getActionList(proposal);
|
|
}
|
|
};
|
|
|
|
function paginate(res, currentPage, itemsPerPage) {
|
|
if (!res) {
|
|
res = {
|
|
totalItems: 0,
|
|
items: [],
|
|
};
|
|
};
|
|
|
|
var r = {
|
|
itemsPerPage: itemsPerPage || res.totalItems,
|
|
currentPage: currentPage || 1,
|
|
nbItems: res.totalItems,
|
|
items: res.items,
|
|
};
|
|
r.nbPages = r.itemsPerPage != 0 ? Math.ceil(r.nbItems / r.itemsPerPage) : 1;
|
|
return r;
|
|
};
|
|
|
|
if (addresses.length > 0) {
|
|
var from = (opts.currentPage - 1) * opts.itemsPerPage;
|
|
var to = opts.currentPage * opts.itemsPerPage;
|
|
if (!_.isNumber(from) || _.isNaN(from)) from = 0;
|
|
if (!_.isNumber(to) || _.isNaN(to)) to = null;
|
|
|
|
self.blockchain.getTransactions(addresses, from, to, function(err, res) {
|
|
if (err) return cb(err);
|
|
|
|
_.each(res.items, function(tx) {
|
|
if (tx) {
|
|
decorateTx(tx);
|
|
}
|
|
});
|
|
|
|
return cb(null, paginate(res, opts.currentPage, opts.itemsPerPage));
|
|
});
|
|
} else {
|
|
return cb(null, paginate(null, opts.currentPage, opts.itemsPerPage));
|
|
}
|
|
};
|
|
|
|
Wallet.prototype.exportEncrypted = function(password, opts) {
|
|
opts = opts || {};
|
|
var crypto = opts.cryptoUtil || cryptoUtil;
|
|
return crypto.encrypt(password, this.toObj());
|
|
};
|
|
|
|
module.exports = Wallet;
|