bitcore-wallet-service
Version:
A service for Mutisig HD Bitcoin Wallets
285 lines • 10.1 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.XrpChain = void 0;
const crypto_wallet_core_1 = require("crypto-wallet-core");
const lodash_1 = __importDefault(require("lodash"));
const common_1 = require("../../common");
const errordefinitions_1 = require("../../errors/errordefinitions");
const logger_1 = __importDefault(require("../../logger"));
const Defaults = common_1.Common.Defaults;
class XrpChain {
convertBitcoreBalance(bitcoreBalance, locked, reserve = Defaults.MIN_XRP_BALANCE) {
const { unconfirmed, confirmed, balance } = bitcoreBalance;
let activatedLocked = locked;
if (balance > 0) {
activatedLocked = locked + reserve;
}
const convertedBalance = {
totalAmount: balance,
totalConfirmedAmount: confirmed,
lockedAmount: activatedLocked,
lockedConfirmedAmount: activatedLocked,
availableAmount: balance - activatedLocked,
availableConfirmedAmount: confirmed - activatedLocked,
byAddress: []
};
return convertedBalance;
}
supportsMultisig() {
return false;
}
getSizeSafetyMargin() {
return 0;
}
getInputSizeSafetyMargin() {
return 0;
}
getWalletBalance(server, wallet, opts, cb) {
const bc = server._getBlockchainExplorer(wallet.chain || wallet.coin, wallet.network);
bc.getBalance(wallet, (err, balance) => {
if (err) {
return cb(err);
}
bc.getReserve((err, reserve) => {
if (err) {
return cb(err);
}
server.getPendingTxs(opts, (err, txps) => {
if (err)
return cb(err);
const lockedSum = txps.reduce((sum, txp) => {
return sum + txp.amount + (txp.fee || 0);
}, 0) || 0;
const convertedBalance = this.convertBitcoreBalance(balance, lockedSum, reserve);
server.storage.fetchAddresses(server.walletId, (err, addresses) => {
if (err)
return cb(err);
if (addresses.length > 0) {
const byAddress = [
{
address: addresses[0].address,
path: addresses[0].path,
amount: convertedBalance.totalAmount
}
];
convertedBalance.byAddress = byAddress;
}
return cb(null, convertedBalance);
});
});
});
});
}
getWalletSendMaxInfo(server, wallet, opts, cb) {
server.getBalance({}, (err, balance) => {
if (err)
return cb(err);
const { totalAmount, availableAmount } = balance;
let fee = opts.feePerKb;
return cb(null, {
utxosBelowFee: 0,
amountBelowFee: 0,
amount: availableAmount - fee,
feePerKb: opts.feePerKb,
fee
});
});
}
getDustAmountValue() {
return 0;
}
getTransactionCount(server, wallet, from) {
return new Promise((resolve, reject) => {
server._getTransactionCount(wallet, from, (err, nonce) => {
if (err)
return reject(err);
return resolve(nonce);
});
});
}
getChangeAddress() { }
checkDust(output, opts) { }
checkScriptOutput(output) { }
getFee(server, wallet, opts) {
return new Promise((resolve, reject) => {
if (lodash_1.default.isNumber(opts.fee)) {
return resolve({ feePerKb: opts.fee });
}
server._getFeePerKb(wallet, opts, (err, inFeePerKb) => {
if (err) {
return reject(err);
}
let feePerKb = inFeePerKb;
opts.fee = feePerKb;
return resolve({ feePerKb });
});
});
}
getBitcoreTx(txp, opts = { signed: true }) {
const { destinationTag, outputs, outputOrder, multiTx } = txp;
const chain = 'XRP';
const unsignedTxs = [];
const length = multiTx ? outputOrder.length : outputs.length;
for (let index = 0; index < length; index++) {
let outputIdx = index;
if (multiTx) {
outputIdx = outputOrder[index];
}
if (!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?.tag || destinationTag;
const rawTx = crypto_wallet_core_1.Transactions.create({
...txp,
tag: _tag ? Number(_tag) : undefined,
chain,
nonce: Number(txp.nonce) + Number(index),
recipients: [recepient]
});
unsignedTxs.push(rawTx);
}
let tx = {
uncheckedSerialize: () => unsignedTxs,
txid: () => txp.txid,
txids: () => txp.txid ? [txp.txid] : [],
toObject: () => {
let ret = lodash_1.default.clone(txp);
ret.outputs[0].satoshis = ret.outputs[0].amount;
return ret;
},
getFee: () => {
return txp.fee;
},
getChangeOutput: () => null
};
if (opts.signed) {
const sigs = txp.getCurrentSignatures();
sigs.forEach(x => {
this.addSignaturesToBitcoreTx(tx, txp.inputs, txp.inputPaths, x.signatures, x.xpub);
});
}
return tx;
}
convertFeePerKb(p, feePerKb) {
return [p, feePerKb];
}
checkTx(txp) {
try {
this.getBitcoreTx(txp);
}
catch (ex) {
logger_1.default.warn('Error building XRP transaction: %o', ex);
return ex;
}
}
checkTxUTXOs(server, txp, opts, cb) {
return cb();
}
selectTxInputs(server, txp, wallet, opts, cb) {
server.getBalance({ wallet }, (err, balance) => {
if (err)
return cb(err);
const { totalAmount, availableAmount } = balance;
const minXrpBalance = Defaults.MIN_XRP_BALANCE;
if (totalAmount - minXrpBalance < txp.getTotalAmount()) {
return cb(errordefinitions_1.Errors.INSUFFICIENT_FUNDS);
}
else if (availableAmount < txp.getTotalAmount()) {
return cb(errordefinitions_1.Errors.LOCKED_FUNDS);
}
else {
return cb(this.checkTx(txp));
}
});
}
checkUtxos(opts) { }
checkValidTxAmount(output) {
if (!lodash_1.default.isNumber(output.amount) || lodash_1.default.isNaN(output.amount) || output.amount < 0) {
return false;
}
return true;
}
isUTXOChain() {
return false;
}
isSingleAddress() {
return true;
}
addressFromStorageTransform(network, address) {
if (network != 'livenet') {
const x = address.address.indexOf(':' + network);
if (x >= 0) {
address.address = address.address.substr(0, x);
}
}
}
addressToStorageTransform(network, address) {
if (network != 'livenet')
address.address += ':' + network;
}
addSignaturesToBitcoreTx(tx, inputs, inputPaths, signatures, xpub) {
if (signatures.length === 0) {
throw new Error('Signatures Required');
}
const chain = 'XRP';
const network = tx.network;
const unsignedTxs = tx.uncheckedSerialize();
const signedTxs = [];
const txids = [];
for (let index = 0; index < signatures.length; index++) {
const signed = crypto_wallet_core_1.Transactions.applySignature({
chain,
tx: unsignedTxs[index],
signature: signatures[index]
});
signedTxs.push(signed);
tx.id = crypto_wallet_core_1.Transactions.getHash({ tx: signed, chain, network });
txids.push(tx.id);
}
tx.txids = () => txids;
tx.uncheckedSerialize = () => signedTxs;
}
notifyConfirmations() {
return false;
}
validateAddress(wallet, inaddr, opts) {
const chain = 'xrp';
const isValidTo = crypto_wallet_core_1.Validation.validateAddress(chain, wallet.network, inaddr);
if (!isValidTo) {
throw errordefinitions_1.Errors.INVALID_ADDRESS;
}
const isValidFrom = crypto_wallet_core_1.Validation.validateAddress(chain, wallet.network, opts.from);
if (!isValidFrom) {
throw errordefinitions_1.Errors.INVALID_ADDRESS;
}
return;
}
onCoin(coin) {
return null;
}
onTx(tx) {
return null;
}
getReserve(server, wallet, cb) {
const bc = server._getBlockchainExplorer(wallet.chain || wallet.coin, wallet.network);
bc.getReserve((err, reserve) => {
if (err) {
return cb(err);
}
return cb(null, reserve);
});
}
refreshTxData(_server, txp, _opts, cb) {
return cb(null, txp);
}
}
exports.XrpChain = XrpChain;
//# sourceMappingURL=index.js.map