@atomiqlabs/lp-lib 17.5.3 → 17.6.1

package/dist/utils/paramcoders/SchemaVerifier.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifySchema = exports.FieldTypeEnum = exports.parseBigInt = void 0;
+exports.verifySchema = exports.verifySchemaField = exports.FieldTypeEnum = exports.parseBigInt = void 0;
 function parseBigInt(str) {
     if (str == null)
         return null;
@@ -21,63 +21,109 @@ var FieldTypeEnum;
     FieldTypeEnum[FieldTypeEnum["Number"] = 2] = "Number";
     FieldTypeEnum[FieldTypeEnum["BigInt"] = 3] = "BigInt";
     FieldTypeEnum[FieldTypeEnum["Any"] = 4] = "Any";
+    FieldTypeEnum[FieldTypeEnum["BigIntPositive"] = 5] = "BigIntPositive";
+    FieldTypeEnum[FieldTypeEnum["BigIntNotNegative"] = 6] = "BigIntNotNegative";
+    FieldTypeEnum[FieldTypeEnum["NumberPositive"] = 7] = "NumberPositive";
+    FieldTypeEnum[FieldTypeEnum["NumberNotNegative"] = 8] = "NumberNotNegative";
     FieldTypeEnum[FieldTypeEnum["StringOptional"] = 100] = "StringOptional";
     FieldTypeEnum[FieldTypeEnum["BooleanOptional"] = 101] = "BooleanOptional";
     FieldTypeEnum[FieldTypeEnum["NumberOptional"] = 102] = "NumberOptional";
     FieldTypeEnum[FieldTypeEnum["BigIntOptional"] = 103] = "BigIntOptional";
     FieldTypeEnum[FieldTypeEnum["AnyOptional"] = 104] = "AnyOptional";
+    FieldTypeEnum[FieldTypeEnum["BigIntPositiveOptional"] = 105] = "BigIntPositiveOptional";
+    FieldTypeEnum[FieldTypeEnum["BigIntNotNegativeOptional"] = 106] = "BigIntNotNegativeOptional";
+    FieldTypeEnum[FieldTypeEnum["NumberPositiveOptional"] = 107] = "NumberPositiveOptional";
+    FieldTypeEnum[FieldTypeEnum["NumberNotNegativeOptional"] = 108] = "NumberNotNegativeOptional";
 })(FieldTypeEnum = exports.FieldTypeEnum || (exports.FieldTypeEnum = {}));
+function verifySchemaField(val, type, fieldName, resultSchema) {
+    if (typeof (type) === "function") {
+        const result = type(val);
+        if (result == null)
+            return false;
+        resultSchema[fieldName] = result;
+        return true;
+    }
+    if (val == null && type >= 100) {
+        resultSchema[fieldName] = null;
+        return true;
+    }
+    if (type === FieldTypeEnum.Any || type === FieldTypeEnum.AnyOptional) {
+        resultSchema[fieldName] = val;
+    }
+    else if (type === FieldTypeEnum.Boolean || type === FieldTypeEnum.BooleanOptional) {
+        if (typeof (val) !== "boolean")
+            return false;
+        resultSchema[fieldName] = val;
+    }
+    else if (type === FieldTypeEnum.Number || type === FieldTypeEnum.NumberOptional) {
+        if (typeof (val) !== "number")
+            return false;
+        if (isNaN(val))
+            return false;
+        resultSchema[fieldName] = val;
+    }
+    else if (type === FieldTypeEnum.NumberPositive || type === FieldTypeEnum.NumberPositiveOptional) {
+        if (typeof (val) !== "number")
+            return false;
+        if (isNaN(val))
+            return false;
+        if (val <= 0)
+            return false;
+        resultSchema[fieldName] = val;
+    }
+    else if (type === FieldTypeEnum.NumberNotNegative || type === FieldTypeEnum.NumberNotNegativeOptional) {
+        if (typeof (val) !== "number")
+            return false;
+        if (isNaN(val))
+            return false;
+        if (val < 0)
+            return false;
+        resultSchema[fieldName] = val;
+    }
+    else if (type === FieldTypeEnum.BigInt || type === FieldTypeEnum.BigIntOptional) {
+        const result = parseBigInt(val);
+        if (result == null)
+            return false;
+        resultSchema[fieldName] = result;
+    }
+    else if (type === FieldTypeEnum.BigIntPositive || type === FieldTypeEnum.BigIntPositiveOptional) {
+        const result = parseBigInt(val);
+        if (result == null)
+            return false;
+        if (result <= 0n)
+            return false;
+        resultSchema[fieldName] = result;
+    }
+    else if (type === FieldTypeEnum.BigIntNotNegative || type === FieldTypeEnum.BigIntNotNegativeOptional) {
+        const result = parseBigInt(val);
+        if (result == null)
+            return false;
+        if (result < 0n)
+            return false;
+        resultSchema[fieldName] = result;
+    }
+    else if (type === FieldTypeEnum.String || type === FieldTypeEnum.StringOptional) {
+        if (typeof (val) !== "string")
+            return false;
+        resultSchema[fieldName] = val;
+    }
+    else {
+        //Probably another request schema
+        const result = verifySchema(val, type);
+        if (result == null)
+            return false;
+        resultSchema[fieldName] = result;
+    }
+    return true;
+}
+exports.verifySchemaField = verifySchemaField;
 function verifySchema(req, schema) {
     if (req == null)
         return null;
     const resultSchema = {};
     for (let fieldName in schema) {
-        const val = req[fieldName];
-        const type = schema[fieldName];
-        if (typeof (type) === "function") {
-            const result = type(val);
-            if (result == null)
-                return null;
-            resultSchema[fieldName] = result;
-            continue;
-        }
-        if (val == null && type >= 100) {
-            resultSchema[fieldName] = null;
-            continue;
-        }
-        if (type === FieldTypeEnum.Any || type === FieldTypeEnum.AnyOptional) {
-            resultSchema[fieldName] = val;
-        }
-        else if (type === FieldTypeEnum.Boolean || type === FieldTypeEnum.BooleanOptional) {
-            if (typeof (val) !== "boolean")
-                return null;
-            resultSchema[fieldName] = val;
-        }
-        else if (type === FieldTypeEnum.Number || type === FieldTypeEnum.NumberOptional) {
-            if (typeof (val) !== "number")
-                return null;
-            if (isNaN(val))
-                return null;
-            resultSchema[fieldName] = val;
-        }
-        else if (type === FieldTypeEnum.BigInt || type === FieldTypeEnum.BigIntOptional) {
-            const result = parseBigInt(val);
-            if (result == null)
-                return null;
-            resultSchema[fieldName] = result;
-        }
-        else if (type === FieldTypeEnum.String || type === FieldTypeEnum.StringOptional) {
-            if (typeof (val) !== "string")
-                return null;
-            resultSchema[fieldName] = val;
-        }
-        else {
-            //Probably another request schema
-            const result = verifySchema(val, type);
-            if (result == null)
-                return null;
-            resultSchema[fieldName] = result;
-        }
+        if (!verifySchemaField(req[fieldName], schema[fieldName], fieldName, resultSchema))
+            return null;
     }
     return resultSchema;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "17.5.3",
+  "version": "17.6.1",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/swaps/assertions/FromBtcAmountAssertions.ts

@@ -186,8 +186,8 @@ export class FromBtcAmountAssertions extends AmountAssertions {
             const tooLow = amountBD < (min * 95n / 100n);
             const tooHigh = amountBD > (max * 105n / 100n);
             if(tooLow || tooHigh) {
-                const adjustedMin = min * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
-                const adjustedMax = max * (1000000n - fees.feePPM) / (1000000n - fees.baseFee);
+                const adjustedMin = min * (1000000n - fees.feePPM) / 1_000_000n - fees.baseFee;
+                const adjustedMax = max * (1000000n - fees.feePPM) / 1_000_000n - fees.baseFee;
                 const minIn = await this.swapPricing.getFromBtcSwapAmount(
                     adjustedMin, requestedAmount.token, chainIdentifier, null, requestedAmount.pricePrefetch
                 );

package/src/swaps/escrow/frombtc_abstract/FromBtcAbs.ts

@@ -8,6 +8,7 @@ import {
     ClaimEvent,
     InitializeEvent,
     RefundEvent,
+    SwapCommitStateType,
     SwapData
 } from "@atomiqlabs/base";
 import {randomBytes} from "crypto";
@@ -21,7 +22,6 @@ import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamE
 import {FromBtcBaseConfig, FromBtcBaseSwapHandler} from "../FromBtcBaseSwapHandler";
 import {IBitcoinWallet} from "../../../wallets/IBitcoinWallet";
 import {isQuoteThrow} from "../../../plugins/IPlugin";
-import {FromBtcLnSwapState} from "../frombtcln_abstract/FromBtcLnSwapAbs";
 
 export type FromBtcConfig = FromBtcBaseConfig & {
     confirmations: number,
@@ -74,7 +74,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
     private getHash(chainIdentifier: string, address: string, amount: bigint): Buffer {
         const parsedOutputScript = this.bitcoin.toOutputScript(address);
         const {swapContract} = this.getChain(chainIdentifier);
-        return swapContract.getHashForOnchain(parsedOutputScript, amount, this.config.confirmations, 0n);
+        return swapContract.getHashForOnchain(parsedOutputScript, amount, this.config.confirmations);
     }
 
     /**
@@ -91,13 +91,18 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
         if(swap.state===FromBtcSwapState.CREATED) {
             if(!await swapContract.isInitAuthorizationExpired(swap.data, swap)) return false;
 
-            const isCommited = await swapContract.isCommited(swap.data);
-            if(isCommited) {
+            const commitState = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
+            if(commitState.type===SwapCommitStateType.COMMITED || commitState.type===SwapCommitStateType.REFUNDABLE) {
                 this.swapLogger.info(swap, "processPastSwap(state=CREATED): swap was commited, but processed from watchdog, address: "+swap.address);
                 await swap.setState(FromBtcSwapState.COMMITED);
                 await this.saveSwapData(swap);
                 return false;
             }
+            if(commitState.type===SwapCommitStateType.PAID) {
+                this.swapLogger.info(swap, "processPastSwap(state=CREATED): swap was claimed, but processed from watchdog, address: "+swap.address);
+                await this.removeSwapData(swap, FromBtcSwapState.CLAIMED);
+                return false;
+            }
 
             this.swapLogger.info(swap, "processPastSwap(state=CREATED): removing past swap due to authorization expiry, address: "+swap.address);
             await this.removeSwapData(swap, FromBtcSwapState.CANCELED);
@@ -109,11 +114,16 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
         if(swap.state===FromBtcSwapState.COMMITED) {
             if(!await swapContract.isExpired(signer.getAddress(), swap.data)) return false;
 
-            const isCommited = await swapContract.isCommited(swap.data);
-            if(isCommited) {
+            const commitState = await swapContract.getCommitStatus(signer.getAddress(), swap.data);
+            if(commitState.type===SwapCommitStateType.COMMITED || commitState.type===SwapCommitStateType.REFUNDABLE) {
                 this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap expired, will refund, address: "+swap.address);
                 return true;
             }
+            if(commitState.type===SwapCommitStateType.PAID) {
+                this.swapLogger.info(swap, "processPastSwap(state=COMMITED): swap was claimed, but processed from watchdog, address: "+swap.address);
+                await this.removeSwapData(swap, FromBtcSwapState.CLAIMED);
+                return false;
+            }
 
             this.swapLogger.warn(swap, "processPastSwap(state=COMMITED): commited swap expired and not committed anymore (already refunded?), address: "+swap.address);
             await this.removeSwapData(swap, FromBtcSwapState.CANCELED);
@@ -139,7 +149,11 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
         const refundSwaps: FromBtcSwapAbs[] = [];
 
         for(let {obj: swap} of queriedData) {
-            if(await this.processPastSwap(swap)) refundSwaps.push(swap);
+            try {
+                if (await this.processPastSwap(swap)) refundSwaps.push(swap);
+            } catch (e) {
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e);
+            }
         }
 
         await this.refundSwaps(refundSwaps);
@@ -156,11 +170,16 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             const {swapContract, signer} = this.getChain(refundSwap.chainIdentifier);
             const unlock = refundSwap.lock(swapContract.refundTimeout);
             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, "refundSwaps(): swap refunded, address: "+refundSwap.address);
-            //The swap should be removed by the event handler
-            await refundSwap.setState(FromBtcSwapState.REFUNDED);
+            try {
+                await swapContract.refund(signer, refundSwap.data, true, false, {waitForConfirmation: true});
+                this.swapLogger.info(refundSwap, "refundSwaps(): swap refunded, address: "+refundSwap.address);
+                //The swap should be removed by the event handler
+                await refundSwap.setState(FromBtcSwapState.REFUNDED);
+            } catch (e) {
+                this.swapLogger.error(refundSwap, "refundSwaps(): error refunding swap: ", e);
+            }
             unlock();
         }
     }
@@ -201,11 +220,11 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
     private async getClaimerBounty(req: Request & {paramReader: IParamReader}, expiry: bigint, signal: AbortSignal): Promise<bigint> {
         const parsedClaimerBounty = await req.paramReader.getParams({
             claimerBounty: {
-                feePerBlock: FieldTypeEnum.BigInt,
-                safetyFactor: FieldTypeEnum.BigInt,
-                startTimestamp: FieldTypeEnum.BigInt,
-                addBlock: FieldTypeEnum.BigInt,
-                addFee: FieldTypeEnum.BigInt,
+                feePerBlock: FieldTypeEnum.BigIntNotNegative,
+                safetyFactor: FieldTypeEnum.BigIntNotNegative,
+                startTimestamp: FieldTypeEnum.BigIntNotNegative,
+                addBlock: FieldTypeEnum.BigIntNotNegative,
+                addFee: FieldTypeEnum.BigIntNotNegative,
             },
         }).catch(e => null);
 
@@ -219,6 +238,12 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
         }
 
         const tsDelta: bigint = expiry - parsedClaimerBounty.claimerBounty.startTimestamp;
+        if(tsDelta < 0n) {
+            throw {
+                code: 20043,
+                msg: "Invalid claimerBounty (ts delta < 0)"
+            };
+        }
         const blocksDelta: bigint = tsDelta / this.config.bitcoinBlocktime * parsedClaimerBounty.claimerBounty.safetyFactor;
         const totalBlock: bigint = blocksDelta + parsedClaimerBounty.claimerBounty.addBlock;
         return parsedClaimerBounty.claimerBounty.addFee + (totalBlock * parsedClaimerBounty.claimerBounty.feePerBlock);
@@ -233,7 +258,7 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             address,
             useToken,
             dummyAmount,
-            swapContract.getHashForOnchain(randomBytes(32), dummyAmount, 3, null).toString("hex"),
+            swapContract.getHashForOnchain(randomBytes(32), dummyAmount, 3).toString("hex"),
             BigIntBufferUtils.fromBuffer(randomBytes(8)),
             BigInt(Math.floor(Date.now()/1000)) + this.config.swapTsCsvDelta,
             false,
@@ -283,11 +308,11 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
                 address: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         chainInterface.isValidAddress(val, true) ? val : null,
-                amount: FieldTypeEnum.BigInt,
+                amount: FieldTypeEnum.BigIntPositive,
                 token: (val: string) => val!=null &&
                         typeof(val)==="string" &&
                         this.isTokenSupported(chainIdentifier, val) ? val : null,
-                sequence: FieldTypeEnum.BigInt,
+                sequence: FieldTypeEnum.BigIntNotNegative,
                 exactOut: FieldTypeEnum.BooleanOptional
             });
             if(parsedBody==null) throw {

package/src/swaps/escrow/frombtcln_abstract/FromBtcLnAbs.ts

@@ -12,7 +12,13 @@ import {
     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";
@@ -32,7 +38,7 @@ import {FromBtcLnAutoSwapState} from "../frombtcln_autoinit/FromBtcLnAutoSwap";
 
 export type FromBtcLnConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
-    minCltv: bigint,
+    destinationHtlcTimeoutSeconds: bigint,
     gracePeriod: bigint
 }
 
@@ -57,6 +63,8 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
     readonly lightning: ILightningWallet;
     readonly LightningAssertions: LightningAssertions;
 
+    readonly minCltv: bigint;
+
     constructor(
         storageDirectory: IIntermediaryStorage<FromBtcLnSwapAbs>,
         path: string,
@@ -70,6 +78,13 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
         this.lightning = lightning;
         this.LightningAssertions = new LightningAssertions(this.logger, lightning);
+
+        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: FromBtcLnSwapAbs): Promise<"REFUND" | "SETTLE" | "CANCEL" | null> {
@@ -169,10 +184,13 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             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(FromBtcLnSwapState.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(FromBtcLnSwapState.REFUNDED);
+            } catch (e) {
+                this.swapLogger.error(refundSwap, "refundSwaps(): error refunding swap: ", e);
+            }
             unlock();
         }
     }
@@ -228,16 +246,20 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
         ]);
 
         for(let {obj: swap} of queriedData) {
-            switch(await this.processPastSwap(swap)) {
-                case "CANCEL":
-                    cancelInvoices.push(swap);
-                    break;
-                case "SETTLE":
-                    settleInvoices.push(swap);
-                    break;
-                case "REFUND":
-                    refundSwaps.push(swap);
-                    break;
+            try {
+                switch (await this.processPastSwap(swap)) {
+                    case "CANCEL":
+                        cancelInvoices.push(swap);
+                        break;
+                    case "SETTLE":
+                        settleInvoices.push(swap);
+                        break;
+                    case "REFUND":
+                        refundSwaps.push(swap);
+                        break;
+                }
+            } catch (e) {
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e)
             }
         }
 
@@ -327,14 +349,13 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
         const blockheightPrefetch = this.getBlockheightPrefetch(abortController);
         const signDataPrefetchPromise: Promise<any> = this.getSignDataPrefetch(invoiceData.chainIdentifier, abortController);
 
-        let expiryTimeout: bigint;
         try {
             //Check if we have enough liquidity to proceed
             await this.checkBalance(escrowAmount, balancePrefetch, abortController.signal);
             if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcBalanceChecked = Date.now();
 
             //Check if HTLC expiry is long enough
-            expiryTimeout = await this.checkHtlcExpiry(invoice, blockheightPrefetch, abortController.signal);
+            await this.checkHtlcExpiry(invoice, blockheightPrefetch, abortController.signal);
             if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcTimeoutCalculated = Date.now();
         } catch (e) {
             if(!abortController.signal.aborted) {
@@ -355,7 +376,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             escrowAmount,
             invoiceData.claimHash,
             0n,
-            BigInt(Math.floor(Date.now() / 1000)) + expiryTimeout,
+            BigInt(Math.floor(Date.now() / 1000)) + this.config.destinationHtlcTimeoutSeconds,
             false,
             true,
             invoiceData.securityDeposit,
@@ -493,28 +514,25 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
      * @param blockheightPrefetch
      * @param signal
      * @throws {DefinedRuntimeError} Will throw if HTLC expires too soon and therefore cannot be processed
-     * @returns expiry timeout in seconds
      */
-    private async checkHtlcExpiry(invoice: LightningNetworkInvoice, blockheightPrefetch: Promise<number>, signal: AbortSignal): Promise<bigint> {
+    private async checkHtlcExpiry(invoice: LightningNetworkInvoice, blockheightPrefetch: Promise<number>, signal: AbortSignal): Promise<void> {
         const timeout: number = this.getInvoicePaymentsTimeout(invoice);
         const current_block_height = await blockheightPrefetch;
         signal.throwIfAborted();
 
         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;
     }
 
     /**
@@ -628,7 +646,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
                             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,
@@ -711,7 +729,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             //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: amountBD * 1000n,
@@ -725,9 +743,8 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
             metadata.invoiceResponse = {...hodlInvoice};
 
             //Pre-compute the security deposit
-            const expiryTimeout = (this.config.minCltv * this.config.bitcoinBlocktime / this.config.safetyFactor) - this.config.gracePeriod;
             const totalSecurityDeposit = await this.getSecurityDeposit(
-                chainIdentifier, amountBD, swapFee, expiryTimeout,
+                chainIdentifier, amountBD, swapFee, this.config.destinationHtlcTimeoutSeconds,
                 baseSDPromise, depositToken, depositTokenPricePrefetchPromise, fees,
                 abortController.signal, metadata
             );
@@ -892,7 +909,7 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
 
     getInfoData(): any {
         return {
-            minCltv: Number(this.config.minCltv)
+            minCltv: Number(this.minCltv)
         };
     }