@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/bitcoin/mempool/MempoolBitcoinRpc.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MempoolBitcoinRpc = void 0;
+const MempoolBitcoinBlock_1 = require("./MempoolBitcoinBlock");
+const MempoolApi_1 = require("./MempoolApi");
+const buffer_1 = require("buffer");
+const Utils_1 = require("../../utils/Utils");
+const btc_signer_1 = require("@scure/btc-signer");
+const sha2_1 = require("@noble/hashes/sha2");
+const TimeoutUtils_1 = require("../../utils/TimeoutUtils");
+const BITCOIN_BLOCKTIME = 600 * 1000;
+const BITCOIN_BLOCKSIZE = 1024 * 1024;
+function bitcoinTxToBtcTx(btcTx) {
+    return {
+        locktime: btcTx.lockTime,
+        version: btcTx.version,
+        confirmations: 0,
+        txid: buffer_1.Buffer.from((0, sha2_1.sha256)((0, sha2_1.sha256)(btcTx.toBytes(true, false)))).reverse().toString("hex"),
+        hex: buffer_1.Buffer.from(btcTx.toBytes(true, false)).toString("hex"),
+        raw: buffer_1.Buffer.from(btcTx.toBytes(true, true)).toString("hex"),
+        vsize: btcTx.isFinal ? btcTx.vsize : NaN,
+        outs: Array.from({ length: btcTx.outputsLength }, (_, i) => i).map((index) => {
+            const output = btcTx.getOutput(index);
+            return {
+                value: Number(output.amount),
+                n: index,
+                scriptPubKey: {
+                    asm: btc_signer_1.Script.decode(output.script).map(val => typeof (val) === "object" ? buffer_1.Buffer.from(val).toString("hex") : val.toString()).join(" "),
+                    hex: buffer_1.Buffer.from(output.script).toString("hex")
+                }
+            };
+        }),
+        ins: Array.from({ length: btcTx.inputsLength }, (_, i) => i).map(index => {
+            const input = btcTx.getInput(index);
+            return {
+                txid: buffer_1.Buffer.from(input.txid).toString("hex"),
+                vout: input.index,
+                scriptSig: {
+                    asm: btc_signer_1.Script.decode(input.finalScriptSig).map(val => typeof (val) === "object" ? buffer_1.Buffer.from(val).toString("hex") : val.toString()).join(" "),
+                    hex: buffer_1.Buffer.from(input.finalScriptSig).toString("hex")
+                },
+                sequence: input.sequence,
+                txinwitness: input.finalScriptWitness == null ? [] : input.finalScriptWitness.map(witness => buffer_1.Buffer.from(witness).toString("hex"))
+            };
+        })
+    };
+}
+/**
+ * Bitcoin RPC implementation via Mempool.space API
+ * @category Bitcoin
+ */
+class MempoolBitcoinRpc {
+    constructor(urlOrMempoolApi) {
+        this.api = urlOrMempoolApi instanceof MempoolApi_1.MempoolApi ? urlOrMempoolApi : new MempoolApi_1.MempoolApi(urlOrMempoolApi);
+    }
+    /**
+     * Returns a txo hash for a specific transaction vout
+     *
+     * @param vout
+     * @private
+     */
+    static getTxoHash(vout) {
+        return (0, Utils_1.getTxoHash)(vout.scriptpubkey, vout.value);
+    }
+    /**
+     * Returns delay in milliseconds till an unconfirmed transaction is expected to confirm, returns -1
+     *  if the transaction won't confirm any time soon
+     *
+     * @param feeRate
+     * @private
+     */
+    async getTimeTillConfirmation(feeRate) {
+        const mempoolBlocks = await this.api.getPendingBlocks();
+        const mempoolBlockIndex = mempoolBlocks.findIndex(block => block.feeRange[0] <= feeRate);
+        if (mempoolBlockIndex === -1)
+            return -1;
+        //Last returned block is usually an aggregate (or a stack) of multiple btc blocks, if tx falls in this block
+        // and the last returned block really is an aggregate one (size bigger than BITCOIN_BLOCKSIZE) we return -1
+        if (mempoolBlockIndex + 1 === mempoolBlocks.length &&
+            mempoolBlocks[mempoolBlocks.length - 1].blockVSize > BITCOIN_BLOCKSIZE)
+            return -1;
+        return (mempoolBlockIndex + 1) * BITCOIN_BLOCKTIME;
+    }
+    /**
+     * Returns an estimate after which time the tx will confirm with the required amount of confirmations,
+     *  confirmationDelay of -1 means the transaction won't confirm in the near future
+     *
+     * @param tx
+     * @param requiredConfirmations
+     * @private
+     *
+     * @returns estimated confirmation delay, -1 if the transaction won't confirm in the near future, null if the
+     *  transaction was replaced or was confirmed in the meantime
+     */
+    async getConfirmationDelay(tx, requiredConfirmations) {
+        if (tx.confirmations == null || tx.confirmations === 0) {
+            //Get CPFP data
+            const cpfpData = await this.api.getCPFPData(tx.txid);
+            if (cpfpData.effectiveFeePerVsize == null) {
+                //Transaction is either confirmed in the meantime, or replaced
+                return null;
+            }
+            let confirmationDelay = (await this.getTimeTillConfirmation(cpfpData.effectiveFeePerVsize));
+            if (confirmationDelay !== -1)
+                confirmationDelay += (requiredConfirmations - 1) * BITCOIN_BLOCKTIME;
+            return confirmationDelay;
+        }
+        if (tx.confirmations > requiredConfirmations)
+            return 0;
+        return ((requiredConfirmations - tx.confirmations) * BITCOIN_BLOCKTIME);
+    }
+    /**
+     * Converts mempool API's transaction to BtcTx object while fetching the raw tx separately
+     * @param tx Transaction to convert
+     * @private
+     */
+    async toBtcTx(tx) {
+        const base = await this.toBtcTxWithoutRawData(tx);
+        if (base == null)
+            return null;
+        const rawTx = await this.api.getRawTransaction(tx.txid);
+        if (rawTx == null)
+            return null;
+        //Strip witness data
+        const btcTx = btc_signer_1.Transaction.fromRaw(rawTx, {
+            allowLegacyWitnessUtxo: true,
+            allowUnknownInputs: true,
+            allowUnknownOutputs: true,
+            disableScriptCheck: true
+        });
+        const strippedRawTx = buffer_1.Buffer.from(btcTx.toBytes(true, false)).toString("hex");
+        return {
+            ...base,
+            hex: strippedRawTx,
+            raw: rawTx.toString("hex")
+        };
+    }
+    /**
+     * Converts mempool API's transaction to BtcTx object, doesn't populate raw and hex fields
+     * @param tx Transaction to convert
+     * @private
+     */
+    async toBtcTxWithoutRawData(tx) {
+        let confirmations = 0;
+        if (tx.status != null && tx.status.confirmed) {
+            const blockheight = await this.api.getTipBlockHeight();
+            confirmations = blockheight - tx.status.block_height + 1;
+        }
+        return {
+            locktime: tx.locktime,
+            version: tx.version,
+            blockheight: tx.status?.block_height,
+            blockhash: tx.status?.block_hash,
+            confirmations,
+            txid: tx.txid,
+            vsize: tx.weight / 4,
+            outs: tx.vout.map((e, index) => {
+                return {
+                    value: e.value,
+                    n: index,
+                    scriptPubKey: {
+                        hex: e.scriptpubkey,
+                        asm: e.scriptpubkey_asm
+                    }
+                };
+            }),
+            ins: tx.vin.map(e => {
+                return {
+                    txid: e.txid,
+                    vout: e.vout,
+                    scriptSig: {
+                        hex: e.scriptsig,
+                        asm: e.scriptsig_asm
+                    },
+                    sequence: e.sequence,
+                    txinwitness: e.witness
+                };
+            }),
+            inputAddresses: tx.vin.map(e => e.prevout.scriptpubkey_address)
+        };
+    }
+    getTipHeight() {
+        return this.api.getTipBlockHeight();
+    }
+    async getBlockHeader(blockhash) {
+        return new MempoolBitcoinBlock_1.MempoolBitcoinBlock(await this.api.getBlockHeader(blockhash));
+    }
+    async getMerkleProof(txId, blockhash) {
+        const proof = await this.api.getTransactionProof(txId);
+        return {
+            reversedTxId: buffer_1.Buffer.from(txId, "hex").reverse(),
+            pos: proof.pos,
+            merkle: proof.merkle.map(e => buffer_1.Buffer.from(e, "hex").reverse()),
+            blockheight: proof.block_height
+        };
+    }
+    async getTransaction(txId) {
+        const tx = await this.api.getTransaction(txId);
+        if (tx == null)
+            return null;
+        return await this.toBtcTx(tx);
+    }
+    async isInMainChain(blockhash) {
+        const blockStatus = await this.api.getBlockStatus(blockhash);
+        return blockStatus.in_best_chain;
+    }
+    getBlockhash(height) {
+        return this.api.getBlockHash(height);
+    }
+    getBlockWithTransactions(blockhash) {
+        throw new Error("Unsupported.");
+    }
+    async getSyncInfo() {
+        const tipHeight = await this.api.getTipBlockHeight();
+        return {
+            verificationProgress: 1,
+            blocks: tipHeight,
+            headers: tipHeight,
+            ibd: false
+        };
+    }
+    async getPast15Blocks(height) {
+        return (await this.api.getPast15BlockHeaders(height)).map(blockHeader => new MempoolBitcoinBlock_1.MempoolBitcoinBlock(blockHeader));
+    }
+    async checkAddressTxos(address, txoHash) {
+        const allTxs = await this.api.getAddressTransactions(address);
+        const relevantTxs = allTxs
+            .map(tx => {
+            return {
+                tx,
+                vout: tx.vout.findIndex(vout => MempoolBitcoinRpc.getTxoHash(vout).equals(txoHash))
+            };
+        })
+            .filter(obj => obj.vout >= 0)
+            .sort((a, b) => {
+            if (a.tx.status.confirmed && !b.tx.status.confirmed)
+                return -1;
+            if (!a.tx.status.confirmed && b.tx.status.confirmed)
+                return 1;
+            if (a.tx.status.confirmed && b.tx.status.confirmed)
+                return a.tx.status.block_height - b.tx.status.block_height;
+            return 0;
+        });
+        if (relevantTxs.length === 0)
+            return null;
+        return {
+            tx: await this.toBtcTxWithoutRawData(relevantTxs[0].tx),
+            vout: relevantTxs[0].vout
+        };
+    }
+    /**
+     * Waits till the address receives a transaction containing a specific txoHash
+     *
+     * @param address
+     * @param txoHash
+     * @param requiredConfirmations
+     * @param stateUpdateCbk
+     * @param abortSignal
+     * @param intervalSeconds
+     */
+    async waitForAddressTxo(address, txoHash, requiredConfirmations, stateUpdateCbk, abortSignal, intervalSeconds) {
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+        while (abortSignal == null || !abortSignal.aborted) {
+            await (0, TimeoutUtils_1.timeoutPromise)((intervalSeconds || 5) * 1000, abortSignal);
+            const result = await this.checkAddressTxos(address, txoHash);
+            if (result == null) {
+                stateUpdateCbk();
+                continue;
+            }
+            const confirmationDelay = await this.getConfirmationDelay(result.tx, requiredConfirmations);
+            if (confirmationDelay == null)
+                continue;
+            if (stateUpdateCbk != null)
+                stateUpdateCbk(result.tx, result.vout, confirmationDelay);
+            if (confirmationDelay === 0)
+                return result;
+        }
+        throw abortSignal.reason;
+    }
+    async waitForTransaction(txId, requiredConfirmations, stateUpdateCbk, abortSignal, intervalSeconds) {
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+        while (abortSignal == null || !abortSignal.aborted) {
+            await (0, TimeoutUtils_1.timeoutPromise)((intervalSeconds || 5) * 1000, abortSignal);
+            const result = await this.getTransaction(txId);
+            if (result == null) {
+                stateUpdateCbk();
+                continue;
+            }
+            const confirmationDelay = await this.getConfirmationDelay(result, requiredConfirmations);
+            if (confirmationDelay == null)
+                continue;
+            if (stateUpdateCbk != null)
+                stateUpdateCbk(result, confirmationDelay);
+            if (confirmationDelay === 0)
+                return result;
+        }
+        throw abortSignal.reason;
+    }
+    async getLNNodeLiquidity(pubkey) {
+        const nodeInfo = await this.api.getLNNodeInfo(pubkey);
+        if (nodeInfo == null)
+            return null;
+        return {
+            publicKey: nodeInfo.public_key,
+            capacity: BigInt(nodeInfo.capacity),
+            numChannels: nodeInfo.active_channel_count
+        };
+    }
+    sendRawTransaction(rawTx) {
+        return this.api.sendTransaction(rawTx);
+    }
+    sendRawPackage(rawTx) {
+        throw new Error("Unsupported");
+    }
+    async isSpent(utxo, confirmed) {
+        const [txId, voutStr] = utxo.split(":");
+        const vout = parseInt(voutStr);
+        const outspends = await this.api.getOutspends(txId);
+        if (outspends[vout] == null)
+            return true;
+        if (confirmed) {
+            return outspends[vout].spent && outspends[vout].status.confirmed;
+        }
+        return outspends[vout].spent;
+    }
+    parseTransaction(rawTx) {
+        const btcTx = btc_signer_1.Transaction.fromRaw(buffer_1.Buffer.from(rawTx, "hex"), {
+            allowLegacyWitnessUtxo: true,
+            allowUnknownInputs: true,
+            allowUnknownOutputs: true,
+            disableScriptCheck: true
+        });
+        return Promise.resolve(bitcoinTxToBtcTx(btcTx));
+    }
+    getEffectiveFeeRate(btcTx) {
+        throw new Error("Unsupported.");
+    }
+    async getFeeRate() {
+        return (await this.api.getFees()).fastestFee;
+    }
+    getAddressBalances(address) {
+        return this.api.getAddressBalances(address);
+    }
+    async getAddressUTXOs(address) {
+        return (await this.api.getAddressUTXOs(address)).map(val => ({
+            txid: val.txid,
+            vout: val.vout,
+            confirmed: val.status.confirmed,
+            block_height: val.status.block_height,
+            block_hash: val.status.block_hash,
+            block_time: val.status.block_time,
+            value: val.value
+        }));
+    }
+    getCPFPData(txId) {
+        return this.api.getCPFPData(txId);
+    }
+}
+exports.MempoolBitcoinRpc = MempoolBitcoinRpc;

package/dist/bitcoin/mempool/synchronizer/MempoolBtcRelaySynchronizer.d.ts

@@ -0,0 +1,22 @@
+import { BtcRelay, BtcStoredHeader, RelaySynchronizer } from "@atomiqlabs/base";
+import { MempoolBitcoinBlock } from "../MempoolBitcoinBlock";
+import { MempoolBitcoinRpc } from "../MempoolBitcoinRpc";
+export declare class MempoolBtcRelaySynchronizer<B extends BtcStoredHeader<any>, TX> implements RelaySynchronizer<B, TX, MempoolBitcoinBlock> {
+    bitcoinRpc: MempoolBitcoinRpc;
+    btcRelay: BtcRelay<B, TX, MempoolBitcoinBlock>;
+    constructor(btcRelay: BtcRelay<B, TX, MempoolBitcoinBlock>, bitcoinRpc: MempoolBitcoinRpc);
+    syncToLatestTxs(signer: string, feeRate?: string): Promise<{
+        txs: TX[];
+        targetCommitedHeader: B;
+        computedHeaderMap: {
+            [blockheight: number]: B;
+        };
+        blockHeaderMap: {
+            [blockheight: number]: MempoolBitcoinBlock;
+        };
+        btcRelayTipCommitedHeader: B;
+        btcRelayTipBlockHeader: MempoolBitcoinBlock;
+        latestBlockHeader: MempoolBitcoinBlock;
+        startForkId?: number;
+    }>;
+}

package/dist/bitcoin/mempool/synchronizer/MempoolBtcRelaySynchronizer.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MempoolBtcRelaySynchronizer = void 0;
+const Logger_1 = require("../../../utils/Logger");
+const TimeoutUtils_1 = require("../../../utils/TimeoutUtils");
+const logger = (0, Logger_1.getLogger)("MempoolBtcRelaySynchronizer: ");
+class MempoolBtcRelaySynchronizer {
+    constructor(btcRelay, bitcoinRpc) {
+        this.btcRelay = btcRelay;
+        this.bitcoinRpc = bitcoinRpc;
+    }
+    async syncToLatestTxs(signer, feeRate) {
+        const tipData = await this.btcRelay.getTipData();
+        if (tipData == null)
+            throw new Error("BtcRelay tip data not found - probably not initialized?");
+        const latestKnownBlockLogData = await this.btcRelay.retrieveLatestKnownBlockLog();
+        if (latestKnownBlockLogData == null)
+            throw new Error("Failed to get latest known block log");
+        const { resultStoredHeader, resultBitcoinHeader } = latestKnownBlockLogData;
+        let cacheData = {
+            forkId: resultStoredHeader.getBlockheight() < tipData.blockheight ? -1 : 0,
+            lastStoredHeader: resultStoredHeader,
+            computedCommitedHeaders: []
+        };
+        let spvTipBlockHeader = latestKnownBlockLogData.resultBitcoinHeader;
+        logger.debug("Retrieved stored header with commitment: ", cacheData.lastStoredHeader);
+        logger.debug("SPV tip bitcoin RPC block header: ", spvTipBlockHeader);
+        let spvTipBlockHeight = spvTipBlockHeader.height;
+        const txsList = [];
+        const blockHeaderMap = {
+            [resultBitcoinHeader.getHeight()]: resultBitcoinHeader
+        };
+        const computedHeaderMap = {
+            [resultStoredHeader.getBlockheight()]: resultStoredHeader
+        };
+        let startForkId = undefined;
+        let forkFee = feeRate;
+        let mainFee = feeRate;
+        const saveHeaders = async (headerCache) => {
+            if (cacheData.forkId === -1) {
+                if (mainFee == null)
+                    mainFee = await this.btcRelay.getMainFeeRate(signer);
+                cacheData = await this.btcRelay.saveNewForkHeaders(signer, headerCache, cacheData.lastStoredHeader, tipData.chainWork, mainFee);
+            }
+            else if (cacheData.forkId === 0) {
+                if (mainFee == null)
+                    mainFee = await this.btcRelay.getMainFeeRate(signer);
+                cacheData = await this.btcRelay.saveMainHeaders(signer, headerCache, cacheData.lastStoredHeader, mainFee);
+            }
+            else {
+                if (forkFee == null)
+                    forkFee = await this.btcRelay.getForkFeeRate(signer, cacheData.forkId);
+                cacheData = await this.btcRelay.saveForkHeaders(signer, headerCache, cacheData.lastStoredHeader, cacheData.forkId, tipData.chainWork, forkFee);
+            }
+            if (cacheData.forkId !== -1 && cacheData.forkId !== 0)
+                startForkId = cacheData.forkId;
+            txsList.push(cacheData.tx);
+            for (let storedHeader of cacheData.computedCommitedHeaders) {
+                computedHeaderMap[storedHeader.getBlockheight()] = storedHeader;
+            }
+        };
+        let headerCache = [];
+        while (true) {
+            const retrievedHeaders = await this.bitcoinRpc.getPast15Blocks(spvTipBlockHeight + 15);
+            let startIndex = retrievedHeaders.findIndex(val => val.height === spvTipBlockHeight);
+            if (startIndex === -1)
+                startIndex = retrievedHeaders.length; //Start from the last block
+            for (let i = startIndex - 1; i >= 0; i--) {
+                const header = retrievedHeaders[i];
+                blockHeaderMap[header.height] = header;
+                headerCache.push(header);
+                if (cacheData.forkId === 0 ?
+                    headerCache.length >= this.btcRelay.maxHeadersPerTx :
+                    headerCache.length >= this.btcRelay.maxForkHeadersPerTx) {
+                    await saveHeaders(headerCache);
+                    headerCache = [];
+                }
+            }
+            if (retrievedHeaders.length > 0) {
+                if (spvTipBlockHeight === retrievedHeaders[0].height)
+                    break; //Already at the tip
+                spvTipBlockHeight = retrievedHeaders[0].height;
+                await (0, TimeoutUtils_1.timeoutPromise)(1000);
+            }
+            else
+                break;
+        }
+        if (headerCache.length > 0)
+            await saveHeaders(headerCache);
+        if (cacheData.forkId !== 0) {
+            throw new Error("Unable to synchronize on-chain bitcoin light client! Not enough chainwork at connected RPC.");
+        }
+        return {
+            txs: txsList,
+            targetCommitedHeader: cacheData.lastStoredHeader,
+            blockHeaderMap,
+            computedHeaderMap,
+            btcRelayTipCommitedHeader: resultStoredHeader,
+            btcRelayTipBlockHeader: resultBitcoinHeader,
+            latestBlockHeader: spvTipBlockHeader,
+            startForkId
+        };
+    }
+}
+exports.MempoolBtcRelaySynchronizer = MempoolBtcRelaySynchronizer;

package/dist/bitcoin/wallet/BitcoinWallet.d.ts

@@ -0,0 +1,93 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { CoinselectAddressTypes } from "../coinselect2";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { Transaction } from "@scure/btc-signer";
+import { IBitcoinWallet } from "./IBitcoinWallet";
+import { Buffer } from "buffer";
+import { BitcoinRpcWithAddressIndex } from "../BitcoinRpcWithAddressIndex";
+/**
+ * UTXO data structure for Bitcoin wallets
+ * @category Bitcoin
+ */
+export type BitcoinWalletUtxo = {
+    vout: number;
+    txId: string;
+    value: number;
+    type: CoinselectAddressTypes;
+    outputScript: Buffer;
+    address: string;
+    cpfp?: {
+        txVsize: number;
+        txEffectiveFeeRate: number;
+    };
+    confirmed: boolean;
+};
+/**
+ * Identifies the address type of a Bitcoin address
+ * @category Bitcoin
+ */
+export declare function identifyAddressType(address: string, network: BTC_NETWORK): CoinselectAddressTypes;
+/**
+ * Abstract base class for Bitcoin wallet implementations
+ * @category Bitcoin
+ */
+export declare abstract class BitcoinWallet implements IBitcoinWallet {
+    rpc: BitcoinRpcWithAddressIndex<any>;
+    network: BTC_NETWORK;
+    feeMultiplier: number;
+    feeOverride?: number;
+    constructor(mempoolApi: BitcoinRpcWithAddressIndex<any>, network: BTC_NETWORK, feeMultiplier?: number, feeOverride?: number);
+    getFeeRate(): Promise<number>;
+    protected _sendTransaction(rawHex: string): Promise<string>;
+    protected _getBalance(address: string): Promise<{
+        confirmedBalance: bigint;
+        unconfirmedBalance: bigint;
+    }>;
+    protected _getUtxoPool(sendingAddress: string, sendingAddressType: CoinselectAddressTypes): Promise<BitcoinWalletUtxo[]>;
+    protected _getPsbt(sendingAccounts: {
+        pubkey: string;
+        address: string;
+        addressType: CoinselectAddressTypes;
+    }[], recipient: string, amount: number, feeRate?: number): Promise<{
+        fee: number;
+        psbt?: Transaction;
+        inputAddressIndexes?: {
+            [address: string]: number[];
+        };
+    }>;
+    protected _fundPsbt(sendingAccounts: {
+        pubkey: string;
+        address: string;
+        addressType: CoinselectAddressTypes;
+    }[], psbt: Transaction, feeRate?: number): Promise<{
+        fee: number;
+        psbt?: Transaction;
+        inputAddressIndexes?: {
+            [address: string]: number[];
+        };
+    }>;
+    protected _getSpendableBalance(sendingAccounts: {
+        address: string;
+        addressType: CoinselectAddressTypes;
+    }[], psbt?: Transaction, feeRate?: number): Promise<{
+        balance: bigint;
+        feeRate: number;
+        totalFee: number;
+    }>;
+    abstract sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
+    abstract fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
+    abstract signPsbt(psbt: Transaction, signInputs: number[]): Promise<Transaction>;
+    abstract getTransactionFee(address: string, amount: bigint, feeRate?: number): Promise<number>;
+    abstract getFundedPsbtFee(psbt: Transaction, feeRate?: number): Promise<number>;
+    abstract getReceiveAddress(): string;
+    abstract getBalance(): Promise<{
+        confirmedBalance: bigint;
+        unconfirmedBalance: bigint;
+    }>;
+    abstract getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+        balance: bigint;
+        feeRate: number;
+        totalFee: number;
+    }>;
+}