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

package/src/swaps/{frombtcln_abstract → escrow/frombtcln_abstract}/FromBtcLnAbs.ts

@@ -1,8 +1,8 @@
 import {Express, Request, Response} from "express";
 import {createHash, randomBytes} from "crypto";
 import {FromBtcLnSwapAbs, FromBtcLnSwapState} from "./FromBtcLnSwapAbs";
-import {MultichainData, SwapHandlerType} from "../SwapHandler";
-import {ISwapPrice} from "../ISwapPrice";
+import {MultichainData, SwapHandlerType} from "../../SwapHandler";
+import {ISwapPrice} from "../../../prices/ISwapPrice";
 import {
     BigIntBufferUtils,
     ChainSwapType,
@@ -11,21 +11,21 @@ import {
     RefundEvent,
     SwapData
 } from "@atomiqlabs/base";
-import {expressHandlerWrapper, HEX_REGEX, isDefinedRuntimeError} from "../../utils/Utils";
-import {PluginManager} from "../../plugins/PluginManager";
-import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
-import {FieldTypeEnum, verifySchema} from "../../utils/paramcoders/SchemaVerifier";
-import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDecoder";
-import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
-import {IParamReader} from "../../utils/paramcoders/IParamReader";
-import {FromBtcBaseConfig} from "../FromBtcBaseSwapHandler";
-import {FromBtcLnBaseSwapHandler} from "../FromBtcLnBaseSwapHandler";
+import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
+import {PluginManager} from "../../../plugins/PluginManager";
+import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
+import {FieldTypeEnum, verifySchema} from "../../../utils/paramcoders/SchemaVerifier";
+import {serverParamDecoder} from "../../../utils/paramcoders/server/ServerParamDecoder";
+import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamEncoder";
+import {IParamReader} from "../../../utils/paramcoders/IParamReader";
+import {FromBtcBaseConfig, FromBtcBaseSwapHandler} from "../FromBtcBaseSwapHandler";
 import {
     HodlInvoiceInit,
     ILightningWallet,
     LightningNetworkChannel,
     LightningNetworkInvoice
-} from "../../wallets/ILightningWallet";
+} from "../../../wallets/ILightningWallet";
+import { LightningAssertions } from "../../assertions/LightningAssertions";
 
 export type FromBtcLnConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
@@ -45,11 +45,13 @@ export type FromBtcLnRequestType = {
 /**
  * Swap handler handling from BTCLN swaps using submarine swaps
  */
-export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, FromBtcLnSwapState> {
+export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromBtcLnSwapState> {
     readonly type = SwapHandlerType.FROM_BTCLN;
     readonly swapType = ChainSwapType.HTLC;
 
     readonly config: FromBtcLnConfig;
+    readonly lightning: ILightningWallet;
+    readonly LightningAssertions: LightningAssertions;
 
     constructor(
         storageDirectory: IIntermediaryStorage<FromBtcLnSwapAbs>,
@@ -59,9 +61,11 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
         swapPricing: ISwapPrice,
         config: FromBtcLnConfig
     ) {
-        super(storageDirectory, path, chains, lightning, swapPricing);
+        super(storageDirectory, path, chains, swapPricing, config);
         this.config = config;
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
+        this.lightning = lightning;
+        this.LightningAssertions = new LightningAssertions(this.logger, lightning);
     }
 
     protected async processPastSwap(swap: FromBtcLnSwapAbs): Promise<"REFUND" | "SETTLE" | "CANCEL" | null> {
@@ -499,8 +503,8 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             chainIdentifier = this.chains.default;
             address = invoice.description;
         }
-        const {swapContract} = this.getChain(chainIdentifier);
-        if(!swapContract.isValidAddress(address)) throw {
+        const {chainInterface} = this.getChain(chainIdentifier);
+        if(!chainInterface.isValidAddress(address)) throw {
             _httpStatus: 200,
             code: 10001,
             msg: "Invoice expired/canceled"
@@ -542,8 +546,8 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             } = {request: {}, times: {}};
 
             const chainIdentifier = req.query.chain as string ?? this.chains.default;
-            const {swapContract, signer} = this.getChain(chainIdentifier);
-            const depositToken = req.query.depositToken as string ?? swapContract.getNativeCurrencyAddress();
+            const {swapContract, signer, chainInterface} = this.getChain(chainIdentifier);
+            const depositToken = req.query.depositToken as string ?? chainInterface.getNativeCurrencyAddress();
             this.checkAllowedDepositToken(chainIdentifier, depositToken);
 
             metadata.times.requestReceived = Date.now();
@@ -563,7 +567,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             const parsedBody: FromBtcLnRequestType = await req.paramReader.getParams({
                 address: (val: string) => val!=null &&
                             typeof(val)==="string" &&
-                            swapContract.isValidAddress(val) ? val : null,
+                            chainInterface.isValidAddress(val) ? val : null,
                 paymentHash: (val: string) => val!=null &&
                             typeof(val)==="string" &&
                             val.length===64 &&
@@ -581,7 +585,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
             };
             metadata.request = parsedBody;
 
-            const requestedAmount = {input: !parsedBody.exactOut, amount: parsedBody.amount};
+            const requestedAmount = {input: !parsedBody.exactOut, amount: parsedBody.amount, token: parsedBody.token};
             const request = {
                 chainIdentifier,
                 raw: req,
@@ -592,12 +596,12 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
 
             //Check request params
             this.checkDescriptionHash(parsedBody.descriptionHash);
-            const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
+            const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount);
             metadata.times.requestChecked = Date.now();
 
             //Create abortController for parallel prefetches
             const responseStream = res.responseStream;
-            const abortController = this.getAbortController(responseStream);
+            const abortController = getAbortController(responseStream);
 
             //Pre-fetch data
             const {
@@ -606,7 +610,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
                 depositTokenPricePrefetchPromise
             } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, depositToken, abortController);
             const balancePrefetch: Promise<bigint> = this.getBalancePrefetch(chainIdentifier, useToken, abortController);
-            const channelsPrefetch: Promise<LightningNetworkChannel[]> = this.getChannelsPrefetch(abortController);
+            const channelsPrefetch: Promise<LightningNetworkChannel[]> = this.LightningAssertions.getChannelsPrefetch(abortController);
 
             const dummySwapData = await this.getDummySwapData(chainIdentifier, useToken, parsedBody.address, parsedBody.paymentHash);
             abortController.signal.throwIfAborted();
@@ -627,7 +631,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
                 totalInToken,
                 securityDepositApyPPM,
                 securityDepositBaseMultiplierPPM
-            } = await this.checkFromBtcAmount(request, requestedAmount, fees, useToken, abortController.signal, pricePrefetchPromise);
+            } = await this.AmountAssertions.checkFromBtcAmount(this.type, request, {...requestedAmount, pricePrefetch: pricePrefetchPromise}, fees, abortController.signal);
             metadata.times.priceCalculated = Date.now();
 
             if(securityDepositApyPPM!=null) fees.securityDepositApyPPM = securityDepositApyPPM;
@@ -635,7 +639,7 @@ export class FromBtcLnAbs extends FromBtcLnBaseSwapHandler<FromBtcLnSwapAbs, Fro
 
             //Check if we have enough funds to honor the request
             await this.checkBalance(totalInToken, balancePrefetch, abortController.signal)
-            await this.checkInboundLiquidity(amountBD, channelsPrefetch, abortController.signal);
+            await this.LightningAssertions.checkInboundLiquidity(amountBD, channelsPrefetch, abortController.signal);
             metadata.times.balanceChecked = Date.now();
 
             //Create swap

package/src/swaps/{frombtcln_abstract → escrow/frombtcln_abstract}/FromBtcLnSwapAbs.ts

@@ -1,7 +1,7 @@
 import {SwapData} from "@atomiqlabs/base";
-import {SwapHandlerType} from "../..";
+import {SwapHandlerType} from "../../../index";
 import {FromBtcBaseSwap} from "../FromBtcBaseSwap";
-import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {deserializeBN, serializeBN} from "../../../utils/Utils";
 
 export enum FromBtcLnSwapState {
     REFUNDED = -2,

package/src/swaps/{tobtc_abstract → escrow/tobtc_abstract}/ToBtcAbs.ts

@@ -1,7 +1,7 @@
 import {Express, Request, Response} from "express";
 import {ToBtcSwapAbs, ToBtcSwapState} from "./ToBtcSwapAbs";
-import {MultichainData, SwapHandlerType} from "../SwapHandler";
-import {ISwapPrice} from "../ISwapPrice";
+import {MultichainData, SwapHandlerType} from "../../SwapHandler";
+import {ISwapPrice} from "../../../prices/ISwapPrice";
 import {
     BtcTx,
     ChainSwapType,
@@ -13,17 +13,17 @@ import {
     BitcoinRpc,
     BtcBlock, BigIntBufferUtils
 } from "@atomiqlabs/base";
-import {expressHandlerWrapper, HEX_REGEX, isDefinedRuntimeError} from "../../utils/Utils";
-import {PluginManager} from "../../plugins/PluginManager";
-import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
+import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
+import {PluginManager} from "../../../plugins/PluginManager";
+import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
 import {randomBytes} from "crypto";
-import {FieldTypeEnum, verifySchema} from "../../utils/paramcoders/SchemaVerifier";
-import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDecoder";
-import {IParamReader} from "../../utils/paramcoders/IParamReader";
-import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
+import {FieldTypeEnum, verifySchema} from "../../../utils/paramcoders/SchemaVerifier";
+import {serverParamDecoder} from "../../../utils/paramcoders/server/ServerParamDecoder";
+import {IParamReader} from "../../../utils/paramcoders/IParamReader";
+import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamEncoder";
 import {ToBtcBaseConfig, ToBtcBaseSwapHandler} from "../ToBtcBaseSwapHandler";
 import {PromiseQueue} from "promise-queue-ts";
-import {IBitcoinWallet} from "../../wallets/IBitcoinWallet";
+import {IBitcoinWallet} from "../../../wallets/IBitcoinWallet";
 
 const OUTPUT_SCRIPT_MAX_LENGTH = 200;
 
@@ -75,7 +75,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         bitcoinRpc: BitcoinRpc<BtcBlock>,
         config: ToBtcConfig
     ) {
-        super(storageDirectory, path, chainData, swapPricing);
+        super(storageDirectory, path, chainData, swapPricing, config);
         this.bitcoinRpc = bitcoinRpc;
         this.bitcoin = bitcoin;
         this.config = config;
@@ -595,7 +595,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             } = {request: {}, times: {}};
 
             const chainIdentifier = req.query.chain as string ?? this.chains.default;
-            const {swapContract, signer} = this.getChain(chainIdentifier);
+            const {swapContract, signer, chainInterface} = this.getChain(chainIdentifier);
 
             metadata.times.requestReceived = Date.now();
             /**
@@ -623,7 +623,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
                 offerer: (val: string) => val!=null &&
                         typeof(val)==="string" &&
-                        swapContract.isValidAddress(val) ? val : null,
+                        chainInterface.isValidAddress(val) ? val : null,
                 exactIn: FieldTypeEnum.BooleanOptional
             });
             if (parsedBody==null) throw {
@@ -632,7 +632,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             };
             metadata.request = parsedBody;
 
-            const requestedAmount = {input: !!parsedBody.exactIn, amount: parsedBody.amount};
+            const requestedAmount = {input: !!parsedBody.exactIn, amount: parsedBody.amount, token: parsedBody.token};
             const request = {
                 chainIdentifier,
                 raw: req,
@@ -648,12 +648,12 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             this.checkRequiredConfirmations(parsedBody.confirmations);
             this.checkAddress(parsedBody.address);
             await this.checkVaultInitialized(chainIdentifier, parsedBody.token);
-            const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
+            const fees = await this.AmountAssertions.preCheckToBtcAmounts(this.type, request, requestedAmount);
 
             metadata.times.requestChecked = Date.now();
 
             //Initialize abort controller for the parallel async operations
-            const abortController = this.getAbortController(responseStream);
+            const abortController = getAbortController(responseStream);
 
             const {pricePrefetchPromise, signDataPrefetchPromise} = this.getToBtcPrefetches(chainIdentifier, useToken, responseStream, abortController);
 
@@ -664,12 +664,13 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                 swapFee,
                 swapFeeInToken,
                 networkFeeInToken
-            } = await this.checkToBtcAmount(request, requestedAmount, fees, useToken, async (amount: bigint) => {
+            } = await this.AmountAssertions.checkToBtcAmount(this.type, request, {...requestedAmount, pricePrefetch: pricePrefetchPromise}, fees, async (amount: bigint) => {
                 metadata.times.amountsChecked = Date.now();
                 const resp = await this.checkAndGetNetworkFee(parsedBody.address, amount);
+                this.logger.debug("checkToBtcAmount(): network fee calculated, amount: "+amount.toString(10)+" fee: "+resp.networkFee.toString(10));
                 metadata.times.chainFeeCalculated = Date.now();
                 return resp;
-            }, abortController.signal, pricePrefetchPromise);
+            }, abortController.signal);
             metadata.times.priceCalculated = Date.now();
 
             const paymentHash = this.getHash(chainIdentifier, parsedBody.address, parsedBody.confirmations, parsedBody.nonce, amountBD).toString("hex");

package/src/swaps/{tobtc_abstract → escrow/tobtc_abstract}/ToBtcSwapAbs.ts

@@ -1,7 +1,7 @@
 import {SwapData} from "@atomiqlabs/base";
-import {SwapHandlerType} from "../..";
+import {SwapHandlerType} from "../../../index";
 import {ToBtcBaseSwap} from "../ToBtcBaseSwap";
-import {deserializeBN} from "../../utils/Utils";
+import {deserializeBN} from "../../../utils/Utils";
 
 export enum ToBtcSwapState {
     REFUNDED = -3,

package/src/swaps/{tobtcln_abstract → escrow/tobtcln_abstract}/ToBtcLnAbs.ts

@@ -1,7 +1,7 @@
 import {Express, Request, Response} from "express";
 import {ToBtcLnSwapAbs, ToBtcLnSwapState} from "./ToBtcLnSwapAbs";
-import {MultichainData, SwapHandlerType} from "../SwapHandler";
-import {ISwapPrice} from "../ISwapPrice";
+import {MultichainData, SwapHandlerType} from "../../SwapHandler";
+import {ISwapPrice} from "../../../prices/ISwapPrice";
 import {
     BigIntBufferUtils,
     ChainSwapType,
@@ -11,14 +11,14 @@ import {
     SwapCommitStatus,
     SwapData
 } from "@atomiqlabs/base";
-import {expressHandlerWrapper, HEX_REGEX, isDefinedRuntimeError} from "../../utils/Utils";
-import {PluginManager} from "../../plugins/PluginManager";
-import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
+import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
+import {PluginManager} from "../../../plugins/PluginManager";
+import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
 import {randomBytes} from "crypto";
-import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDecoder";
-import {IParamReader} from "../../utils/paramcoders/IParamReader";
-import {FieldTypeEnum, verifySchema} from "../../utils/paramcoders/SchemaVerifier";
-import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
+import {serverParamDecoder} from "../../../utils/paramcoders/server/ServerParamDecoder";
+import {IParamReader} from "../../../utils/paramcoders/IParamReader";
+import {FieldTypeEnum, verifySchema} from "../../../utils/paramcoders/SchemaVerifier";
+import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamEncoder";
 import {ToBtcBaseConfig, ToBtcBaseSwapHandler} from "../ToBtcBaseSwapHandler";
 import {
     ILightningWallet,
@@ -27,7 +27,8 @@ import {
     ProbeAndRouteInit,
     ProbeAndRouteResponse,
     routesMatch
-} from "../../wallets/ILightningWallet";
+} from "../../../wallets/ILightningWallet";
+import { LightningAssertions } from "../../assertions/LightningAssertions";
 
 export type ToBtcLnConfig = ToBtcBaseConfig & {
     routingFeeMultiplier: bigint,
@@ -86,13 +87,8 @@ export type ToBtcLnRequestType = {
  * Swap handler handling to BTCLN swaps using submarine swaps
  */
 export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwapState> {
-    protected readonly LIGHTNING_LIQUIDITY_CACHE_TIMEOUT = 5*1000;
 
     activeSubscriptions: Set<string> = new Set<string>();
-    lightningLiquidityCache: {
-        liquidity: bigint,
-        timestamp: number
-    };
 
     readonly type = SwapHandlerType.TO_BTCLN;
     readonly swapType = ChainSwapType.HTLC;
@@ -104,6 +100,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
     } = {};
 
     readonly lightning: ILightningWallet;
+    readonly LightningAssertions: LightningAssertions;
 
     constructor(
         storageDirectory: IIntermediaryStorage<ToBtcLnSwapAbs>,
@@ -113,8 +110,9 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         swapPricing: ISwapPrice,
         config: ToBtcLnConfig
     ) {
-        super(storageDirectory, path, chainData, swapPricing);
+        super(storageDirectory, path, chainData, swapPricing, config);
         this.lightning = lightning;
+        this.LightningAssertions = new LightningAssertions(this.logger, lightning);
         const anyConfig = config as any;
         anyConfig.minTsSendCltv = config.gracePeriod + (config.bitcoinBlocktime * config.minSendCltv * config.safetyFactor);
         this.config = anyConfig;
@@ -522,47 +520,6 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         }
     }
 
-    /**
-     * Checks if the prior payment with the same paymentHash exists
-     *
-     * @param paymentHash
-     * @param abortSignal
-     * @throws {DefinedRuntimeError} will throw an error if payment already exists
-     */
-    private async checkPriorPayment(paymentHash: string, abortSignal: AbortSignal): Promise<void> {
-        const payment = await this.lightning.getPayment(paymentHash);
-        if(payment!=null) throw {
-            code: 20010,
-            msg: "Already processed"
-        };
-        abortSignal.throwIfAborted();
-    }
-
-    /**
-     * Checks if the underlying LND backend has enough liquidity in channels to honor the swap
-     *
-     * @param amount
-     * @param abortSignal
-     * @param useCached Whether to use cached liquidity values
-     * @throws {DefinedRuntimeError} will throw an error if there isn't enough liquidity
-     */
-    private async checkLiquidity(amount: bigint, abortSignal: AbortSignal, useCached: boolean = false): Promise<void> {
-        if(!useCached || this.lightningLiquidityCache==null || this.lightningLiquidityCache.timestamp<Date.now()-this.LIGHTNING_LIQUIDITY_CACHE_TIMEOUT) {
-            const channelBalances = await this.lightning.getLightningBalance();
-            this.lightningLiquidityCache = {
-                liquidity: channelBalances.localBalance,
-                timestamp: Date.now()
-            }
-        }
-        if(amount > this.lightningLiquidityCache.liquidity) {
-            throw {
-                code: 20002,
-                msg: "Not enough liquidity"
-            };
-        }
-        abortSignal.throwIfAborted();
-    }
-
     /**
      * Estimates the routing fee & confidence by either probing or routing (if probing fails), the fee is also adjusted
      *  according to routing fee multiplier, and subject to minimums set in config
@@ -645,6 +602,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             actualRoutingFee = maxFee;
         }
 
+        this.logger.debug("checkAndGetNetworkFee(): network fee calculated, amount: "+amountBD.toString(10)+" fee: "+actualRoutingFee.toString(10));
+
         return {
             networkFee: actualRoutingFee,
             confidence: probeOrRouteResp.confidence
@@ -822,7 +781,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             } = {request: {}, times: {}};
 
             const chainIdentifier = req.query.chain as string ?? this.chains.default;
-            const {swapContract, signer} = this.getChain(chainIdentifier);
+            const {swapContract, signer, chainInterface} = this.getChain(chainIdentifier);
 
             metadata.times.requestReceived = Date.now();
             /**
@@ -847,7 +806,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
                 offerer: (val: string) => val!=null &&
                         typeof(val)==="string" &&
-                        swapContract.isValidAddress(val) ? val : null,
+                        chainInterface.isValidAddress(val) ? val : null,
                 exactIn: FieldTypeEnum.BooleanOptional,
                 amount: FieldTypeEnum.BigIntOptional
             });
@@ -879,19 +838,20 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             const {parsedPR, halfConfidence} = await this.checkPaymentRequest(chainIdentifier, parsedBody.pr);
             const requestedAmount = {
                 input: !!parsedBody.exactIn,
-                amount: !!parsedBody.exactIn ? parsedBody.amount : (parsedPR.mtokens + 999n) / 1000n
+                amount: !!parsedBody.exactIn ? parsedBody.amount : (parsedPR.mtokens + 999n) / 1000n,
+                token: useToken
             };
-            const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
+            const fees = await this.AmountAssertions.preCheckToBtcAmounts(this.type, request, requestedAmount);
             metadata.times.requestChecked = Date.now();
 
             //Create abort controller for parallel pre-fetches
-            const abortController = this.getAbortController(responseStream);
+            const abortController = getAbortController(responseStream);
 
             //Pre-fetch
             const {pricePrefetchPromise, signDataPrefetchPromise} = this.getToBtcPrefetches(chainIdentifier, useToken, responseStream, abortController);
 
             //Check if prior payment has been made
-            await this.checkPriorPayment(parsedPR.id, abortController.signal);
+            await this.LightningAssertions.checkPriorPayment(parsedPR.id, abortController.signal);
             metadata.times.priorPaymentChecked = Date.now();
 
             //Check amounts
@@ -902,9 +862,9 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 swapFee,
                 swapFeeInToken,
                 networkFeeInToken
-            } = await this.checkToBtcAmount(request, requestedAmount, fees, useToken, async (amountBD: bigint) => {
+            } = await this.AmountAssertions.checkToBtcAmount(this.type, request, {...requestedAmount, pricePrefetch: pricePrefetchPromise}, fees, async (amountBD: bigint) => {
                 //Check if we have enough liquidity to process the swap
-                await this.checkLiquidity(amountBD, abortController.signal, true);
+                await this.LightningAssertions.checkLiquidity(amountBD, abortController.signal, true);
                 metadata.times.liquidityChecked = Date.now();
 
                 const maxFee = parsedBody.exactIn ?
@@ -912,7 +872,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                     parsedBody.maxFee;
 
                 return await this.checkAndGetNetworkFee(amountBD, maxFee, parsedBody.expiryTimestamp, currentTimestamp, parsedBody.pr, metadata, abortController.signal);
-            }, abortController.signal, pricePrefetchPromise);
+            }, abortController.signal);
             metadata.times.priceCalculated = Date.now();
 
             //For exactIn swap, just save and wait for the actual invoice to be submitted

package/src/swaps/{tobtcln_abstract → escrow/tobtcln_abstract}/ToBtcLnSwapAbs.ts

@@ -1,6 +1,6 @@
 import {SwapData} from "@atomiqlabs/base";
-import {SwapHandlerType} from "../..";
-import {deserializeBN} from "../../utils/Utils";
+import {SwapHandlerType} from "../../../index";
+import {deserializeBN} from "../../../utils/Utils";
 import {ToBtcBaseSwap} from "../ToBtcBaseSwap";
 
 export enum ToBtcLnSwapState {

package/src/swaps/spv_vault_swap/SpvVault.ts

@@ -0,0 +1,143 @@
+import {
+    Lockable,
+    SpvVaultClaimEvent,
+    SpvVaultCloseEvent,
+    SpvVaultData,
+    SpvVaultDepositEvent,
+    SpvVaultOpenEvent,
+    SpvVaultTokenBalance,
+    SpvWithdrawalTransactionData,
+    StorageObject
+} from "@atomiqlabs/base";
+
+export enum SpvVaultState {
+    CLOSED = -1,
+    BTC_INITIATED = 0,
+    BTC_CONFIRMED = 1,
+    OPENED = 2
+}
+
+export class SpvVault<
+    D extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData,
+    T extends SpvVaultData = SpvVaultData
+> extends Lockable implements StorageObject {
+
+    readonly chainId: string;
+
+    readonly initialUtxo: string;
+    readonly btcAddress: string;
+
+    readonly pendingWithdrawals: D[];
+    data: T;
+
+    state: SpvVaultState;
+
+    balances: SpvVaultTokenBalance[];
+
+    scOpenTx: {txId: string, rawTx: string};
+
+    constructor(chainId: string, vault: T, btcAddress: string);
+    constructor(obj: any);
+    constructor(chainIdOrObj: string | any, vault?: T, btcAddress?: string) {
+        super();
+        if(typeof(chainIdOrObj)==="string") {
+            this.state = SpvVaultState.BTC_INITIATED;
+            this.chainId = chainIdOrObj;
+            this.data = vault;
+            this.initialUtxo = vault.getUtxo();
+            this.btcAddress = btcAddress;
+            this.pendingWithdrawals = [];
+        } else {
+            this.state = chainIdOrObj.state;
+            this.chainId = chainIdOrObj.chainId;
+            this.data = SpvVaultData.deserialize<T>(chainIdOrObj.data);
+            this.initialUtxo = chainIdOrObj.initialUtxo;
+            this.btcAddress = chainIdOrObj.btcAddress;
+            this.pendingWithdrawals = chainIdOrObj.pendingWithdrawals.map(SpvWithdrawalTransactionData.deserialize<D>);
+            this.scOpenTx = chainIdOrObj.scOpenTx;
+        }
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+    }
+
+    update(event: SpvVaultOpenEvent | SpvVaultDepositEvent | SpvVaultCloseEvent | SpvVaultClaimEvent): void {
+        if(event instanceof SpvVaultClaimEvent || event instanceof SpvVaultCloseEvent) {
+            const processedWithdrawalIndex = this.pendingWithdrawals.findIndex(val => val.btcTx.txid === event.btcTxId);
+            if(processedWithdrawalIndex!==-1) this.pendingWithdrawals.splice(0, processedWithdrawalIndex + 1);
+        }
+        this.data.updateState(event);
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+    }
+
+    addWithdrawal(withdrawalData: D): void {
+        //Make sure this is a valid state transition before adding the tx to pending withdrawals
+        this.balances = this.data.calculateStateAfter([...this.pendingWithdrawals, withdrawalData]).balances;
+        this.pendingWithdrawals.push(withdrawalData);
+    }
+
+    removeWithdrawal(withdrawalData: D): boolean {
+        const index = this.pendingWithdrawals.indexOf(withdrawalData);
+        if(index===-1) return false;
+        this.pendingWithdrawals.splice(index, 1);
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+        return true;
+    }
+
+    toRawAmounts(amounts: bigint[]): bigint[] {
+        return amounts.map((amt, index) => {
+            const tokenData = this.data.getTokenData()[index];
+            if(tokenData==null) throw new Error("Amount index out of bounds!");
+            return amt / tokenData.multiplier;
+        });
+    }
+
+    fromRawAmounts(rawAmounts: bigint[]): bigint[] {
+        return rawAmounts.map((amt, index) => {
+            const tokenData = this.data.getTokenData()[index];
+            if(tokenData==null) throw new Error("Amount index out of bounds!");
+            return amt * tokenData.multiplier;
+        });
+    }
+
+    /**
+     * Returns the vault balance after processing all currently confirmed (at least 1 btc confirmation) withdrawals
+     */
+    getConfirmedBalance(): SpvVaultTokenBalance[] {
+        return this.data.calculateStateAfter(this.pendingWithdrawals.filter(val => val.btcTx.confirmations>=1)).balances;
+    }
+
+    serialize(): any {
+        return {
+            state: this.state,
+            chainId: this.chainId,
+            data: this.data.serialize(),
+            initialUtxo: this.initialUtxo,
+            btcAddress: this.btcAddress,
+            pendingWithdrawals: this.pendingWithdrawals.map(val => val.serialize()),
+            scOpenTx: this.scOpenTx
+        }
+    }
+
+    getIdentifier(): string {
+        return this.chainId+"_"+this.data.getOwner()+"_"+this.data.getVaultId().toString(10);
+    }
+
+    /**
+     * Returns the latest vault utxo
+     */
+    getLatestUtxo(): string {
+        if(this.pendingWithdrawals.length===0) {
+            return this.data.getUtxo();
+        }
+        const latestWithdrawal = this.pendingWithdrawals[this.pendingWithdrawals.length - 1];
+        if(latestWithdrawal.btcTx.confirmations>=1) return latestWithdrawal.btcTx.txid+":0";
+        return null;
+    }
+
+    /**
+     * Returns whether the vault is ready for the next swap
+     */
+    isReady(): boolean {
+        return this.data.isOpened() && this.getLatestUtxo()!=null;
+    }
+
+}