@atomiqlabs/lp-lib 17.6.0 → 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.6.0",
+  "version": "17.6.1",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

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);
@@ -210,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);
 
@@ -228,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);
@@ -242,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,
@@ -292,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

@@ -646,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,

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

@@ -657,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,
@@ -666,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,

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

@@ -540,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)"
         };
@@ -561,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)"
@@ -578,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)"
@@ -678,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,
@@ -805,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/tobtcln_abstract/ToBtcLnAbs.ts

@@ -11,7 +11,13 @@ import {
     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";
@@ -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
+        );
     }
 
     /**
@@ -334,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,"+
@@ -591,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();
@@ -863,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,
@@ -872,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 {

package/src/swaps/spv_vault_swap/SpvVaultSwapHandler.ts

@@ -35,7 +35,7 @@ import {FromBtcAmountAssertions} from "../assertions/FromBtcAmountAssertions";
 import {randomBytes} from "crypto";
 import {Transaction} from "@scure/btc-signer";
 import {SpvVaults, VAULT_DUST_AMOUNT} from "./SpvVaults";
-import {isLegacyInput} from "../../utils/BitcoinUtils";
+import {checkTransactionReplaced, isLegacyInput} from "../../utils/BitcoinUtils";
 import {AmountAssertions} from "../assertions/AmountAssertions";
 import {isQuoteThrow} from "../../plugins/IPlugin";
 import {StickyAddress} from "./StickyAddress";
@@ -263,12 +263,20 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
             const vault = await this.Vaults.getVault(swap.chainIdentifier, swap.vaultOwner, swap.vaultId);
             const foundWithdrawal = vault.pendingWithdrawals.find(val => val.btcTx.txid === swap.btcTxId);
             let tx = foundWithdrawal?.btcTx;
-            if(tx==null) tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
+            if(tx==null) {
+                tx = await this.bitcoinRpc.getTransaction(swap.btcTxId);
+            } else {
+                tx = await checkTransactionReplaced(tx.txid, tx.raw, this.bitcoinRpc);
+            }
 
             if(tx==null) {
                 await this.removeSwapData(swap, SpvVaultSwapState.FAILED);
+                if(foundWithdrawal!=null) {
+                    vault.removeWithdrawal(foundWithdrawal);
+                    await this.Vaults.saveVault(vault);
+                }
                 return;
-            } else if(tx.confirmations===0) {
+            } else if(tx.confirmations==null || tx.confirmations===0) {
                 await swap.setState(SpvVaultSwapState.SENT)
                 await this.saveSwapData(swap);
                 return;
@@ -420,11 +428,11 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
              * frontingFeeRate: string      Fronting fee (in output token) to assign to the swap
              */
             const actualParsedBody = await req.paramReader.getParams({
-                amount: FieldTypeEnum.BigInt,
-                gasAmount: FieldTypeEnum.BigInt,
+                amount: FieldTypeEnum.BigIntPositive,
+                gasAmount: FieldTypeEnum.BigIntNotNegative,
                 exactOut: FieldTypeEnum.BooleanOptional,
-                callerFeeRate: FieldTypeEnum.BigInt,
-                frontingFeeRate: FieldTypeEnum.BigInt,
+                callerFeeRate: FieldTypeEnum.BigIntNotNegative,
+                frontingFeeRate: FieldTypeEnum.BigIntNotNegative,
             });
             abortController.signal.throwIfAborted();
             if(actualParsedBody==null) throw {
@@ -434,7 +442,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
 
             const inputAmountAdjustments = req.paramReader.getExistingParamsOrNull({
                 amountUtxos: FieldTypeEnum.AnyOptional,
-                amountFeeRate: FieldTypeEnum.NumberOptional
+                amountFeeRate: FieldTypeEnum.NumberPositiveOptional
             });
             if(inputAmountAdjustments==null) throw {
                 code: 20100,
@@ -811,27 +819,29 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 };
             }
 
+            //Double-check the state to prevent race condition
+            if(swap.state!==SpvVaultSwapState.CREATED) throw {
+                code: 20505,
+                msg: "Invalid quote ID, not found or expired!"
+            }; //Continues here is only synchronous code until the state change to SIGNED
+
             const unlock = swap.lock(120);
             if(!unlock) throw {
                 code: 20517,
                 msg: "Bitcoin transaction submission already in progress, please retry later!"
             };
 
+            const txId = signedTx.id;
+
             let swapSendingSet = false;
             let dataSendingSet = false;
             try {
                 const btcRawTx = Buffer.from(signedTx.toBytes(true, true)).toString("hex");
 
-                //Double-check the state to prevent race condition
-                if(swap.state!==SpvVaultSwapState.CREATED) throw {
-                    code: 20505,
-                    msg: "Invalid quote ID, not found or expired!"
-                };
-
                 //Double check in-flight swap count
                 this.checkTooManyInflightSwaps();
 
-                swap.btcTxId = signedTx.id;
+                swap.btcTxId = txId;
                 swap.state = SpvVaultSwapState.SIGNED;
                 swap.sending = true;
                 swapSendingSet = true;
@@ -843,7 +853,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 dataSendingSet = true;
                 await this.Vaults.saveVault(vault);
 
-                this.swapLogger.info(swap, "REST: /postQuote: BTC transaction signed, txId: "+swap.btcTxId);
+                this.swapLogger.info(swap, "REST: /postQuote: BTC transaction signed, txId: "+txId);
 
                 try {
                     await this.bitcoin.sendRawTransaction(btcRawTx);
@@ -859,22 +869,40 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 }
             } catch (e) {
                 if(swapSendingSet) swap.sending = false;
-                if(dataSendingSet) {
-                    (data as any).sending = false;
-                    vault.removeWithdrawal(data);
-                    await this.Vaults.saveVault(vault);
-                }
-
-                //Check if the error is only because the state has already changed
-                if(!isDefinedRuntimeError(e) || e.code!==20505) {
-                    //We only make the swap failed if the error happened in CREATED or SIGNED states
-                    if(swap.state===SpvVaultSwapState.CREATED || swap.state===SpvVaultSwapState.SIGNED) {
-                        if(isDefinedRuntimeError(e) && swap.metadata!=null) swap.metadata.postQuoteError = e;
-                        await this.removeSwapData(swap, SpvVaultSwapState.FAILED);
+                if(dataSendingSet) (data as any).sending = false;
+
+                //We only make the swap failed if the error happened in CREATED or SIGNED states
+                if(swap.state===SpvVaultSwapState.CREATED || swap.state===SpvVaultSwapState.SIGNED) {
+                    try {
+                        const fetchedBtcTx = await this.bitcoin.getWalletTransaction(txId);
+                        if(fetchedBtcTx==null) {
+                            if(dataSendingSet) {
+                                vault.removeWithdrawal(data);
+                                await this.Vaults.saveVault(vault);
+                            }
+                            if(isDefinedRuntimeError(e) && swap.metadata!=null) swap.metadata.postQuoteError = e;
+                            await this.removeSwapData(swap, SpvVaultSwapState.FAILED);
+                            throw e; //This will get caught locally and throw the post quote error
+                        } else {
+                            //Transaction not-null set state to sent and fall through without throwing
+                            await swap.setState(SpvVaultSwapState.SENT);
+                        }
+                    } catch (getTxErr) {
+                        if(getTxErr===e) throw e;
+                        //Cannot determine whether the bitcoin transaction was broadcasted or not
+                        // do nothing here and let the watchdog handle this!
+                        throw {
+                            _httpStatus: 200,
+                            code: 20001,
+                            msg: "Transaction status unknown",
+                            data: {
+                                txId: swap.btcTxId
+                            }
+                        };
                     }
+                } else {
+                    throw e;
                 }
-
-                throw e;
             } finally {
                 unlock();
             }

package/src/swaps/trusted/frombtcln_trusted/FromBtcLnTrusted.ts

@@ -260,13 +260,9 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
             }).catch(e => this.swapLogger.error(invoiceData, "htlcReceived(): Error sending transfer txns", e));
 
             if(result==null) {
-                //Cancel invoice
-                await invoiceData.setState(FromBtcLnTrustedSwapState.REFUNDED);
-                await this.storageManager.saveData(invoice.id, null, invoiceData);
-                await this.lightning.cancelHodlInvoice(invoice.id);
-                this.unsubscribeInvoice(invoice.id);
-                await this.removeSwapData(invoiceData);
-                this.swapLogger.info(invoiceData, "htlcReceived(): transaction sending failed, refunding lightning: ", invoiceData.pr);
+                this.swapLogger.info(invoiceData, "htlcReceived(): transaction sending failed: ", invoiceData.pr);
+                //Let the swap watchdog handle this case
+                unlock();
                 throw {
                     code: 20002,
                     msg: "Transaction sending failed"
@@ -285,14 +281,8 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
             if(invoiceData.isLocked()) return;
 
             const txStatus = await chainInterface.getTxStatus(invoiceData.scRawTx);
-            if(txStatus==="not_found") {
-                //Retry
-                invoiceData.txIds = {init: null};
-                invoiceData.scRawTx = null;
-                await invoiceData.setState(FromBtcLnTrustedSwapState.RECEIVED);
-                await this.storageManager.saveData(invoice.id, null, invoiceData);
-            }
-            if(txStatus==="reverted") {
+
+            if(txStatus==="reverted" || txStatus==="not_found") {
                 //Cancel invoice
                 await invoiceData.setState(FromBtcLnTrustedSwapState.REFUNDED);
                 await this.storageManager.saveData(invoice.id, null, invoiceData);