bivcore-wallet-service
Version:
A service for Mutisig HD Bitcoin Value Wallets
1,183 lines • 153 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.WalletService = void 0;
var async = __importStar(require("async"));
var _ = __importStar(require("lodash"));
require("source-map-support/register");
var logger_1 = __importDefault(require("./logger"));
var blockchainexplorer_1 = require("./blockchainexplorer");
var index_1 = require("./chain/index");
var clienterror_1 = require("./errors/clienterror");
var fiatrateservice_1 = require("./fiatrateservice");
var lock_1 = require("./lock");
var messagebroker_1 = require("./messagebroker");
var model_1 = require("./model");
var storage_1 = require("./storage");
var config = require('../config');
var Uuid = require('uuid');
var $ = require('preconditions').singleton();
var deprecatedServerMessage = require('../deprecated-serverMessages');
var serverMessages = require('../serverMessages');
var BCHAddressTranslator = require('./bchaddresstranslator');
var EmailValidator = require('email-validator');
var crypto_value_wallet_core_1 = require("crypto-value-wallet-core");
var Bitcore = require('bitcore-lib');
var Bitcore_ = {
btc: Bitcore,
bch: require('bitcore-lib-cash'),
biv: require('bitcore-lib-value'),
eth: Bitcore,
xrp: Bitcore
};
var Common = require('./common');
var Utils = Common.Utils;
var Constants = Common.Constants;
var Defaults = Common.Defaults;
var Errors = require('./errors/errordefinitions');
var request = require('request');
var initialized = false;
var doNotCheckV8 = false;
var lock;
var storage;
var blockchainExplorer;
var blockchainExplorerOpts;
var messageBroker;
var fiatRateService;
var serviceVersion;
function boolToNum(x) {
return x ? 1 : 0;
}
var WalletService = (function () {
function WalletService() {
if (!initialized) {
throw new Error('Server not initialized');
}
this.lock = lock;
this.storage = storage;
this.blockchainExplorer = blockchainExplorer;
this.blockchainExplorerOpts = blockchainExplorerOpts;
this.messageBroker = messageBroker;
this.fiatRateService = fiatRateService;
this.notifyTicker = 0;
this.request = request;
}
WalletService.getServiceVersion = function () {
if (!serviceVersion) {
serviceVersion = 'bws-' + require('../../package').version;
}
return serviceVersion;
};
WalletService.initialize = function (opts, cb) {
$.shouldBeFunction(cb);
opts = opts || {};
blockchainExplorer = opts.blockchainExplorer;
blockchainExplorerOpts = opts.blockchainExplorerOpts;
doNotCheckV8 = opts.doNotCheckV8;
if (opts.request) {
request = opts.request;
}
var initStorage = function (cb) {
if (opts.storage) {
storage = opts.storage;
return cb();
}
else {
var newStorage_1 = new storage_1.Storage();
newStorage_1.connect(opts.storageOpts, function (err) {
if (err) {
return cb(err);
}
storage = newStorage_1;
return cb();
});
}
};
var initMessageBroker = function (cb) {
messageBroker = opts.messageBroker || new messagebroker_1.MessageBroker(opts.messageBrokerOpts);
if (messageBroker) {
messageBroker.onMessage(WalletService.handleIncomingNotifications);
}
return cb();
};
var initFiatRateService = function (cb) {
if (opts.fiatRateService) {
fiatRateService = opts.fiatRateService;
return cb();
}
else {
var newFiatRateService_1 = new fiatrateservice_1.FiatRateService();
var opts2 = opts.fiatRateServiceOpts || {};
opts2.storage = storage;
newFiatRateService_1.init(opts2, function (err) {
if (err) {
return cb(err);
}
fiatRateService = newFiatRateService_1;
return cb();
});
}
};
async.series([
function (next) {
initStorage(next);
},
function (next) {
initMessageBroker(next);
},
function (next) {
initFiatRateService(next);
}
], function (err) {
lock = opts.lock || new lock_1.Lock(storage, opts.lockOpts);
if (err) {
logger_1.default.error('Could not initialize', err);
throw err;
}
initialized = true;
return cb();
});
};
WalletService.handleIncomingNotifications = function (notification, cb) {
cb = cb || function () { };
return cb();
};
WalletService.shutDown = function (cb) {
if (!initialized) {
return cb();
}
storage.disconnect(function (err) {
if (err) {
return cb(err);
}
initialized = false;
return cb();
});
};
WalletService.getInstance = function (opts) {
opts = opts || {};
var version = Utils.parseVersion(opts.clientVersion);
if (version && version.agent === 'bwc') {
if (version.major === 0 || (version.major === 1 && version.minor < 2)) {
throw new clienterror_1.ClientError(Errors.codes.UPGRADE_NEEDED, 'BWC clients < 1.2 are no longer supported.');
}
}
var server = new WalletService();
server._setClientVersion(opts.clientVersion);
server._setAppVersion(opts.userAgent);
server.userAgent = opts.userAgent;
return server;
};
WalletService.getInstanceWithAuth = function (opts, cb) {
var withSignature = function (cb) {
if (!checkRequired(opts, ['copayerId', 'message', 'signature'], cb)) {
return;
}
var server;
try {
server = WalletService.getInstance(opts);
}
catch (ex) {
return cb(ex);
}
server.storage.fetchCopayerLookup(opts.copayerId, function (err, copayer) {
if (err) {
return cb(err);
}
if (!copayer) {
return cb(new clienterror_1.ClientError(Errors.codes.NOT_AUTHORIZED, 'Copayer not found'));
}
var isValid = !!server._getSigningKey(opts.message, opts.signature, copayer.requestPubKeys);
if (!isValid) {
return cb(new clienterror_1.ClientError(Errors.codes.NOT_AUTHORIZED, 'Invalid signature'));
}
server.walletId = copayer.walletId;
if (copayer.isSupportStaff) {
server.walletId = opts.walletId || copayer.walletId;
server.copayerIsSupportStaff = true;
}
if (copayer.isMarketingStaff) {
server.copayerIsMarketingStaff = true;
}
server.copayerId = opts.copayerId;
return cb(null, server);
});
};
var withSession = function (cb) {
if (!checkRequired(opts, ['copayerId', 'session'], cb)) {
return;
}
var server;
try {
server = WalletService.getInstance(opts);
}
catch (ex) {
return cb(ex);
}
server.storage.getSession(opts.copayerId, function (err, s) {
if (err) {
return cb(err);
}
var isValid = s && s.id === opts.session && s.isValid();
if (!isValid) {
return cb(new clienterror_1.ClientError(Errors.codes.NOT_AUTHORIZED, 'Session expired'));
}
server.storage.fetchCopayerLookup(opts.copayerId, function (err, copayer) {
if (err) {
return cb(err);
}
if (!copayer) {
return cb(new clienterror_1.ClientError(Errors.codes.NOT_AUTHORIZED, 'Copayer not found'));
}
server.copayerId = opts.copayerId;
server.walletId = copayer.walletId;
return cb(null, server);
});
});
};
var authFn = opts.session ? withSession : withSignature;
return authFn(cb);
};
WalletService.prototype._runLocked = function (cb, task, waitTime) {
$.checkState(this.walletId);
this.lock.runLocked(this.walletId, { waitTime: waitTime }, cb, task);
};
WalletService.prototype.logi = function (message) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (!this || !this.walletId) {
return logger_1.default.warn.apply(logger_1.default, __spreadArrays([message], args));
}
message = '<' + this.walletId + '>' + message;
return logger_1.default.info.apply(logger_1.default, __spreadArrays([message], args));
};
WalletService.prototype.logw = function (message) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (!this || !this.walletId) {
return logger_1.default.warn.apply(logger_1.default, __spreadArrays([message], args));
}
message = '<' + this.walletId + '>' + message;
return logger_1.default.warn.apply(logger_1.default, __spreadArrays([message], args));
};
WalletService.prototype.logd = function (message) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (!this || !this.walletId) {
return logger_1.default.verbose.apply(logger_1.default, __spreadArrays([message], args));
}
message = '<' + this.walletId + '>' + message;
return logger_1.default.verbose.apply(logger_1.default, __spreadArrays([message], args));
};
WalletService.prototype.login = function (opts, cb) {
var _this = this;
var session;
async.series([
function (next) {
_this.storage.getSession(_this.copayerId, function (err, s) {
if (err) {
return next(err);
}
session = s;
next();
});
},
function (next) {
if (!session || !session.isValid()) {
session = model_1.Session.create({
copayerId: _this.copayerId,
walletId: _this.walletId
});
}
else {
session.touch();
}
next();
},
function (next) {
_this.storage.storeSession(session, next);
}
], function (err) {
if (err) {
return cb(err);
}
if (!session) {
return cb(new Error('Could not get current session for this copayer'));
}
return cb(null, session.id);
});
};
WalletService.prototype.logout = function (opts, cb) {
};
WalletService.prototype.createWallet = function (opts, cb) {
var _this = this;
var pubKey;
if (opts.coin === 'bch' && opts.n > 1) {
var version = Utils.parseVersion(this.clientVersion);
if (version && version.agent === 'bwc') {
if (version.major < 8 || (version.major === 8 && version.minor < 3)) {
return cb(new clienterror_1.ClientError(Errors.codes.UPGRADE_NEEDED, 'BWC clients < 8.3 are no longer supported for multisig BCH wallets.'));
}
}
}
if (!checkRequired(opts, ['name', 'm', 'n', 'pubKey'], cb)) {
return;
}
if (_.isEmpty(opts.name)) {
return cb(new clienterror_1.ClientError('Invalid wallet name'));
}
if (!model_1.Wallet.verifyCopayerLimits(opts.m, opts.n)) {
return cb(new clienterror_1.ClientError('Invalid combination of required copayers / total copayers'));
}
opts.coin = opts.coin || Defaults.COIN;
if (!Utils.checkValueInCollection(opts.coin, Constants.COINS)) {
return cb(new clienterror_1.ClientError('Invalid coin'));
}
opts.network = opts.network || 'livenet';
if (!Utils.checkValueInCollection(opts.network, Constants.NETWORKS)) {
return cb(new clienterror_1.ClientError('Invalid network'));
}
var derivationStrategy = Constants.DERIVATION_STRATEGIES.BIP44;
var addressType = opts.n === 1 ? Constants.SCRIPT_TYPES.P2PKH : Constants.SCRIPT_TYPES.P2SH;
if (opts.useNativeSegwit) {
addressType = opts.n === 1 ? Constants.SCRIPT_TYPES.P2WPKH : Constants.SCRIPT_TYPES.P2WSH;
}
try {
pubKey = new Bitcore.PublicKey.fromString(opts.pubKey);
}
catch (ex) {
return cb(new clienterror_1.ClientError('Invalid public key'));
}
if (opts.n > 1 && !index_1.ChainService.supportsMultisig(opts.coin)) {
return cb(new clienterror_1.ClientError('Multisig wallets are not supported for this coin'));
}
if (index_1.ChainService.isSingleAddress(opts.coin)) {
opts.singleAddress = true;
}
var newWallet;
async.series([
function (acb) {
if (!opts.id) {
return acb();
}
_this.storage.fetchWallet(opts.id, function (err, wallet) {
if (wallet) {
return acb(Errors.WALLET_ALREADY_EXISTS);
}
return acb(err);
});
},
function (acb) {
var wallet = model_1.Wallet.create({
id: opts.id,
name: opts.name,
m: opts.m,
n: opts.n,
coin: opts.coin,
network: opts.network,
pubKey: pubKey.toString(),
singleAddress: !!opts.singleAddress,
derivationStrategy: derivationStrategy,
addressType: addressType,
nativeCashAddr: opts.nativeCashAddr,
usePurpose48: opts.n > 1 && !!opts.usePurpose48
});
_this.storage.storeWallet(wallet, function (err) {
_this.logd('Wallet created', wallet.id, opts.network);
newWallet = wallet;
return acb(err);
});
}
], function (err) {
return cb(err, newWallet ? newWallet.id : null);
});
};
WalletService.prototype.getWallet = function (opts, cb) {
var _this = this;
this.storage.fetchWallet(this.walletId, function (err, wallet) {
if (err)
return cb(err);
if (!wallet)
return cb(Errors.WALLET_NOT_FOUND);
if (wallet.coin != 'bch' || wallet.nativeCashAddr)
return cb(null, wallet);
if (opts.doNotMigrate)
return cb(null, wallet);
logger_1.default.info("Migrating wallet " + wallet.id + " to cashAddr");
_this.storage.migrateToCashAddr(_this.walletId, function (e) {
if (e)
return cb(e);
wallet.nativeCashAddr = true;
return _this.storage.storeWallet(wallet, function (e) {
if (e)
return cb(e);
return cb(e, wallet);
});
});
});
};
WalletService.prototype.getWalletFromIdentifier = function (opts, cb) {
var _this = this;
if (!opts.identifier)
return cb();
var end = function (err, ret) {
if (opts.walletCheck && !err && ret) {
return _this.syncWallet(ret, cb);
}
else {
return cb(err, ret);
}
};
var walletId;
async.parallel([
function (done) {
_this.storage.fetchWallet(opts.identifier, function (err, wallet) {
if (wallet)
walletId = wallet.id;
return done(err);
});
},
function (done) {
_this.storage.fetchAddressByCoin(Defaults.COIN, opts.identifier, function (err, address) {
if (address)
walletId = address.walletId;
return done(err);
});
},
function (done) {
_this.storage.fetchTxByHash(opts.identifier, function (err, tx) {
if (tx)
walletId = tx.walletId;
return done(err);
});
}
], function (err) {
if (err)
return cb(err);
if (walletId) {
return _this.storage.fetchWallet(walletId, end);
}
return cb();
});
};
WalletService.prototype.getStatus = function (opts, cb) {
var _this = this;
opts = opts || {};
var status = {};
async.parallel([
function (next) {
_this.getWallet({}, function (err, wallet) {
if (err)
return next(err);
var walletExtendedKeys = ['publicKeyRing', 'pubKey', 'addressManager'];
var copayerExtendedKeys = ['xPubKey', 'requestPubKey', 'signature', 'addressManager', 'customData'];
wallet.copayers = _.map(wallet.copayers, function (copayer) {
if (copayer.id == _this.copayerId)
return copayer;
return _.omit(copayer, 'customData');
});
if (!opts.includeExtendedInfo) {
wallet = _.omit(wallet, walletExtendedKeys);
wallet.copayers = _.map(wallet.copayers, function (copayer) {
return _.omit(copayer, copayerExtendedKeys);
});
}
status.wallet = wallet;
if (opts.includeServerMessages) {
status.serverMessages = serverMessages(wallet, _this.appName, _this.appVersion);
}
else {
status.serverMessage = deprecatedServerMessage(wallet, _this.appName, _this.appVersion);
}
next();
});
},
function (next) {
opts.wallet = status.wallet;
_this.getBalance(opts, function (err, balance) {
if (opts.includeExtendedInfo) {
if (err && err.code != 'WALLET_NEED_SCAN') {
return next(err);
}
}
else if (err) {
return next(err);
}
status.balance = balance;
next();
});
},
function (next) {
_this.getPendingTxs(opts, function (err, pendingTxps) {
if (err)
return next(err);
status.pendingTxps = pendingTxps;
next();
});
},
function (next) {
_this.getPreferences({}, function (err, preferences) {
if (err)
return next(err);
status.preferences = preferences;
next();
});
}
], function (err) {
if (err)
return cb(err);
return cb(null, status);
});
};
WalletService.prototype._verifySignature = function (text, signature, pubkey) {
return Utils.verifyMessage(text, signature, pubkey);
};
WalletService.prototype._verifyRequestPubKey = function (requestPubKey, signature, xPubKey) {
var pub = new Bitcore.HDPublicKey(xPubKey).deriveChild(Constants.PATHS.REQUEST_KEY_AUTH).publicKey;
return Utils.verifyMessage(requestPubKey, signature, pub.toString());
};
WalletService.prototype._getSigningKey = function (text, signature, pubKeys) {
var _this = this;
return _.find(pubKeys, function (item) {
return _this._verifySignature(text, signature, item.key);
});
};
WalletService.prototype._notify = function (type, data, opts, cb) {
var _this = this;
if (_.isFunction(opts)) {
cb = opts;
opts = {};
}
opts = opts || {};
cb = cb || function () { };
var walletId = this.walletId || data.walletId;
var copayerId = this.copayerId || data.copayerId;
$.checkState(walletId);
var notification = model_1.Notification.create({
type: type,
data: data,
ticker: this.notifyTicker++,
creatorId: opts.isGlobal ? null : copayerId,
walletId: walletId
});
this.storage.storeNotification(walletId, notification, function () {
_this.messageBroker.send(notification);
return cb();
});
};
WalletService.prototype._notifyTxProposalAction = function (type, txp, extraArgs, cb) {
if (_.isFunction(extraArgs)) {
cb = extraArgs;
extraArgs = {};
}
var data = _.assign({
txProposalId: txp.id,
creatorId: txp.creatorId,
amount: txp.getTotalAmount(),
message: txp.message
}, extraArgs);
this._notify(type, data, {}, cb);
};
WalletService.prototype._addCopayerToWallet = function (wallet, opts, cb) {
var _this = this;
var copayer = model_1.Copayer.create({
coin: wallet.coin,
name: opts.name,
copayerIndex: wallet.copayers.length,
xPubKey: opts.xPubKey,
requestPubKey: opts.requestPubKey,
signature: opts.copayerSignature,
customData: opts.customData,
derivationStrategy: wallet.derivationStrategy
});
this.storage.fetchCopayerLookup(copayer.id, function (err, res) {
if (err)
return cb(err);
if (res)
return cb(Errors.COPAYER_REGISTERED);
if (opts.dryRun)
return cb(null, {
copayerId: null,
wallet: wallet
});
wallet.addCopayer(copayer);
_this.storage.storeWalletAndUpdateCopayersLookup(wallet, function (err) {
if (err)
return cb(err);
async.series([
function (next) {
_this._notify('NewCopayer', {
walletId: opts.walletId,
copayerId: copayer.id,
copayerName: copayer.name
}, {}, next);
},
function (next) {
if (wallet.isComplete() && wallet.isShared()) {
_this._notify('WalletComplete', {
walletId: opts.walletId
}, {
isGlobal: true
}, next);
}
else {
next();
}
}
], function () {
return cb(null, {
copayerId: copayer.id,
wallet: wallet
});
});
});
});
};
WalletService.prototype._addKeyToCopayer = function (wallet, copayer, opts, cb) {
wallet.addCopayerRequestKey(copayer.copayerId, opts.requestPubKey, opts.signature, opts.restrictions, opts.name);
this.storage.storeWalletAndUpdateCopayersLookup(wallet, function (err) {
if (err)
return cb(err);
return cb(null, {
copayerId: copayer.id,
wallet: wallet
});
});
};
WalletService.prototype.addAccess = function (opts, cb) {
var _this = this;
if (!checkRequired(opts, ['copayerId', 'requestPubKey', 'signature'], cb))
return;
this.storage.fetchCopayerLookup(opts.copayerId, function (err, copayer) {
if (err)
return cb(err);
if (!copayer)
return cb(Errors.NOT_AUTHORIZED);
_this.storage.fetchWallet(copayer.walletId, function (err, wallet) {
if (err)
return cb(err);
if (!wallet)
return cb(Errors.NOT_AUTHORIZED);
var xPubKey = wallet.copayers.find(function (c) { return c.id === opts.copayerId; }).xPubKey;
if (!_this._verifyRequestPubKey(opts.requestPubKey, opts.signature, xPubKey)) {
return cb(Errors.NOT_AUTHORIZED);
}
if (copayer.requestPubKeys.length > Defaults.MAX_KEYS)
return cb(Errors.TOO_MANY_KEYS);
_this._addKeyToCopayer(wallet, copayer, opts, cb);
});
});
};
WalletService.prototype._setClientVersion = function (version) {
delete this.parsedClientVersion;
this.clientVersion = version;
};
WalletService.prototype._setAppVersion = function (userAgent) {
var parsed = Utils.parseAppVersion(userAgent);
if (!parsed) {
this.appName = this.appVersion = null;
}
else {
this.appName = parsed.app;
this.appVersion = parsed;
}
};
WalletService.prototype._parseClientVersion = function () {
if (_.isUndefined(this.parsedClientVersion)) {
this.parsedClientVersion = Utils.parseVersion(this.clientVersion);
}
return this.parsedClientVersion;
};
WalletService.prototype._clientSupportsPayProRefund = function () {
var version = this._parseClientVersion();
if (!version)
return false;
if (version.agent != 'bwc')
return true;
if (version.major < 1 || (version.major == 1 && version.minor < 2))
return false;
return true;
};
WalletService._getCopayerHash = function (name, xPubKey, requestPubKey) {
return [name, xPubKey, requestPubKey].join('|');
};
WalletService.prototype.joinWallet = function (opts, cb) {
var _this = this;
if (!checkRequired(opts, ['walletId', 'name', 'xPubKey', 'requestPubKey', 'copayerSignature'], cb))
return;
if (_.isEmpty(opts.name))
return cb(new clienterror_1.ClientError('Invalid copayer name'));
opts.coin = opts.coin || Defaults.COIN;
if (!Utils.checkValueInCollection(opts.coin, Constants.COINS))
return cb(new clienterror_1.ClientError('Invalid coin'));
var xPubKey;
try {
xPubKey = Bitcore.HDPublicKey(opts.xPubKey);
}
catch (ex) {
return cb(new clienterror_1.ClientError('Invalid extended public key'));
}
if (_.isUndefined(xPubKey.network)) {
return cb(new clienterror_1.ClientError('Invalid extended public key'));
}
this.walletId = opts.walletId;
this._runLocked(cb, function (cb) {
_this.storage.fetchWallet(opts.walletId, function (err, wallet) {
if (err)
return cb(err);
if (!wallet)
return cb(Errors.WALLET_NOT_FOUND);
if (opts.coin === 'bch' && wallet.n > 1) {
var version = Utils.parseVersion(_this.clientVersion);
if (version && version.agent === 'bwc') {
if (version.major < 8 || (version.major === 8 && version.minor < 3)) {
return cb(new clienterror_1.ClientError(Errors.codes.UPGRADE_NEEDED, 'BWC clients < 8.3 are no longer supported for multisig BCH wallets.'));
}
}
}
if (wallet.n > 1 && wallet.usePurpose48) {
var version = Utils.parseVersion(_this.clientVersion);
if (version && version.agent === 'bwc') {
if (version.major < 8 || (version.major === 8 && version.minor < 4)) {
return cb(new clienterror_1.ClientError(Errors.codes.UPGRADE_NEEDED, 'Please upgrade your client to join this multisig wallet'));
}
}
}
if (wallet.n > 1 && wallet.addressType === 'P2WSH') {
var version = Utils.parseVersion(_this.clientVersion);
if (version && version.agent === 'bwc') {
if (version.major < 8 || (version.major === 8 && version.minor < 17)) {
return cb(new clienterror_1.ClientError(Errors.codes.UPGRADE_NEEDED, 'Please upgrade your client to join this multisig wallet'));
}
}
}
if (opts.coin != wallet.coin) {
return cb(new clienterror_1.ClientError('The wallet you are trying to join was created for a different coin'));
}
if (wallet.network != xPubKey.network.name) {
return cb(new clienterror_1.ClientError('The wallet you are trying to join was created for a different network'));
}
if (wallet.derivationStrategy == Constants.DERIVATION_STRATEGIES.BIP45) {
return cb(new clienterror_1.ClientError('The wallet you are trying to join was created with an older version of the client app.'));
}
var hash = WalletService._getCopayerHash(opts.name, opts.xPubKey, opts.requestPubKey);
if (!_this._verifySignature(hash, opts.copayerSignature, wallet.pubKey)) {
return cb(new clienterror_1.ClientError());
}
if (_.find(wallet.copayers, {
xPubKey: opts.xPubKey
}))
return cb(Errors.COPAYER_IN_WALLET);
if (wallet.copayers.length == wallet.n)
return cb(Errors.WALLET_FULL);
_this._addCopayerToWallet(wallet, opts, cb);
});
});
};
WalletService.prototype.savePreferences = function (opts, cb) {
var _this = this;
opts = opts || {};
var preferences = [
{
name: 'email',
isValid: function (value) {
return EmailValidator.validate(value);
}
},
{
name: 'language',
isValid: function (value) {
return _.isString(value) && value.length == 2;
}
},
{
name: 'unit',
isValid: function (value) {
return _.isString(value) && _.includes(['btc', 'bit'], value.toLowerCase());
}
},
{
name: 'tokenAddresses',
isValid: function (value) {
return _.isArray(value) && value.every(function (x) { return crypto_value_wallet_core_1.Validation.validateAddress('eth', 'mainnet', x); });
}
},
{
name: 'multisigEthInfo',
isValid: function (value) {
return (_.isArray(value) &&
value.every(function (x) { return crypto_value_wallet_core_1.Validation.validateAddress('eth', 'mainnet', x.multisigContractAddress); }));
}
}
];
opts = _.pick(opts, _.map(preferences, 'name'));
try {
_.each(preferences, function (preference) {
var value = opts[preference.name];
if (!value)
return;
if (!preference.isValid(value)) {
throw new Error('Invalid ' + preference.name);
}
});
}
catch (ex) {
return cb(new clienterror_1.ClientError(ex));
}
this.getWallet({}, function (err, wallet) {
if (err)
return cb(err);
if (wallet.coin != 'eth') {
opts.tokenAddresses = null;
opts.multisigEthInfo = null;
}
_this._runLocked(cb, function (cb) {
_this.storage.fetchPreferences(_this.walletId, _this.copayerId, function (err, oldPref) {
if (err)
return cb(err);
var newPref = model_1.Preferences.create({
walletId: _this.walletId,
copayerId: _this.copayerId
});
var preferences = model_1.Preferences.fromObj(_.defaults(newPref, opts, oldPref));
if (opts.tokenAddresses) {
oldPref = oldPref || {};
oldPref.tokenAddresses = oldPref.tokenAddresses || [];
preferences.tokenAddresses = _.uniq(oldPref.tokenAddresses.concat(opts.tokenAddresses));
}
if (opts.multisigEthInfo) {
oldPref = oldPref || {};
oldPref.multisigEthInfo = oldPref.multisigEthInfo || [];
preferences.multisigEthInfo = _.uniq(oldPref.multisigEthInfo.concat(opts.multisigEthInfo).reduce(function (x, y) {
var exists = false;
x.forEach(function (e) {
if (e.multisigContractAddress === y.multisigContractAddress) {
e.tokenAddresses = e.tokenAddresses || [];
y.tokenAddresses = _.uniq(e.tokenAddresses.concat(y.tokenAddresses));
e = Object.assign(e, y);
exists = true;
}
});
return exists ? x : __spreadArrays(x, [y]);
}, []));
}
_this.storage.storePreferences(preferences, function (err) {
return cb(err);
});
});
});
});
};
WalletService.prototype.getPreferences = function (opts, cb) {
this.storage.fetchPreferences(this.walletId, this.copayerId, function (err, preferences) {
if (err)
return cb(err);
return cb(null, preferences || {});
});
};
WalletService.prototype._canCreateAddress = function (ignoreMaxGap, cb) {
var _this = this;
if (ignoreMaxGap)
return cb(null, true);
this.storage.fetchAddresses(this.walletId, function (err, addresses) {
if (err)
return cb(err);
var latestAddresses = addresses.filter(function (x) { return !x.isChange; }).slice(-Defaults.MAX_MAIN_ADDRESS_GAP);
if (latestAddresses.length < Defaults.MAX_MAIN_ADDRESS_GAP ||
_.some(latestAddresses, {
hasActivity: true
}))
return cb(null, true);
var bc = _this._getBlockchainExplorer(latestAddresses[0].coin, latestAddresses[0].network);
if (!bc)
return cb(new Error('Could not get blockchain explorer instance'));
var activityFound = false;
var i = latestAddresses.length;
async.whilst(function () {
return i > 0 && !activityFound;
}, function (next) {
bc.getAddressActivity(latestAddresses[--i].address, function (err, res) {
if (err)
return next(err);
activityFound = !!res;
return next();
});
}, function (err) {
if (err)
return cb(err);
if (!activityFound)
return cb(null, false);
var address = latestAddresses[i];
address.hasActivity = true;
_this.storage.storeAddress(address, function (err) {
return cb(err, true);
});
});
});
};
WalletService.prototype._store = function (wallet, address, cb, checkSync) {
var _this = this;
if (checkSync === void 0) { checkSync = false; }
var stoAddress = _.clone(address);
index_1.ChainService.addressToStorageTransform(wallet.coin, wallet.network, stoAddress);
this.storage.storeAddressAndWallet(wallet, stoAddress, function (err, isDuplicate) {
if (err)
return cb(err);
_this.syncWallet(wallet, function (err2) {
if (err2) {
_this.logw('Error syncing v8 addresses: ', err2);
}
return cb(null, isDuplicate);
}, !checkSync);
});
};
WalletService.prototype.createAddress = function (opts, cb) {
var _this = this;
opts = opts || {};
var createNewAddress = function (wallet, cb) {
var address;
try {
address = wallet.createAddress(false);
}
catch (e) {
_this.logw('Error creating address', e);
return cb('Bad xPub');
}
_this._store(wallet, address, function (err, duplicate) {
if (err)
return cb(err);
if (duplicate)
return cb(null, address);
if (wallet.coin == 'bch' && opts.noCashAddr) {
address = _.cloneDeep(address);
address.address = BCHAddressTranslator.translate(address.address, 'copay');
}
_this._notify('NewAddress', {
address: address.address
}, function () {
return cb(null, address);
});
}, true);
};
var getFirstAddress = function (wallet, cb) {
_this.storage.fetchAddresses(_this.walletId, function (err, addresses) {
if (err)
return cb(err);
if (!_.isEmpty(addresses)) {
var x = _.head(addresses);
index_1.ChainService.addressFromStorageTransform(wallet.coin, wallet.network, x);
return cb(null, x);
}
return createNewAddress(wallet, cb);
});
};
this.getWallet({ doNotMigrate: opts.doNotMigrate }, function (err, wallet) {
if (err)
return cb(err);
if (index_1.ChainService.isSingleAddress(wallet.coin)) {
opts.ignoreMaxGap = true;
opts.singleAddress = true;
}
_this._canCreateAddress(opts.ignoreMaxGap || opts.singleAddress || wallet.singleAddress, function (err, canCreate) {
if (err)
return cb(err);
if (!canCreate)
return cb(Errors.MAIN_ADDRESS_GAP_REACHED);
_this._runLocked(cb, function (cb) {
_this.getWallet({ doNotMigrate: opts.doNotMigrate }, function (err, wallet) {
if (err)
return cb(err);
if (!wallet.isComplete())
return cb(Errors.WALLET_NOT_COMPLETE);
if (wallet.scanStatus == 'error')
return cb(Errors.WALLET_NEED_SCAN);
var createFn = opts.singleAddress || wallet.singleAddress ? getFirstAddress : createNewAddress;
return createFn(wallet, function (err, address) {
if (err) {
return cb(err);
}
return cb(err, address);
});
});
}, 10 * 1000);
});
});
};
WalletService.prototype.getMainAddresses = function (opts, cb) {
var _this = this;
opts = opts || {};
this.storage.fetchAddresses(this.walletId, function (err, addresses) {
if (err)
return cb(err);
var onlyMain = _.reject(addresses, {
isChange: true
});
if (opts.reverse)
onlyMain.reverse();
if (opts.limit > 0)
onlyMain = _.take(onlyMain, opts.limit);
_this.getWallet({}, function (err, wallet) {
_.each(onlyMain, function (x) {
index_1.ChainService.addressFromStorageTransform(wallet.coin, wallet.network, x);
});
return cb(null, onlyMain);
});
});
};
WalletService.prototype.verifyMessageSignature = function (opts, cb) {
var _this = this;
if (!checkRequired(opts, ['message', 'signature'], cb))
return;
this.getWallet({}, function (err, wallet) {
if (err)
return cb(err);
var copayer = wallet.getCopayer(_this.copayerId);
var isValid = !!_this._getSigningKey(opts.message, opts.signature, copayer.requestPubKeys);
return cb(null, isValid);
});
};
WalletService.prototype._getBlockchainExplorer = function (coin, network) {
var opts = {};
var provider;
if (this.blockchainExplorer)
return this.blockchainExplorer;
if (this.blockchainExplorerOpts) {
if (this.blockchainExplorerOpts[coin] && this.blockchainExplorerOpts[coin][network]) {
opts = this.blockchainExplorerOpts[coin][network];
provider = opts.provider;
}
else if (this.blockchainExplorerOpts[network]) {
opts = this.blockchainExplorerOpts[network];
}
}
opts.provider = provider;
opts.coin = coin;
opts.network = network;
opts.userAgent = WalletService.getServiceVersion();
var bc;
try {
bc = blockchainexplorer_1.BlockChainExplorer(opts);
}
catch (ex) {
this.logw('Could not instantiate blockchain explorer', ex);
}
return bc;
};
WalletService.prototype.getUtxosForCurrentWallet = function (opts, cb) {
var _this = this;
opts = opts || {};
var utxoKey = function (utxo) {
return utxo.txid + '|' + utxo.vout;
};
var coin, allAddresses, allUtxos, utxoIndex, addressStrs, bc, wallet;
async.series([
function (next) {
_this.getWallet({}, function (err, w) {
if (err)
return next(err);
wallet = w;
if (wallet.scanStatus == 'error')
return cb(Errors.WALLET_NEED_SCAN);
coin = wallet.coin;
bc = _this._getBlockchainExplorer(coin, wallet.network);
if (!bc)
return cb(new Error('Could not get blockchain explorer instance'));
return next();
});
},
function (next) {
if (_.isArray(opts.addresses)) {
allAddresses = opts.addresses;
return next();
}
_this.storage.fetchAddresses(_this.walletId, function (err, addresses) {
_.each(addresses, function (x) {
index_1.ChainService.addressFromStorageTransform(wallet.coin, wallet.network, x);
});
allAddresses = addresses;
if (allAddresses.length == 0)
return cb(null, []);
return next();
});
},
function (next) {
addressStrs = _.map(allAddresses, 'address');
return next();
},
function (next) {
if (!wallet.isComplete())
return next();
_this._getBlockchainHeight(wallet.coin, wallet.network, function (err, height, hash) {
if (err)
return next(err);
var dustThreshold = Bitcore_[wallet.coin].Transac