beignet 0.0.1

package/dist/transaction/index.js

@@ -0,0 +1,692 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const types_1 = require("../types");
+const shapes_1 = require("../shapes");
+const utils_1 = require("../utils");
+const utils_2 = require("../utils");
+const constants_1 = require("../wallet/constants");
+const utils_3 = require("../utils");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const secp256k1_1 = __importDefault(require("@bitcoinerlab/secp256k1"));
+const bitcoin = __importStar(require("bitcoinjs-lib"));
+const bitcoin_address_validation_1 = require("bitcoin-address-validation");
+bitcoin.initEccLib(secp256k1_1.default);
+class Transaction {
+    constructor({ wallet }) {
+        this.getTotalFee = ({ satsPerByte, message = '', transaction = this.data, fundingLightning = false }) => {
+            const baseTransactionSize = constants_1.TRANSACTION_DEFAULTS.recommendedBaseFee;
+            try {
+                const inputs = transaction.inputs || [];
+                const outputs = transaction.outputs || [];
+                const changeAddress = transaction.changeAddress;
+                const inputAddresses = inputs.map((input) => input.address);
+                const outputAddresses = outputs.map((output) => output.address);
+                if (changeAddress && !transaction.max) {
+                    outputAddresses.push(changeAddress);
+                }
+                const inputParam = (0, utils_3.constructByteCountParam)(inputAddresses);
+                const outputParam = (0, utils_3.constructByteCountParam)(outputAddresses);
+                if (fundingLightning) {
+                    outputParam.P2WPKH = (outputParam.P2WPKH || 0) + 1;
+                }
+                const transactionByteCount = (0, utils_3.getByteCount)(inputParam, outputParam, message);
+                return transactionByteCount * satsPerByte;
+            }
+            catch (_a) {
+                return baseTransactionSize * satsPerByte;
+            }
+        };
+        this.getTotalFeeObj = ({ satsPerByte = this._wallet.feeEstimates.normal, message = '', transaction = this.data, fundingLightning = false } = {}) => {
+            var _a;
+            try {
+                if (!((_a = transaction.inputs) === null || _a === void 0 ? void 0 : _a.length)) {
+                    this.setupTransaction({});
+                    transaction = this.data;
+                }
+                const inputs = transaction.inputs || [];
+                const outputs = transaction.outputs || [];
+                const changeAddress = transaction.changeAddress;
+                const inputAddresses = inputs.map((input) => input.address);
+                const outputAddresses = outputs.map((output) => output.address);
+                let increaseAddressCount = 0;
+                if (!outputAddresses.length) {
+                    increaseAddressCount++;
+                }
+                if (changeAddress && !transaction.max) {
+                    outputAddresses.push(changeAddress);
+                }
+                const inputParam = (0, utils_3.constructByteCountParam)(inputAddresses);
+                const outputParam = (0, utils_3.constructByteCountParam)(outputAddresses, [
+                    { addrType: this._wallet.data.addressType, count: increaseAddressCount }
+                ]);
+                if (fundingLightning) {
+                    outputParam.P2WPKH = (outputParam.P2WPKH || 0) + 1;
+                }
+                const transactionByteCount = (0, utils_3.getByteCount)(inputParam, outputParam, message);
+                const maxSatPerByte = this.getMaxSatsPerByte({
+                    transactionByteCount,
+                    balance: this._wallet.getBalance()
+                });
+                if (maxSatPerByte < satsPerByte) {
+                    return (0, utils_1.ok)({
+                        totalFee: transactionByteCount * maxSatPerByte,
+                        transactionByteCount: maxSatPerByte ? transactionByteCount : 0,
+                        satsPerByte: maxSatPerByte,
+                        maxSatPerByte
+                    });
+                }
+                return (0, utils_1.ok)({
+                    totalFee: transactionByteCount * satsPerByte,
+                    transactionByteCount,
+                    satsPerByte,
+                    maxSatPerByte
+                });
+            }
+            catch (e) {
+                return (0, utils_1.err)(e);
+            }
+        };
+        this.getMaxSatsPerByte = ({ transactionByteCount, balance = this._wallet.getBalance() }) => {
+            return Math.floor(balance / (2 * transactionByteCount));
+        };
+        this.createTransaction = async ({ transactionData = this.data, shuffleOutputs = true } = {}) => {
+            (0, utils_3.removeDustOutputs)(transactionData.outputs);
+            const inputValue = this.getTransactionInputValue({
+                inputs: transactionData.inputs
+            });
+            const outputValue = this.getTransactionOutputValue({
+                outputs: transactionData.outputs
+            });
+            if (inputValue === 0) {
+                const message = 'No inputs to spend.';
+                return (0, utils_1.err)(message);
+            }
+            const fee = inputValue - outputValue;
+            if (fee > inputValue) {
+                const message = 'Fee is larger than the intended payment.';
+                return (0, utils_1.err)(message);
+            }
+            const validateRes = (0, utils_1.validateTransaction)(transactionData);
+            if (validateRes.isErr())
+                return (0, utils_1.err)(validateRes.error.message);
+            try {
+                const bip32InterfaceRes = await this._wallet.getBip32Interface();
+                if (bip32InterfaceRes.isErr()) {
+                    return (0, utils_1.err)(bip32InterfaceRes.error.message);
+                }
+                const psbtRes = await this.createPsbtFromTransactionData({
+                    transactionData,
+                    bip32Interface: bip32InterfaceRes.value,
+                    shuffleTargets: shuffleOutputs
+                });
+                if (psbtRes.isErr()) {
+                    return (0, utils_1.err)(psbtRes.error);
+                }
+                const psbt = psbtRes.value;
+                const signedPsbtRes = await this.signPsbt({
+                    psbt,
+                    bip32Interface: bip32InterfaceRes.value
+                });
+                if (signedPsbtRes.isErr()) {
+                    return (0, utils_1.err)(signedPsbtRes.error);
+                }
+                const tx = signedPsbtRes.value.extractTransaction();
+                const id = tx.getId();
+                const hex = tx.toHex();
+                return (0, utils_1.ok)({ id, hex });
+            }
+            catch (e) {
+                return (0, utils_1.err)(e);
+            }
+        };
+        this.getTransactionInputValue = ({ inputs }) => {
+            try {
+                if (!inputs) {
+                    const transaction = this.data;
+                    inputs = transaction.inputs;
+                }
+                if (inputs) {
+                    const response = (0, utils_2.reduceValue)({ arr: inputs, value: 'value' });
+                    if (response.isOk()) {
+                        return response.value;
+                    }
+                }
+                return 0;
+            }
+            catch (e) {
+                return 0;
+            }
+        };
+        this.signPsbt = async ({ psbt, bip32Interface }) => {
+            const transactionDataRes = this.data;
+            const { inputs } = transactionDataRes;
+            for (const [index, input] of inputs.entries()) {
+                try {
+                    const keyPair = bip32Interface.derivePath(input.path);
+                    psbt.signInput(index, keyPair);
+                }
+                catch (e) {
+                    return (0, utils_1.err)(e);
+                }
+            }
+            psbt.finalizeAllInputs();
+            return (0, utils_1.ok)(psbt);
+        };
+        this.createPsbtFromTransactionData = async ({ transactionData, bip32Interface, shuffleTargets = true }) => {
+            const { inputs, outputs, fee, rbf } = transactionData;
+            let { changeAddress, message } = transactionData;
+            const balance = this.getTransactionInputValue({
+                inputs
+            });
+            const outputValue = this.getTransactionOutputValue({
+                outputs
+            });
+            const network = bitcoinjs_lib_1.networks[this._wallet.network];
+            let targets = outputs.concat();
+            if (changeAddress) {
+                const changeAddressValue = balance - (outputValue + fee);
+                if (changeAddressValue > constants_1.TRANSACTION_DEFAULTS.dustLimit) {
+                    targets.push({
+                        address: changeAddress,
+                        value: changeAddressValue,
+                        index: targets.length
+                    });
+                }
+            }
+            else if (outputValue + fee < balance) {
+                const diffValue = balance - (outputValue + fee);
+                if (diffValue > constants_1.TRANSACTION_DEFAULTS.dustLimit) {
+                    const changeAddressRes = await this._wallet.getChangeAddress();
+                    if (changeAddressRes.isErr()) {
+                        return (0, utils_1.err)(changeAddressRes.error.message);
+                    }
+                    changeAddress = changeAddressRes.value.address;
+                    targets.push({
+                        address: changeAddress,
+                        value: diffValue,
+                        index: targets.length
+                    });
+                }
+            }
+            if (message.trim() !== '') {
+                const messageLength = message.length;
+                const lengthMin = 5;
+                if (messageLength > 0 && messageLength < lengthMin) {
+                    message += ' '.repeat(lengthMin - messageLength);
+                }
+                const data = Buffer.from(message, 'utf8');
+                const embed = bitcoin.payments.embed({
+                    data: [data],
+                    network
+                });
+                targets.push({ script: embed.output, value: 0, index: targets.length });
+            }
+            if (!bip32Interface) {
+                const bip32InterfaceRes = await this._wallet.getBip32Interface();
+                if (bip32InterfaceRes.isErr()) {
+                    return (0, utils_1.err)(bip32InterfaceRes.error.message);
+                }
+                bip32Interface = bip32InterfaceRes.value;
+            }
+            const root = bip32Interface;
+            const psbt = new bitcoin.Psbt({ network });
+            try {
+                for (const input of inputs) {
+                    const path = input.path;
+                    const keyPair = root.derivePath(path);
+                    await this.addInput({
+                        psbt,
+                        keyPair,
+                        input
+                    });
+                }
+            }
+            catch (e) {
+                return (0, utils_1.err)(e);
+            }
+            (0, utils_3.setReplaceByFee)({ psbt, setRbf: !!rbf });
+            if (shuffleTargets) {
+                targets = (0, utils_2.shuffleArray)(targets);
+            }
+            targets.forEach((target) => {
+                var _a;
+                let isOpReturn = false;
+                try {
+                    isOpReturn = !!target.script;
+                }
+                catch (e) { }
+                if (isOpReturn) {
+                    if (target.script) {
+                        psbt.addOutput({
+                            script: target.script,
+                            value: (_a = target.value) !== null && _a !== void 0 ? _a : 0
+                        });
+                    }
+                }
+                else {
+                    if (target.address && target.value) {
+                        psbt.addOutput({
+                            address: target.address,
+                            value: target.value
+                        });
+                    }
+                }
+            });
+            return (0, utils_1.ok)(psbt);
+        };
+        this.addInput = async ({ psbt, keyPair, input }) => {
+            try {
+                const network = bitcoinjs_lib_1.networks[this._wallet.network];
+                const { type } = (0, bitcoin_address_validation_1.getAddressInfo)(input.address);
+                if (!input.value) {
+                    return (0, utils_1.err)('No input provided.');
+                }
+                if (type === 'p2wpkh') {
+                    const p2wpkh = bitcoin.payments.p2wpkh({
+                        pubkey: keyPair.publicKey,
+                        network
+                    });
+                    if (!(p2wpkh === null || p2wpkh === void 0 ? void 0 : p2wpkh.output)) {
+                        return (0, utils_1.err)('p2wpkh.output is undefined.');
+                    }
+                    psbt.addInput({
+                        hash: input.tx_hash,
+                        index: input.tx_pos,
+                        witnessUtxo: {
+                            script: p2wpkh.output,
+                            value: input.value
+                        }
+                    });
+                }
+                if (type === 'p2sh') {
+                    const p2wpkh = bitcoin.payments.p2wpkh({
+                        pubkey: keyPair.publicKey,
+                        network
+                    });
+                    const p2sh = bitcoin.payments.p2sh({ redeem: p2wpkh, network });
+                    if (!(p2sh === null || p2sh === void 0 ? void 0 : p2sh.output)) {
+                        return (0, utils_1.err)('p2sh.output is undefined.');
+                    }
+                    if (!(p2sh === null || p2sh === void 0 ? void 0 : p2sh.redeem)) {
+                        return (0, utils_1.err)('p2sh.redeem.output is undefined.');
+                    }
+                    psbt.addInput({
+                        hash: input.tx_hash,
+                        index: input.tx_pos,
+                        witnessUtxo: {
+                            script: p2sh.output,
+                            value: input.value
+                        },
+                        redeemScript: p2sh.redeem.output
+                    });
+                }
+                if (type === 'p2pkh') {
+                    const transaction = await this._wallet.electrum.getTransactions({
+                        txHashes: [{ tx_hash: input.tx_hash }]
+                    });
+                    if (transaction.isErr()) {
+                        return (0, utils_1.err)(transaction.error.message);
+                    }
+                    const hex = transaction.value.data[0].result.hex;
+                    const nonWitnessUtxo = Buffer.from(hex, 'hex');
+                    psbt.addInput({
+                        hash: input.tx_hash,
+                        index: input.tx_pos,
+                        nonWitnessUtxo
+                    });
+                }
+                return (0, utils_1.ok)('Success');
+            }
+            catch (_a) {
+                return (0, utils_1.err)('Unable to add input.');
+            }
+        };
+        this.addOutput = async ({ address, value, index = 0 }) => {
+            var _a;
+            if (!((_a = this.data.inputs) === null || _a === void 0 ? void 0 : _a.length)) {
+                const setupRes = await this.setupTransaction();
+                if (setupRes.isErr())
+                    return (0, utils_1.err)(setupRes.error.message);
+            }
+            return this.updateSendTransaction({
+                transaction: {
+                    outputs: [{ address, value, index }]
+                }
+            });
+        };
+        this.getTransactionOutputValue = ({ outputs } = {}) => {
+            try {
+                if (!outputs) {
+                    const transaction = this.data;
+                    outputs = transaction.outputs;
+                }
+                const response = (0, utils_2.reduceValue)({ arr: outputs, value: 'value' });
+                if (response.isOk()) {
+                    return response.value;
+                }
+                return 0;
+            }
+            catch (_a) {
+                return 0;
+            }
+        };
+        this.updateSendTransaction = ({ transaction }) => {
+            try {
+                if (transaction.outputs) {
+                    const currentTransaction = this._wallet.transaction.data;
+                    const outputs = currentTransaction.outputs.concat();
+                    transaction.outputs.forEach((output) => {
+                        outputs[output.index] = output;
+                    });
+                    transaction.outputs = outputs;
+                }
+                this._data = Object.assign(Object.assign({}, this._data), transaction);
+                this._wallet.saveWalletData('transaction', this.data).then();
+                return (0, utils_1.ok)('Transaction updated');
+            }
+            catch (e) {
+                return (0, utils_1.err)(e);
+            }
+        };
+        this.sendMax = async ({ address, transaction, index = 0, satsPerByte, rbf = false } = {}) => {
+            var _a, _b, _c, _d;
+            try {
+                if (!transaction) {
+                    transaction = this.data;
+                }
+                if (!((_a = transaction.inputs) === null || _a === void 0 ? void 0 : _a.length)) {
+                    const setupRes = await this.setupTransaction({ rbf });
+                    if (setupRes.isErr())
+                        return (0, utils_1.err)(setupRes.error.message);
+                }
+                const outputs = (_b = transaction.outputs) !== null && _b !== void 0 ? _b : [];
+                if (!address) {
+                    address = (_d = (_c = outputs[index]) === null || _c === void 0 ? void 0 : _c.address) !== null && _d !== void 0 ? _d : '';
+                }
+                const maxAmountResponse = this.getMaxSendAmount({
+                    satsPerByte: satsPerByte !== null && satsPerByte !== void 0 ? satsPerByte : 1,
+                    selectedFeeId: transaction.selectedFeeId,
+                    transaction
+                });
+                if (maxAmountResponse.isErr()) {
+                    return (0, utils_1.err)(maxAmountResponse.error);
+                }
+                const { amount, fee } = maxAmountResponse.value;
+                if (!transaction.max) {
+                    this.updateSendTransaction({
+                        transaction: {
+                            max: true,
+                            outputs: [{ address, value: amount, index }],
+                            fee
+                        }
+                    });
+                }
+                else {
+                    this.updateSendTransaction({
+                        transaction: {
+                            max: false
+                        }
+                    });
+                }
+                return (0, utils_1.ok)('Successfully setup max send transaction.');
+            }
+            catch (e) {
+                return (0, utils_1.err)(e);
+            }
+        };
+        this.estimateTransactionCosts = ({ transaction, customFeeRate }) => {
+            var _a, _b;
+            try {
+                if (!transaction) {
+                    transaction = this.data;
+                }
+                const currentWallet = this._wallet.data;
+                const onchainBalance = currentWallet.balance;
+                const inputValue = this.getTransactionInputValue({
+                    inputs: transaction.inputs
+                });
+                const amount = onchainBalance > inputValue ? onchainBalance : inputValue;
+                let utxos = [];
+                if (transaction.inputs.length > (currentWallet === null || currentWallet === void 0 ? void 0 : currentWallet.utxos.length)) {
+                    utxos = transaction.inputs;
+                }
+                else {
+                    utxos = (_a = currentWallet === null || currentWallet === void 0 ? void 0 : currentWallet.utxos) !== null && _a !== void 0 ? _a : [];
+                }
+                const fees = this._wallet.feeEstimates;
+                const selectedFeeId = this._wallet.selectedFeeId;
+                const satsPerByte = (_b = customFeeRate !== null && customFeeRate !== void 0 ? customFeeRate : fees[selectedFeeId]) !== null && _b !== void 0 ? _b : 1;
+                const fee = this.getTotalFee({
+                    satsPerByte,
+                    message: transaction.message,
+                    transaction: Object.assign(Object.assign({}, transaction), { max: true, inputs: utxos, selectedFeeId,
+                        satsPerByte })
+                });
+                const maxAmount = {
+                    amount: amount - fee,
+                    fee,
+                    satsPerByte
+                };
+                if (amount <= fee) {
+                    return (0, utils_1.err)('Balance is too low to spend.');
+                }
+                return (0, utils_1.ok)(maxAmount);
+            }
+            catch (e) {
+                return (0, utils_1.err)(e);
+            }
+        };
+        this._wallet = wallet;
+        this._data = (0, shapes_1.getDefaultSendTransaction)();
+    }
+    get data() {
+        return this._data;
+    }
+    async setupTransaction({ inputTxHashes, utxos, rbf = false, satsPerByte = 1 } = {}) {
+        var _a;
+        try {
+            const addressType = this._wallet.data.addressType;
+            const currentWallet = this._wallet.data;
+            const transaction = currentWallet.transaction;
+            let inputs = [];
+            if (inputTxHashes) {
+                inputs = currentWallet.utxos.filter((utxo) => {
+                    return inputTxHashes.includes(utxo.tx_hash);
+                });
+            }
+            else if (utxos) {
+                inputs = utxos;
+            }
+            else {
+                inputs = currentWallet.utxos;
+            }
+            if (!inputs.length) {
+                if (transaction.inputs.length > 0) {
+                    inputs = transaction.inputs;
+                }
+                else {
+                    inputs = this.removeBlackListedUtxos(currentWallet.utxos);
+                }
+            }
+            if (!inputs.length) {
+                return (0, utils_1.err)('No inputs specified.');
+            }
+            const currentChangeAddresses = currentWallet.changeAddresses;
+            const addressTypeKeys = Object.values(types_1.EAddressType);
+            let changeAddresses = {};
+            addressTypeKeys.forEach((key) => {
+                changeAddresses = Object.assign(Object.assign({}, changeAddresses), currentChangeAddresses[key]);
+            });
+            const changeAddressesArr = Object.values(changeAddresses).map(({ address }) => address);
+            const changeAddressIndexContent = currentWallet.changeAddressIndex[addressType];
+            const changeAddress = changeAddressIndexContent.address;
+            if (!changeAddress) {
+                return (0, utils_1.err)('Unable to successfully generate a change address.');
+            }
+            const fee = this.getTotalFee({
+                satsPerByte,
+                message: ''
+            });
+            const lightningInvoice = (_a = currentWallet.transaction) === null || _a === void 0 ? void 0 : _a.lightningInvoice;
+            let outputs = currentWallet.transaction.outputs || [];
+            if (!lightningInvoice) {
+                outputs = outputs.filter((output) => {
+                    if (output.address && !changeAddressesArr.includes(output.address)) {
+                        return output;
+                    }
+                });
+            }
+            const payload = {
+                inputs,
+                changeAddress,
+                fee,
+                outputs,
+                rbf,
+                satsPerByte
+            };
+            this._data = Object.assign(Object.assign({}, this._data), payload);
+            await this._wallet.saveWalletData('transaction', this._data);
+            return (0, utils_1.ok)(payload);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async resetSendTransaction() {
+        this._data = (0, shapes_1.getDefaultSendTransaction)();
+        await this._wallet.saveWalletData('transaction', this._data);
+        return (0, utils_1.ok)('Transaction reset.');
+    }
+    removeBlackListedUtxos(utxos) {
+        if (!utxos) {
+            utxos = this._wallet.data.utxos;
+        }
+        const blacklistedUtxos = this._wallet.data.blacklistedUtxos;
+        return utxos.filter((utxo) => {
+            return !blacklistedUtxos.find((blacklistedUtxo) => utxo.address === blacklistedUtxo.address &&
+                utxo.height === blacklistedUtxo.height &&
+                utxo.tx_hash === blacklistedUtxo.tx_hash &&
+                utxo.tx_pos === blacklistedUtxo.tx_pos);
+        });
+    }
+    updateFee({ satsPerByte, selectedFeeId = types_1.EFeeId.custom, index = 0, transaction = this.data }) {
+        var _a, _b;
+        const inputTotal = this.getTransactionInputValue({
+            inputs: transaction.inputs
+        });
+        const { max, message, outputs } = transaction;
+        let address = '';
+        if (outputs.length > index) {
+            address = (_b = (_a = outputs[index]) === null || _a === void 0 ? void 0 : _a.address) !== null && _b !== void 0 ? _b : '';
+        }
+        const newFee = this.getTotalFee({ satsPerByte, message });
+        if (newFee >= inputTotal / 2) {
+            return (0, utils_1.err)('Unable to increase the fee any further. Otherwise, it will exceed half the current balance.');
+        }
+        const totalTransactionValue = this.getTransactionOutputValue({
+            outputs
+        });
+        const newTotalAmount = totalTransactionValue + newFee;
+        const _transaction = {
+            satsPerByte,
+            fee: newFee,
+            selectedFeeId
+        };
+        if (max) {
+            _transaction.outputs = [{ address, value: inputTotal - newFee, index }];
+        }
+        if (max || newTotalAmount <= inputTotal) {
+            this.updateSendTransaction({
+                transaction: _transaction
+            });
+            return (0, utils_1.ok)({ fee: newFee });
+        }
+        return (0, utils_1.err)('New total amount exceeds the available balance. Unable to update the transaction fee.');
+    }
+    getMaxSendAmount({ satsPerByte, selectedFeeId = types_1.EFeeId.none, transaction }) {
+        var _a;
+        try {
+            if (!transaction) {
+                transaction = this.data;
+            }
+            const currentWallet = this._wallet.data;
+            const onchainBalance = currentWallet.balance;
+            const inputValue = this.getTransactionInputValue({
+                inputs: transaction.inputs
+            });
+            const amount = onchainBalance > inputValue ? onchainBalance : inputValue;
+            let utxos = [];
+            if (transaction.inputs.length > (currentWallet === null || currentWallet === void 0 ? void 0 : currentWallet.utxos.length)) {
+                utxos = transaction.inputs;
+            }
+            else {
+                utxos = (_a = currentWallet === null || currentWallet === void 0 ? void 0 : currentWallet.utxos) !== null && _a !== void 0 ? _a : [];
+            }
+            const fee = this.getTotalFee({
+                satsPerByte,
+                message: transaction.message,
+                transaction: Object.assign(Object.assign({}, transaction), { max: true, inputs: utxos, selectedFeeId,
+                    satsPerByte })
+            });
+            const maxAmount = {
+                amount: amount - fee,
+                fee
+            };
+            if (amount <= fee) {
+                return (0, utils_1.err)('Balance is too low to spend.');
+            }
+            return (0, utils_1.ok)(maxAmount);
+        }
+        catch (e) {
+            return (0, utils_1.err)(e);
+        }
+    }
+    async setupCpfp({ txid, satsPerByte }) {
+        var _a, _b;
+        const response = await this.setupTransaction({
+            inputTxHashes: txid ? [txid] : undefined,
+            rbf: true
+        });
+        const receiveAddress = await this._wallet.getReceiveAddress({});
+        if (receiveAddress.isErr()) {
+            return (0, utils_1.err)(receiveAddress.error.message);
+        }
+        this._data = Object.assign(Object.assign(Object.assign({}, this._data), response), { satsPerByte: (_b = satsPerByte !== null && satsPerByte !== void 0 ? satsPerByte : (_a = this.data) === null || _a === void 0 ? void 0 : _a.satsPerByte) !== null && _b !== void 0 ? _b : 1, boostType: types_1.EBoostType.cpfp });
+        const sendMaxResponse = await this.sendMax({
+            address: receiveAddress.value
+        });
+        if (sendMaxResponse.isErr()) {
+            return (0, utils_1.err)(sendMaxResponse.error.message);
+        }
+        return (0, utils_1.ok)(this.data);
+    }
+}
+exports.Transaction = Transaction;
+//# sourceMappingURL=index.js.map