@abcpros/bitcore-wallet-service
Version:
A service for Mutisig HD Bitcoin Wallets
1,241 lines • 455 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 units_1 = require("@abcpros/crypto-wallet-core/ts_build/src/constants/units");
var async = __importStar(require("async"));
var _ = __importStar(require("lodash"));
require("source-map-support/register");
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 logger_1 = __importDefault(require("./logger"));
var messagebroker_1 = require("./messagebroker");
var model_1 = require("./model");
var storage_1 = require("./storage");
var cuid_1 = __importDefault(require("cuid"));
var forge = __importStar(require("node-forge"));
var crypto_wallet_core_1 = require("@abcpros/crypto-wallet-core");
var bitcoinjs_message_1 = __importDefault(require("bitcoinjs-message"));
var currencyrate_1 = require("./currencyrate");
var config_swap_1 = require("./model/config-swap");
var conversionOrder_1 = require("./model/conversionOrder");
var merchantinfo_1 = require("./model/merchantinfo");
var merchantorder_1 = require("./model/merchantorder");
var order_1 = require("./model/order");
var OrderInfoNoti_1 = require("./model/OrderInfoNoti");
var raipayfee_1 = require("./model/raipayfee");
var Client = require('@abcpros/bitcore-wallet-client').default;
var Key = Client.Key;
var commonBWC = require('@abcpros/bitcore-wallet-client/ts_build/lib/common');
var walletLotus = require('../../../../wallet-lotus-donation.json');
var merchantList = require('../../../../merchant-list.json');
var raipayFee = require('../../../../raipay-fee.json');
var dirname = require('path').dirname;
var appDir = dirname(require.main.filename);
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 sgMail = require('@sendgrid/mail');
sgMail.setApiKey(config.emailMerchant.SENDGRID_API_KEY);
var checkOrderInSwapQueueInterval = null;
var swapQueueInterval = null;
var conversionQueueInterval = null;
var merchantOrderQueueInterval = null;
var clientsFundConversion = null;
var bot = null;
var botNotification = null;
var botSwap = null;
var clientsFund = null;
var clientsReceive = null;
var keyFund = null;
var mnemonicKeyFund = null;
var mnemonicKeyFundConversion = null;
var isNotiSwapOutOfFundToTelegram = false;
var isNotiFundXecBelowMinimumToTelegram = false;
var isNotiFundTokenBelowMinimumToTelegram = false;
var isNotiFundXecInsufficientMinimumToTelegram = false;
var isNotiFundTokenInsufficientMinimumToTelegram = false;
var listRateWithPromise = null;
var GAP_RESTART_QUEUE = config.queueNoti.GAP_RESTART_QUEUE;
var NOTI_AFTER_MANY_RESTART = config.queueNoti.NOTI_AFTER_MANY_RESTART;
var MAXIMUM_NOTI = config.queueNoti.MAXIMUM_NOTI;
var minsOfNoti = 5;
var merchantQueueFailed = 0;
var merchantNotiCount = 0;
var conversionQueueFailed = 0;
var conversionNotiCount = 0;
var swapQueueFailed = 0;
var swapNotiCount = 0;
var bcrypt = require('bcrypt');
var saltRounds = 10;
var txIdHandled = [];
var ws = null;
var Bitcore = require('@abcpros/bitcore-lib');
var Bitcore_ = {
btc: Bitcore,
bch: require('@abcpros/bitcore-lib-cash'),
xec: require('@abcpros/bitcore-lib-xec'),
eth: Bitcore,
xrp: Bitcore,
doge: require('@abcpros/bitcore-lib-doge'),
xpi: require('@abcpros/bitcore-lib-xpi'),
ltc: require('@abcpros/bitcore-lib-ltc')
};
var Common = require('./common');
var Utils = Common.Utils;
var Constants = Common.Constants;
var Defaults = Common.Defaults;
var Errors = require('./errors/errordefinitions');
var shell = require('shelljs');
var BCHJS = require('@abcpros/xpi-js');
var bchURL = config.supportToken.xec.bchUrl;
var bchjs = new BCHJS({ restURL: bchURL });
var ecashaddr = require('ecashaddrjs');
var request = require('request');
var initialized = false;
var doNotCheckV8 = false;
var lock;
var storage;
var blockchainExplorer;
var blockchainExplorerOpts;
var messageBroker;
var fiatRateService;
var currencyRateService;
var serviceVersion;
var fundingWalletClients;
var receivingWalletClients;
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.prototype._checkingValidAddress = function (address) {
try {
var _a = ecashaddr.decode(address), prefix = _a.prefix, type = _a.type, hash = _a.hash;
if (prefix === 'ecash' || prefix === 'etoken') {
return true;
}
else {
return false;
}
}
catch (_b) {
return false;
}
};
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();
});
}
};
var initCurrencyRateService = function (cb) {
if (opts.currency) {
currencyRateService = opts.currencyRateService;
return cb();
}
else {
var newCurrencyRateService_1 = new currencyrate_1.CurrencyRateService();
var opts2 = opts.currencyRateServiceOpts || {};
opts2.storage = storage;
newCurrencyRateService_1.init(opts2, function (err) {
if (err) {
return cb(err);
}
currencyRateService = newCurrencyRateService_1;
return cb();
});
}
};
async.series([
function (next) {
initStorage(next);
},
function (next) {
initMessageBroker(next);
},
function (next) {
initFiatRateService(next);
},
function (next) {
initCurrencyRateService(next);
}
], function (err) {
lock = opts.lock || new lock_1.Lock(storage);
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, 'Failed state: this.walletId undefined at <_runLocked()>');
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,
isSlpToken: opts.isSlpToken,
isFromRaipay: opts.isFromRaipay
});
_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;
var walletId = this.walletId;
if (opts.walletId) {
walletId = opts.walletId;
}
this.storage.fetchWallet(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(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.getWalletFromId = function (walletId, cb) {
var _this = this;
this.storage.fetchWallet(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);
logger_1.default.info("Migrating wallet " + wallet.id + " to cashAddr");
_this.storage.migrateToCashAddr(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, 'Failed state: walletId undefined at <_notify()>');
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,
tokenAddress: txp.tokenAddress,
multisigContractAddress: txp.multisigContractAddress
}, 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.updateKeysPassword = function (opts, cb) {
if (!opts.password) {
return cb(new Error('Missing required parameter password'));
}
var storage = this.storage;
bcrypt.hash(opts.password, saltRounds, function (err, hashPass) {
if (err)
return cb(err);
var recoveryKey = cuid_1.default();
bcrypt.hash(recoveryKey, saltRounds, function (err, hashKey) {
storage.fetchKeys(function (err, result) {
if (err)
return cb(err);
if (result) {
result.hashPassword = hashPass;
storage.updateKeys(result, function (err, result) {
if (err)
return cb(err);
if (result)
return cb(null, recoveryKey);
});
}
else {
var keys = {
keyFund: null,
keyReceive: null,
hashPassword: hashPass,
hashRecoveryKey: recoveryKey
};
storage.storeKeys(keys, function (err, result) {
if (err)
return cb(err);
return cb(null, recoveryKey);
});
}
});
});
});
};
WalletService.prototype.updateKeysPasswordConversion = function (opts, cb) {
if (!opts.password) {
return cb(new Error('Missing required parameter password'));
}
var storage = this.storage;
bcrypt.hash(opts.password, saltRounds, function (err, hashPass) {
if (err)
return cb(err);
var recoveryKey = cuid_1.default();
bcrypt.hash(recoveryKey, saltRounds, function (err, hashKey) {
storage.fetchKeysConversion(function (err, result) {
if (err)
return cb(err);
if (result) {
result.hashPassword = hashPass;
storage.updateKeysConversion(result, function (err, result) {
if (err)
return cb(err);
if (result)
return cb(null, recoveryKey);
});
}
else {
var keys = {
keyFund: null,
hashPassword: hashPass,
hashRecoveryKey: recoveryKey
};
storage.storeKeysConversion(keys, function (err, result) {
if (err)
return cb(err);
return cb(null, recoveryKey);
});
}
});
});
});
};
WalletService.prototype.verifyPassword = function (opts, cb) {
if (!opts.email) {
return cb(new Error('Missing required parameter email'));
}
if (!opts.password) {
return cb(new Error('Missing required parameter password'));
}
this.storage.fetchKeys(function (err, keys) {
if (err)
return cb(err);
bcrypt
.compare(opts.password, keys.hashPassword)
.then(function (result) {
if (err)
return cb(err);
if (!result)
return cb(new Error('Invalid password'));
return cb(null, result);
})
.catch(function (e) {
return cb(e);
});
});
};
WalletService.prototype.verifyConversionPassword = function (opts, cb) {
if (!opts.email) {
return cb(new Error('Missing required parameter email'));
}
if (!opts.password) {
return cb(new Error('Missing required parameter password'));
}
this.storage.fetchKeysConversion(function (err, keys) {
if (err)
return cb(err);
bcrypt
.compare(opts.password, keys.hashPassword)
.then(function (result) {
if (err)
return cb(err);
if (!result)
return cb(new Error('Invalid password'));
return cb(null, result);
})
.catch(function (e) {
return cb(e);
});
});
};
WalletService.prototype.encrypt = function (sharedKey, plainText) {
var iv = forge.util.createBuffer(sharedKey.slice(0, 16));
var key = forge.util.createBuffer(sharedKey.slice(0, 16));
var cipher = forge.cipher.createCipher('AES-CBC', key);
cipher.start({ iv: iv });
var rawBuffer = forge.util.createBuffer(plainText);
cipher.update(rawBuffer);
cipher.finish();
var cipherText = cipher.output.toHex();
return cipherText;
};
WalletService.prototype.decrypt = function (sharedKey, cipherText) {
try {
var iv = forge.util.createBuffer(sharedKey.slice(0, 16));
var key = forge.util.createBuffer(sharedKey.slice(0, 16));
var cipher = forge.cipher.createDecipher('AES-CBC', key);
cipher.start({ iv: iv });
var convertedCiphertext = forge.util.hexToBytes(cipherText);
var rawBuffer = new forge.util.ByteBuffer(convertedCiphertext);
cipher.update(rawBuffer);
cipher.finish();
var plainText = Uint8Array.from(Buffer.from(cipher.output.toHex(), 'hex'));
return plainText;
}
catch (e) {
console.log(e);
}
};
WalletService.prototype.importSeed = function (opts, cb) {
var _this = this;
if (!opts.keyFund && !opts.keyReceive) {
return cb(new Error('Missing required key'));
}
this.storage.fetchKeys(function (err, keys) {
if (keys) {
if (opts.keyFund && opts.keyFund.length > 0) {
keys.keyFund = _this.encrypt(config.sharedKey, opts.keyFund);
}
if (opts.keyReceive && opts.keyReceive.length > 0) {
keys.keyReceive = _this.encrypt(config.sharedKey, opts.keyReceive);
}
_this.storage.updateKeys(keys, function (err, result) {
if (err)
return cb(err);
_this.restartHandleSwapQueue(function (err) {
if (err)
return cb(err);
return cb(null, true);
});
});
}
else {
return cb(null, false);
}
});
};
WalletService.prototype.importSeedConversion = function (opts, cb) {
var _this = this;
if (!opts.keyFund) {
return cb(new Error('Missing required key'));
}
this.storage.fetchKeysConversion(function (err, keys) {
if (err)
return cb(err);
if (keys) {
if (opts.keyFund && opts.keyFund.length > 0) {
keys.keyFund = _this.encrypt(config.sharedKey, opts.keyFund);
}
_this.storage.updateKeysConversion(keys, function (err, result) {
if (err)
return cb(err);
_this.restartHandleConversionQueue(function (err) {
if (err)
return cb(err);
return cb(null, true);
});
});
}
else {
return cb(null, false);
}
});
};
WalletService.prototype.checkingSeedExist = function (cb) {
this.storage.fetchKeys(function (err, keys) {
if (err)
return cb(err);
if (!keys) {
return cb(null, { isKeyExisted: false });
}
else {
return cb(null, { isKeyExisted: true });
}
});
};
WalletService.prototype.checkingSeedConversionExist = function (cb) {
this.storage.fetchKeysConversion(function (err, keys) {
if (err)
return cb(err);
if (!keys) {
return cb(null, { isKeyExisted: false });
}
else {
return cb(null, { isKeyExisted: true });
}
});
};
WalletService.prototype.renewPassword = function (opts, cb) {
var _this = this;
if (!opts.newPassword) {
return cb(new Error('Missing required parameter new password'));
}
if (!(opts.oldPassword || opts.recoveryKey)) {
return cb(new Error('Missing requirement parameter password or recovery key to re new password'));
}
this.storage.fetchKeys(function (err, keys) {
if (err)
return cb(err);
var compareValue = {
text: '',
hash: ''
};
if (opts.oldPassword.length > 0) {
compareValue.text = opts.oldPassword;
compareValue.hash = keys.hashPassword;
}
else if (opts.recoveryKey.length > 0) {
compareValue.text = opts.recoveryKey;
compareValue.hash = keys.hashRecoveryKey;
}
bcrypt
.compare(compareValue.text, compareValue.hash)
.then(function (result) {
if (result) {
_this.updateKeysPassword({ password: opts.newPassword }, function (err, recoveryKey) {
if (err)
return cb(err);
return cb(null, recoveryKey);
});
}
else {
return cb(new Error('Invalid data. Please try again'));
}
})
.catch(function (e) {
return cb(e);
});
});
};
WalletService.prototype.renewPasswordConversion = function (opts, cb) {
var _this = this;
if (!opts.newPassword) {
return cb(new Error('Missing required parameter new password'));
}
if (!(opts.oldPassword || opts.recoveryKey)) {
return cb(new Error('Missing requirement parameter password or recovery key to re new password'));
}
this.storage.fetchKeysConversion(function (err, keys) {
if (err)
return cb(err);
var compareValue = {
text: '',
hash: ''
};
if (opts.oldPassword.length > 0) {
compareValue.text = opts.oldPassword;
compareValue.hash = keys.hashPassword;
}
else if (opts.recoveryKey.length > 0) {
compareValue.text = opts.recoveryKey;
compareValue.hash = keys.hashRecoveryKey;
}
bcrypt
.compare(compareValue.text, compareValue.hash)
.then(function (result) {
if (result) {
_this.updateKeysPasswordConversion({ password: opts.newPassword }, function (err, recoveryKey) {
if (err)
return cb(err);
return cb(null, recoveryKey);
});
}
else {
return cb(new Error('Invalid data. Please try again'));
}
})
.catch(function (e) {
return cb(e);
});
});
};
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_[opts.coin].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, fun