@atomiqlabs/lp-lib 17.5.3 → 17.6.1

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

@@ -4,7 +4,13 @@ import {FromBtcLnAutoSwap, FromBtcLnAutoSwapState} from "./FromBtcLnAutoSwap";
 import {MultichainData, SwapHandlerType} from "../../SwapHandler";
 import {ISwapPrice} from "../../../prices/ISwapPrice";
 import {ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapCommitStateType, SwapData} from "@atomiqlabs/base";
-import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
+import {
+    bigIntMax,
+    expressHandlerWrapper,
+    getAbortController, getMinSafeBlockWindowFast,
+    HEX_REGEX,
+    isDefinedRuntimeError
+} from "../../../utils/Utils";
 import {PluginManager} from "../../../plugins/PluginManager";
 import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
 import {FieldTypeEnum, verifySchema} from "../../../utils/paramcoders/SchemaVerifier";
@@ -23,7 +29,7 @@ import {isQuoteThrow} from "../../../plugins/IPlugin";
 
 export type FromBtcLnAutoConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
-    minCltv: bigint,
+    destinationHtlcTimeoutSeconds: bigint,
     gracePeriod: bigint,
     gasTokenMax: {[chainId: string]: bigint}
 }
@@ -54,6 +60,8 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
     readonly lightning: ILightningWallet;
     readonly LightningAssertions: LightningAssertions;
 
+    readonly minCltv: bigint;
+
     constructor(
         storageDirectory: IIntermediaryStorage<FromBtcLnAutoSwap>,
         path: string,
@@ -73,6 +81,13 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             const {swapContract} = this.getChain(chain);
             if(!swapContract.supportsInitWithoutClaimer) this.allowedTokens[chain].clear();
         }
+
+        const numerator = (this.config.destinationHtlcTimeoutSeconds + this.config.gracePeriod) * this.config.safetyFactor;
+        this.minCltv = bigIntMax(
+            (numerator + this.config.bitcoinBlocktime - 1n)
+                / this.config.bitcoinBlocktime, //Ceil division
+            getMinSafeBlockWindowFast(this.config.safetyFactor)
+        );
     }
 
     protected async processPastSwap(swap: FromBtcLnAutoSwap): Promise<"REFUND" | "SETTLE" | null> {
@@ -184,10 +199,13 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             if(unlock==null) continue;
 
             this.swapLogger.debug(refundSwap, "refundSwaps(): initiate refund of swap");
-            await swapContract.refund(signer, refundSwap.data, true, false, {waitForConfirmation: true});
-            this.swapLogger.info(refundSwap, "refundsSwaps(): swap refunded, invoice: "+refundSwap.pr);
-
-            await refundSwap.setState(FromBtcLnAutoSwapState.REFUNDED);
+            try {
+                await swapContract.refund(signer, refundSwap.data, true, false, {waitForConfirmation: true});
+                this.swapLogger.info(refundSwap, "refundsSwaps(): swap refunded, invoice: "+refundSwap.pr);
+                await refundSwap.setState(FromBtcLnAutoSwapState.REFUNDED);
+            } catch (e) {
+                this.swapLogger.error(refundSwap, "refundSwaps(): error refunding swap: ", e);
+            }
             unlock();
         }
     }
@@ -229,13 +247,17 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
         ]);
 
         for(let {obj: swap} of queriedData) {
-            switch(await this.processPastSwap(swap)) {
-                case "SETTLE":
-                    settleInvoices.push(swap);
-                    break;
-                case "REFUND":
-                    refundSwaps.push(swap);
-                    break;
+            try {
+                switch(await this.processPastSwap(swap)) {
+                    case "SETTLE":
+                        settleInvoices.push(swap);
+                        break;
+                    case "REFUND":
+                        refundSwaps.push(swap);
+                        break;
+                }
+            } catch (e) {
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e);
             }
         }
 
@@ -322,10 +344,9 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
 
         const useToken = invoiceData.token;
 
-        let expiryTimeout: bigint;
         try {
             //Check if HTLC expiry is long enough
-            expiryTimeout = await this.checkHtlcExpiry(invoice);
+            await this.checkHtlcExpiry(invoice);
             if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcTimeoutCalculated = Date.now();
         } catch (e) {
             if(isDefinedRuntimeError(e) && invoiceData.metadata!=null) invoiceData.metadata.htlcReceiveError = e;
@@ -344,7 +365,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             invoiceData.amountToken,
             invoiceData.claimHash,
             0n,
-            BigInt(Math.floor(Date.now() / 1000)) + expiryTimeout,
+            BigInt(Math.floor(Date.now() / 1000)) + this.config.destinationHtlcTimeoutSeconds,
             false,
             true,
             invoiceData.amountGasToken + invoiceData.claimerBounty,
@@ -524,27 +545,24 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
      *
      * @param invoice
      * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
-     * @returns expiry timeout in seconds
      */
-    private async checkHtlcExpiry(invoice: LightningNetworkInvoice): Promise<bigint> {
+    private async checkHtlcExpiry(invoice: LightningNetworkInvoice): Promise<void> {
         const timeout: number = this.getInvoicePaymentsTimeout(invoice);
         const current_block_height = await this.lightning.getBlockheight();
 
         const blockDelta = BigInt(timeout - current_block_height);
 
-        const htlcExpiresTooSoon = blockDelta < this.config.minCltv;
+        const htlcExpiresTooSoon = blockDelta < this.minCltv;
         if(htlcExpiresTooSoon) {
             throw {
                 code: 20002,
                 msg: "Not enough time to reliably process the swap",
                 data: {
-                    requiredDelta: this.config.minCltv.toString(10),
+                    requiredDelta: this.minCltv.toString(10),
                     actualDelta: blockDelta.toString(10)
                 }
             };
         }
-
-        return (this.config.minCltv * this.config.bitcoinBlocktime / this.config.safetyFactor) - this.config.gracePeriod;
     }
 
     /**
@@ -639,7 +657,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
                             typeof(val)==="string" &&
                             val.length===64 &&
                             HEX_REGEX.test(val) ? val: null,
-                amount: FieldTypeEnum.BigInt,
+                amount: FieldTypeEnum.BigIntPositive,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -648,8 +666,8 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
                 gasToken: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         chainInterface.isValidToken(val) ? val : null,
-                gasAmount: FieldTypeEnum.BigInt,
-                claimerBounty: FieldTypeEnum.BigInt
+                gasAmount: FieldTypeEnum.BigIntNotNegative,
+                claimerBounty: FieldTypeEnum.BigIntNotNegative
             });
             if(parsedBody==null) throw {
                 code: 20100,
@@ -752,7 +770,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             //Create swap
             const hodlInvoiceObj: HodlInvoiceInit = {
                 description: description ?? (chainIdentifier+"-"+parsedBody.address),
-                cltvDelta:  Number(this.config.minCltv) + 5,
+                cltvDelta:  Number(this.minCltv) + 5,
                 expiresAt: Date.now()+(this.config.invoiceTimeoutSeconds*1000),
                 id: parsedBody.paymentHash,
                 mtokens: totalBtcInput * 1000n,
@@ -882,7 +900,7 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             };
         }
         return {
-            minCltv: Number(this.config.minCltv),
+            minCltv: Number(this.minCltv),
             invoiceTimeoutSeconds: this.config.invoiceTimeoutSeconds,
             gasTokens: mappedDict
         };

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

@@ -220,7 +220,8 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         ]);
 
         for(let {obj: swap} of queriedData) {
-            await this.processPastSwap(swap);
+            await this.processPastSwap(swap)
+                .catch(e => this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e));
         }
     }
 
@@ -338,7 +339,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @private
      * @throws DefinedRuntimeError will throw an error in case the actual fee is higher than quoted fee
      */
-    protected checkCalculatedTxFee(quotedSatsPerVbyte: bigint, actualSatsPerVbyte: bigint): void {
+    protected checkCalculatedTxFee(quotedSatsPerVbyte: number, actualSatsPerVbyte: number): void {
         const swapPaysEnoughNetworkFee = quotedSatsPerVbyte >= actualSatsPerVbyte;
         if(!swapPaysEnoughNetworkFee) throw {
             code: 90003,
@@ -367,7 +368,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             if(swap.metadata!=null) swap.metadata.times.payCLTVChecked = Date.now();
 
             const satsPerVbyte = await this.bitcoin.getFeeRate();
-            this.checkCalculatedTxFee(swap.satsPerVbyte, BigInt(satsPerVbyte));
+            this.checkCalculatedTxFee(swap.satsPerVbyte, satsPerVbyte);
             if(swap.metadata!=null) swap.metadata.times.payChainFee = Date.now();
 
             const signResult = await this.bitcoin.getSignedTransaction(
@@ -421,8 +422,13 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
             const isTxSent = tx!=null;
             if(!isTxSent) {
                 //Reset the state to COMMITED
-                this.swapLogger.info(swap, "processInitialized(state=BTC_SENDING): btc transaction not found, resetting to COMMITED state, txId: "+swap.txId+" address: "+swap.address);
-                await swap.setState(ToBtcSwapState.COMMITED);
+                const walletTx = await this.bitcoin.getWalletTransaction(swap.txId);
+                if(walletTx==null) {
+                    this.swapLogger.info(swap, "processInitialized(state=BTC_SENDING): btc transaction not found, resetting to COMMITED state, txId: "+swap.txId+" address: "+swap.address);
+                    await swap.setState(ToBtcSwapState.COMMITED);
+                } else {
+                    this.swapLogger.error(swap, "processInitialized(state=BTC_SENDING): btc transaction not found in mempool, but known to the wallet! txId: "+swap.txId+" address: "+swap.address);
+                }
             } else {
                 this.swapLogger.info(swap, "processInitialized(state=BTC_SENDING): btc transaction found, advancing to BTC_SENT state, txId: "+swap.txId+" address: "+swap.address);
                 await swap.setState(ToBtcSwapState.BTC_SENT);
@@ -534,7 +540,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @throws {DefinedRuntimeError} will throw an error if the nonce is invalid
      */
     private checkNonceValid(nonce: bigint): void {
-        if(nonce < 0 || nonce >= (2n ** 64n)) throw {
+        if(nonce < 1 || nonce >= (2n ** 64n)) throw {
             code: 20021,
             msg: "Invalid request body (nonce - cannot be parsed)"
         };
@@ -555,6 +561,10 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @throws {DefinedRuntimeError} will throw an error if the confirmationTarget is out of bounds
      */
     protected checkConfirmationTarget(confirmationTarget: number): void {
+        if(!Number.isFinite(confirmationTarget) || !Number.isSafeInteger(confirmationTarget)) throw {
+            code: 20028,
+            msg: "Invalid request body (confirmationTarget - not whole number)"
+        };
         if(confirmationTarget>this.config.maxConfTarget) throw {
             code: 20023,
             msg: "Invalid request body (confirmationTarget - too high)"
@@ -572,6 +582,10 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @throws {DefinedRuntimeError} will throw an error if the confirmations are out of bounds
      */
     protected checkRequiredConfirmations(confirmations: number): void {
+        if(!Number.isFinite(confirmations) || !Number.isSafeInteger(confirmations)) throw {
+            code: 20027,
+            msg: "Invalid request body (confirmations - not whole number)"
+        };
         if(confirmations>this.config.maxConfirmations) throw {
             code: 20025,
             msg: "Invalid request body (confirmations - too high)"
@@ -629,7 +643,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
      * @param amount
      * @throws {DefinedRuntimeError} will throw an error if there are not enough BTC funds
      */
-    private async checkAndGetNetworkFee(address: string, amount: bigint): Promise<{ networkFee: bigint, satsPerVbyte: bigint }> {
+    private async checkAndGetNetworkFee(address: string, amount: bigint): Promise<{ networkFee: bigint, satsPerVbyte: number }> {
         let chainFeeResp = await this.bitcoin.estimateFee(address, Number(amount), null, this.config.networkFeeMultiplier);
 
         const hasEnoughFunds = chainFeeResp!=null;
@@ -640,7 +654,7 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
 
         return {
             networkFee: BigInt(chainFeeResp.networkFee),
-            satsPerVbyte: BigInt(chainFeeResp.satsPerVbyte)
+            satsPerVbyte: chainFeeResp.satsPerVbyte
         };
     }
 
@@ -672,10 +686,10 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
              */
             const parsedBody: ToBtcRequestType = await req.paramReader.getParams({
                 address: FieldTypeEnum.String,
-                amount: FieldTypeEnum.BigInt,
-                confirmationTarget: FieldTypeEnum.Number,
-                confirmations: FieldTypeEnum.Number,
-                nonce: FieldTypeEnum.BigInt,
+                amount: FieldTypeEnum.BigIntPositive,
+                confirmationTarget: FieldTypeEnum.NumberPositive,
+                confirmations: FieldTypeEnum.NumberPositive,
+                nonce: FieldTypeEnum.BigIntNotNegative,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -799,7 +813,8 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                 data: {
                     amount: amountBD.toString(10),
                     address: signer.getAddress(),
-                    satsPervByte: networkFeeData.satsPerVbyte.toString(10),
+                    satsPervByte: Math.floor(networkFeeData.satsPerVbyte).toString(10),
+                    satsPervByteNumber: networkFeeData.satsPerVbyte,
                     networkFee: networkFeeInToken.toString(10),
                     swapFee: swapFeeInToken.toString(10),
                     totalFee: (swapFeeInToken + networkFeeInToken).toString(10),

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

@@ -20,7 +20,7 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
     sending: boolean;
 
     readonly address: string;
-    readonly satsPerVbyte: bigint;
+    readonly satsPerVbyte: number;
     readonly nonce: bigint;
     readonly requiredConfirmations: number;
     readonly preferedConfirmationTarget: number;
@@ -36,7 +36,7 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
         swapFeeInToken: bigint,
         networkFee: bigint,
         networkFeeInToken: bigint,
-        satsPerVbyte: bigint,
+        satsPerVbyte: number,
         nonce: bigint,
         requiredConfirmations: number,
         preferedConfirmationTarget: number
@@ -51,7 +51,7 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
         swapFeeInToken?: bigint,
         networkFee?: bigint,
         networkFeeInToken?: bigint,
-        satsPerVbyte?: bigint,
+        satsPerVbyte?: number,
         nonce?: bigint,
         requiredConfirmations?: number,
         preferedConfirmationTarget?: number
@@ -67,7 +67,7 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
         } else {
             super(chainIdOrObj);
             this.address = chainIdOrObj.address;
-            this.satsPerVbyte = BigInt(chainIdOrObj.satsPerVbyte);
+            this.satsPerVbyte = Number(chainIdOrObj.satsPerVbyte);
             this.nonce = BigInt(chainIdOrObj.nonce);
             this.requiredConfirmations = chainIdOrObj.requiredConfirmations;
             this.preferedConfirmationTarget = chainIdOrObj.preferedConfirmationTarget;

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

@@ -7,10 +7,17 @@ import {
     ChainSwapType,
     ClaimEvent,
     InitializeEvent,
-    RefundEvent, SwapCommitStateType,
+    RefundEvent,
+    SwapCommitStateType,
     SwapData
 } from "@atomiqlabs/base";
-import {expressHandlerWrapper, getAbortController, HEX_REGEX, isDefinedRuntimeError} from "../../../utils/Utils";
+import {
+    expressHandlerWrapper,
+    getAbortController,
+    getMinSafeBlockWindowSlow,
+    HEX_REGEX,
+    isDefinedRuntimeError
+} from "../../../utils/Utils";
 import {PluginManager} from "../../../plugins/PluginManager";
 import {IIntermediaryStorage} from "../../../storage/IIntermediaryStorage";
 import {randomBytes} from "crypto";
@@ -27,9 +34,8 @@ import {
     ProbeAndRouteResponse,
     routesMatch
 } from "../../../wallets/ILightningWallet";
-import { LightningAssertions } from "../../assertions/LightningAssertions";
+import {LightningAssertions} from "../../assertions/LightningAssertions";
 import {isQuoteThrow} from "../../../plugins/IPlugin";
-import {ToBtcSwapState} from "../tobtc_abstract/ToBtcSwapAbs";
 
 export type ToBtcLnConfig = ToBtcBaseConfig & {
     routingFeeMultiplier: bigint | number,
@@ -105,6 +111,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
     readonly lightning: ILightningWallet;
     readonly LightningAssertions: LightningAssertions;
 
+    readonly cltvDeltaLowerBound: bigint;
+
     constructor(
         storageDirectory: IIntermediaryStorage<ToBtcLnSwapAbs>,
         path: string,
@@ -123,9 +131,13 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         this.config.minLnBaseFee = this.config.minLnBaseFee || 5n;
         this.config.exactInExpiry = this.config.exactInExpiry || 10*1000;
         this.config.lnSendBitcoinBlockTimeSafetyFactorPPM = this.config.lnSendBitcoinBlockTimeSafetyFactorPPM ?? (this.config.safetyFactor * 1_000_000n);
-        if(this.config.lnSendBitcoinBlockTimeSafetyFactorPPM <= 1_100_000n) {
-            throw new Error("Lightning network send block safety factor set below 1.1, this is insecure!");
+        if(this.config.lnSendBitcoinBlockTimeSafetyFactorPPM <= 1_250_000n) {
+            throw new Error("Lightning network send block safety factor set below 1.25, this is insecure!");
         }
+
+        this.cltvDeltaLowerBound = getMinSafeBlockWindowSlow(
+            Number(this.config.lnSendBitcoinBlockTimeSafetyFactorPPM) / 1_000_000
+        );
     }
 
     /**
@@ -197,7 +209,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         ]);
 
         for(let {obj: swap} of queriedData) {
-            await this.processPastSwap(swap);
+            await this.processPastSwap(swap)
+                .catch(e => this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e));
         }
     }
 
@@ -300,6 +313,10 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             this.swapLogger.info(invoiceData, "subscribeToPayment(): result callback, outcome: "+result.status+" invoice: "+invoiceData.pr);
             this.processPaymentResult(invoiceData, result).catch(e => this.swapLogger.error(invoiceData, "subscribeToPayment(): process payment result", e));
             this.activeSubscriptions.delete(paymentHash);
+        }).catch(e => {
+            this.swapLogger.error(invoiceData, "subscribeToPayment(): error while waiting for invoice payment: ", e);
+            //Delete from active subscription, the watchdog will re-subscribe later
+            this.activeSubscriptions.delete(paymentHash);
         });
         this.swapLogger.info(invoiceData, "subscribeToPayment(): subscribe to payment outcome, invoice: "+invoiceData.pr);
 
@@ -329,6 +346,10 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         const maxFee = swap.quotedNetworkFee;
         const maxUsableCLTVdelta = (expiryTimestamp - currentTimestamp - this.config.gracePeriod)
             / (this.config.bitcoinBlocktime * this.config.lnSendBitcoinBlockTimeSafetyFactorPPM / 1_000_000n);
+        if(maxUsableCLTVdelta < this.cltvDeltaLowerBound) throw {
+            code: 90008,
+            msg: "Calculated CLTV delta is too low for current safety factor!"
+        }
 
         //Initiate payment
         this.swapLogger.info(swap, "sendLightningPayment(): paying lightning network invoice,"+
@@ -418,6 +439,9 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 } else throw e;
             }
 
+            const unlock = swap.lock(120);
+            if(unlock==null) return;
+
             await swap.setState(ToBtcLnSwapState.COMMITED);
             await this.saveSwapData(swap);
             try {
@@ -426,10 +450,22 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 this.swapLogger.error(swap, "processInitialized(): lightning payment error", e);
                 if(isDefinedRuntimeError(e)) {
                     if(swap.metadata!=null) swap.metadata.payError = e;
-                    await swap.setState(ToBtcLnSwapState.NON_PAYABLE);
-                    await this.saveSwapData(swap);
-                    return;
+                    const payment = await this.lightning.getPayment(swap.lnPaymentHash);
+                    if(!unlock()) return;
+                    if(payment==null || payment.status==="failed") {
+                        if(swap.state as ToBtcLnSwapState === ToBtcLnSwapState.COMMITED)
+                            await swap.setState(ToBtcLnSwapState.NON_PAYABLE);
+                        await this.saveSwapData(swap);
+                        return;
+                    } else if(payment.status==="confirmed") {
+                        await this.processPaymentResult(swap, payment);
+                        return;
+                    } else {
+                        //Fall-through to subscribe
+                    }
                 } else throw e;
+            } finally {
+                unlock();
             }
             this.subscribeToPayment(swap);
             return;
@@ -571,6 +607,10 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
     }> {
         const maxUsableCLTV: bigint = (expiryTimestamp - currentTimestamp - this.config.gracePeriod)
             / (this.config.bitcoinBlocktime * this.config.lnSendBitcoinBlockTimeSafetyFactorPPM / 1_000_000n);
+        if(maxUsableCLTV < this.cltvDeltaLowerBound) throw {
+            code: 20002,
+            msg: "Cannot route the payment (calculated CLTV delta too short - increase timeout)!"
+        };
 
         const blockHeight = await this.lightning.getBlockheight();
         abortSignal.throwIfAborted();
@@ -843,8 +883,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
              */
             const parsedBody: ToBtcLnRequestType = await req.paramReader.getParams({
                 pr: FieldTypeEnum.String,
-                maxFee: FieldTypeEnum.BigInt,
-                expiryTimestamp: FieldTypeEnum.BigInt,
+                maxFee: FieldTypeEnum.BigIntPositive,
+                expiryTimestamp: FieldTypeEnum.BigIntPositive,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -852,7 +892,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                         typeof(val)==="string" &&
                         chainInterface.isValidAddress(val, true) ? val : null,
                 exactIn: FieldTypeEnum.BooleanOptional,
-                amount: FieldTypeEnum.BigIntOptional
+                amount: FieldTypeEnum.BigIntPositiveOptional
             });
             if (parsedBody==null) {
                 throw {
@@ -1078,6 +1118,16 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
                 };
 
                 if(data.state===ToBtcLnSwapState.NON_PAYABLE) {
+                    if(data.payInitiated) {
+                        //Check that the ln payment is indeed non-existent or failed
+                        const lnPayment = await this.lightning.getPayment(data.lnPaymentHash);
+                        if(lnPayment!=null && lnPayment.status!=="failed") throw {
+                            _httpStatus: 200,
+                            code: 20008,
+                            msg: "Payment in-flight"
+                        };
+                    }
+
                     const refundSigData = await swapContract.getRefundSignature(signer, data.data, this.config.refundAuthorizationTimeout);
 
                     //Double check the state after promise result