@atomiqlabs/lp-lib 16.1.2 → 16.2.0

package/dist/swaps/spv_vault_swap/SpvVaultSwapHandler.js

@@ -420,7 +420,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
             const { spvVaultContract } = this.getChain(swap.chainIdentifier);
             let data;
             try {
-                data = await spvVaultContract.getWithdrawalData(await this.bitcoin.parsePsbt(transaction));
+                data = await spvVaultContract.getWithdrawalData((0, Utils_1.parsePsbt)(transaction));
             }
             catch (e) {
                 this.swapLogger.error(swap, "REST: /postQuote: failed to parse PSBT to withdrawal tx data: ", e);
@@ -463,7 +463,7 @@ class SpvVaultSwapHandler extends SwapHandler_1.SwapHandler {
                     code: 20513,
                     msg: "One or more PSBT inputs not finalized!"
                 };
-            const effectiveFeeRate = await this.bitcoinRpc.getEffectiveFeeRate(await this.bitcoin.parsePsbt(signedTx));
+            const effectiveFeeRate = await this.bitcoinRpc.getEffectiveFeeRate((0, Utils_1.parsePsbt)(signedTx));
             if (effectiveFeeRate.feeRate < 1 || Math.round(effectiveFeeRate.feeRate) < swap.btcFeeRate)
                 throw {
                     code: 20511,

package/dist/utils/Utils.d.ts

@@ -1,5 +1,7 @@
 import { Request, Response } from "express";
 import { ServerParamEncoder } from "./paramcoders/server/ServerParamEncoder";
+import { Transaction } from "@scure/btc-signer";
+import { BtcTx } from "@atomiqlabs/base";
 export type LoggerType = {
     debug: (msg: string, ...args: any[]) => void;
     info: (msg: string, ...args: any[]) => void;
@@ -27,3 +29,4 @@ export declare function bigIntSorter(a: bigint, b: bigint): -1 | 0 | 1;
  * @param responseStream
  */
 export declare function getAbortController(responseStream: ServerParamEncoder): AbortController;
+export declare function parsePsbt(btcTx: Transaction): BtcTx;

package/dist/utils/Utils.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAbortController = exports.bigIntSorter = exports.deserializeBN = exports.serializeBN = exports.HEX_REGEX = exports.expressHandlerWrapper = exports.isDefinedRuntimeError = exports.getLogger = void 0;
+exports.parsePsbt = exports.getAbortController = exports.bigIntSorter = exports.deserializeBN = exports.serializeBN = exports.HEX_REGEX = exports.expressHandlerWrapper = exports.isDefinedRuntimeError = exports.getLogger = void 0;
+const crypto_1 = require("crypto");
+const btc_signer_1 = require("@scure/btc-signer");
 function getLogger(prefix) {
     return {
         debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug((typeof (prefix) === "function" ? prefix() : prefix) + msg, ...args),
@@ -87,3 +89,41 @@ function getAbortController(responseStream) {
     return abortController;
 }
 exports.getAbortController = getAbortController;
+function parsePsbt(btcTx) {
+    const txWithoutWitness = btcTx.toBytes(true, false);
+    return {
+        locktime: btcTx.lockTime,
+        version: btcTx.version,
+        blockhash: null,
+        confirmations: 0,
+        txid: (0, crypto_1.createHash)("sha256").update((0, crypto_1.createHash)("sha256").update(txWithoutWitness).digest()).digest().reverse().toString("hex"),
+        hex: Buffer.from(txWithoutWitness).toString("hex"),
+        raw: Buffer.from(btcTx.toBytes(true, true)).toString("hex"),
+        vsize: btcTx.isFinal ? btcTx.vsize : null,
+        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.from(val).toString("hex") : val.toString()).join(" "),
+                    hex: Buffer.from(output.script).toString("hex")
+                }
+            };
+        }),
+        ins: Array.from({ length: btcTx.inputsLength }, (_, i) => i).map(index => {
+            const input = btcTx.getInput(index);
+            return {
+                txid: Buffer.from(input.txid).toString("hex"),
+                vout: input.index,
+                scriptSig: {
+                    asm: btc_signer_1.Script.decode(input.finalScriptSig).map(val => typeof (val) === "object" ? Buffer.from(val).toString("hex") : val.toString()).join(" "),
+                    hex: Buffer.from(input.finalScriptSig).toString("hex")
+                },
+                sequence: input.sequence,
+                txinwitness: input.finalScriptWitness == null ? [] : input.finalScriptWitness.map(witness => Buffer.from(witness).toString("hex"))
+            };
+        })
+    };
+}
+exports.parsePsbt = parsePsbt;

package/dist/wallets/IBitcoinWallet.d.ts

@@ -2,6 +2,7 @@
 import { BtcTx } from "@atomiqlabs/base";
 import { Command } from "@atomiqlabs/server-base";
 import { Transaction } from "@scure/btc-signer";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
 export type BitcoinUtxo = {
     address: string;
     type: "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
@@ -18,55 +19,129 @@ export type SignPsbtResponse = {
     txId: string;
     networkFee: number;
 };
-export interface IBitcoinWallet {
-    init(): Promise<void>;
-    isReady(): boolean;
-    getStatus(): string;
-    getStatusInfo(): Promise<Record<string, string>>;
-    getCommands(): Command<any>[];
+export declare abstract class IBitcoinWallet {
+    readonly network: BTC_NETWORK;
+    protected constructor(network: BTC_NETWORK);
     toOutputScript(address: string): Buffer;
-    getAddressType(): "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
+    getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
+    getSignedMultiTransaction(destinations: {
+        address: string;
+        amount: number;
+    }[], feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
+    estimateFee(destination: string, amount: number, feeRate?: number, feeRateMultiplier?: number): Promise<{
+        satsPerVbyte: number;
+        networkFee: number;
+    }>;
+    drainAll(destination: string | Buffer, inputs: Omit<BitcoinUtxo, "address">[], feeRate?: number): Promise<SignPsbtResponse>;
+    burnAll(inputs: Omit<BitcoinUtxo, "address">[]): Promise<SignPsbtResponse>;
+    /**
+     * Initializes the wallet, called before any actions on the wallet
+     */
+    abstract init(): Promise<void>;
+    /**
+     * Returns whether the wallet is ready
+     */
+    abstract isReady(): boolean;
+    /**
+     * Returns the status defined string to be displayed in the status message
+     */
+    abstract getStatus(): string;
+    /**
+     * Additional status information to be displayed in the status message
+     */
+    abstract getStatusInfo(): Promise<Record<string, string>>;
+    /**
+     * Returns the commands that will be exposed
+     */
+    abstract getCommands(): Command<any>[];
+    /**
+     * Returns the address type of the wallet
+     */
+    abstract getAddressType(): "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
     /**
      * Returns an unused address suitable for receiving
      */
-    getAddress(): Promise<string>;
+    abstract getAddress(): Promise<string>;
     /**
      * Adds previously returned address (with getAddress call), to the pool of unused addresses
      * @param address
      */
-    addUnusedAddress(address: string): Promise<void>;
-    getUtxos(): Promise<BitcoinUtxo[]>;
-    getBalance(): Promise<{
+    abstract addUnusedAddress(address: string): Promise<void>;
+    /**
+     * Returns the wallet balance, separated between confirmed and unconfirmed balance (both in sats)
+     */
+    abstract getBalance(): Promise<{
         confirmed: number;
         unconfirmed: number;
     }>;
     /**
-     * Returns required reserve amount that needs to be kept in the wallet (for e.g. lightning anchor channels)
+     * Returns the total spendable wallet balance in sats
      */
-    getRequiredReserve(): Promise<number>;
-    getWalletTransactions(startHeight?: number): Promise<BtcTx[]>;
-    getWalletTransaction(txId: string): Promise<BtcTx | null>;
-    subscribeToWalletTransactions(callback: (tx: BtcTx) => void, abortSignal?: AbortSignal): void;
-    fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
-    signPsbt(psbt: Transaction): Promise<SignPsbtResponse>;
-    sendRawTransaction(tx: string): Promise<void>;
-    getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
-    getSignedMultiTransaction(destinations: {
-        address: string;
-        amount: number;
-    }[], feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
-    estimateFee(destination: string, amount: number, feeRate?: number, feeRateMultiplier?: number): Promise<{
+    abstract getSpendableBalance(): Promise<number>;
+    /**
+     * Returns all wallet transactions confirmed after the specified blockheight (includes also unconfirmed
+     *  wallet transaction!!)
+     *
+     * @param startHeight
+     */
+    abstract getWalletTransactions(startHeight?: number): Promise<BtcTx[]>;
+    /**
+     * Returns the in-wallet transaction as identified by its transaction ID
+     *
+     * @param txId
+     */
+    abstract getWalletTransaction(txId: string): Promise<BtcTx | null>;
+    /**
+     * Subscribes to wallet transactions, should fire when transaction enters mempool, and then also
+     *  for the first confirmation of the transactions
+     *
+     * @param callback
+     * @param abortSignal
+     */
+    abstract subscribeToWalletTransactions(callback: (tx: BtcTx) => void, abortSignal?: AbortSignal): void;
+    /**
+     * Estimates a network fee (in sats), for sending a specific PSBT, the provided PSBT might not contain
+     *  any inputs, hence the fee returned should also reflect the transaction size increase by adding
+     *  wallet UTXOs as inputs
+     *
+     * @param psbt
+     * @param feeRate
+     */
+    abstract estimatePsbtFee(psbt: Transaction, feeRate?: number): Promise<{
         satsPerVbyte: number;
         networkFee: number;
     }>;
-    drainAll(destination: string | Buffer, inputs: Omit<BitcoinUtxo, "address">[], feeRate?: number): Promise<SignPsbtResponse>;
-    burnAll(inputs: Omit<BitcoinUtxo, "address">[]): Promise<SignPsbtResponse>;
-    parsePsbt(psbt: Transaction): Promise<BtcTx>;
-    getBlockheight(): Promise<number>;
-    getFeeRate(): Promise<number>;
     /**
-     * Post a task to be executed on the sequential thread of the wallet, this makes sure the UTXOs stay consistent during
-     *  operation, it is recommended to use this approach when spending wallet UTXOs
+     * Funds the provided PSBT (adds wallet UTXOs)
+     *
+     * @param psbt
+     * @param feeRate
+     * @param maxAllowedFeeRate
+     */
+    abstract fundPsbt(psbt: Transaction, feeRate?: number, maxAllowedFeeRate?: number): Promise<Transaction>;
+    /**
+     * Signs the provided PSBT
+     *
+     * @param psbt
+     */
+    abstract signPsbt(psbt: Transaction): Promise<SignPsbtResponse>;
+    /**
+     * Broadcasts a raw bitcoin hex encoded transaction
+     *
+     * @param tx
+     */
+    abstract sendRawTransaction(tx: string): Promise<void>;
+    /**
+     * Returns bitcoin network fee in sats/vB
+     */
+    abstract getFeeRate(): Promise<number>;
+    /**
+     * Returns the blockheight of the bitcoin chain
+     */
+    abstract getBlockheight(): Promise<number>;
+    /**
+     * Post a task to be executed on the sequential thread of the wallet, in case wallets requires
+     *  the UTXOs staying consistent during operation, it is recommended to implement this function
      *
      * @param executor
      */

package/dist/wallets/IBitcoinWallet.js

@@ -1,2 +1,97 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IBitcoinWallet = void 0;
+const btc_signer_1 = require("@scure/btc-signer");
+class IBitcoinWallet {
+    constructor(network) {
+        this.network = network;
+    }
+    toOutputScript(address) {
+        const outputScript = (0, btc_signer_1.Address)(this.network).decode(address);
+        switch (outputScript.type) {
+            case "pkh":
+            case "sh":
+            case "wpkh":
+            case "wsh":
+                return Buffer.from(btc_signer_1.OutScript.encode({
+                    type: outputScript.type,
+                    hash: outputScript.hash
+                }));
+            case "tr":
+                return Buffer.from(btc_signer_1.OutScript.encode({
+                    type: "tr",
+                    pubkey: outputScript.pubkey
+                }));
+        }
+        throw new Error("Unrecognized address type");
+    }
+    getSignedTransaction(destination, amount, feeRate, nonce, maxAllowedFeeRate) {
+        return this.getSignedMultiTransaction([{ address: destination, amount }], feeRate, nonce, maxAllowedFeeRate);
+    }
+    async getSignedMultiTransaction(destinations, feeRate, nonce, maxAllowedFeeRate) {
+        let locktime = 0;
+        let sequence = 0xFFFFFFFD;
+        //Apply nonce
+        if (nonce != null) {
+            const locktimeBN = nonce >> 24n;
+            locktime = Number(locktimeBN) + 500000000;
+            if (locktime > (Date.now() / 1000 - 24 * 60 * 60))
+                throw new Error("Invalid escrow nonce (locktime)!");
+            const sequenceBN = nonce & 0xffffffn;
+            sequence = 0xFE000000 + Number(sequenceBN);
+        }
+        let psbt = new btc_signer_1.Transaction({ lockTime: locktime });
+        destinations.forEach(dst => psbt.addOutput({
+            script: this.toOutputScript(dst.address),
+            amount: BigInt(dst.amount)
+        }));
+        await this.fundPsbt(psbt, feeRate, maxAllowedFeeRate);
+        //Apply nonce
+        for (let i = 0; i < psbt.inputsLength; i++) {
+            psbt.updateInput(i, { sequence });
+        }
+        return await this.signPsbt(psbt);
+    }
+    async estimateFee(destination, amount, feeRate, feeRateMultiplier) {
+        feeRate ?? (feeRate = await this.getFeeRate());
+        if (feeRateMultiplier != null)
+            feeRate = feeRate * feeRateMultiplier;
+        let psbt = new btc_signer_1.Transaction();
+        psbt.addOutput({
+            script: this.toOutputScript(destination),
+            amount: BigInt(amount)
+        });
+        return await this.estimatePsbtFee(psbt, feeRate);
+    }
+    drainAll(destination, inputs, feeRate) {
+        throw new Error("Not implemented");
+    }
+    burnAll(inputs) {
+        let psbt = new btc_signer_1.Transaction();
+        inputs.forEach(input => psbt.addInput({
+            txid: input.txId,
+            index: input.vout,
+            witnessUtxo: {
+                script: input.outputScript,
+                amount: BigInt(input.value)
+            },
+            sighashType: 0x01,
+            sequence: 0
+        }));
+        psbt.addOutput({
+            script: Buffer.concat([Buffer.from([0x6a, 20]), Buffer.from("BURN, BABY, BURN! AQ", "ascii")]),
+            amount: 0n
+        });
+        return this.signPsbt(psbt);
+    }
+    /**
+     * Post a task to be executed on the sequential thread of the wallet, in case wallets requires
+     *  the UTXOs staying consistent during operation, it is recommended to implement this function
+     *
+     * @param executor
+     */
+    execute(executor) {
+        return executor();
+    }
+}
+exports.IBitcoinWallet = IBitcoinWallet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "16.1.2",
+  "version": "16.2.0",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/swaps/spv_vault_swap/SpvVaultSwapHandler.ts

@@ -21,7 +21,13 @@ import {ISpvVaultSigner} from "../../wallets/ISpvVaultSigner";
 import {PluginManager} from "../../plugins/PluginManager";
 import {SpvVault} from "./SpvVault";
 import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDecoder";
-import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../utils/Utils";
+import {
+    expressHandlerWrapper,
+    getAbortController,
+    HEX_REGEX,
+    isDefinedRuntimeError,
+    parsePsbt
+} from "../../utils/Utils";
 import {IParamReader} from "../../utils/paramcoders/IParamReader";
 import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
 import {FieldTypeEnum} from "../../utils/paramcoders/SchemaVerifier";
@@ -558,7 +564,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
 
             let data: SpvWithdrawalTransactionData;
             try {
-                data = await spvVaultContract.getWithdrawalData(await this.bitcoin.parsePsbt(transaction));
+                data = await spvVaultContract.getWithdrawalData(parsePsbt(transaction));
             } catch (e) {
                 this.swapLogger.error(swap, "REST: /postQuote: failed to parse PSBT to withdrawal tx data: ", e);
                 throw {
@@ -606,7 +612,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 msg: "One or more PSBT inputs not finalized!"
             };
 
-            const effectiveFeeRate = await this.bitcoinRpc.getEffectiveFeeRate(await this.bitcoin.parsePsbt(signedTx));
+            const effectiveFeeRate = await this.bitcoinRpc.getEffectiveFeeRate(parsePsbt(signedTx));
             if(effectiveFeeRate.feeRate < 1 || Math.round(effectiveFeeRate.feeRate) < swap.btcFeeRate) throw {
                 code: 20511,
                 msg: "Bitcoin transaction fee too low, expected minimum: "+swap.btcFeeRate+" adjusted effective fee rate: "+effectiveFeeRate.feeRate

package/src/utils/Utils.ts

@@ -1,5 +1,8 @@
 import {Request, Response} from "express";
 import {ServerParamEncoder} from "./paramcoders/server/ServerParamEncoder";
+import {createHash} from "crypto";
+import {Script, Transaction} from "@scure/btc-signer";
+import {BtcTx} from "@atomiqlabs/base";
 
 export type LoggerType = {
     debug: (msg: string, ...args: any[]) => void,
@@ -102,3 +105,46 @@ export function getAbortController(responseStream: ServerParamEncoder): AbortCon
     responseStreamAbortController.addEventListener("abort", () => abortController.abort(responseStreamAbortController.reason));
     return abortController;
 }
+
+export function parsePsbt(btcTx: Transaction): BtcTx {
+    const txWithoutWitness = btcTx.toBytes(true, false);
+    return {
+        locktime: btcTx.lockTime,
+        version: btcTx.version,
+        blockhash: null,
+        confirmations: 0,
+        txid: createHash("sha256").update(
+            createHash("sha256").update(
+                txWithoutWitness
+            ).digest()
+        ).digest().reverse().toString("hex"),
+        hex: Buffer.from(txWithoutWitness).toString("hex"),
+        raw: Buffer.from(btcTx.toBytes(true, true)).toString("hex"),
+        vsize: btcTx.isFinal ? btcTx.vsize : null,
+
+        outs: Array.from({length: btcTx.outputsLength}, (_, i) => i).map((index) => {
+            const output = btcTx.getOutput(index);
+            return {
+                value: Number(output.amount),
+                n: index,
+                scriptPubKey: {
+                    asm: Script.decode(output.script).map(val => typeof(val)==="object" ? Buffer.from(val).toString("hex") : val.toString()).join(" "),
+                    hex: Buffer.from(output.script).toString("hex")
+                }
+            }
+        }),
+        ins: Array.from({length: btcTx.inputsLength}, (_, i) => i).map(index => {
+            const input = btcTx.getInput(index);
+            return {
+                txid: Buffer.from(input.txid).toString("hex"),
+                vout: input.index,
+                scriptSig: {
+                    asm: Script.decode(input.finalScriptSig).map(val => typeof(val)==="object" ? Buffer.from(val).toString("hex") : val.toString()).join(" "),
+                    hex: Buffer.from(input.finalScriptSig).toString("hex")
+                },
+                sequence: input.sequence,
+                txinwitness: input.finalScriptWitness==null ? [] : input.finalScriptWitness.map(witness => Buffer.from(witness).toString("hex"))
+            }
+        })
+    };
+}

package/src/wallets/IBitcoinWallet.ts

@@ -1,6 +1,7 @@
 import {BtcTx} from "@atomiqlabs/base";
 import {Command} from "@atomiqlabs/server-base";
-import {Transaction} from "@scure/btc-signer";
+import {Address, OutScript, Transaction} from "@scure/btc-signer";
+import {BTC_NETWORK} from "@scure/btc-signer/utils";
 
 export type BitcoinUtxo = {
     address: string,
@@ -20,58 +21,218 @@ export type SignPsbtResponse = {
     networkFee: number
 };
 
-export interface IBitcoinWallet {
+export abstract class IBitcoinWallet {
 
-    init(): Promise<void>;
+    readonly network: BTC_NETWORK;
 
-    isReady(): boolean;
-    getStatus(): string;
-    getStatusInfo(): Promise<Record<string, string>>;
-    getCommands(): Command<any>[];
+    protected constructor(network: BTC_NETWORK) {
+        this.network = network;
+    }
 
-    toOutputScript(address: string): Buffer;
+    toOutputScript(address: string): Buffer {
+        const outputScript = Address(this.network).decode(address);
+        switch(outputScript.type) {
+            case "pkh":
+            case "sh":
+            case "wpkh":
+            case "wsh":
+                return Buffer.from(OutScript.encode({
+                    type: outputScript.type,
+                    hash: outputScript.hash
+                }));
+            case "tr":
+                return Buffer.from(OutScript.encode({
+                    type: "tr",
+                    pubkey: outputScript.pubkey
+                }));
+        }
+        throw new Error("Unrecognized address type");
+    }
+
+    getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse> {
+        return this.getSignedMultiTransaction([{address: destination, amount}], feeRate, nonce, maxAllowedFeeRate);
+    }
+
+    async getSignedMultiTransaction(
+      destinations: {address: string, amount: number}[], feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number
+    ): Promise<SignPsbtResponse> {
+        let locktime = 0;
+        let sequence = 0xFFFFFFFD;
+        //Apply nonce
+        if(nonce!=null) {
+            const locktimeBN = nonce >> 24n;
+            locktime = Number(locktimeBN) + 500000000;
+            if(locktime > (Date.now()/1000 - 24*60*60)) throw new Error("Invalid escrow nonce (locktime)!");
+
+            const sequenceBN = nonce & 0xFFFFFFn;
+            sequence = 0xFE000000 + Number(sequenceBN);
+        }
+
+        let psbt = new Transaction({lockTime: locktime});
+        destinations.forEach(dst => psbt.addOutput({
+            script: this.toOutputScript(dst.address),
+            amount: BigInt(dst.amount)
+        }));
+
+        await this.fundPsbt(psbt, feeRate, maxAllowedFeeRate);
+
+        //Apply nonce
+        for(let i=0;i<psbt.inputsLength;i++) {
+            psbt.updateInput(i, {sequence});
+        }
+
+        return await this.signPsbt(psbt);
+    }
+
+    async estimateFee(destination: string, amount: number, feeRate?: number, feeRateMultiplier?: number): Promise<{satsPerVbyte: number, networkFee: number}> {
+        feeRate ??= await this.getFeeRate();
+        if(feeRateMultiplier!=null) feeRate = feeRate * feeRateMultiplier;
+
+        let psbt = new Transaction();
+        psbt.addOutput({
+            script: this.toOutputScript(destination),
+            amount: BigInt(amount)
+        });
+
+        return await this.estimatePsbtFee(psbt, feeRate);
+    }
+
+    drainAll(destination: string | Buffer, inputs: Omit<BitcoinUtxo, "address">[], feeRate?: number): Promise<SignPsbtResponse> {
+        throw new Error("Not implemented");
+    }
+
+    burnAll(inputs: Omit<BitcoinUtxo, "address">[]): Promise<SignPsbtResponse> {
+        let psbt = new Transaction();
+        inputs.forEach(input => psbt.addInput({
+            txid: input.txId,
+            index: input.vout,
+            witnessUtxo: {
+                script: input.outputScript,
+                amount: BigInt(input.value)
+            },
+            sighashType: 0x01,
+            sequence: 0
+        }));
+        psbt.addOutput({
+            script: Buffer.concat([Buffer.from([0x6a, 20]), Buffer.from("BURN, BABY, BURN! AQ", "ascii")]),
+            amount: 0n
+        });
+        return this.signPsbt(psbt);
+    }
 
-    getAddressType(): "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
+    /**
+     * Initializes the wallet, called before any actions on the wallet
+     */
+    abstract init(): Promise<void>;
+
+    /**
+     * Returns whether the wallet is ready
+     */
+    abstract isReady(): boolean;
+    /**
+     * Returns the status defined string to be displayed in the status message
+     */
+    abstract getStatus(): string;
+    /**
+     * Additional status information to be displayed in the status message
+     */
+    abstract getStatusInfo(): Promise<Record<string, string>>;
+    /**
+     * Returns the commands that will be exposed
+     */
+    abstract getCommands(): Command<any>[];
+
+    /**
+     * Returns the address type of the wallet
+     */
+    abstract getAddressType(): "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
     /**
      * Returns an unused address suitable for receiving
      */
-    getAddress(): Promise<string>;
+    abstract getAddress(): Promise<string>;
     /**
      * Adds previously returned address (with getAddress call), to the pool of unused addresses
      * @param address
      */
-    addUnusedAddress(address: string): Promise<void>;
-
-    getUtxos(): Promise<BitcoinUtxo[]>;
-    getBalance(): Promise<{confirmed: number, unconfirmed: number}>;
+    abstract addUnusedAddress(address: string): Promise<void>;
     /**
-     * Returns required reserve amount that needs to be kept in the wallet (for e.g. lightning anchor channels)
+     * Returns the wallet balance, separated between confirmed and unconfirmed balance (both in sats)
      */
-    getRequiredReserve(): Promise<number>;
-    getWalletTransactions(startHeight?: number): Promise<BtcTx[]>;
-    getWalletTransaction(txId: string): Promise<BtcTx | null>;
-    subscribeToWalletTransactions(callback: (tx: BtcTx) => void, abortSignal?: AbortSignal): void;
+    abstract getBalance(): Promise<{confirmed: number, unconfirmed: number}>;
+    /**
+     * Returns the total spendable wallet balance in sats
+     */
+    abstract getSpendableBalance(): Promise<number>;
 
-    fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
-    signPsbt(psbt: Transaction): Promise<SignPsbtResponse>;
-    sendRawTransaction(tx: string): Promise<void>;
-    getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
-    getSignedMultiTransaction(destinations: {address: string, amount: number}[], feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
-    estimateFee(destination: string, amount: number, feeRate?: number, feeRateMultiplier?: number): Promise<{satsPerVbyte: number, networkFee: number}>;
-    drainAll(destination: string | Buffer, inputs: Omit<BitcoinUtxo, "address">[], feeRate?: number): Promise<SignPsbtResponse>;
-    burnAll(inputs: Omit<BitcoinUtxo, "address">[]): Promise<SignPsbtResponse>;
+    /**
+     * Returns all wallet transactions confirmed after the specified blockheight (includes also unconfirmed
+     *  wallet transaction!!)
+     *
+     * @param startHeight
+     */
+    abstract getWalletTransactions(startHeight?: number): Promise<BtcTx[]>;
+    /**
+     * Returns the in-wallet transaction as identified by its transaction ID
+     *
+     * @param txId
+     */
+    abstract getWalletTransaction(txId: string): Promise<BtcTx | null>;
+    /**
+     * Subscribes to wallet transactions, should fire when transaction enters mempool, and then also
+     *  for the first confirmation of the transactions
+     *
+     * @param callback
+     * @param abortSignal
+     */
+    abstract subscribeToWalletTransactions(callback: (tx: BtcTx) => void, abortSignal?: AbortSignal): void;
 
-    parsePsbt(psbt: Transaction): Promise<BtcTx>;
+    /**
+     * Estimates a network fee (in sats), for sending a specific PSBT, the provided PSBT might not contain
+     *  any inputs, hence the fee returned should also reflect the transaction size increase by adding
+     *  wallet UTXOs as inputs
+     *
+     * @param psbt
+     * @param feeRate
+     */
+    abstract estimatePsbtFee(psbt: Transaction, feeRate?: number): Promise<{satsPerVbyte: number, networkFee: number}>;
+    /**
+     * Funds the provided PSBT (adds wallet UTXOs)
+     *
+     * @param psbt
+     * @param feeRate
+     * @param maxAllowedFeeRate
+     */
+    abstract fundPsbt(psbt: Transaction, feeRate?: number, maxAllowedFeeRate?: number): Promise<Transaction>;
+    /**
+     * Signs the provided PSBT
+     *
+     * @param psbt
+     */
+    abstract signPsbt(psbt: Transaction): Promise<SignPsbtResponse>;
+    /**
+     * Broadcasts a raw bitcoin hex encoded transaction
+     *
+     * @param tx
+     */
+    abstract sendRawTransaction(tx: string): Promise<void>;
 
-    getBlockheight(): Promise<number>;
-    getFeeRate(): Promise<number>;
+    /**
+     * Returns bitcoin network fee in sats/vB
+     */
+    abstract getFeeRate(): Promise<number>;
+    /**
+     * Returns the blockheight of the bitcoin chain
+     */
+    abstract getBlockheight(): Promise<number>;
 
     /**
-     * Post a task to be executed on the sequential thread of the wallet, this makes sure the UTXOs stay consistent during
-     *  operation, it is recommended to use this approach when spending wallet UTXOs
+     * Post a task to be executed on the sequential thread of the wallet, in case wallets requires
+     *  the UTXOs staying consistent during operation, it is recommended to implement this function
      *
      * @param executor
      */
-    execute(executor: () => Promise<void>): Promise<void>;
+    execute(executor: () => Promise<void>): Promise<void> {
+        return executor();
+    }
 
 }