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

package/src/swaps/{frombtc_trusted → trusted/frombtc_trusted}/FromBtcTrustedSwap.ts

@@ -1,7 +1,8 @@
 import {BigIntBufferUtils, BtcTx, SwapData} from "@atomiqlabs/base";
-import {FromBtcBaseSwap} from "../FromBtcBaseSwap";
-import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {deserializeBN, serializeBN} from "../../../utils/Utils";
 import {createHash, randomBytes} from "crypto";
+import {SwapHandlerSwap} from "../../SwapHandlerSwap";
+import {SwapHandlerType} from "../../SwapHandler";
 
 
 export enum FromBtcTrustedSwapState {
@@ -17,8 +18,9 @@ export enum FromBtcTrustedSwapState {
     FINISHED = 5
 }
 
-export class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcTrustedSwapState> {
+export class FromBtcTrustedSwap extends SwapHandlerSwap<FromBtcTrustedSwapState> {
 
+    readonly amount: bigint;
     readonly sequence: bigint;
     readonly btcAddress: string;
 
@@ -79,9 +81,10 @@ export class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBa
         token?: string
     ) {
         if(typeof(objOrChainIdentifier)==="string") {
-            super(objOrChainIdentifier, inputSats, swapFee, swapFeeInToken);
+            super(objOrChainIdentifier, swapFee, swapFeeInToken);
             this.state = FromBtcTrustedSwapState.CREATED;
             this.doubleSpent = false;
+            this.amount = inputSats;
             this.sequence = BigIntBufferUtils.fromBuffer(randomBytes(8));
             this.btcAddress = btcAddress;
             this.dstAddress = dstAddress;
@@ -94,6 +97,7 @@ export class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBa
         } else {
             super(objOrChainIdentifier);
             this.btcAddress = objOrChainIdentifier.btcAddress;
+            this.amount = deserializeBN(objOrChainIdentifier.amount);
             this.sequence = deserializeBN(objOrChainIdentifier.sequence);
             this.dstAddress = objOrChainIdentifier.dstAddress;
             this.outputTokens = deserializeBN(objOrChainIdentifier.outputTokens);
@@ -114,11 +118,13 @@ export class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBa
             this.refundTxId = objOrChainIdentifier.refundTxId;
             this.token = objOrChainIdentifier.token;
         }
+        this.type = SwapHandlerType.FROM_BTC_TRUSTED;
     }
 
     serialize(): any {
         const partialSerialized = super.serialize();
         partialSerialized.btcAddress = this.btcAddress;
+        partialSerialized.amount = serializeBN(this.amount);
         partialSerialized.sequence = serializeBN(this.sequence);
         partialSerialized.dstAddress = this.dstAddress;
         partialSerialized.outputTokens = serializeBN(this.outputTokens);
@@ -141,10 +147,6 @@ export class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBa
         return partialSerialized;
     }
 
-    getClaimHash(): string {
-        return createHash("sha256").update(this.btcAddress).digest().toString("hex");
-    }
-
     getSequence(): bigint {
         return this.sequence;
     }
@@ -161,6 +163,10 @@ export class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBa
         return this.adjustedInput || this.amount;
     }
 
+    getSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
+        return {inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken};
+    }
+
     isFailed(): boolean {
         return this.state===FromBtcTrustedSwapState.EXPIRED || this.state===FromBtcTrustedSwapState.REFUNDED || this.state===FromBtcTrustedSwapState.DOUBLE_SPENT;
     }
@@ -173,4 +179,8 @@ export class FromBtcTrustedSwap<T extends SwapData = SwapData> extends FromBtcBa
         return this.state===FromBtcTrustedSwapState.CONFIRMED;
     }
 
+    getIdentifierHash(): string {
+        return createHash("sha256").update(this.btcAddress).digest().toString("hex");
+    }
+
 }

package/src/swaps/{frombtcln_trusted → trusted/frombtcln_trusted}/FromBtcLnTrusted.ts

@@ -1,30 +1,24 @@
 import {Express, Request, Response} from "express";
 import {createHash, randomBytes} from "crypto";
-import {
-    ClaimEvent,
-    InitializeEvent,
-    RefundEvent,
-    SwapData,
-} from "@atomiqlabs/base";
 import {FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState} from "./FromBtcLnTrustedSwap";
-import {FromBtcBaseConfig} from "../FromBtcBaseSwapHandler";
-import {ISwapPrice} from "../ISwapPrice";
-import {MultichainData, SwapHandlerType} from "../SwapHandler";
-import {IIntermediaryStorage} from "../../storage/IIntermediaryStorage";
-import {expressHandlerWrapper, HEX_REGEX} from "../../utils/Utils";
-import {IParamReader} from "../../utils/paramcoders/IParamReader";
-import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEncoder";
-import {FieldTypeEnum, verifySchema} from "../../utils/paramcoders/SchemaVerifier";
-import {PluginManager} from "../../plugins/PluginManager";
-import {FromBtcLnBaseSwapHandler} from "../FromBtcLnBaseSwapHandler";
+import {ISwapPrice} from "../../../prices/ISwapPrice";
+import {MultichainData, SwapBaseConfig, SwapHandler, SwapHandlerType} from "../../SwapHandler";
+import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
+import {expressHandlerWrapper, getAbortController, HEX_REGEX} from "../../../utils/Utils";
+import {IParamReader} from "../../../utils/paramcoders/IParamReader";
+import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamEncoder";
+import {FieldTypeEnum, verifySchema} from "../../../utils/paramcoders/SchemaVerifier";
+import {PluginManager} from "../../../plugins/PluginManager";
 import {
     HodlInvoiceInit,
     ILightningWallet,
     LightningNetworkChannel,
     LightningNetworkInvoice
-} from "../../wallets/ILightningWallet";
+} from "../../../wallets/ILightningWallet";
+import {FromBtcAmountAssertions} from "../../assertions/FromBtcAmountAssertions";
+import { LightningAssertions } from "../../assertions/LightningAssertions";
 
-export type SwapForGasServerConfig = FromBtcBaseConfig & {
+export type SwapForGasServerConfig = SwapBaseConfig & {
     minCltv: bigint,
 
     invoiceTimeoutSeconds?: number
@@ -40,14 +34,16 @@ export type FromBtcLnTrustedRequestType = {
 /**
  * Swap handler handling from BTCLN swaps using submarine swaps
  */
-export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState> {
-    readonly type: SwapHandlerType = SwapHandlerType.FROM_BTCLN_TRUSTED;
-    readonly swapType = null;
+export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState> {
+    readonly type = SwapHandlerType.FROM_BTCLN_TRUSTED;
 
     activeSubscriptions: Map<string, AbortController> = new Map<string, AbortController>();
     processedTxIds: Map<string, string> = new Map<string, string>();
 
     readonly config: SwapForGasServerConfig;
+    readonly lightning: ILightningWallet;
+    readonly LightningAssertions: LightningAssertions;
+    readonly AmountAssertions: FromBtcAmountAssertions;
 
     constructor(
         storageDirectory: IIntermediaryStorage<FromBtcLnTrustedSwap>,
@@ -57,7 +53,10 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
         swapPricing: ISwapPrice,
         config: SwapForGasServerConfig
     ) {
-        super(storageDirectory, path, chains, lightning, swapPricing);
+        super(storageDirectory, path, chains, swapPricing);
+        this.lightning = lightning;
+        this.LightningAssertions = new LightningAssertions(this.logger, lightning);
+        this.AmountAssertions = new FromBtcAmountAssertions(config, swapPricing);
         this.config = config;
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
     }
@@ -193,7 +192,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
      */
     private async htlcReceived(invoiceData: FromBtcLnTrustedSwap, invoice: { id: string }) {
 
-        const {swapContract, signer} = this.getChain(invoiceData.chainIdentifier);
+        const { signer, chainInterface} = this.getChain(invoiceData.chainIdentifier);
 
         //Important to prevent race condition and issuing 2 signed init messages at the same time
         if(invoiceData.state===FromBtcLnTrustedSwapState.CREATED) {
@@ -203,7 +202,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
         }
 
         if(invoiceData.state===FromBtcLnTrustedSwapState.RECEIVED) {
-            const balance: Promise<bigint> = swapContract.getBalance(signer.getAddress(), invoiceData.token, false);
+            const balance: Promise<bigint> = chainInterface.getBalance(signer.getAddress(), invoiceData.token);
             try {
                 await this.checkBalance(invoiceData.output, balance, null);
                 if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcBalanceChecked = Date.now();
@@ -214,12 +213,12 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
 
             if(invoiceData.state!==FromBtcLnTrustedSwapState.RECEIVED) return;
 
-            const txns = await swapContract.txsTransfer(signer.getAddress(), invoiceData.token, invoiceData.output, invoiceData.dstAddress);
+            const txns = await chainInterface.txsTransfer(signer.getAddress(), invoiceData.token, invoiceData.output, invoiceData.dstAddress);
 
             let unlock = invoiceData.lock(Infinity);
             if(unlock==null) return;
 
-            const result = await swapContract.sendAndConfirm(signer, txns, true, null, false, async (txId: string, rawTx: string) => {
+            const result = await chainInterface.sendAndConfirm(signer, txns, true, null, false, async (txId: string, rawTx: string) => {
                 invoiceData.txIds = {init: txId};
                 invoiceData.scRawTx = rawTx;
                 if(invoiceData.state===FromBtcLnTrustedSwapState.RECEIVED) {
@@ -253,7 +252,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
         if(invoiceData.state===FromBtcLnTrustedSwapState.SENT) {
             if(invoiceData.isLocked()) return;
 
-            const txStatus = await swapContract.getTxStatus(invoiceData.scRawTx);
+            const txStatus = await chainInterface.getTxStatus(invoiceData.scRawTx);
             if(txStatus==="not_found") {
                 //Retry
                 invoiceData.txIds = {init: null};
@@ -324,8 +323,8 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
             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"
@@ -371,7 +370,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
             } = {request: {}, times: {}};
 
             const chainIdentifier = req.query.chain as string ?? this.chains.default;
-            const {swapContract, signer} = this.getChain(chainIdentifier);
+            const {signer, chainInterface} = this.getChain(chainIdentifier);
 
             metadata.times.requestReceived = Date.now();
             /**
@@ -379,12 +378,12 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
              * amount: string               amount (in lamports/smart chain base units) of the invoice
              */
 
-            req.query.token ??= swapContract.getNativeCurrencyAddress();
+            req.query.token ??= chainInterface.getNativeCurrencyAddress();
 
             const parsedBody: FromBtcLnTrustedRequestType = verifySchema(req.query,{
                 address: (val: string) => val!=null &&
                     typeof(val)==="string" &&
-                    swapContract.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val) ? val : null,
                 token: (val: string) => val!=null &&
                     typeof(val)==="string" &&
                     this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -398,7 +397,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
             };
             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,
@@ -408,21 +407,25 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
             const useToken = parsedBody.token;
 
             //Check request params
-            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 {pricePrefetchPromise} = this.getFromBtcPricePrefetches(chainIdentifier, useToken, useToken, abortController);
-            const balancePrefetch = swapContract.getBalance(signer.getAddress(), useToken, false).catch(e => {
+            const pricePrefetchPromise: Promise<bigint> = this.swapPricing.preFetchPrice(useToken, chainIdentifier).catch(e => {
+                this.logger.error("pricePrefetchPromise(): pricePrefetch error: ", e);
+                abortController.abort(e);
+                return null;
+            });
+            const balancePrefetch = chainInterface.getBalance(signer.getAddress(), useToken).catch(e => {
                 this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
                 abortController.abort(e);
                 return null;
             });
-            const channelsPrefetch: Promise<LightningNetworkChannel[]> = this.getChannelsPrefetch(abortController);
+            const channelsPrefetch: Promise<LightningNetworkChannel[]> = this.LightningAssertions.getChannelsPrefetch(abortController);
 
             //Check valid amount specified (min/max)
             const {
@@ -430,12 +433,12 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
                 swapFee,
                 swapFeeInToken,
                 totalInToken
-            } = 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();
 
             //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();
 
             const secret = randomBytes(32);
@@ -584,17 +587,5 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
         };
     }
 
-    protected processClaimEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: ClaimEvent<SwapData>): Promise<void> {
-        return Promise.resolve();
-    }
-
-    protected processInitializeEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: InitializeEvent<SwapData>): Promise<void> {
-        return Promise.resolve();
-    }
-
-    protected processRefundEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: RefundEvent<SwapData>): Promise<void> {
-        return Promise.resolve();
-    }
-
 }
 

package/src/swaps/{frombtcln_trusted → trusted/frombtcln_trusted}/FromBtcLnTrustedSwap.ts

@@ -1,7 +1,7 @@
-import {SwapData} from "@atomiqlabs/base";
 import {createHash} from "crypto";
-import {FromBtcBaseSwap} from "../FromBtcBaseSwap";
-import {deserializeBN, serializeBN} from "../../utils/Utils";
+import {deserializeBN, serializeBN} from "../../../utils/Utils";
+import {SwapHandlerSwap} from "../../SwapHandlerSwap";
+import {SwapHandlerType} from "../../SwapHandler";
 
 export enum FromBtcLnTrustedSwapState {
     REFUNDED = -2,
@@ -13,9 +13,10 @@ export enum FromBtcLnTrustedSwapState {
     SETTLED = 4,
 }
 
-export class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcLnTrustedSwapState> {
+export class FromBtcLnTrustedSwap extends SwapHandlerSwap<FromBtcLnTrustedSwapState> {
 
     readonly pr: string;
+    amount: bigint;
     readonly output: bigint;
     readonly dstAddress: string;
     readonly secret: string;
@@ -48,9 +49,10 @@ export class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtc
         token?: string
     ) {
         if(typeof(chainIdOrObj)==="string") {
-            super(chainIdOrObj, (inputMtokens + 999n) / 1000n, swapFee, swapFeeInToken);
+            super(chainIdOrObj, swapFee, swapFeeInToken);
             this.state = FromBtcLnTrustedSwapState.CREATED;
             this.pr = pr;
+            this.amount = (inputMtokens + 999n) / 1000n;
             this.output = output;
             this.secret = secret;
             this.dstAddress = dstAddress;
@@ -58,13 +60,14 @@ export class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtc
         } else {
             super(chainIdOrObj);
             this.pr = chainIdOrObj.pr;
+            this.amount = deserializeBN(chainIdOrObj.amount);
             this.output = deserializeBN(chainIdOrObj.output);
             this.secret = chainIdOrObj.secret;
             this.dstAddress = chainIdOrObj.dstAddress;
             this.token = chainIdOrObj.token;
             this.scRawTx = chainIdOrObj.scRawTx;
         }
-        this.type = null;
+        this.type = SwapHandlerType.FROM_BTCLN_TRUSTED;
     }
 
     getToken(): string {
@@ -75,8 +78,12 @@ export class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtc
         return this.output;
     }
 
-    getClaimHash(): string {
-        return createHash("sha256").update(Buffer.from(this.secret, "hex")).digest().toString("hex");
+    getSwapFee(): { inInputToken: bigint; inOutputToken: bigint } {
+        return {inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken};
+    }
+
+    getTotalInputAmount(): bigint {
+        return this.amount;
     }
 
     getSequence(): bigint {
@@ -86,6 +93,7 @@ export class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtc
     serialize(): any {
         const partialSerialized = super.serialize();
         partialSerialized.pr = this.pr;
+        partialSerialized.amount = serializeBN(this.amount);
         partialSerialized.output = serializeBN(this.output);
         partialSerialized.secret = this.secret;
         partialSerialized.dstAddress = this.dstAddress;
@@ -106,4 +114,8 @@ export class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtc
         return this.state===FromBtcLnTrustedSwapState.SETTLED;
     }
 
+    getIdentifierHash(): string {
+        return createHash("sha256").update(Buffer.from(this.secret, "hex")).digest().toString("hex");
+    }
+
 }

package/src/utils/Utils.ts

@@ -56,7 +56,14 @@ export function expressHandlerWrapper(func: (
     }
 }
 
-export function getLogger(prefix: string) {
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void,
+    info: (msg: string, ...args: any[]) => void,
+    warn: (msg: string, ...args: any[]) => void,
+    error: (msg: string, ...args: any[]) => void
+};
+
+export function getLogger(prefix: string): LoggerType {
     return {
         debug: (msg, ...args) => console.debug(prefix+msg, ...args),
         info: (msg, ...args) => console.info(prefix+msg, ...args),
@@ -74,3 +81,22 @@ export function serializeBN(bn: bigint | null): string | null {
 export function deserializeBN(str: string | null): bigint | null {
     return str==null ? null : BigInt(str);
 }
+
+export function bigIntSorter(a: bigint, b: bigint): -1 | 0 | 1 {
+    if(a < b) return -1;
+    if(a > b) return 1;
+    return 0;
+}
+
+/**
+ * Creates an abort controller that extends the responseStream's abort signal
+ *
+ * @param responseStream
+ */
+export function 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;
+}

package/src/wallets/IBitcoinWallet.ts

@@ -52,13 +52,17 @@ export interface IBitcoinWallet {
     getWalletTransaction(txId: string): Promise<BtcTx | null>;
     subscribeToWalletTransactions(callback: (tx: BtcTx) => void, abortSignal?: AbortSignal): void;
 
+    fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
     signPsbt(psbt: Transaction): Promise<SignPsbtResponse>;
     sendRawTransaction(tx: string): Promise<void>;
     getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
+    getSignedMultiTransaction(destinations: {address: string, amount: number}[], feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
     estimateFee(destination: string, amount: number, feeRate?: number, feeRateMultiplier?: number): Promise<{satsPerVbyte: number, networkFee: number}>;
     drainAll(destination: string | Buffer, inputs: Omit<BitcoinUtxo, "address">[], feeRate?: number): Promise<SignPsbtResponse>;
     burnAll(inputs: Omit<BitcoinUtxo, "address">[]): Promise<SignPsbtResponse>;
 
+    parsePsbt(psbt: Transaction): Promise<BtcTx>;
+
     getBlockheight(): Promise<number>;
     getFeeRate(): Promise<number>;
 

package/src/wallets/ISpvVaultSigner.ts

@@ -0,0 +1,11 @@
+import {Transaction} from "@scure/btc-signer";
+
+export interface ISpvVaultSigner {
+
+    init(): Promise<void>;
+
+    getAddressType(): "p2wpkh" | "p2tr";
+    getAddress(chainId: string, vaultId: bigint): Promise<string>;
+    signPsbt(chainId: string, vaultId: bigint, psbt: Transaction, inputs: number[]): Promise<Transaction>;
+
+}

package/dist/swaps/FromBtcLnBaseSwapHandler.d.ts

@@ -1,26 +0,0 @@
-import { SwapHandlerSwap } from "./SwapHandlerSwap";
-import { SwapData } from "@atomiqlabs/base";
-import { FromBtcBaseSwapHandler } from "./FromBtcBaseSwapHandler";
-import { ILightningWallet, LightningNetworkChannel } from "../wallets/ILightningWallet";
-import { IIntermediaryStorage } from "../storage/IIntermediaryStorage";
-import { MultichainData } from "./SwapHandler";
-import { ISwapPrice } from "./ISwapPrice";
-export declare abstract class FromBtcLnBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends FromBtcBaseSwapHandler<V, S> {
-    readonly lightning: ILightningWallet;
-    constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chains: MultichainData, lightning: ILightningWallet, swapPricing: ISwapPrice);
-    /**
-     * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
-     *
-     * @param amountBD
-     * @param channelsPrefetch
-     * @param signal
-     * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
-     */
-    protected checkInboundLiquidity(amountBD: bigint, channelsPrefetch: Promise<LightningNetworkChannel[]>, signal: AbortSignal): Promise<void>;
-    /**
-     * Starts LN channels pre-fetch
-     *
-     * @param abortController
-     */
-    protected getChannelsPrefetch(abortController: AbortController): Promise<LightningNetworkChannel[]>;
-}

package/dist/swaps/FromBtcLnBaseSwapHandler.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FromBtcLnBaseSwapHandler = void 0;
-const FromBtcBaseSwapHandler_1 = require("./FromBtcBaseSwapHandler");
-class FromBtcLnBaseSwapHandler extends FromBtcBaseSwapHandler_1.FromBtcBaseSwapHandler {
-    constructor(storageDirectory, path, chains, lightning, swapPricing) {
-        super(storageDirectory, path, chains, swapPricing);
-        this.lightning = lightning;
-    }
-    /**
-     * Checks if we have enough inbound liquidity to be able to receive an LN payment (without MPP)
-     *
-     * @param amountBD
-     * @param channelsPrefetch
-     * @param signal
-     * @throws {DefinedRuntimeError} will throw an error if there isn't enough inbound liquidity to receive the LN payment
-     */
-    async checkInboundLiquidity(amountBD, channelsPrefetch, signal) {
-        const channelsResponse = await channelsPrefetch;
-        signal.throwIfAborted();
-        let hasEnoughInboundLiquidity = false;
-        channelsResponse.forEach(channel => {
-            if (channel.remoteBalance >= amountBD)
-                hasEnoughInboundLiquidity = true;
-        });
-        if (!hasEnoughInboundLiquidity) {
-            throw {
-                code: 20050,
-                msg: "Not enough LN inbound liquidity"
-            };
-        }
-    }
-    /**
-     * Starts LN channels pre-fetch
-     *
-     * @param abortController
-     */
-    getChannelsPrefetch(abortController) {
-        return this.lightning.getChannels(true).catch(e => {
-            this.logger.error("getChannelsPrefetch(): error", e);
-            abortController.abort(e);
-            return null;
-        });
-    }
-}
-exports.FromBtcLnBaseSwapHandler = FromBtcLnBaseSwapHandler;

package/dist/swaps/ToBtcBaseSwapHandler.d.ts

@@ -1,95 +0,0 @@
-import { RequestData, SwapBaseConfig, SwapHandler } from "./SwapHandler";
-import { SwapHandlerSwap } from "./SwapHandlerSwap";
-import { SwapData } from "@atomiqlabs/base";
-import { ServerParamEncoder } from "../utils/paramcoders/server/ServerParamEncoder";
-import { IParamReader } from "../utils/paramcoders/IParamReader";
-import { ToBtcLnRequestType } from "./tobtcln_abstract/ToBtcLnAbs";
-import { ToBtcRequestType } from "./tobtc_abstract/ToBtcAbs";
-import { Request } from "express";
-export type ToBtcBaseConfig = SwapBaseConfig & {
-    gracePeriod: bigint;
-    refundAuthorizationTimeout: number;
-};
-export declare abstract class ToBtcBaseSwapHandler<V extends SwapHandlerSwap<SwapData, S>, S> extends SwapHandler<V, S> {
-    readonly pdaExistsForToken: {
-        [chainIdentifier: string]: {
-            [token: string]: boolean;
-        };
-    };
-    abstract config: ToBtcBaseConfig;
-    protected checkVaultInitialized(chainIdentifier: string, token: string): Promise<void>;
-    /**
-     * Checks minimums/maximums, calculates the fee & total amount
-     *
-     * @param request
-     * @param requestedAmount
-     * @param useToken
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds
-     */
-    protected preCheckAmounts(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
-        input: boolean;
-        amount: bigint;
-    }, useToken: string): Promise<{
-        baseFee: bigint;
-        feePPM: bigint;
-    }>;
-    /**
-     * Checks minimums/maximums, calculates network fee (based on the callback passed), swap fee & total amount
-     *
-     * @param request
-     * @param requestedAmount
-     * @param fees
-     * @param useToken
-     * @param getNetworkFee
-     * @param signal
-     * @param pricePrefetchPromise
-     * @throws {DefinedRuntimeError} will throw an error if the amount is outside minimum/maximum bounds,
-     *  or if we don't have enough funds (getNetworkFee callback throws)
-     */
-    protected checkToBtcAmount<T extends {
-        networkFee: bigint;
-    }>(request: RequestData<ToBtcLnRequestType | ToBtcRequestType>, requestedAmount: {
-        input: boolean;
-        amount: bigint;
-    }, fees: {
-        baseFee: bigint;
-        feePPM: bigint;
-    }, useToken: string, getNetworkFee: (amount: bigint) => Promise<T>, signal: AbortSignal, pricePrefetchPromise?: Promise<bigint>): Promise<{
-        amountBD: bigint;
-        networkFeeData: T;
-        swapFee: bigint;
-        swapFeeInToken: bigint;
-        networkFee: bigint;
-        networkFeeInToken: bigint;
-        totalInToken: bigint;
-    }>;
-    /**
-     * Starts pre-fetches for swap pricing & signature data
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param responseStream
-     * @param abortController
-     */
-    protected getToBtcPrefetches(chainIdentifier: string, token: string, responseStream: ServerParamEncoder, abortController: AbortController): {
-        pricePrefetchPromise?: Promise<bigint>;
-        signDataPrefetchPromise?: Promise<any>;
-    };
-    /**
-     * Signs the created swap
-     *
-     * @param chainIdentifier
-     * @param swapObject
-     * @param req
-     * @param abortSignal
-     * @param signDataPrefetchPromise
-     */
-    protected getToBtcSignatureData(chainIdentifier: string, swapObject: SwapData, req: Request & {
-        paramReader: IParamReader;
-    }, abortSignal: AbortSignal, signDataPrefetchPromise?: Promise<any>): Promise<{
-        prefix: string;
-        timeout: string;
-        signature: string;
-        feeRate: string;
-    }>;
-}