@atomiqlabs/lp-lib 12.1.0 → 13.0.0-beta.0

package/dist/index.d.ts

@@ -5,19 +5,19 @@ export * from "./prices/OKXSwapPrice";
 export * from "./storage/IIntermediaryStorage";
 export * from "./storagemanager/StorageManager";
 export * from "./storagemanager/IntermediaryStorageManager";
-export * from "./swaps/frombtc_abstract/FromBtcAbs";
-export * from "./swaps/frombtc_abstract/FromBtcSwapAbs";
-export * from "./swaps/frombtcln_abstract/FromBtcLnAbs";
-export * from "./swaps/frombtcln_abstract/FromBtcLnSwapAbs";
-export * from "./swaps/tobtc_abstract/ToBtcAbs";
-export * from "./swaps/tobtc_abstract/ToBtcSwapAbs";
-export * from "./swaps/tobtcln_abstract/ToBtcLnAbs";
-export * from "./swaps/tobtcln_abstract/ToBtcLnSwapAbs";
-export * from "./swaps/frombtc_trusted/FromBtcTrusted";
-export * from "./swaps/frombtc_trusted/FromBtcTrustedSwap";
-export * from "./swaps/frombtcln_trusted/FromBtcLnTrusted";
-export * from "./swaps/frombtcln_trusted/FromBtcLnTrustedSwap";
-export * from "./swaps/ISwapPrice";
+export * from "./swaps/escrow/frombtc_abstract/FromBtcAbs";
+export * from "./swaps/escrow/frombtc_abstract/FromBtcSwapAbs";
+export * from "./swaps/escrow/frombtcln_abstract/FromBtcLnAbs";
+export * from "./swaps/escrow/frombtcln_abstract/FromBtcLnSwapAbs";
+export * from "./swaps/escrow/tobtc_abstract/ToBtcAbs";
+export * from "./swaps/escrow/tobtc_abstract/ToBtcSwapAbs";
+export * from "./swaps/escrow/tobtcln_abstract/ToBtcLnAbs";
+export * from "./swaps/escrow/tobtcln_abstract/ToBtcLnSwapAbs";
+export * from "./swaps/trusted/frombtc_trusted/FromBtcTrusted";
+export * from "./swaps/trusted/frombtc_trusted/FromBtcTrustedSwap";
+export * from "./swaps/trusted/frombtcln_trusted/FromBtcLnTrusted";
+export * from "./swaps/trusted/frombtcln_trusted/FromBtcLnTrustedSwap";
+export * from "./prices/ISwapPrice";
 export * from "./swaps/SwapHandler";
 export * from "./swaps/SwapHandlerSwap";
 export * from "./plugins/PluginManager";
@@ -33,3 +33,8 @@ export * from "./utils/paramcoders/server/ServerParamDecoder";
 export * from "./utils/paramcoders/server/ServerParamEncoder";
 export * from "./wallets/IBitcoinWallet";
 export * from "./wallets/ILightningWallet";
+export * from "./wallets/ISpvVaultSigner";
+export * from "./swaps/spv_vault_swap/SpvVaults";
+export * from "./swaps/spv_vault_swap/SpvVault";
+export * from "./swaps/spv_vault_swap/SpvVaultSwap";
+export * from "./swaps/spv_vault_swap/SpvVaultSwapHandler";

package/dist/index.js

@@ -21,19 +21,19 @@ __exportStar(require("./prices/OKXSwapPrice"), exports);
 __exportStar(require("./storage/IIntermediaryStorage"), exports);
 __exportStar(require("./storagemanager/StorageManager"), exports);
 __exportStar(require("./storagemanager/IntermediaryStorageManager"), exports);
-__exportStar(require("./swaps/frombtc_abstract/FromBtcAbs"), exports);
-__exportStar(require("./swaps/frombtc_abstract/FromBtcSwapAbs"), exports);
-__exportStar(require("./swaps/frombtcln_abstract/FromBtcLnAbs"), exports);
-__exportStar(require("./swaps/frombtcln_abstract/FromBtcLnSwapAbs"), exports);
-__exportStar(require("./swaps/tobtc_abstract/ToBtcAbs"), exports);
-__exportStar(require("./swaps/tobtc_abstract/ToBtcSwapAbs"), exports);
-__exportStar(require("./swaps/tobtcln_abstract/ToBtcLnAbs"), exports);
-__exportStar(require("./swaps/tobtcln_abstract/ToBtcLnSwapAbs"), exports);
-__exportStar(require("./swaps/frombtc_trusted/FromBtcTrusted"), exports);
-__exportStar(require("./swaps/frombtc_trusted/FromBtcTrustedSwap"), exports);
-__exportStar(require("./swaps/frombtcln_trusted/FromBtcLnTrusted"), exports);
-__exportStar(require("./swaps/frombtcln_trusted/FromBtcLnTrustedSwap"), exports);
-__exportStar(require("./swaps/ISwapPrice"), exports);
+__exportStar(require("./swaps/escrow/frombtc_abstract/FromBtcAbs"), exports);
+__exportStar(require("./swaps/escrow/frombtc_abstract/FromBtcSwapAbs"), exports);
+__exportStar(require("./swaps/escrow/frombtcln_abstract/FromBtcLnAbs"), exports);
+__exportStar(require("./swaps/escrow/frombtcln_abstract/FromBtcLnSwapAbs"), exports);
+__exportStar(require("./swaps/escrow/tobtc_abstract/ToBtcAbs"), exports);
+__exportStar(require("./swaps/escrow/tobtc_abstract/ToBtcSwapAbs"), exports);
+__exportStar(require("./swaps/escrow/tobtcln_abstract/ToBtcLnAbs"), exports);
+__exportStar(require("./swaps/escrow/tobtcln_abstract/ToBtcLnSwapAbs"), exports);
+__exportStar(require("./swaps/trusted/frombtc_trusted/FromBtcTrusted"), exports);
+__exportStar(require("./swaps/trusted/frombtc_trusted/FromBtcTrustedSwap"), exports);
+__exportStar(require("./swaps/trusted/frombtcln_trusted/FromBtcLnTrusted"), exports);
+__exportStar(require("./swaps/trusted/frombtcln_trusted/FromBtcLnTrustedSwap"), exports);
+__exportStar(require("./prices/ISwapPrice"), exports);
 __exportStar(require("./swaps/SwapHandler"), exports);
 __exportStar(require("./swaps/SwapHandlerSwap"), exports);
 __exportStar(require("./plugins/PluginManager"), exports);
@@ -49,3 +49,8 @@ __exportStar(require("./utils/paramcoders/server/ServerParamDecoder"), exports);
 __exportStar(require("./utils/paramcoders/server/ServerParamEncoder"), exports);
 __exportStar(require("./wallets/IBitcoinWallet"), exports);
 __exportStar(require("./wallets/ILightningWallet"), exports);
+__exportStar(require("./wallets/ISpvVaultSigner"), exports);
+__exportStar(require("./swaps/spv_vault_swap/SpvVaults"), exports);
+__exportStar(require("./swaps/spv_vault_swap/SpvVault"), exports);
+__exportStar(require("./swaps/spv_vault_swap/SpvVaultSwap"), exports);
+__exportStar(require("./swaps/spv_vault_swap/SpvVaultSwapHandler"), exports);

package/dist/plugins/IPlugin.d.ts

@@ -1,10 +1,11 @@
 import { BitcoinRpc } from "@atomiqlabs/base";
-import { FromBtcLnRequestType, FromBtcRequestType, ISwapPrice, MultichainData, RequestData, SwapHandler, ToBtcLnRequestType, ToBtcRequestType } from "..";
+import { FromBtcLnRequestType, FromBtcRequestType, FromBtcTrustedRequestType, ISwapPrice, MultichainData, RequestData, SpvVaultSwapRequestType, SwapHandler, SwapHandlerType, ToBtcLnRequestType, ToBtcRequestType } from "..";
 import { SwapHandlerSwap } from "../swaps/SwapHandlerSwap";
 import { Command } from "@atomiqlabs/server-base";
-import { FromBtcLnTrustedRequestType } from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
+import { FromBtcLnTrustedRequestType } from "../swaps/trusted/frombtcln_trusted/FromBtcLnTrusted";
 import { IBitcoinWallet } from "../wallets/IBitcoinWallet";
 import { ILightningWallet } from "../wallets/ILightningWallet";
+import { SpvVault } from "../swaps/spv_vault_swap/SpvVault";
 export type QuoteThrow = {
     type: "throw";
     message: string;
@@ -71,47 +72,69 @@ export interface IPlugin {
     onSwapStateChange?(swap: SwapHandlerSwap): Promise<void>;
     onSwapCreate?(swap: SwapHandlerSwap): Promise<void>;
     onSwapRemove?(swap: SwapHandlerSwap): Promise<void>;
-    onHandlePreFromBtcQuote?(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
+    onHandlePreFromBtcQuote?(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
         input: boolean;
         amount: bigint;
-    }, chainIdentifier: string, token: string, constraints: {
+        token: string;
+    }, chainIdentifier: string, constraints: {
         minInBtc: bigint;
         maxInBtc: bigint;
     }, fees: {
         baseFeeInBtc: bigint;
         feePPM: bigint;
+    }, gasTokenAmount?: {
+        input: false;
+        amount: bigint;
+        token: string;
     }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
-    onHandlePostFromBtcQuote?(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
+    onHandlePostFromBtcQuote?(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
         input: boolean;
         amount: bigint;
-    }, chainIdentifier: string, token: string, constraints: {
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }, chainIdentifier: string, constraints: {
         minInBtc: bigint;
         maxInBtc: bigint;
     }, fees: {
         baseFeeInBtc: bigint;
         feePPM: bigint;
-    }, pricePrefetchPromise?: Promise<bigint> | null): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote>;
-    onHandlePreToBtcQuote?(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+    }, gasTokenAmount?: {
+        input: false;
+        amount: bigint;
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote>;
+    onHandlePreToBtcQuote?(swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC, request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
         input: boolean;
         amount: bigint;
-    }, chainIdentifier: string, token: string, constraints: {
+        token: string;
+    }, chainIdentifier: string, constraints: {
         minInBtc: bigint;
         maxInBtc: bigint;
     }, fees: {
         baseFeeInBtc: bigint;
         feePPM: bigint;
     }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
-    onHandlePostToBtcQuote?(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+    onHandlePostToBtcQuote?(swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC, request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
         input: boolean;
         amount: bigint;
-    }, chainIdentifier: string, token: string, constraints: {
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }, chainIdentifier: string, constraints: {
         minInBtc: bigint;
         maxInBtc: bigint;
     }, fees: {
         baseFeeInBtc: bigint;
         feePPM: bigint;
         networkFeeGetter: (amount: bigint) => Promise<bigint>;
-    }, pricePrefetchPromise?: Promise<bigint> | null): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | ToBtcPluginQuote>;
+    }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | ToBtcPluginQuote>;
+    onVaultSelection?(chainIdentifier: string, totalSats: bigint, requestedAmount: {
+        amount: bigint;
+        token: string;
+    }, gasAmount: {
+        amount: bigint;
+        token: string;
+    }): Promise<SpvVault | QuoteThrow | QuoteAmountTooHigh | QuoteAmountTooLow | null>;
     /**
      * Returns whitelisted bitcoin txIds that are OK to spend even with 0-confs
      */

package/dist/plugins/PluginManager.d.ts

@@ -1,10 +1,11 @@
 import { BitcoinRpc, SwapData } from "@atomiqlabs/base";
 import { IPlugin, PluginQuote, QuoteAmountTooHigh, QuoteAmountTooLow, QuoteSetFees, QuoteThrow, ToBtcPluginQuote } from "./IPlugin";
-import { FromBtcLnRequestType, FromBtcRequestType, ISwapPrice, MultichainData, RequestData, SwapHandler, ToBtcLnRequestType, ToBtcRequestType } from "..";
+import { FromBtcLnRequestType, FromBtcRequestType, FromBtcTrustedRequestType, ISwapPrice, MultichainData, RequestData, SpvVaultSwapRequestType, SwapHandler, SwapHandlerType, ToBtcLnRequestType, ToBtcRequestType } from "..";
 import { SwapHandlerSwap } from "../swaps/SwapHandlerSwap";
-import { FromBtcLnTrustedRequestType } from "../swaps/frombtcln_trusted/FromBtcLnTrusted";
+import { FromBtcLnTrustedRequestType } from "../swaps/trusted/frombtcln_trusted/FromBtcLnTrusted";
 import { IBitcoinWallet } from "../wallets/IBitcoinWallet";
 import { ILightningWallet } from "../wallets/ILightningWallet";
+import { SpvVault } from "../swaps/spv_vault_swap/SpvVault";
 export type FailSwapResponse = {
     type: "fail";
     code?: number;
@@ -37,53 +38,75 @@ export declare class PluginManager {
     static disable(): Promise<void>;
     static serviceInitialize(handler: SwapHandler<any>): Promise<void>;
     static onHttpServerStarted(httpServer: any): Promise<void>;
-    static swapStateChange<T extends SwapData>(swap: SwapHandlerSwap<T>, oldState?: any): Promise<void>;
-    static swapCreate<T extends SwapData>(swap: SwapHandlerSwap<T>): Promise<void>;
-    static swapRemove<T extends SwapData>(swap: SwapHandlerSwap<T>): Promise<void>;
-    static onHandlePostFromBtcQuote(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
+    static swapStateChange(swap: SwapHandlerSwap, oldState?: any): Promise<void>;
+    static swapCreate(swap: SwapHandlerSwap): Promise<void>;
+    static swapRemove(swap: SwapHandlerSwap): Promise<void>;
+    static onHandlePostFromBtcQuote(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
         input: boolean;
         amount: bigint;
-    }, chainIdentifier: string, token: string, constraints: {
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }, chainIdentifier: string, constraints: {
         minInBtc: bigint;
         maxInBtc: bigint;
     }, fees: {
         baseFeeInBtc: bigint;
         feePPM: bigint;
-    }, pricePrefetchPromise?: Promise<bigint> | null): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote>;
-    static onHandlePreFromBtcQuote(request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>, requestedAmount: {
+    }, gasTokenAmount?: {
+        input: false;
+        amount: bigint;
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote>;
+    static onHandlePreFromBtcQuote(swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV, request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType | FromBtcTrustedRequestType | SpvVaultSwapRequestType>, requestedAmount: {
         input: boolean;
         amount: bigint;
-    }, chainIdentifier: string, token: string, constraints: {
+        token: string;
+    }, chainIdentifier: string, constraints: {
         minInBtc: bigint;
         maxInBtc: bigint;
     }, fees: {
         baseFeeInBtc: bigint;
         feePPM: bigint;
+    }, gasTokenAmount?: {
+        input: false;
+        amount: bigint;
+        token: string;
     }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
     static onHandlePostToBtcQuote<T extends {
         networkFee: bigint;
-    }>(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+    }>(swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC, request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
         input: boolean;
         amount: bigint;
-    }, chainIdentifier: string, token: string, constraints: {
+        token: string;
+        pricePrefetch?: Promise<bigint>;
+    }, chainIdentifier: string, constraints: {
         minInBtc: bigint;
         maxInBtc: bigint;
     }, fees: {
         baseFeeInBtc: bigint;
         feePPM: bigint;
         networkFeeGetter: (amount: bigint) => Promise<T>;
-    }, pricePrefetchPromise?: Promise<bigint> | null): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | (ToBtcPluginQuote & {
+    }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | (ToBtcPluginQuote & {
         networkFeeData: T;
     })>;
-    static onHandlePreToBtcQuote(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
+    static onHandlePreToBtcQuote(swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC, request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
         input: boolean;
         amount: bigint;
-    }, chainIdentifier: string, token: string, constraints: {
+        token: string;
+    }, chainIdentifier: string, constraints: {
         minInBtc: bigint;
         maxInBtc: bigint;
     }, fees: {
         baseFeeInBtc: bigint;
         feePPM: bigint;
     }): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
+    static onVaultSelection(chainIdentifier: string, totalSats: bigint, requestedAmount: {
+        amount: bigint;
+        token: string;
+    }, gasAmount: {
+        amount: bigint;
+        token: string;
+    }): Promise<SpvVault | QuoteThrow | QuoteAmountTooHigh | QuoteAmountTooLow>;
     static getWhitelistedTxIds(): Set<string>;
 }

package/dist/plugins/PluginManager.js

@@ -4,6 +4,7 @@ exports.PluginManager = void 0;
 const IPlugin_1 = require("./IPlugin");
 const fs = require("fs");
 const Utils_1 = require("../utils/Utils");
+const SpvVault_1 = require("../swaps/spv_vault_swap/SpvVault");
 const logger = (0, Utils_1.getLogger)("PluginManager: ");
 const pluginLogger = {
     debug: (plugin, msg, ...args) => logger.debug(plugin.name + ": " + msg, ...args),
@@ -100,11 +101,11 @@ class PluginManager {
             }
         }
     }
-    static async onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise) {
+    static async onHandlePostFromBtcQuote(swapType, request, requestedAmount, chainIdentifier, constraints, fees, gasTokenAmount) {
         for (let plugin of PluginManager.plugins.values()) {
             try {
                 if (plugin.onHandlePostFromBtcQuote != null) {
-                    const result = await plugin.onHandlePostFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise);
+                    const result = await plugin.onHandlePostFromBtcQuote(swapType, request, requestedAmount, chainIdentifier, constraints, fees, gasTokenAmount);
                     if (result != null) {
                         if ((0, IPlugin_1.isQuoteSetFees)(result))
                             return result;
@@ -128,11 +129,11 @@ class PluginManager {
         }
         return null;
     }
-    static async onHandlePreFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees) {
+    static async onHandlePreFromBtcQuote(swapType, request, requestedAmount, chainIdentifier, constraints, fees, gasTokenAmount) {
         for (let plugin of PluginManager.plugins.values()) {
             try {
                 if (plugin.onHandlePreFromBtcQuote != null) {
-                    const result = await plugin.onHandlePreFromBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees);
+                    const result = await plugin.onHandlePreFromBtcQuote(swapType, request, requestedAmount, chainIdentifier, constraints, fees, gasTokenAmount);
                     if (result != null) {
                         if ((0, IPlugin_1.isQuoteSetFees)(result))
                             return result;
@@ -151,19 +152,19 @@ class PluginManager {
         }
         return null;
     }
-    static async onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees, pricePrefetchPromise) {
+    static async onHandlePostToBtcQuote(swapType, request, requestedAmount, chainIdentifier, constraints, fees) {
         for (let plugin of PluginManager.plugins.values()) {
             try {
                 if (plugin.onHandlePostToBtcQuote != null) {
                     let networkFeeData;
-                    const result = await plugin.onHandlePostToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, {
+                    const result = await plugin.onHandlePostToBtcQuote(swapType, request, requestedAmount, chainIdentifier, constraints, {
                         baseFeeInBtc: fees.baseFeeInBtc,
                         feePPM: fees.feePPM,
                         networkFeeGetter: async (amount) => {
                             networkFeeData = await fees.networkFeeGetter(amount);
                             return networkFeeData.networkFee;
                         }
-                    }, pricePrefetchPromise);
+                    });
                     if (result != null) {
                         if ((0, IPlugin_1.isQuoteSetFees)(result))
                             return result;
@@ -190,11 +191,11 @@ class PluginManager {
         }
         return null;
     }
-    static async onHandlePreToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees) {
+    static async onHandlePreToBtcQuote(swapType, request, requestedAmount, chainIdentifier, constraints, fees) {
         for (let plugin of PluginManager.plugins.values()) {
             try {
                 if (plugin.onHandlePreToBtcQuote != null) {
-                    const result = await plugin.onHandlePreToBtcQuote(request, requestedAmount, chainIdentifier, token, constraints, fees);
+                    const result = await plugin.onHandlePreToBtcQuote(swapType, request, requestedAmount, chainIdentifier, constraints, fees);
                     if (result != null) {
                         if ((0, IPlugin_1.isQuoteSetFees)(result))
                             return result;
@@ -213,6 +214,29 @@ class PluginManager {
         }
         return null;
     }
+    static async onVaultSelection(chainIdentifier, totalSats, requestedAmount, gasAmount) {
+        for (let plugin of PluginManager.plugins.values()) {
+            try {
+                if (plugin.onVaultSelection != null) {
+                    const result = await plugin.onVaultSelection(chainIdentifier, totalSats, requestedAmount, gasAmount);
+                    if (result != null) {
+                        if ((0, IPlugin_1.isQuoteThrow)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooHigh)(result))
+                            return result;
+                        if ((0, IPlugin_1.isQuoteAmountTooLow)(result))
+                            return result;
+                        if (result instanceof SpvVault_1.SpvVault)
+                            return result;
+                    }
+                }
+            }
+            catch (e) {
+                pluginLogger.error(plugin, "onVaultSelection(): plugin error", e);
+            }
+        }
+        return null;
+    }
     static getWhitelistedTxIds() {
         const whitelist = new Set();
         for (let plugin of PluginManager.plugins.values()) {

package/dist/prices/BinanceSwapPrice.d.ts

@@ -1,4 +1,4 @@
-import { ISwapPrice } from "../swaps/ISwapPrice";
+import { ISwapPrice } from "./ISwapPrice";
 export type BinancePriceData = {
     [pair: string]: {
         [chainId: string]: {

package/dist/prices/BinanceSwapPrice.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinanceSwapPrice = void 0;
-const ISwapPrice_1 = require("../swaps/ISwapPrice");
+const ISwapPrice_1 = require("./ISwapPrice");
 const CACHE_DURATION = 15000;
 class BinanceSwapPrice extends ISwapPrice_1.ISwapPrice {
     constructor(url, coins) {

package/dist/prices/CoinGeckoSwapPrice.d.ts

@@ -1,4 +1,4 @@
-import { ISwapPrice } from "../swaps/ISwapPrice";
+import { ISwapPrice } from "./ISwapPrice";
 export type CoinGeckoPriceData = {
     [coinId: string]: {
         [chainId: string]: {

package/dist/prices/CoinGeckoSwapPrice.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoinGeckoSwapPrice = void 0;
-const ISwapPrice_1 = require("../swaps/ISwapPrice");
+const ISwapPrice_1 = require("./ISwapPrice");
 const CACHE_DURATION = 15000;
 class CoinGeckoSwapPrice extends ISwapPrice_1.ISwapPrice {
     constructor(url, coins) {

package/dist/{swaps → prices}/ISwapPrice.js

@@ -29,6 +29,8 @@ class ISwapPrice {
      * @param preFetch Price pre-fetch promise returned from preFetchPrice()
      */
     async getToBtcSwapAmount(fromAmount, fromToken, tokenChainIdentification, roundUp, preFetch) {
+        if (fromAmount === 0n)
+            return 0n;
         const coin = this.getTokenData(fromToken, tokenChainIdentification);
         const price = (preFetch == null ? null : await preFetch) || await this.getPrice(coin);
         return ((fromAmount * price / (10n ** BigInt(coin.decimals))) + (roundUp ? 999999n : 0n)) / 1000000n;
@@ -43,6 +45,8 @@ class ISwapPrice {
      * @param preFetch Price pre-fetch promise returned from preFetchPrice()
      */
     async getFromBtcSwapAmount(fromAmount, toToken, tokenChainIdentification, roundUp, preFetch) {
+        if (fromAmount === 0n)
+            return 0n;
         const coin = this.getTokenData(toToken, tokenChainIdentification);
         const price = (preFetch == null ? null : await preFetch) || await this.getPrice(coin);
         return ((fromAmount * (10n ** BigInt(coin.decimals)) * 1000000n) + (roundUp ? price - 1n : 0n)) / price;

package/dist/prices/OKXSwapPrice.d.ts

@@ -1,4 +1,4 @@
-import { ISwapPrice } from "../swaps/ISwapPrice";
+import { ISwapPrice } from "./ISwapPrice";
 export type OKXPriceData = {
     [pair: string]: {
         [chainId: string]: {

package/dist/prices/OKXSwapPrice.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OKXSwapPrice = void 0;
-const ISwapPrice_1 = require("../swaps/ISwapPrice");
+const ISwapPrice_1 = require("./ISwapPrice");
 const CACHE_DURATION = 15000;
 class OKXSwapPrice extends ISwapPrice_1.ISwapPrice {
     constructor(url, coins) {

package/dist/swaps/SwapHandler.d.ts

@@ -1,9 +1,8 @@
 import { Express, Request } from "express";
-import { ISwapPrice } from "./ISwapPrice";
-import { ChainSwapType, ChainType, ClaimEvent, InitializeEvent, RefundEvent, SwapData, SwapEvent } from "@atomiqlabs/base";
+import { ISwapPrice } from "../prices/ISwapPrice";
+import { ChainType } from "@atomiqlabs/base";
 import { SwapHandlerSwap } from "./SwapHandlerSwap";
 import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
-import { ServerParamEncoder } from "../utils/paramcoders/server/ServerParamEncoder";
 import { IParamReader } from "../utils/paramcoders/IParamReader";
 export declare enum SwapHandlerType {
     TO_BTC = "TO_BTC",
@@ -11,7 +10,8 @@ export declare enum SwapHandlerType {
     TO_BTCLN = "TO_BTCLN",
     FROM_BTCLN = "FROM_BTCLN",
     FROM_BTCLN_TRUSTED = "FROM_BTCLN_TRUSTED",
-    FROM_BTC_TRUSTED = "FROM_BTC_TRUSTED"
+    FROM_BTC_TRUSTED = "FROM_BTC_TRUSTED",
+    FROM_BTC_SPV = "FROM_BTC_SPV"
 }
 export type SwapHandlerInfoType = {
     swapFeePPM: number;
@@ -46,8 +46,13 @@ export type MultichainData = {
 export type ChainData<T extends ChainType = ChainType> = {
     signer: T["Signer"];
     swapContract: T["Contract"];
+    spvVaultContract: T["SpvVaultContract"];
+    chainInterface: T["ChainInterface"];
     chainEvents: T["Events"];
     allowedTokens: string[];
+    tokenMultipliers?: {
+        [tokenAddress: string]: bigint;
+    };
     allowedDepositTokens?: string[];
     btcRelay?: T["BtcRelay"];
 };
@@ -62,11 +67,9 @@ export type RequestData<T> = {
 /**
  * An abstract class defining a singular swap service
  */
-export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapHandlerSwap, S = any> {
+export declare abstract class SwapHandler<V extends SwapHandlerSwap<S> = SwapHandlerSwap, S = any> {
     abstract readonly type: SwapHandlerType;
-    abstract readonly swapType: ChainSwapType;
     readonly storageManager: IIntermediaryStorage<V>;
-    readonly escrowHashMap: Map<string, V>;
     readonly path: string;
     readonly chains: MultichainData;
     readonly allowedTokens: {
@@ -81,10 +84,10 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
         error: (msg: string, ...args: any) => void;
     };
     protected swapLogger: {
-        debug: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
-        info: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
-        warn: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
-        error: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => void;
+        debug: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
+        info: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
+        warn: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
+        error: (swap: SwapHandlerSwap, msg: string, ...args: any) => void;
     };
     protected constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, swapPricing: ISwapPrice);
     protected getDefaultChain(): ChainData;
@@ -94,20 +97,6 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      * Starts the watchdog checking past swaps for expiry or claim eligibility.
      */
     startWatchdog(): Promise<void>;
-    protected abstract processInitializeEvent?(chainIdentifier: string, swap: V, event: InitializeEvent<SwapData>): Promise<void>;
-    protected abstract processClaimEvent?(chainIdentifier: string, swap: V, event: ClaimEvent<SwapData>): Promise<void>;
-    protected abstract processRefundEvent?(chainIdentifier: string, swap: V, event: RefundEvent<SwapData>): Promise<void>;
-    /**
-     * Chain event processor
-     *
-     * @param chainIdentifier
-     * @param eventData
-     */
-    protected processEvent(chainIdentifier: string, eventData: SwapEvent<SwapData>[]): Promise<boolean>;
-    /**
-     * Initializes chain events subscription
-     */
-    protected subscribeToEvents(): void;
     /**
      * Initializes swap handler, loads data and subscribes to chain events
      */
@@ -138,42 +127,15 @@ export declare abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S>
      */
     protected removeSwapData(swap: V, ultimateState?: S): Promise<void>;
     protected saveSwapData(swap: V): Promise<void>;
-    protected saveSwapToEscrowHashMap(swap: V): void;
-    protected removeSwapFromEscrowHashMap(swap: V): void;
-    protected getSwapByEscrowHash(chainIdentifier: string, escrowHash: string): V;
-    /**
-     * Checks whether the bitcoin amount is within specified min/max bounds
-     *
-     * @param amount
-     * @protected
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    protected checkBtcAmountInBounds(amount: bigint): void;
-    /**
-     * Handles and throws plugin errors
-     *
-     * @param res Response as returned from the PluginManager.onHandlePost{To,From}BtcQuote
-     * @protected
-     * @throws {DefinedRuntimeError} will throw an error if the response is an error
-     */
-    protected handlePluginErrorResponses(res: any): void;
-    /**
-     * Creates an abort controller that extends the responseStream's abort signal
-     *
-     * @param responseStream
-     */
-    protected getAbortController(responseStream: ServerParamEncoder): AbortController;
     /**
-     * Starts a pre-fetch for signature data
+     * Checks if we have enough balance of the token in the swap vault
      *
-     * @param chainIdentifier
-     * @param abortController
-     * @param responseStream
+     * @param totalInToken
+     * @param balancePrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
-    protected getSignDataPrefetch(chainIdentifier: string, abortController: AbortController, responseStream?: ServerParamEncoder): Promise<any>;
-    protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string;
-    protected getIdentifierFromSwapData(swapData: SwapData): string;
-    protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData): string;
+    protected checkBalance(totalInToken: bigint, balancePrefetch: Promise<bigint>, signal: AbortSignal | null): Promise<void>;
     /**
      * Checks if the sequence number is between 0-2^64
      *