bitcore-wallet-client
Version:
Client for bitcore-wallet-service
434 lines • 19.1 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (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.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Utils = void 0;
const crypto_wallet_core_1 = require("crypto-wallet-core");
const _ = __importStar(require("lodash"));
const constants_1 = require("./constants");
const defaults_1 = require("./defaults");
const $ = require('preconditions').singleton();
const sjcl = require('sjcl');
const Stringify = require('json-stable-stringify');
const Bitcore = crypto_wallet_core_1.BitcoreLib;
const Bitcore_ = {
btc: Bitcore,
bch: crypto_wallet_core_1.BitcoreLibCash,
eth: Bitcore,
matic: Bitcore,
arb: Bitcore,
base: Bitcore,
op: Bitcore,
xrp: Bitcore,
doge: crypto_wallet_core_1.BitcoreLibDoge,
ltc: crypto_wallet_core_1.BitcoreLibLtc
};
const PrivateKey = Bitcore.PrivateKey;
const PublicKey = Bitcore.PublicKey;
const crypto = Bitcore.crypto;
let SJCL = {};
const MAX_DECIMAL_ANY_CHAIN = 18;
class Utils {
static getChain(coin) {
try {
let normalizedChain = coin.toLowerCase();
if (constants_1.Constants.BITPAY_SUPPORTED_ETH_ERC20.includes(normalizedChain) ||
!constants_1.Constants.CHAINS.includes(normalizedChain)) {
normalizedChain = 'eth';
}
return normalizedChain;
}
catch (_) {
return 'btc';
}
}
static encryptMessage(message, encryptingKey) {
var key = sjcl.codec.base64.toBits(encryptingKey);
return sjcl.encrypt(key, message, _.defaults({
ks: 128,
iter: 1
}, SJCL));
}
static decryptMessage(cyphertextJson, encryptingKey) {
if (!cyphertextJson)
return;
if (!encryptingKey)
throw new Error('No key');
var key = sjcl.codec.base64.toBits(encryptingKey);
return sjcl.decrypt(key, cyphertextJson);
}
static decryptMessageNoThrow(cyphertextJson, encryptingKey) {
if (!encryptingKey)
return '<ECANNOTDECRYPT>';
if (!cyphertextJson)
return '';
var r = this.isJsonString(cyphertextJson);
if (!r || !r.iv || !r.ct) {
return cyphertextJson;
}
try {
return this.decryptMessage(cyphertextJson, encryptingKey);
}
catch (e) {
return '<ECANNOTDECRYPT>';
}
}
static isJsonString(str) {
var r;
try {
r = JSON.parse(str);
}
catch (e) {
return false;
}
return r;
}
static hashMessage(text) {
$.checkArgument(text);
var buf = Buffer.from(text);
var ret = crypto.Hash.sha256sha256(buf);
ret = new Bitcore.encoding.BufferReader(ret).readReverse();
return ret;
}
static signMessage(message, privKey) {
$.checkArgument(message);
var priv = new PrivateKey(privKey);
const flattenedMessage = _.isArray(message) ? _.join(message) : message;
var hash = this.hashMessage(flattenedMessage);
return crypto.ECDSA.sign(hash, priv, 'little').toString();
}
static verifyMessage(message, signature, pubKey) {
$.checkArgument(message);
$.checkArgument(pubKey);
if (!signature)
return false;
var pub = new PublicKey(pubKey);
const flattenedMessage = _.isArray(message) ? _.join(message) : message;
const hash = this.hashMessage(flattenedMessage);
try {
var sig = new crypto.Signature.fromString(signature);
return crypto.ECDSA.verify(hash, sig, pub, 'little');
}
catch (e) {
return false;
}
}
static privateKeyToAESKey(privKey) {
$.checkArgument(privKey && _.isString(privKey));
$.checkArgument(Bitcore.PrivateKey.isValid(privKey), 'The private key received is invalid');
var pk = Bitcore.PrivateKey.fromString(privKey);
return Bitcore.crypto.Hash.sha256(pk.toBuffer())
.slice(0, 16)
.toString('base64');
}
static getCopayerHash(name, xPubKey, requestPubKey) {
return [name, xPubKey, requestPubKey].join('|');
}
static getProposalHash(proposalHeader) {
if (arguments.length > 1) {
return this.getOldHash.apply(this, arguments);
}
return Stringify(proposalHeader);
}
static getOldHash(toAddress, amount, message, payProUrl) {
return [toAddress, amount, message || '', payProUrl || ''].join('|');
}
static parseDerivationPath(path) {
const pathIndex = /m\/([0-9]*)\/([0-9]*)/;
const [_input, changeIndex, addressIndex] = path.match(pathIndex);
const isChange = Number.parseInt(changeIndex) > 0;
return { _input, addressIndex, isChange };
}
static deriveAddress(scriptType, publicKeyRing, path, m, network, chain, escrowInputs, hardwareSourcePublicKey) {
$.checkArgument(_.includes(_.values(constants_1.Constants.SCRIPT_TYPES), scriptType));
if (hardwareSourcePublicKey) {
const bitcoreAddress = crypto_wallet_core_1.Deriver.getAddress(chain.toUpperCase(), network, hardwareSourcePublicKey, scriptType);
return {
address: bitcoreAddress.toString(),
path,
publicKeys: [hardwareSourcePublicKey]
};
}
chain = chain || 'btc';
var bitcore = Bitcore_[chain];
var publicKeys = _.map(publicKeyRing, item => {
var xpub = new bitcore.HDPublicKey(item.xPubKey);
return xpub.deriveChild(path).publicKey;
});
var bitcoreAddress;
switch (scriptType) {
case constants_1.Constants.SCRIPT_TYPES.P2WSH:
const nestedWitness = false;
bitcoreAddress = bitcore.Address.createMultisig(publicKeys, m, network, nestedWitness, 'witnessscripthash');
break;
case constants_1.Constants.SCRIPT_TYPES.P2SH:
if (escrowInputs) {
var xpub = new bitcore.HDPublicKey(publicKeyRing[0].xPubKey);
const inputPublicKeys = escrowInputs.map(input => xpub.deriveChild(input.path).publicKey);
bitcoreAddress = bitcore.Address.createEscrow(inputPublicKeys, publicKeys[0], network);
publicKeys = [publicKeys[0], ...inputPublicKeys];
}
else {
bitcoreAddress = bitcore.Address.createMultisig(publicKeys, m, network);
}
break;
case constants_1.Constants.SCRIPT_TYPES.P2WPKH:
bitcoreAddress = bitcore.Address.fromPublicKey(publicKeys[0], network, 'witnesspubkeyhash');
break;
case constants_1.Constants.SCRIPT_TYPES.P2PKH:
$.checkState(_.isArray(publicKeys) && publicKeys.length == 1, 'publicKeys array undefined');
if (constants_1.Constants.UTXO_CHAINS.includes(chain)) {
bitcoreAddress = bitcore.Address.fromPublicKey(publicKeys[0], network);
}
else {
const { addressIndex, isChange } = this.parseDerivationPath(path);
const [{ xPubKey }] = publicKeyRing;
bitcoreAddress = crypto_wallet_core_1.Deriver.deriveAddress(chain.toUpperCase(), network, xPubKey, addressIndex, isChange);
}
break;
case constants_1.Constants.SCRIPT_TYPES.P2TR:
bitcoreAddress = bitcore.Address.fromPublicKey(publicKeys[0], network, 'taproot');
break;
}
return {
address: bitcoreAddress.toString(true),
path,
publicKeys: _.invokeMap(publicKeys, 'toString')
};
}
static xPubToCopayerId(_chain, xpub) {
const chain = _chain.toLowerCase();
var str = chain == 'btc' ? xpub : chain + xpub;
var hash = sjcl.hash.sha256.hash(str);
return sjcl.codec.hex.fromBits(hash);
}
static signRequestPubKey(requestPubKey, xPrivKey) {
var priv = new Bitcore.HDPrivateKey(xPrivKey).deriveChild(constants_1.Constants.PATHS.REQUEST_KEY_AUTH).privateKey;
return this.signMessage(requestPubKey, priv);
}
static verifyRequestPubKey(requestPubKey, signature, xPubKey) {
var pub = new Bitcore.HDPublicKey(xPubKey).deriveChild(constants_1.Constants.PATHS.REQUEST_KEY_AUTH).publicKey;
return this.verifyMessage(requestPubKey, signature, pub.toString());
}
static formatAmount(satoshis, unit, opts) {
$.shouldBeNumber(satoshis);
var clipDecimals = (number, decimals) => {
let str = number.toString();
if (str.indexOf('e') >= 0) {
str = number.toFixed(MAX_DECIMAL_ANY_CHAIN);
}
var x = str.split('.');
var d = (x[1] || '0').substring(0, decimals);
const ret = parseFloat(x[0] + '.' + d);
return ret;
};
var addSeparators = (nStr, thousands, decimal, minDecimals) => {
nStr = nStr.replace('.', decimal);
var x = nStr.split(decimal);
var x0 = x[0];
var x1 = x[1];
x1 = _.dropRightWhile(x1, (n, i) => {
return n == '0' && i >= minDecimals;
}).join('');
var x2 = x.length > 1 ? decimal + x1 : '';
x0 = x0.replace(/\B(?=(\d{3})+(?!\d))/g, thousands);
return x0 + x2;
};
opts = opts || {};
var u = constants_1.Constants.UNITS[unit];
var precision = opts.fullPrecision ? 'full' : 'short';
var decimals = opts.decimals ? opts.decimals[precision] : u[precision];
var toSatoshis = opts.toSatoshis ? opts.toSatoshis : u.toSatoshis;
var amount = clipDecimals(satoshis / toSatoshis, decimals.maxDecimals).toFixed(decimals.maxDecimals);
return addSeparators(amount, opts.thousandsSeparator || ',', opts.decimalSeparator || '.', decimals.minDecimals);
}
static buildTx(txp) {
var _a;
var chain = ((_a = txp.chain) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || Utils.getChain(txp.coin);
if (constants_1.Constants.UTXO_CHAINS.includes(chain)) {
var bitcore = Bitcore_[chain];
var t = new bitcore.Transaction();
if (txp.version >= 4) {
t.setVersion(2);
}
else {
t.setVersion(1);
}
$.checkState(_.includes(_.values(constants_1.Constants.SCRIPT_TYPES), txp.addressType), 'Failed state: addressType not in SCRIPT_TYPES');
switch (txp.addressType) {
case constants_1.Constants.SCRIPT_TYPES.P2WSH:
case constants_1.Constants.SCRIPT_TYPES.P2SH:
_.each(txp.inputs, i => {
t.from(i, i.publicKeys, txp.requiredSignatures);
});
break;
case constants_1.Constants.SCRIPT_TYPES.P2WPKH:
case constants_1.Constants.SCRIPT_TYPES.P2PKH:
case constants_1.Constants.SCRIPT_TYPES.P2TR:
t.from(txp.inputs);
break;
}
if (txp.toAddress && txp.amount && !txp.outputs) {
t.to(txp.toAddress, txp.amount);
}
else if (txp.outputs) {
_.each(txp.outputs, o => {
$.checkState(o.script || o.toAddress, 'Output should have either toAddress or script specified');
if (o.script) {
t.addOutput(new bitcore.Transaction.Output({
script: o.script,
satoshis: o.amount
}));
}
else {
t.to(o.toAddress, o.amount);
}
});
}
t.fee(txp.fee);
if (txp.instantAcceptanceEscrow && txp.escrowAddress) {
t.escrow(txp.escrowAddress.address, txp.instantAcceptanceEscrow + txp.fee);
}
t.change(txp.changeAddress.address);
if (txp.enableRBF)
t.enableRBF();
if (t.outputs.length > 1) {
var outputOrder = _.reject(txp.outputOrder, order => {
return order >= t.outputs.length;
});
$.checkState(t.outputs.length == outputOrder.length, 'Failed state: t.ouputs.length == outputOrder.length at buildTx()');
t.sortOutputs(outputs => {
return _.map(outputOrder, i => {
return outputs[i];
});
});
}
var totalInputs = _.reduce(txp.inputs, (memo, i) => {
return +i.satoshis + memo;
}, 0);
var totalOutputs = _.reduce(t.outputs, (memo, o) => {
return +o.satoshis + memo;
}, 0);
$.checkState(totalInputs - totalOutputs >= 0, 'Failed state: totalInputs - totalOutputs >= 0 at buildTx');
$.checkState(totalInputs - totalOutputs <= defaults_1.Defaults.MAX_TX_FEE(chain), 'Failed state: totalInputs - totalOutputs <= Defaults.MAX_TX_FEE(chain) at buildTx');
return t;
}
else {
const { data, destinationTag, outputs, payProUrl, tokenAddress, multisigContractAddress, multiSendContractAddress, isTokenSwap, gasLimit, multiTx, outputOrder } = txp;
const recipients = outputs.map(output => {
return {
amount: output.amount,
address: output.toAddress,
data: output.data,
gasLimit: output.gasLimit
};
});
if (data) {
recipients[0].data = data;
}
const unsignedTxs = [];
const isERC20 = tokenAddress && !payProUrl && !isTokenSwap;
const isMULTISIG = multisigContractAddress;
const chainName = chain.toUpperCase();
const _chain = isMULTISIG
? chainName + 'MULTISIG'
: isERC20
? chainName + 'ERC20'
: chainName;
if (multiSendContractAddress) {
let multiSendParams = {
nonce: Number(txp.nonce),
recipients,
chain: _chain,
contractAddress: multiSendContractAddress,
gasLimit
};
unsignedTxs.push(crypto_wallet_core_1.Transactions.create(Object.assign(Object.assign({}, txp), multiSendParams)));
}
else if (multiTx) {
for (let index = 0; index < outputOrder.length; index++) {
const outputIdx = outputOrder[index];
if (!(outputs === null || outputs === void 0 ? void 0 : outputs[outputIdx])) {
throw new Error('Output index out of range');
}
const recepient = {
amount: outputs[outputIdx].amount,
address: outputs[outputIdx].toAddress,
tag: outputs[outputIdx].tag
};
const _tag = (recepient === null || recepient === void 0 ? void 0 : recepient.tag) || destinationTag;
const rawTx = crypto_wallet_core_1.Transactions.create(Object.assign(Object.assign(Object.assign({}, txp), recepient), { tag: _tag ? Number(_tag) : undefined, chain: _chain, nonce: Number(txp.nonce) + Number(index), recipients: [recepient] }));
unsignedTxs.push(rawTx);
}
}
else {
for (let index = 0; index < recipients.length; index++) {
const rawTx = crypto_wallet_core_1.Transactions.create(Object.assign(Object.assign(Object.assign({}, txp), recipients[index]), { tag: destinationTag ? Number(destinationTag) : undefined, chain: _chain, nonce: Number(txp.nonce) + Number(index), recipients: [recipients[index]] }));
unsignedTxs.push(rawTx);
}
}
return { uncheckedSerialize: () => unsignedTxs };
}
}
static getCurrencyCodeFromCoinAndChain(coin, chain) {
if (coin.toLowerCase() === chain.toLowerCase()) {
return coin.toUpperCase();
}
if (coin.toLowerCase() === 'pol') {
return 'MATIC';
}
const suffix = constants_1.Constants.EVM_CHAINSUFFIXMAP[chain.toLowerCase()];
const coinIsAChain = !!constants_1.Constants.EVM_CHAINSUFFIXMAP[coin.toLowerCase()];
if (suffix && (coinIsAChain || chain.toLowerCase() !== 'eth')) {
if (chain.toLowerCase() === 'matic' && coin.toLowerCase() === 'usdc.e') {
return 'USDC_m';
}
else if (chain.toLowerCase() === 'matic' && coin.toLowerCase() === 'usdc') {
return 'USDCn_m';
}
return `${coin.toUpperCase()}_${suffix}`;
}
return coin.toUpperCase();
}
static isNativeSegwit(addressType) {
return [
constants_1.Constants.SCRIPT_TYPES.P2WPKH,
constants_1.Constants.SCRIPT_TYPES.P2WSH,
constants_1.Constants.SCRIPT_TYPES.P2TR,
].includes(addressType);
}
static getSegwitVersion(addressType) {
switch (addressType) {
case constants_1.Constants.SCRIPT_TYPES.P2WPKH:
case constants_1.Constants.SCRIPT_TYPES.P2WSH:
return 0;
case constants_1.Constants.SCRIPT_TYPES.P2TR:
return 1;
default:
return undefined;
}
}
}
exports.Utils = Utils;
//# sourceMappingURL=utils.js.map