909 lines
22 KiB
JavaScript
909 lines
22 KiB
JavaScript
'use strict';
|
|
|
|
var _ = require('lodash');
|
|
var $ = require('preconditions').singleton();
|
|
var util = require('util');
|
|
var async = require('async');
|
|
var log = require('npmlog');
|
|
var request = require('request')
|
|
var events = require('events');
|
|
log.debug = log.verbose;
|
|
|
|
var Bitcore = require('bitcore')
|
|
var WalletUtils = require('../walletutils');
|
|
var Verifier = require('./verifier');
|
|
var ServerCompromisedError = require('./servercompromisederror');
|
|
var ClientError = require('../clienterror');
|
|
|
|
var BASE_URL = 'http://localhost:3001/copay/api';
|
|
|
|
var WALLET_CRITICAL_DATA = ['xPrivKey', 'm', 'n', 'publicKeyRing', 'sharedEncryptingKey'];
|
|
var WALLET_EXTRA_DATA = ['copayerId', 'roPrivKey', 'rwPrivKey'];
|
|
|
|
var WALLET_AIRGAPPED_TOCOMPLETE = ['publicKeyRing', 'm', 'n', 'sharedEncryptingKey'];
|
|
|
|
function _encryptMessage(message, encryptingKey) {
|
|
if (!message) return null;
|
|
return WalletUtils.encryptMessage(message, encryptingKey);
|
|
};
|
|
|
|
function _decryptMessage(message, encryptingKey) {
|
|
if (!message) return '';
|
|
try {
|
|
return WalletUtils.decryptMessage(message, encryptingKey);
|
|
} catch (ex) {
|
|
return '<ECANNOTDECRYPT>';
|
|
}
|
|
};
|
|
|
|
function _processTxps(txps, encryptingKey) {
|
|
if (!txps) return;
|
|
_.each([].concat(txps), function(txp) {
|
|
txp.encryptedMessage = txp.message;
|
|
txp.message = _decryptMessage(txp.message, encryptingKey);
|
|
_.each(txp.actions, function(action) {
|
|
action.comment = _decryptMessage(action.comment, encryptingKey);
|
|
});
|
|
});
|
|
};
|
|
|
|
function _parseError(body) {
|
|
if (_.isString(body)) {
|
|
try {
|
|
body = JSON.parse(body);
|
|
} catch (e) {
|
|
body = {
|
|
error: body
|
|
};
|
|
}
|
|
}
|
|
var ret;
|
|
if (body.code) {
|
|
ret = new ClientError(body.code, body.message);
|
|
} else {
|
|
ret = {
|
|
code: 'ERROR',
|
|
error: body.error || 'There was an unknown error processing the request',
|
|
};
|
|
}
|
|
log.error(ret);
|
|
return ret;
|
|
};
|
|
|
|
function _signRequest(method, url, args, privKey) {
|
|
var message = method.toLowerCase() + '|' + url + '|' + JSON.stringify(args);
|
|
return WalletUtils.signMessage(message, privKey);
|
|
};
|
|
|
|
function _initWcd(network) {
|
|
$.checkArgument(network);
|
|
var xPrivKey = new Bitcore.HDPrivateKey(network);
|
|
var xPubKey = (new Bitcore.HDPublicKey(xPrivKey)).toString();
|
|
var roPrivKey = xPrivKey.derive('m/1/0').privateKey;
|
|
var rwPrivKey = xPrivKey.derive('m/1/1').privateKey;
|
|
var copayerId = WalletUtils.xPubToCopayerId(xPubKey);
|
|
|
|
|
|
return {
|
|
copayerId: copayerId,
|
|
xPrivKey: xPrivKey.toString(),
|
|
publicKeyRing: [xPubKey],
|
|
network: network,
|
|
roPrivKey: roPrivKey.toWIF(),
|
|
rwPrivKey: rwPrivKey.toWIF(),
|
|
};
|
|
};
|
|
|
|
function _addWalletToWcd(wcd, walletPrivKey, m, n) {
|
|
$.checkArgument(wcd);
|
|
var sharedEncryptingKey = WalletUtils.privateKeyToAESKey(walletPrivKey);
|
|
|
|
wcd.walletPrivKey = walletPrivKey.toWIF();
|
|
wcd.sharedEncryptingKey = sharedEncryptingKey;
|
|
wcd.m = m;
|
|
wcd.n = n;
|
|
};
|
|
|
|
function API(opts) {
|
|
if (!opts.storage) {
|
|
throw new Error('Must provide storage option');
|
|
}
|
|
this.storage = opts.storage;
|
|
this.verbose = !!opts.verbose;
|
|
this.request = request || opts.request;
|
|
this.baseUrl = opts.baseUrl || BASE_URL;
|
|
this.basePath = this.baseUrl.replace(/http.?:\/\/[a-zA-Z0-9:-]*\//, '/');
|
|
this.noPasswdAccess = opts.noPasswdAccess || 'full';
|
|
if (this.verbose) {
|
|
log.level = 'debug';
|
|
} else {
|
|
log.level = 'info';
|
|
}
|
|
};
|
|
|
|
util.inherits(API, events.EventEmitter);
|
|
|
|
API.prototype._tryToCompleteFromServer = function(wcd, cb) {
|
|
|
|
if (!wcd.walletPrivKey)
|
|
return cb('Could not perform that action. Wallet Incomplete');
|
|
|
|
var self = this;
|
|
var url = '/v1/wallets/';
|
|
self._doGetRequest(url, wcd, function(err, ret) {
|
|
if (err) return cb(err);
|
|
var wallet = ret.wallet;
|
|
|
|
if (wallet.status != 'complete')
|
|
return cb('Wallet Incomplete');
|
|
|
|
if (!Verifier.checkCopayers(wallet.copayers, wcd.walletPrivKey,
|
|
wcd.xPrivKey, wcd.n)) {
|
|
|
|
return cb(new ServerCompromisedError(
|
|
'Copayers in the wallet could not be verified to have known the wallet secret'));
|
|
}
|
|
|
|
wcd.publicKeyRing = _.pluck(wallet.copayers, 'xPubKey')
|
|
|
|
self.save(wcd, function(err) {
|
|
return cb(err, wcd);
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
API.prototype._tryToCompleteFromData = function(wcd, toComplete, cb) {
|
|
var inData = _decryptMessage(toComplete,
|
|
WalletUtils.privateKeyToAESKey(wcd.roPrivKey));
|
|
if (!inData)
|
|
return cb('Could not complete wallet');
|
|
|
|
try {
|
|
inData = JSON.parse(inData);
|
|
_.extend(wcd, _.pick(inData, WALLET_AIRGAPPED_TOCOMPLETE));
|
|
} catch (ex) {
|
|
return cb(ex);
|
|
}
|
|
|
|
this.save(wcd, function(err) {
|
|
return cb(err, wcd);
|
|
});
|
|
};
|
|
|
|
|
|
API.prototype._tryToComplete = function(opts, wcd, cb) {
|
|
if (opts.toComplete) {
|
|
this._tryToCompleteFromData(wcd, opts.toComplete, cb);
|
|
} else {
|
|
this._tryToCompleteFromServer(wcd, cb);
|
|
}
|
|
};
|
|
|
|
|
|
// access: 'full' > 'readwrite' > readonly'
|
|
API.prototype._processWcdAfterRead = function(rawData, requiredAccess, cb) {
|
|
var WU = WalletUtils;
|
|
requiredAccess = requiredAccess || 'full';
|
|
|
|
if (!rawData)
|
|
return cb(null, rawData);
|
|
|
|
var requiredAccessLevel = WU.accessNameToLevel(requiredAccess);
|
|
|
|
var access = WU.accessFromData(rawData);
|
|
var accessLevel = WU.accessNameToLevel(access);
|
|
|
|
// Is the data available?
|
|
if (requiredAccessLevel <= accessLevel)
|
|
return cb(null, rawData);
|
|
|
|
// Has any encrypted info?
|
|
if (!rawData.enc)
|
|
return cb('NOTAUTH');
|
|
|
|
// Decrypt it and try again
|
|
this.emit('needPassword', function(password) {
|
|
if (!password) return cb('No password');
|
|
|
|
try {
|
|
rawData = WU.decryptWallet(rawData, password);
|
|
} catch (e) {};
|
|
|
|
if (!rawData)
|
|
return cb('NOTAUTH');
|
|
|
|
access = WU.accessFromData(rawData);
|
|
accessLevel = WU.accessNameToLevel(access);
|
|
|
|
// Is the data available?
|
|
if (requiredAccessLevel <= accessLevel)
|
|
return cb(null, rawData);
|
|
|
|
return cb('NOTAUTH');
|
|
});
|
|
};
|
|
|
|
|
|
API.prototype.setNopasswdAccess = function(noPasswdAccess) {
|
|
if (!_.contains(['none', 'readonly', 'readwrite', 'full'], noPasswdAccess))
|
|
throw new Error('Bad nopasswd access:' + noPasswdAccess);
|
|
|
|
this.noPasswdAccess = noPasswdAccess;
|
|
};
|
|
|
|
API.prototype._processWcdBeforeWrite = function(wcd, cb) {
|
|
var self = this;
|
|
// Is any encrypted?
|
|
if (this.noPasswdAccess == 'full') {
|
|
return cb(null, wcd);
|
|
} else {
|
|
this.emit('needNewPassword', function(password) {
|
|
if (!password) return cb('No password given');
|
|
var ewcd = WalletUtils.encryptWallet(wcd, self.noPasswdAccess, password);
|
|
return cb(null, ewcd);
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
|
|
API.prototype._load = function(opts, cb) {
|
|
var self = this;
|
|
$.shouldBeFunction(cb);
|
|
|
|
this.storage.load(function(err, rawdata) {
|
|
if (err || !rawdata) {
|
|
if (err && err.code == 'ENOENT') err = 'NOTFOUND';
|
|
return cb(err || 'NOTFOUND');
|
|
}
|
|
self._processWcdAfterRead(rawdata, opts.requiredAccess, cb);
|
|
});
|
|
};
|
|
|
|
|
|
/**
|
|
* _loadAndCheck
|
|
*
|
|
* @param opts.pkr
|
|
*/
|
|
API.prototype._loadAndCheck = function(opts, cb) {
|
|
var self = this;
|
|
|
|
this._load(opts, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
if (!wcd.n || (wcd.n > 1 && wcd.publicKeyRing.length != wcd.n)) {
|
|
return self._tryToComplete(opts, wcd, cb);
|
|
}
|
|
|
|
return cb(null, wcd);
|
|
});
|
|
};
|
|
|
|
API.prototype._doRequest = function(method, url, args, wcd, cb) {
|
|
var reqSignature;
|
|
wcd = wcd || {};
|
|
|
|
if (method == 'get') {
|
|
if (wcd.roPrivKey)
|
|
reqSignature = _signRequest(method, url, args, wcd.roPrivKey);
|
|
} else {
|
|
if (wcd.rwPrivKey)
|
|
reqSignature = _signRequest(method, url, args, wcd.rwPrivKey);
|
|
}
|
|
|
|
var absUrl = this.baseUrl + url;
|
|
var args = {
|
|
// relUrl: only for testing with `supertest`
|
|
relUrl: this.basePath + url,
|
|
headers: {
|
|
'x-identity': wcd.copayerId,
|
|
'x-signature': reqSignature,
|
|
},
|
|
method: method,
|
|
url: absUrl,
|
|
body: args,
|
|
json: true,
|
|
};
|
|
log.verbose('Request Args', util.inspect(args, {
|
|
depth: 10
|
|
}));
|
|
this.request(args, function(err, res, body) {
|
|
log.verbose(util.inspect(body, {
|
|
depth: 10
|
|
}));
|
|
if (err) return cb(err);
|
|
|
|
if (res.statusCode != 200) {
|
|
return cb(_parseError(body));
|
|
}
|
|
|
|
return cb(null, body, res.header);
|
|
});
|
|
};
|
|
|
|
|
|
API.prototype._doPostRequest = function(url, args, wcd, cb) {
|
|
return this._doRequest('post', url, args, wcd, cb);
|
|
};
|
|
|
|
API.prototype._doGetRequest = function(url, wcd, cb) {
|
|
return this._doRequest('get', url, {}, wcd, cb);
|
|
};
|
|
|
|
|
|
API.prototype._doJoinWallet = function(walletId, walletPrivKey, xPubKey, copayerName, cb) {
|
|
var args = {
|
|
walletId: walletId,
|
|
name: copayerName,
|
|
xPubKey: xPubKey,
|
|
xPubKeySignature: WalletUtils.signMessage(xPubKey, walletPrivKey),
|
|
};
|
|
var url = '/v1/wallets/' + walletId + '/copayers';
|
|
this._doPostRequest(url, args, {}, function(err, body) {
|
|
if (err) return cb(err);
|
|
return cb(null, body.wallet);
|
|
});
|
|
};
|
|
|
|
API.prototype.save = function(inWcd, cb) {
|
|
var self = this;
|
|
|
|
self._processWcdBeforeWrite(inWcd, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
self.storage.save(wcd, function(err) {
|
|
return cb(err, null);
|
|
});
|
|
});
|
|
}
|
|
|
|
API.prototype.generateKey = function(network, cb) {
|
|
var self = this;
|
|
network = network || 'livenet';
|
|
if (!_.contains(['testnet', 'livenet'], network))
|
|
return cb('Invalid network');
|
|
|
|
this.storage.load(function(err, wcd) {
|
|
if (wcd)
|
|
return cb(self.storage.getName() + ' already contains a wallet');
|
|
|
|
var wcd = _initWcd(network);
|
|
|
|
self.save(wcd, function(err) {
|
|
return cb(err, null);
|
|
});
|
|
});
|
|
};
|
|
|
|
API.prototype.createWallet = function(walletName, copayerName, m, n, network, cb) {
|
|
var self = this;
|
|
network = network || 'livenet';
|
|
if (!_.contains(['testnet', 'livenet'], network))
|
|
return cb('Invalid network');
|
|
|
|
this._load({
|
|
requiredAccess: 'readonly',
|
|
}, function(err, wcd) {
|
|
if (err && err != 'NOTFOUND')
|
|
return cb(err);
|
|
|
|
if (wcd && wcd.n)
|
|
return cb(self.storage.getName() + ' already contains a wallet');
|
|
|
|
if (wcd && wcd.network && wcd.network != network)
|
|
return cb('Storage ' + self.storage.getName() + ' is set to network:' + wcd.network);
|
|
|
|
var walletPrivKey = new Bitcore.PrivateKey();
|
|
var args = {
|
|
name: walletName,
|
|
m: m,
|
|
n: n,
|
|
pubKey: walletPrivKey.toPublicKey().toString(),
|
|
network: network,
|
|
};
|
|
var url = '/v1/wallets/';
|
|
self._doPostRequest(url, args, {}, function(err, body) {
|
|
if (err) return cb(err);
|
|
|
|
var walletId = body.walletId;
|
|
|
|
var secret = WalletUtils.toSecret(walletId, walletPrivKey, network);
|
|
|
|
wcd = wcd || _initWcd(network);
|
|
_addWalletToWcd(wcd, walletPrivKey, m, n)
|
|
|
|
self._doJoinWallet(walletId, walletPrivKey, wcd.publicKeyRing[0], copayerName,
|
|
function(err, wallet) {
|
|
if (err) return cb(err);
|
|
self.save(wcd, function(err) {
|
|
return cb(err, n > 1 ? secret : null);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
API.prototype.reCreateWallet = function(walletName, cb) {
|
|
var self = this;
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readonly',
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
var walletPrivKey = new Bitcore.PrivateKey();
|
|
var args = {
|
|
name: walletName,
|
|
m: wcd.m,
|
|
n: wcd.n,
|
|
pubKey: walletPrivKey.toPublicKey().toString(),
|
|
network: wcd.network,
|
|
};
|
|
var url = '/v1/wallets/';
|
|
self._doPostRequest(url, args, {}, function(err, body) {
|
|
if (err) return cb(err);
|
|
|
|
var walletId = body.walletId;
|
|
|
|
var secret = WalletUtils.toSecret(walletId, walletPrivKey, wcd.network);
|
|
var i = 0;
|
|
async.each(wcd.publicKeyRing, function(xpub, next) {
|
|
var copayerName = 'recovered Copayer #' + i;
|
|
self._doJoinWallet(walletId, walletPrivKey, wcd.publicKeyRing[i++], copayerName, next);
|
|
}, function(err) {
|
|
return cb(err);
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
API.prototype.joinWallet = function(secret, copayerName, cb) {
|
|
var self = this;
|
|
|
|
this._load({
|
|
requiredAccess: 'readonly'
|
|
}, function(err, wcd) {
|
|
if (err && err != 'NOTFOUND')
|
|
return cb(err);
|
|
|
|
if (wcd && wcd.n)
|
|
return cb(self.storage.getName() + ' already contains a wallet');
|
|
|
|
try {
|
|
var secretData = WalletUtils.fromSecret(secret);
|
|
} catch (ex) {
|
|
return cb(ex);
|
|
}
|
|
wcd = wcd || _initWcd(secretData.network);
|
|
|
|
self._doJoinWallet(secretData.walletId, secretData.walletPrivKey, wcd.publicKeyRing[0], copayerName,
|
|
function(err, joinedWallet) {
|
|
if (err) return cb(err);
|
|
_addWalletToWcd(wcd, secretData.walletPrivKey, joinedWallet.m, joinedWallet.n);
|
|
self.save(wcd, cb);
|
|
});
|
|
});
|
|
};
|
|
|
|
API.prototype.getStatus = function(cb) {
|
|
var self = this;
|
|
|
|
this._load({
|
|
requiredAccess: 'readonly'
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
var url = '/v1/wallets/';
|
|
self._doGetRequest(url, wcd, function(err, result) {
|
|
_processTxps(result.pendingTxps, wcd.sharedEncryptingKey);
|
|
return cb(err, result, wcd.copayerId);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* send
|
|
*
|
|
* @param opts
|
|
* @param opts.toAddress
|
|
* @param opts.amount
|
|
* @param opts.message
|
|
*/
|
|
API.prototype.sendTxProposal = function(opts, cb) {
|
|
$.checkArgument(opts);
|
|
$.shouldBeNumber(opts.amount);
|
|
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readonly',
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
if (!wcd.rwPrivKey)
|
|
return cb('No key to generate proposals');
|
|
|
|
var args = {
|
|
toAddress: opts.toAddress,
|
|
amount: opts.amount,
|
|
message: _encryptMessage(opts.message, wcd.sharedEncryptingKey),
|
|
};
|
|
var hash = WalletUtils.getProposalHash(args.toAddress, args.amount, args.message);
|
|
args.proposalSignature = WalletUtils.signMessage(hash, wcd.rwPrivKey);
|
|
log.debug('Generating & signing tx proposal hash -> Hash: ', hash, ' Signature: ', args.proposalSignature);
|
|
|
|
var url = '/v1/txproposals/';
|
|
self._doPostRequest(url, args, wcd, cb);
|
|
});
|
|
};
|
|
|
|
API.prototype.createAddress = function(cb) {
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readwrite',
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
var url = '/v1/addresses/';
|
|
self._doPostRequest(url, {}, wcd, function(err, address) {
|
|
if (err) return cb(err);
|
|
if (!Verifier.checkAddress(wcd, address)) {
|
|
return cb(new ServerCompromisedError('Server sent fake address'));
|
|
}
|
|
|
|
return cb(null, address);
|
|
});
|
|
});
|
|
};
|
|
|
|
/*
|
|
* opts.doNotVerify
|
|
*/
|
|
|
|
API.prototype.getMainAddresses = function(opts, cb) {
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readonly',
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
var url = '/v1/addresses/';
|
|
self._doGetRequest(url, wcd, function(err, addresses) {
|
|
if (err) return cb(err);
|
|
|
|
if (!opts.doNotVerify) {
|
|
var fake = _.any(addresses, function(address) {
|
|
return !Verifier.checkAddress(wcd, address);
|
|
});
|
|
if (fake)
|
|
return cb(new ServerCompromisedError('Server sent fake address'));
|
|
}
|
|
return cb(null, addresses);
|
|
});
|
|
});
|
|
};
|
|
|
|
API.prototype.getBalance = function(cb) {
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readonly',
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
var url = '/v1/balance/';
|
|
self._doGetRequest(url, wcd, cb);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Export does not try to complete the wallet from the server. Exports the
|
|
* wallet as it is now.
|
|
*
|
|
* @param opts.access =['full', 'readonly', 'readwrite']
|
|
*/
|
|
API.prototype.export = function(opts, cb) {
|
|
var self = this;
|
|
$.shouldBeFunction(cb);
|
|
opts = opts || {};
|
|
var access = opts.access || 'full';
|
|
|
|
this._load({
|
|
requiredAccess: access,
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
var v = [];
|
|
|
|
var myXPubKey = (new Bitcore.HDPublicKey(wcd.xPrivKey)).toString();
|
|
|
|
_.each(WALLET_CRITICAL_DATA, function(k) {
|
|
var d;
|
|
|
|
if (access != 'full' && k === 'xPrivKey') {
|
|
v.push(null);
|
|
return;
|
|
}
|
|
|
|
// Skips own pub key IF priv key is exported
|
|
if (access == 'full' && k === 'publicKeyRing') {
|
|
d = _.without(wcd[k], myXPubKey);
|
|
} else {
|
|
d = wcd[k];
|
|
}
|
|
v.push(d);
|
|
});
|
|
|
|
if (access != 'full') {
|
|
v.push(wcd.copayerId);
|
|
v.push(wcd.roPrivKey);
|
|
if (access == 'readwrite') {
|
|
v.push(wcd.rwPrivKey);
|
|
}
|
|
}
|
|
|
|
return cb(null, JSON.stringify(v));
|
|
});
|
|
}
|
|
|
|
|
|
API.prototype.import = function(str, cb) {
|
|
var self = this;
|
|
|
|
this.storage.load(function(err, wcd) {
|
|
if (wcd)
|
|
return cb('Storage already contains a wallet');
|
|
|
|
wcd = {};
|
|
|
|
var inData = JSON.parse(str);
|
|
var i = 0;
|
|
|
|
_.each(WALLET_CRITICAL_DATA.concat(WALLET_EXTRA_DATA), function(k) {
|
|
wcd[k] = inData[i++];
|
|
});
|
|
|
|
if (wcd.xPrivKey) {
|
|
var xpriv = new Bitcore.HDPrivateKey(wcd.xPrivKey);
|
|
var xPubKey = new Bitcore.HDPublicKey(xpriv).toString();
|
|
wcd.publicKeyRing.unshift(xPubKey);
|
|
wcd.copayerId = WalletUtils.xPubToCopayerId(xPubKey);
|
|
wcd.roPrivKey = xpriv.derive('m/1/0').privateKey.toWIF();
|
|
wcd.rwPrivKey = xpriv.derive('m/1/1').privateKey.toWIF();
|
|
}
|
|
|
|
if (!wcd.publicKeyRing)
|
|
return cb('Invalid source wallet');
|
|
|
|
wcd.network = wcd.publicKeyRing[0].substr(0, 4) == 'tpub' ? 'testnet' : 'livenet';
|
|
self.save(wcd, function(err) {
|
|
return cb(err, WalletUtils.accessFromData(wcd));
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
|
|
API.prototype.parseTxProposals = function(txData, cb) {
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readonly',
|
|
toComplete: txData.toComplete
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
var txps = txData.txps;
|
|
_processTxps(txps, wcd.sharedEncryptingKey);
|
|
|
|
var fake = _.any(txps, function(txp) {
|
|
return (!Verifier.checkTxProposal(wcd, txp));
|
|
});
|
|
|
|
if (fake)
|
|
return cb(new ServerCompromisedError('Server sent fake transaction proposal'));
|
|
|
|
return cb(null, txps);
|
|
});
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
*
|
|
* opts.doNotVerify
|
|
* opts.getRawTxps
|
|
* @return {undefined}
|
|
*/
|
|
|
|
API.prototype.getTxProposals = function(opts, cb) {
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readonly'
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
var url = '/v1/txproposals/';
|
|
self._doGetRequest(url, wcd, function(err, txps) {
|
|
if (err) return cb(err);
|
|
|
|
var rawTxps;
|
|
if (opts.getRawTxps)
|
|
rawTxps = JSON.parse(JSON.stringify(txps));
|
|
|
|
_processTxps(txps, wcd.sharedEncryptingKey);
|
|
|
|
var fake = _.any(txps, function(txp) {
|
|
return (!opts.doNotVerify && !Verifier.checkTxProposal(wcd, txp));
|
|
});
|
|
|
|
if (fake)
|
|
return cb(new ServerCompromisedError('Server sent fake transaction proposal'));
|
|
|
|
return cb(null, txps, rawTxps);
|
|
});
|
|
});
|
|
};
|
|
|
|
API.prototype._getSignaturesFor = function(txp, wcd) {
|
|
|
|
//Derive proper key to sign, for each input
|
|
var privs = [],
|
|
derived = {};
|
|
|
|
var network = new Bitcore.Address(txp.toAddress).network.name;
|
|
var xpriv = new Bitcore.HDPrivateKey(wcd.xPrivKey, network);
|
|
|
|
_.each(txp.inputs, function(i) {
|
|
if (!derived[i.path]) {
|
|
derived[i.path] = xpriv.derive(i.path).privateKey;
|
|
privs.push(derived[i.path]);
|
|
}
|
|
});
|
|
|
|
var t = new Bitcore.Transaction();
|
|
|
|
_.each(txp.inputs, function(i) {
|
|
t.from(i, i.publicKeys, txp.requiredSignatures);
|
|
});
|
|
|
|
t.to(txp.toAddress, txp.amount)
|
|
.change(txp.changeAddress.address);
|
|
|
|
var signatures = _.map(privs, function(priv, i) {
|
|
return t.getSignatures(priv);
|
|
});
|
|
|
|
signatures = _.map(_.sortBy(_.flatten(signatures), 'inputIndex'), function(s) {
|
|
return s.signature.toDER().toString('hex');
|
|
});
|
|
|
|
return signatures;
|
|
};
|
|
|
|
API.prototype.getSignatures = function(txp, cb) {
|
|
$.checkArgument(txp.creatorId);
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'full'
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
if (!Verifier.checkTxProposal(wcd, txp)) {
|
|
return cb(new ServerCompromisedError('Transaction proposal is invalid'));
|
|
}
|
|
|
|
return cb(null, self._getSignaturesFor(txp, wcd));
|
|
});
|
|
};
|
|
|
|
API.prototype.getEncryptedWalletData = function(cb) {
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readonly'
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
var toComplete = JSON.stringify(_.pick(wcd, WALLET_AIRGAPPED_TOCOMPLETE));
|
|
return cb(null, _encryptMessage(toComplete, WalletUtils.privateKeyToAESKey(wcd.roPrivKey)));
|
|
});
|
|
};
|
|
|
|
|
|
|
|
API.prototype.signTxProposal = function(txp, cb) {
|
|
$.checkArgument(txp.creatorId);
|
|
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: txp.signatures ? 'readwrite' : 'full'
|
|
}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
if (!Verifier.checkTxProposal(wcd, txp)) {
|
|
return cb(new ServerCompromisedError('Server sent fake transaction proposal'));
|
|
}
|
|
|
|
var signatures = txp.signatures || self._getSignaturesFor(txp, wcd);
|
|
|
|
var url = '/v1/txproposals/' + txp.id + '/signatures/';
|
|
var args = {
|
|
signatures: signatures
|
|
};
|
|
|
|
self._doPostRequest(url, args, wcd, cb);
|
|
});
|
|
};
|
|
|
|
API.prototype.rejectTxProposal = function(txp, reason, cb) {
|
|
$.checkArgument(cb);
|
|
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readwrite'
|
|
},
|
|
function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
var url = '/v1/txproposals/' + txp.id + '/rejections/';
|
|
var args = {
|
|
reason: _encryptMessage(reason, wcd.sharedEncryptingKey) || '',
|
|
};
|
|
self._doPostRequest(url, args, wcd, cb);
|
|
});
|
|
};
|
|
|
|
API.prototype.broadcastTxProposal = function(txp, cb) {
|
|
var self = this;
|
|
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readwrite'
|
|
},
|
|
function(err, wcd) {
|
|
if (err) return cb(err);
|
|
|
|
var url = '/v1/txproposals/' + txp.id + '/broadcast/';
|
|
self._doPostRequest(url, {}, wcd, cb);
|
|
});
|
|
};
|
|
|
|
|
|
|
|
API.prototype.removeTxProposal = function(txp, cb) {
|
|
var self = this;
|
|
this._loadAndCheck({
|
|
requiredAccess: 'readwrite'
|
|
},
|
|
function(err, wcd) {
|
|
if (err) return cb(err);
|
|
var url = '/v1/txproposals/' + txp.id;
|
|
self._doRequest('delete', url, {}, wcd, cb);
|
|
});
|
|
};
|
|
|
|
API.prototype.getTxHistory = function(opts, cb) {
|
|
var self = this;
|
|
|
|
this._loadAndCheck({}, function(err, wcd) {
|
|
if (err) return cb(err);
|
|
var url = '/v1/txhistory/';
|
|
self._doGetRequest(url, wcd, function(err, txs) {
|
|
if (err) return cb(err);
|
|
|
|
_processTxps(txs, wcd.sharedEncryptingKey);
|
|
|
|
return cb(null, txs);
|
|
});
|
|
});
|
|
};
|
|
|
|
module.exports = API;
|