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

package/src/plugins/IPlugin.ts

@@ -1,17 +1,18 @@
-import {BitcoinRpc, SwapData} from "@atomiqlabs/base";
+import {BitcoinRpc, SpvWithdrawalTransactionData, SwapData} from "@atomiqlabs/base";
 import {
     FromBtcLnRequestType,
-    FromBtcRequestType,
-    ISwapPrice, MultichainData, RequestData,
-    SwapHandler,
+    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",
@@ -115,41 +116,48 @@ export interface IPlugin {
     onSwapRemove?(swap: SwapHandlerSwap): Promise<void>;
 
     onHandlePreFromBtcQuote?(
-        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
+        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, token: string},
         chainIdentifier: string,
-        token: string,
         constraints: {minInBtc: bigint, maxInBtc: bigint},
-        fees: {baseFeeInBtc: bigint, feePPM: 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: {input: boolean, amount: bigint},
+        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, token: string, pricePrefetch?: Promise<bigint>},
         chainIdentifier: string,
-        token: string,
         constraints: {minInBtc: bigint, maxInBtc: bigint},
         fees: {baseFeeInBtc: bigint, feePPM: bigint},
-        pricePrefetchPromise?: Promise<bigint> | null
+        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},
+        requestedAmount: {input: boolean, amount: bigint, token: string},
         chainIdentifier: string,
-        token: string,
         constraints: {minInBtc: bigint, maxInBtc: bigint},
         fees: {baseFeeInBtc: bigint, feePPM: bigint}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh>;
     onHandlePostToBtcQuote?(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
+        requestedAmount: {input: boolean, amount: bigint, token: string, pricePrefetch?: Promise<bigint>},
         chainIdentifier: string,
-        token: string,
         constraints: {minInBtc: bigint, maxInBtc: bigint},
-        fees: {baseFeeInBtc: bigint, feePPM: bigint, networkFeeGetter: (amount: bigint) => Promise<bigint>},
-        pricePrefetchPromise?: Promise<bigint> | null
+        fees: {baseFeeInBtc: bigint, feePPM: bigint, networkFeeGetter: (amount: bigint) => Promise<bigint>}
     ): 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/src/plugins/PluginManager.ts

@@ -1,4 +1,4 @@
-import {BitcoinRpc, SwapData} from "@atomiqlabs/base";
+import {BitcoinRpc, SpvWithdrawalTransactionData, SwapData} from "@atomiqlabs/base";
 import {
     IPlugin, isPluginQuote, isQuoteAmountTooHigh, isQuoteAmountTooLow, isQuoteSetFees,
     isQuoteThrow, isToBtcPluginQuote, PluginQuote,
@@ -9,18 +9,19 @@ import {
 } from "./IPlugin";
 import {
     FromBtcLnRequestType,
-    FromBtcRequestType,
-    ISwapPrice, MultichainData, RequestData,
-    SwapHandler,
+    FromBtcRequestType, FromBtcTrustedRequestType,
+    ISwapPrice, MultichainData, RequestData, SpvVaultSwapRequestType,
+    SwapHandler, SwapHandlerType,
     ToBtcLnRequestType,
     ToBtcRequestType
 } from "..";
 import {SwapHandlerSwap} from "../swaps/SwapHandlerSwap";
 import * as fs from "fs";
 import {getLogger} from "../utils/Utils";
-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",
@@ -135,7 +136,7 @@ export class PluginManager {
         }
     }
 
-    static async swapStateChange<T extends SwapData>(swap: SwapHandlerSwap<T>, oldState?: any) {
+    static async swapStateChange(swap: SwapHandlerSwap, oldState?: any) {
         for(let plugin of PluginManager.plugins.values()) {
             try {
                 if(plugin.onSwapStateChange!=null) await plugin.onSwapStateChange(swap);
@@ -145,7 +146,7 @@ export class PluginManager {
         }
     }
 
-    static async swapCreate<T extends SwapData>(swap: SwapHandlerSwap<T>) {
+    static async swapCreate(swap: SwapHandlerSwap) {
         for(let plugin of PluginManager.plugins.values()) {
             try {
                 if(plugin.onSwapCreate!=null) await plugin.onSwapCreate(swap);
@@ -155,7 +156,7 @@ export class PluginManager {
         }
     }
 
-    static async swapRemove<T extends SwapData>(swap: SwapHandlerSwap<T>) {
+    static async swapRemove(swap: SwapHandlerSwap) {
         for(let plugin of PluginManager.plugins.values()) {
             try {
                 if(plugin.onSwapRemove!=null) await plugin.onSwapRemove(swap);
@@ -166,18 +167,18 @@ export class PluginManager {
     }
 
     static async onHandlePostFromBtcQuote(
-        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
+        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, token: string, pricePrefetch?: Promise<bigint>},
         chainIdentifier: string,
-        token: string,
         constraints: {minInBtc: bigint, maxInBtc: bigint},
         fees: {baseFeeInBtc: bigint, feePPM: bigint},
-        pricePrefetchPromise?: Promise<bigint> | null
+        gasTokenAmount?: {input: false, amount: bigint, token: string, pricePrefetch?: Promise<bigint>}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote> {
         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(isQuoteSetFees(result)) return result;
                         if(isQuoteThrow(result)) return result;
@@ -197,17 +198,18 @@ export class PluginManager {
     }
 
     static async onHandlePreFromBtcQuote(
-        request: RequestData<FromBtcLnRequestType | FromBtcRequestType | FromBtcLnTrustedRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
+        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, token: string},
         chainIdentifier: string,
-        token: string,
         constraints: {minInBtc: bigint, maxInBtc: bigint},
-        fees: {baseFeeInBtc: bigint, feePPM: bigint}
+        fees: {baseFeeInBtc: bigint, feePPM: bigint},
+        gasTokenAmount?: {input: false, amount: bigint, token: string}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh> {
         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(isQuoteSetFees(result)) return result;
                         if(isQuoteThrow(result)) return result;
@@ -223,26 +225,25 @@ export class PluginManager {
     }
 
     static async onHandlePostToBtcQuote<T extends {networkFee: bigint}>(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
+        requestedAmount: {input: boolean, amount: bigint, token: string, pricePrefetch?: Promise<bigint>},
         chainIdentifier: string,
-        token: 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 & {networkFeeData: T})> {
         for(let plugin of PluginManager.plugins.values()) {
             try {
                 if(plugin.onHandlePostToBtcQuote!=null) {
                     let networkFeeData: T;
-                    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: bigint) => {
                             networkFeeData = await fees.networkFeeGetter(amount);
                             return networkFeeData.networkFee;
                         }
-                    }, pricePrefetchPromise);
+                    });
                     if(result!=null) {
                         if(isQuoteSetFees(result)) return result;
                         if(isQuoteThrow(result)) return result;
@@ -265,17 +266,17 @@ export class PluginManager {
     }
 
     static async onHandlePreToBtcQuote(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
-        requestedAmount: {input: boolean, amount: bigint},
+        requestedAmount: {input: boolean, amount: bigint, token: string},
         chainIdentifier: string,
-        token: string,
         constraints: {minInBtc: bigint, maxInBtc: bigint},
         fees: {baseFeeInBtc: bigint, feePPM: bigint}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh> {
         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(isQuoteSetFees(result)) return result;
                         if(isQuoteThrow(result)) return result;
@@ -290,6 +291,30 @@ export class PluginManager {
         return null;
     }
 
+    static async onVaultSelection(
+        chainIdentifier: string,
+        totalSats: bigint,
+        requestedAmount: {amount: bigint, token: string},
+        gasAmount: {amount: bigint, token: string}
+    ): Promise<SpvVault | QuoteThrow | QuoteAmountTooHigh | QuoteAmountTooLow> {
+        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(isQuoteThrow(result)) return result;
+                        if(isQuoteAmountTooHigh(result)) return result;
+                        if(isQuoteAmountTooLow(result)) return result;
+                        if(result instanceof SpvVault) return result;
+                    }
+                }
+            } catch (e) {
+                pluginLogger.error(plugin, "onVaultSelection(): plugin error", e);
+            }
+        }
+        return null;
+    }
+
     static getWhitelistedTxIds(): Set<string> {
         const whitelist: Set<string> = new Set<string>();
 

package/src/prices/BinanceSwapPrice.ts

@@ -1,4 +1,4 @@
-import {ISwapPrice} from "../swaps/ISwapPrice";
+import {ISwapPrice} from "./ISwapPrice";
 
 const CACHE_DURATION = 15000;
 

package/src/prices/CoinGeckoSwapPrice.ts

@@ -1,4 +1,4 @@
-import {ISwapPrice} from "../swaps/ISwapPrice";
+import {ISwapPrice} from "./ISwapPrice";
 
 const CACHE_DURATION = 15000;
 

package/src/{swaps → prices}/ISwapPrice.ts

@@ -51,6 +51,8 @@ export abstract class ISwapPrice<T extends {decimals: number} = {decimals: numbe
         roundUp?: boolean,
         preFetch?: Promise<bigint>
     ): Promise<bigint> {
+        if(fromAmount===0n) return 0n;
+
         const coin = this.getTokenData(fromToken, tokenChainIdentification);
 
         const price = (preFetch==null ? null : await preFetch) || await this.getPrice(coin);
@@ -74,6 +76,8 @@ export abstract class ISwapPrice<T extends {decimals: number} = {decimals: numbe
         roundUp?: boolean,
         preFetch?: Promise<bigint>
     ): Promise<bigint> {
+        if(fromAmount===0n) return 0n;
+
         const coin = this.getTokenData(toToken, tokenChainIdentification);
 
         const price = (preFetch==null ? null : await preFetch) || await this.getPrice(coin);

package/src/prices/OKXSwapPrice.ts

@@ -1,4 +1,4 @@
-import {ISwapPrice} from "../swaps/ISwapPrice";
+import {ISwapPrice} from "./ISwapPrice";
 
 const CACHE_DURATION = 15000;
 

package/src/swaps/SwapHandler.ts

@@ -1,22 +1,12 @@
 import {Express, Request} from "express";
-import {ISwapPrice} from "./ISwapPrice";
+import {ISwapPrice} from "../prices/ISwapPrice";
 import {
     ChainSwapType,
-    ChainType,
-    ClaimEvent,
-    InitializeEvent, RefundEvent,
-    SwapData,
-    SwapEvent
+    ChainType
 } from "@atomiqlabs/base";
 import {SwapHandlerSwap} from "./SwapHandlerSwap";
 import {PluginManager} from "../plugins/PluginManager";
 import {IIntermediaryStorage} from "../storage/IIntermediaryStorage";
-import {ServerParamEncoder} from "../utils/paramcoders/server/ServerParamEncoder";
-import {
-    isQuoteAmountTooHigh,
-    isQuoteAmountTooLow,
-    isQuoteThrow,
-} from "../plugins/IPlugin";
 import {IParamReader} from "../utils/paramcoders/IParamReader";
 
 export enum SwapHandlerType {
@@ -26,6 +16,7 @@ export enum SwapHandlerType {
     FROM_BTCLN = "FROM_BTCLN",
     FROM_BTCLN_TRUSTED = "FROM_BTCLN_TRUSTED",
     FROM_BTC_TRUSTED = "FROM_BTC_TRUSTED",
+    FROM_BTC_SPV = "FROM_BTC_SPV"
 }
 
 export type SwapHandlerInfoType = {
@@ -62,8 +53,11 @@ 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"]
 }
@@ -78,13 +72,11 @@ export type RequestData<T> = {
 /**
  * An abstract class defining a singular swap service
  */
-export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapHandlerSwap, S = any> {
+export 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> = new Map();
     readonly path: string;
 
     readonly chains: MultichainData;
@@ -101,10 +93,10 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
     };
 
     protected swapLogger = {
-        debug: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.debug(this.getIdentifier(swap)+": "+msg, ...args),
-        info: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.info(this.getIdentifier(swap)+": "+msg, ...args),
-        warn: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.warn(this.getIdentifier(swap)+": "+msg, ...args),
-        error: (swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData, msg: string, ...args: any) => this.logger.error(this.getIdentifier(swap)+": "+msg, ...args)
+        debug: (swap: SwapHandlerSwap, msg: string, ...args: any) => this.logger.debug(swap.getIdentifier()+": "+msg, ...args),
+        info: (swap: SwapHandlerSwap, msg: string, ...args: any) => this.logger.info(swap.getIdentifier()+": "+msg, ...args),
+        warn: (swap: SwapHandlerSwap, msg: string, ...args: any) => this.logger.warn(swap.getIdentifier()+": "+msg, ...args),
+        error: (swap: SwapHandlerSwap, msg: string, ...args: any) => this.logger.error(swap.getIdentifier()+": "+msg, ...args)
     };
 
     protected constructor(
@@ -151,61 +143,6 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
         await rerun();
     }
 
-    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 async processEvent(chainIdentifier: string, eventData: SwapEvent<SwapData>[]): Promise<boolean> {
-        if(this.swapType==null) return true;
-
-        for(let event of eventData) {
-            if(event instanceof InitializeEvent) {
-                if(event.swapType!==this.swapType) continue;
-                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
-                if(swap==null) continue;
-
-                swap.txIds.init = (event as any).meta?.txId;
-                if(swap.metadata!=null) swap.metadata.times.initTxReceived = Date.now();
-
-                await this.processInitializeEvent(chainIdentifier, swap, event);
-            } else if(event instanceof ClaimEvent) {
-                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
-                if(swap==null) continue;
-
-                swap.txIds.claim = (event as any).meta?.txId;
-                if(swap.metadata!=null) swap.metadata.times.claimTxReceived = Date.now();
-
-                await this.processClaimEvent(chainIdentifier, swap, event);
-            } else if(event instanceof RefundEvent) {
-                const swap = this.getSwapByEscrowHash(chainIdentifier, event.escrowHash);
-                if(swap==null) continue;
-
-                swap.txIds.refund = (event as any).meta?.txId;
-                if(swap.metadata!=null) swap.metadata.times.refundTxReceived = Date.now();
-
-                await this.processRefundEvent(chainIdentifier, swap, event);
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Initializes chain events subscription
-     */
-    protected subscribeToEvents() {
-        for(let key in this.chains.chains) {
-            this.chains.chains[key].chainEvents.registerListener((events: SwapEvent<SwapData>[]) => this.processEvent(key, events));
-        }
-        this.logger.info("SC: Events: subscribed to smartchain events");
-    }
-
     /**
      * Initializes swap handler, loads data and subscribes to chain events
      */
@@ -223,7 +160,6 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
                 await this.storageManager.removeData(hash, sequence);
                 await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
             }
-            this.saveSwapToEscrowHashMap(swap);
         }
     }
 
@@ -266,152 +202,33 @@ export abstract class SwapHandler<V extends SwapHandlerSwap<SwapData, S> = SwapH
         }
         if(swap!=null) await PluginManager.swapRemove(swap);
         this.swapLogger.debug(swap, "removeSwapData(): removing swap final state: "+swap.state);
-        this.removeSwapFromEscrowHashMap(swap);
         await this.storageManager.removeData(swap.getIdentifierHash(), swap.getSequence());
     }
 
     protected async saveSwapData(swap: V) {
-        this.saveSwapToEscrowHashMap(swap);
         await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
     }
 
-    protected saveSwapToEscrowHashMap(swap: V) {
-        if(swap.data!=null) this.escrowHashMap.set(swap.chainIdentifier+"_"+swap.getEscrowHash(), swap);
-    }
-
-    protected removeSwapFromEscrowHashMap(swap: V) {
-        if(swap.data!=null) this.escrowHashMap.delete(swap.chainIdentifier+"_"+swap.data.getEscrowHash());
-    }
-
-    protected getSwapByEscrowHash(chainIdentifier: string, escrowHash: string) {
-        return this.escrowHashMap.get(chainIdentifier+"_"+escrowHash);
-    }
-
     /**
-     * Checks whether the bitcoin amount is within specified min/max bounds
+     * Checks if we have enough balance of the token in the swap vault
      *
-     * @param amount
-     * @protected
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
+     * @param totalInToken
+     * @param balancePrefetch
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if there are not enough funds in the vault
      */
-    protected checkBtcAmountInBounds(amount: bigint): void {
-        if (amount < this.config.min) {
-            throw {
-                code: 20003,
-                msg: "Amount too low!",
-                data: {
-                    min: this.config.min.toString(10),
-                    max: this.config.max.toString(10)
-                }
-            };
-        }
+    protected async checkBalance(totalInToken: bigint, balancePrefetch: Promise<bigint>, signal: AbortSignal | null): Promise<void> {
+        const balance = await balancePrefetch;
+        if(signal!=null) signal.throwIfAborted();
 
-        if(amount > this.config.max) {
+        if(balance==null || balance < totalInToken) {
             throw {
-                code: 20004,
-                msg: "Amount too high!",
-                data: {
-                    min: this.config.min.toString(10),
-                    max: this.config.max.toString(10)
-                }
+                code: 20002,
+                msg: "Not enough liquidity"
             };
         }
     }
 
-    /**
-     * 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 {
-        if(isQuoteThrow(res)) throw {
-            code: 29999,
-            msg: res.message
-        };
-        if(isQuoteAmountTooHigh(res)) throw {
-            code: 20004,
-            msg: "Amount too high!",
-            data: {
-                min: res.data.min.toString(10),
-                max: res.data.max.toString(10)
-            }
-        };
-        if(isQuoteAmountTooLow(res)) throw {
-            code: 20003,
-            msg: "Amount too low!",
-            data: {
-                min: res.data.min.toString(10),
-                max: res.data.max.toString(10)
-            }
-        };
-    }
-
-    /**
-     * Creates an abort controller that extends the responseStream's abort signal
-     *
-     * @param responseStream
-     */
-    protected getAbortController(responseStream: ServerParamEncoder): AbortController {
-        const abortController = new AbortController();
-        if(responseStream==null || responseStream.getAbortSignal==null) return abortController;
-        const responseStreamAbortController = responseStream.getAbortSignal();
-        responseStreamAbortController.addEventListener("abort", () => abortController.abort(responseStreamAbortController.reason));
-        return abortController;
-    }
-
-    /**
-     * Starts a pre-fetch for signature data
-     *
-     * @param chainIdentifier
-     * @param abortController
-     * @param responseStream
-     */
-    protected getSignDataPrefetch(chainIdentifier: string, abortController: AbortController, responseStream?: ServerParamEncoder): Promise<any> {
-        const {swapContract} = this.getChain(chainIdentifier);
-        let signDataPrefetchPromise: Promise<any> = swapContract.preFetchBlockDataForSignatures!=null ? swapContract.preFetchBlockDataForSignatures().catch(e => {
-            this.logger.error("getSignDataPrefetch(): signDataPrefetch: ", e);
-            abortController.abort(e);
-            return null;
-        }) : null;
-
-        if(signDataPrefetchPromise!=null && responseStream!=null) {
-            signDataPrefetchPromise = signDataPrefetchPromise.then(val => val==null || abortController.signal.aborted ? null : responseStream.writeParams({
-                signDataPrefetch: val
-            }).then(() => val).catch(e => {
-                this.logger.error("getSignDataPrefetch(): signDataPreFetch: error when sending sign data to the client: ", e);
-                abortController.abort(e);
-                return null;
-            }));
-        }
-
-        return signDataPrefetchPromise;
-    }
-
-    protected getIdentifierFromEvent(event: SwapEvent<SwapData>): string {
-        const foundSwap = this.escrowHashMap.get(event.escrowHash);
-        if(foundSwap!=null) {
-            return foundSwap.getIdentifier();
-        }
-        return "UNKNOWN_"+event.escrowHash;
-    }
-
-    protected getIdentifierFromSwapData(swapData: SwapData): string {
-        if(swapData.getSequence==null) return swapData.getClaimHash();
-        return swapData.getClaimHash()+"_"+swapData.getSequence().toString(16);
-    }
-
-    protected getIdentifier(swap: SwapHandlerSwap | SwapEvent<SwapData> | SwapData) {
-        if(swap instanceof SwapHandlerSwap) {
-            return swap.getIdentifier();
-        }
-        if(swap instanceof SwapEvent) {
-            return this.getIdentifierFromEvent(swap);
-        }
-        return this.getIdentifierFromSwapData(swap);
-    }
-
     /**
      * Checks if the sequence number is between 0-2^64
      *