@atomiqlabs/lp-lib 13.0.0 → 14.0.0-dev.10

package/src/swaps/escrow/frombtcln_autoinit/FromBtcLnAutoSwap.ts

@@ -0,0 +1,196 @@
+import {SwapData} from "@atomiqlabs/base";
+import {SwapHandlerType} from "../../../index";
+import {FromBtcBaseSwap} from "../FromBtcBaseSwap";
+import {deserializeBN, serializeBN} from "../../../utils/Utils";
+
+export enum FromBtcLnAutoSwapState {
+    REFUNDED = -2,
+    CANCELED = -1,
+    CREATED = 0,
+    RECEIVED = 1,
+    TXS_SENT = 2,
+    COMMITED = 3,
+    CLAIMED = 4,
+    SETTLED = 5,
+}
+
+export class FromBtcLnAutoSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcLnAutoSwapState> {
+
+    readonly pr: string;
+    readonly lnPaymentHash: string;
+    readonly claimHash: string;
+
+    readonly claimer: string;
+
+    readonly token: string;
+    readonly gasToken: string;
+    readonly amountToken: bigint;
+    readonly amountGasToken: bigint;
+
+    readonly tokenSwapFee: bigint;
+    readonly tokenSwapFeeInToken: bigint;
+    readonly gasSwapFee: bigint;
+    readonly gasSwapFeeInToken: bigint;
+
+    readonly claimerBounty: bigint;
+
+    secret: string;
+
+    constructor(
+        chainIdentifier: string,
+        pr: string,
+        lnPaymentHash: string,
+        claimHash: string,
+        amountMtokens: bigint,
+
+        claimer: string,
+        token: string,
+        gasToken: string,
+        amountToken: bigint,
+        amountGasToken: bigint,
+
+        tokenSwapFee: bigint,
+        tokenSwapFeeInToken: bigint,
+        gasSwapFee: bigint,
+        gasSwapFeeInToken: bigint,
+
+        claimerBounty: bigint
+    );
+    constructor(obj: any);
+
+    constructor(
+        chainIdOrObj: string | any,
+        pr?: string,
+        lnPaymentHash?: string,
+        claimHash?: string,
+        amountMtokens?: bigint,
+
+        claimer?: string,
+        token?: string,
+        gasToken?: string,
+        amountToken?: bigint,
+        amountGasToken?: bigint,
+
+        tokenSwapFee?: bigint,
+        tokenSwapFeeInToken?: bigint,
+        gasSwapFee?: bigint,
+        gasSwapFeeInToken?: bigint,
+
+        claimerBounty?: bigint
+    ) {
+        if(typeof(chainIdOrObj)==="string") {
+            super(chainIdOrObj, (amountMtokens + 999n) / 1000n, tokenSwapFee + gasSwapFee, tokenSwapFeeInToken);
+            this.state = FromBtcLnAutoSwapState.CREATED;
+            this.pr = pr;
+            this.lnPaymentHash = lnPaymentHash;
+            this.claimHash = claimHash;
+            this.claimer = claimer;
+            this.token = token;
+            this.gasToken = gasToken;
+            this.amountToken = amountToken;
+            this.amountGasToken = amountGasToken;
+            this.tokenSwapFee = tokenSwapFee;
+            this.tokenSwapFeeInToken = tokenSwapFeeInToken;
+            this.gasSwapFee = gasSwapFee;
+            this.gasSwapFeeInToken = gasSwapFeeInToken;
+            this.claimerBounty = claimerBounty;
+        } else {
+            super(chainIdOrObj);
+            this.pr = chainIdOrObj.pr;
+            this.lnPaymentHash = chainIdOrObj.lnPaymentHash;
+            this.claimHash = chainIdOrObj.claimHash;
+            this.claimer = chainIdOrObj.claimer;
+            this.token = chainIdOrObj.token;
+            this.gasToken = chainIdOrObj.gasToken;
+            this.amountToken = deserializeBN(chainIdOrObj.amountToken);
+            this.amountGasToken = deserializeBN(chainIdOrObj.amountGasToken);
+            this.tokenSwapFee = deserializeBN(chainIdOrObj.tokenSwapFee);
+            this.tokenSwapFeeInToken = deserializeBN(chainIdOrObj.tokenSwapFeeInToken);
+            this.gasSwapFee = deserializeBN(chainIdOrObj.gasSwapFee);
+            this.gasSwapFeeInToken = deserializeBN(chainIdOrObj.gasSwapFeeInToken);
+            this.claimerBounty = deserializeBN(chainIdOrObj.claimerBounty);
+            this.secret = chainIdOrObj.secret;
+        }
+        this.type = SwapHandlerType.FROM_BTCLN;
+    }
+
+    serialize(): any {
+        const partialSerialized = super.serialize();
+        partialSerialized.pr = this.pr;
+        partialSerialized.secret = this.secret;
+        partialSerialized.lnPaymentHash = this.lnPaymentHash;
+        partialSerialized.claimHash = this.claimHash;
+        partialSerialized.claimer = this.claimer;
+        partialSerialized.token = this.token;
+        partialSerialized.gasToken = this.gasToken;
+        partialSerialized.amountToken = serializeBN(this.amountToken);
+        partialSerialized.amountGasToken = serializeBN(this.amountGasToken);
+        partialSerialized.tokenSwapFee = serializeBN(this.tokenSwapFee);
+        partialSerialized.tokenSwapFeeInToken = serializeBN(this.tokenSwapFeeInToken);
+        partialSerialized.gasSwapFee = serializeBN(this.gasSwapFee);
+        partialSerialized.gasSwapFeeInToken = serializeBN(this.gasSwapFeeInToken);
+        partialSerialized.claimerBounty = serializeBN(this.claimerBounty);
+        return partialSerialized;
+    }
+
+    getClaimHash(): string {
+        return this.claimHash;
+    }
+
+    getIdentifierHash(): string {
+        return this.lnPaymentHash;
+    }
+
+    getOutputGasAmount(): bigint {
+        return this.amountGasToken;
+    }
+
+    getOutputAmount(): bigint {
+        return this.amountToken;
+    }
+
+    getTotalOutputAmount(): bigint {
+        return this.amountToken;
+    }
+
+    getTotalOutputGasAmount(): bigint {
+        return this.amountGasToken + this.claimerBounty;
+    }
+
+    getSequence(): bigint {
+        return 0n;
+    }
+
+    getSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
+        return {inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken};
+    }
+
+    getTokenSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
+        return {inInputToken: this.tokenSwapFee, inOutputToken: this.tokenSwapFeeInToken};
+    }
+
+    getGasSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
+        return {inInputToken: this.gasSwapFee, inOutputToken: this.gasSwapFeeInToken};
+    }
+
+    getToken(): string {
+        return this.token;
+    }
+
+    getGasToken(): string {
+        return this.gasToken;
+    }
+
+    isInitiated(): boolean {
+        return this.state!==FromBtcLnAutoSwapState.CREATED;
+    }
+
+    isFailed(): boolean {
+        return this.state===FromBtcLnAutoSwapState.CANCELED || this.state===FromBtcLnAutoSwapState.REFUNDED;
+    }
+
+    isSuccess(): boolean {
+        return this.state===FromBtcLnAutoSwapState.SETTLED;
+    }
+
+}

package/src/swaps/escrow/tobtc_abstract/ToBtcAbs.ts

@@ -8,10 +8,9 @@ import {
     ClaimEvent,
     InitializeEvent,
     RefundEvent,
-    SwapCommitStatus,
     SwapData,
     BitcoinRpc,
-    BtcBlock, BigIntBufferUtils
+    BtcBlock, BigIntBufferUtils, SwapCommitStateType
 } from "@atomiqlabs/base";
 import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
 import {PluginManager} from "../../../plugins/PluginManager";
@@ -169,13 +168,17 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             const isCommited = await swapContract.isCommited(swap.data);
             if(!isCommited) {
                 const status = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
-                if(status===SwapCommitStatus.PAID) {
+                if(status.type===SwapCommitStateType.PAID) {
                     this.swapLogger.info(swap, "processPastSwap(state=BTC_SENT): swap claimed (detected from processPastSwap), address: "+swap.address);
                     this.unsubscribePayment(swap);
+                    swap.txIds ??= {};
+                    swap.txIds.claim = await status.getClaimTxId();
                     await this.removeSwapData(swap, ToBtcSwapState.CLAIMED);
-                } else if(status===SwapCommitStatus.EXPIRED) {
+                } else if(status.type===SwapCommitStateType.EXPIRED) {
                     this.swapLogger.warn(swap, "processPastSwap(state=BTC_SENT): swap expired, but bitcoin was probably already sent, txId: "+swap.txId+" address: "+swap.address);
                     this.unsubscribePayment(swap);
+                    swap.txIds ??= {};
+                    swap.txIds.refund = status.getRefundTxId==null ? null : await status.getRefundTxId();
                     await this.removeSwapData(swap, ToBtcSwapState.REFUNDED);
                 }
                 return;

package/src/swaps/escrow/tobtcln_abstract/ToBtcLnAbs.ts

@@ -7,8 +7,7 @@ import {
     ChainSwapType,
     ClaimEvent,
     InitializeEvent,
-    RefundEvent,
-    SwapCommitStatus,
+    RefundEvent, SwapCommitStateType,
     SwapData
 } from "@atomiqlabs/base";
 import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
@@ -218,12 +217,16 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         const isCommited = await swapContract.isCommited(swap.data);
         if(!isCommited) {
             const status = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
-            if(status===SwapCommitStatus.PAID) {
+            if(status?.type===SwapCommitStateType.PAID) {
                 //This is alright, we got the money
+                swap.txIds ??= {};
+                swap.txIds.claim = await status.getClaimTxId();
                 await this.removeSwapData(swap, ToBtcLnSwapState.CLAIMED);
                 return true;
-            } else if(status===SwapCommitStatus.EXPIRED) {
+            } else if(status?.type===SwapCommitStateType.EXPIRED) {
                 //This means the user was able to refund before we were able to claim, no good
+                swap.txIds ??= {};
+                swap.txIds.refund = status.getRefundTxId==null ? null : await status.getRefundTxId();
                 await this.removeSwapData(swap, ToBtcLnSwapState.REFUNDED);
             }
             this.swapLogger.warn(swap, "processPaymentResult(): tried to claim but escrow doesn't exist anymore,"+

package/src/swaps/spv_vault_swap/SpvVaultSwapHandler.ts

@@ -496,7 +496,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
             }
 
             if(
-                data.recipient!==swap.recipient ||
+                !data.isRecipient(swap.recipient) ||
                 data.callerFeeRate!==swap.callerFeeShare ||
                 data.frontingFeeRate!==swap.frontingFeeShare ||
                 data.executionFeeRate!==swap.executionFeeShare ||
@@ -506,7 +506,9 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 data.btcTx.outs[0].value!==VAULT_DUST_AMOUNT ||
                 !Buffer.from(data.btcTx.outs[0].scriptPubKey.hex, "hex").equals(this.bitcoin.toOutputScript(swap.vaultAddress)) ||
                 BigInt(data.btcTx.outs[2].value)!==swap.amountBtc ||
-                !Buffer.from(data.btcTx.outs[2].scriptPubKey.hex, "hex").equals(this.bitcoin.toOutputScript(swap.btcAddress))
+                !Buffer.from(data.btcTx.outs[2].scriptPubKey.hex, "hex").equals(this.bitcoin.toOutputScript(swap.btcAddress)) ||
+                (data.btcTx.locktime > 0 && data.btcTx.locktime < 500_000_000) ||
+                data.btcTx.locktime > Math.floor(Date.now()/1000) - 1_000_000
             ) {
                 this.swapLogger.error(swap, "REST: /postQuote: Invalid psbt data submitted, raw psbt hex: ", parsedBody.psbtHex);
                 throw {

package/src/swaps/spv_vault_swap/SpvVaults.ts

@@ -8,7 +8,7 @@ import {
     SpvVaultOpenEvent, SpvWithdrawalTransactionData
 } from "@atomiqlabs/base";
 import {SpvVaultSwap} from "./SpvVaultSwap";
-import {bigIntSorter} from "../../utils/Utils";
+import {bigIntSorter, getLogger} from "../../utils/Utils";
 import {PluginManager} from "../../plugins/PluginManager";
 import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
 import {ISpvVaultSigner} from "../../wallets/ISpvVaultSigner";
@@ -30,12 +30,7 @@ export class SpvVaults {
     readonly config: {vaultsCheckInterval: number, maxUnclaimedWithdrawals?: number};
     readonly getChain: (chainId: string) => ChainData
 
-    readonly logger = {
-        debug: (msg: string, ...args: any) => console.debug("SpvVaults: "+msg, ...args),
-        info: (msg: string, ...args: any) => console.info("SpvVaults: "+msg, ...args),
-        warn: (msg: string, ...args: any) => console.warn("SpvVaults: "+msg, ...args),
-        error: (msg: string, ...args: any) => console.error("SpvVaults: "+msg, ...args)
-    };
+    readonly logger = getLogger("SpvVaults: ");
 
     constructor(
         vaultStorage: IStorageManager<SpvVault>,
@@ -428,7 +423,7 @@ export class SpvVaults {
     async startVaultsWatchdog() {
         let rerun: () => Promise<void>;
         rerun = async () => {
-            await this.checkVaults().catch( e => console.error(e));
+            await this.checkVaults().catch( e => this.logger.error("startVaultsWatchdog(): Error when periodically checking SPV vaults: ", e));
             setTimeout(rerun, this.config.vaultsCheckInterval);
         };
         await rerun();

package/src/swaps/trusted/frombtc_trusted/FromBtcTrusted.ts

@@ -713,7 +713,7 @@ export class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrust
     private async startDoubleSpendWatchdog() {
         let rerun: () => Promise<void>;
         rerun = async () => {
-            await this.checkDoubleSpends().catch( e => console.error(e));
+            await this.checkDoubleSpends().catch( e => this.logger.error("startDoubleSpendWatchdog(): Error when checking double spends: ", e));
             setTimeout(rerun, this.config.doubleSpendCheckInterval);
         };
         await rerun();

package/src/swaps/trusted/frombtcln_trusted/FromBtcLnTrusted.ts

@@ -90,7 +90,7 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
         this.lightning.waitForInvoice(hash, abortController.signal).then(invoice => {
             this.swapLogger.debug(invoiceData, "subscribeToInvoice(): invoice_updated: ", invoice);
             if(invoice.status!=="held") return;
-            this.htlcReceived(invoiceData, invoice).catch(e => console.error(e));
+            this.htlcReceived(invoiceData, invoice).catch(e => this.swapLogger.error(invoiceData, "subscribeToInvoice(): Error calling htlcReceived(): ", e));
             this.activeSubscriptions.delete(hash);
         });
 
@@ -117,7 +117,7 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
                     await this.htlcReceived(swap, invoice);
                     //Result is either FromBtcLnTrustedSwapState.RECEIVED or FromBtcLnTrustedSwapState.CANCELED
                 } catch (e) {
-                    console.error(e);
+                    this.swapLogger.error(swap, "processPastSwap(): Error calling htlcReceived(): ", e);
                 }
                 return false;
             case "confirmed":
@@ -226,7 +226,7 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
                     await invoiceData.setState(FromBtcLnTrustedSwapState.SENT);
                     await this.storageManager.saveData(invoice.id, null, invoiceData);
                 }
-            }).catch(e => console.error(e));
+            }).catch(e => this.swapLogger.error(invoiceData, "htlcReceived(): Error sending transfer txns", e));
 
             if(result==null) {
                 //Cancel invoice
@@ -459,8 +459,6 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
             metadata.times.invoiceCreated = Date.now();
             metadata.invoiceResponse = {...hodlInvoice};
 
-            console.log("[From BTC-LN: REST.CreateInvoice] hodl invoice created: ", hodlInvoice);
-
             const createdSwap = new FromBtcLnTrustedSwap(
                 chainIdentifier,
                 hodlInvoice.request,

package/src/utils/Utils.ts

@@ -1,6 +1,22 @@
 import {Request, Response} from "express";
 import {ServerParamEncoder} from "./paramcoders/server/ServerParamEncoder";
 
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void,
+    info: (msg: string, ...args: any[]) => void,
+    warn: (msg: string, ...args: any[]) => void,
+    error: (msg: string, ...args: any[]) => void
+};
+
+export function getLogger(prefix: string | (() => string)): LoggerType {
+    return {
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug((typeof(prefix)==="function" ? prefix() : prefix)+msg, ...args),
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info((typeof(prefix)==="function" ? prefix() : prefix)+msg, ...args),
+        warn: (msg, ...args) => (global.atomiqLogLevel==null || global.atomiqLogLevel >= 1) && console.warn((typeof(prefix)==="function" ? prefix() : prefix)+msg, ...args),
+        error: (msg, ...args) => (global.atomiqLogLevel==null || global.atomiqLogLevel >= 0) && console.error((typeof(prefix)==="function" ? prefix() : prefix)+msg, ...args)
+    };
+}
+
 export type DefinedRuntimeError = {
     code: number;
     msg?: string;
@@ -17,6 +33,8 @@ export function isDefinedRuntimeError(obj: any): obj is DefinedRuntimeError {
     return false;
 }
 
+const expressHandlerWrapperLogger = getLogger("ExpressHandlerWrapper: ");
+
 export function expressHandlerWrapper(func: (
     req: Request,
     res: Response
@@ -32,7 +50,7 @@ export function expressHandlerWrapper(func: (
             try {
                 await func(req, res);
             } catch (e) {
-                console.error(e);
+                expressHandlerWrapperLogger.error("Error in called function "+req.path+": ", e);
                 let statusCode = 500;
                 const obj: {code: number, msg: string, data?: any} = {
                     code: 0,
@@ -56,22 +74,6 @@ export function expressHandlerWrapper(func: (
     }
 }
 
-export type LoggerType = {
-    debug: (msg: string, ...args: any[]) => void,
-    info: (msg: string, ...args: any[]) => void,
-    warn: (msg: string, ...args: any[]) => void,
-    error: (msg: string, ...args: any[]) => void
-};
-
-export function getLogger(prefix: string): LoggerType {
-    return {
-        debug: (msg, ...args) => console.debug(prefix+msg, ...args),
-        info: (msg, ...args) => console.info(prefix+msg, ...args),
-        warn: (msg, ...args) => console.warn(prefix+msg, ...args),
-        error: (msg, ...args) => console.error(prefix+msg, ...args)
-    };
-}
-
 export const HEX_REGEX = /[0-9a-fA-F]+/;
 
 export function serializeBN(bn: bigint | null): string | null {

package/src/utils/paramcoders/server/ServerParamDecoder.ts

@@ -3,6 +3,7 @@ import {RequestSchema, verifySchema} from "../SchemaVerifier";
 import {ParamDecoder} from "../ParamDecoder";
 import {ServerParamEncoder} from "./ServerParamEncoder";
 import {IParamReader} from "../IParamReader";
+import {getLogger} from "../../Utils";
 
 export class RequestTimeoutError extends Error {
 
@@ -24,6 +25,8 @@ export class RequestParsingError extends Error {
 
 }
 
+const logger = getLogger("ServerParamDecoder: ");
+
 export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res: Response, next: () => void) => {
 
     let timeout;
@@ -50,14 +53,14 @@ export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res:
                 (req as any).paramReader = paramReader;
                 next();
             } catch (e) {
-                console.error("ServerParamDecoder: error reading legacy (non-streaming) http request", e);
+                logger.error("error reading legacy (non-streaming) http request", e);
                 req.destroy(new RequestParsingError());
                 res.destroy(new RequestParsingError());
             }
             clearTimeout(timeout);
         });
         req.on("error", (e) => {
-            console.error("ServerParamDecoder: error reading legacy (non-streaming) http request",e);
+            logger.error("error reading legacy (non-streaming) http request",e);
         });
 
         timeout = setTimeout(() => {
@@ -74,7 +77,7 @@ export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res:
         try {
             decoder.onData(data);
         } catch (e) {
-            console.error("ServerParamDecoder: error reading streaming http request: on(\"data\")", e);
+            logger.error("error reading streaming http request: on(\"data\")", e);
             req.destroy(new RequestParsingError());
             res.destroy(new RequestParsingError());
         }
@@ -83,7 +86,7 @@ export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res:
         try {
             decoder.onEnd();
         } catch (e) {
-            console.error("ServerParamDecoder: error reading streaming http request: on(\"end\")", e);
+            logger.error("error reading streaming http request: on(\"end\")", e);
             req.destroy(new RequestParsingError());
             res.destroy(new RequestParsingError());
         }
@@ -93,7 +96,7 @@ export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res:
         try {
             decoder.onError(e);
         } catch(e) {
-            console.error("ServerParamDecoder: error reading streaming http request: on(\"error\")", e);
+            logger.error("error reading streaming http request: on(\"error\")", e);
         }
     });
 
@@ -101,7 +104,7 @@ export const serverParamDecoder = (timeoutMillis: number) => (req: Request, res:
         try {
             decoder.onEnd();
         } catch(e) {
-            console.error("ServerParamDecoder: error reading streaming http request: timeout", e);
+            logger.error("error reading streaming http request: timeout", e);
         }
         req.destroy(new RequestTimeoutError());
         res.destroy(new RequestTimeoutError());

package/dist/wallets/ISpvVaultWallet.d.ts

@@ -1,42 +0,0 @@
-/// <reference types="node" />
-import { Command } from "@atomiqlabs/server-base";
-import { Transaction } from "@scure/btc-signer";
-export type BitcoinUtxo = {
-    address: string;
-    type: "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
-    confirmations: number;
-    outputScript: Buffer;
-    value: number;
-    txId: string;
-    vout: number;
-};
-export type SignPsbtResponse = {
-    psbt: Transaction;
-    tx: Transaction;
-    raw: string;
-    txId: string;
-    networkFee: number;
-};
-export interface ISpvVaultSigner {
-    init(): Promise<void>;
-    isReady(): boolean;
-    getStatus(): string;
-    getStatusInfo(): Promise<Record<string, string>>;
-    getCommands(): Command<any>[];
-    getAddressType(): "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
-    /**
-     * Returns an unused address suitable for receiving
-     */
-    getAddress(vaultId: bigint): Promise<string>;
-    signPsbt(vaultId: bigint, psbt: Transaction): Promise<SignPsbtResponse>;
-    sendRawTransaction(tx: string): Promise<void>;
-    getSignedTransaction(destination: 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>;
-    getBlockheight(): Promise<number>;
-    getFeeRate(): Promise<number>;
-}

package/dist/wallets/ISpvVaultWallet.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });