@atomiqlabs/lp-lib 17.5.3 → 17.6.1

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;
@@ -311,7 +319,8 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
         ]);
 
         for(let {obj: swap} of swaps) {
-            await this.processPastSwap(swap);
+            await this.processPastSwap(swap)
+                .catch(e => this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e));
         }
     }
 
@@ -419,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 {
@@ -433,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,
@@ -794,13 +803,12 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 swap
             );
             if(isQuoteThrow(pluginCheckResult)) {
-                const error = {
+                if(swap.state===SpvVaultSwapState.CREATED)
+                    await this.removeSwapData(swap, SpvVaultSwapState.FAILED);
+                throw {
                     code: 29999,
                     msg: pluginCheckResult.message
-                }
-                if(swap.metadata!=null) swap.metadata.postQuoteError = error;
-                await this.removeSwapData(swap, SpvVaultSwapState.FAILED);
-                throw error;
+                };
             }
 
             await this.Vaults.checkVaultReplacedTransactions(vault, true);
@@ -811,31 +819,41 @@ 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;
                 await this.saveSwapData(swap);
 
                 data.btcTx.raw = btcRawTx;
                 (data as any).sending = true;
                 vault.addWithdrawal(data);
+                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);
@@ -850,15 +868,43 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                     };
                 }
             } catch (e) {
-                (data as any).sending = false;
-                swap.sending = false;
-                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;
+                if(swapSendingSet) swap.sending = false;
+                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;
+                }
+            } finally {
+                unlock();
             }
 
             await responseStream.writeParamsAndEnd({

package/src/swaps/trusted/frombtc_trusted/FromBtcTrusted.ts

@@ -13,6 +13,29 @@ import {IBitcoinWallet} from "../../../wallets/IBitcoinWallet";
 import {FromBtcAmountAssertions} from "../../assertions/FromBtcAmountAssertions";
 import {isQuoteThrow} from "../../../plugins/IPlugin";
 
+/*
+TODO: IN CASE THIS EVER GETS USED, FIX THE FOLLOWING:
+
+HIGH 5 — FromBtcTrusted (0-conf): no RBF check, fee gate is min not max, and the burn defense only fires when it shouldn't
+
+Handler is opt-in (ONCHAIN_TRUSTED, not in shipped configs), but if enabled:
+
+• Acceptance (FromBtcTrusted.js:186-194) checks only: direct parents confirmed + fee threshold. Nothing inspects tx.ins[].sequence for BIP-125 (grep: only storage-sequence hits). A double-spendable opt-in-RBF tx is
+ accepted and tokens are sent within seconds.
+• The fee gate is fee >= recommendedFee || fee >= currentRate (line 187) — the weaker of the two wins; the documented intent is max(...). The runner even overrides the library's 1.25 multiplier to 1
+ (IntermediaryRunner.ts FromBtcTrusted section). A stale low fee maximizes the replacement window and minimizes the attacker's BIP-125 cost.
+• The burn defense (checkDoubleSpends → burn() → sendRawPackage([tx1, burnChild])) is rejected by any node whose mempool already holds the replacement — so it structurally loses against a broadcast double-spend, and
+ with mempoolfullrbf (default since Core 28) even non-signaling txs are replaceable.
+• Worse, checkDoubleSpends (lines 636-644) treats getTransaction == null as "double-spent" — but null also means mempool eviction (fee spike, node restart). With no conflict anywhere, the burn package is valid and
+ burns the entire deposit to miners — after tokens were already sent, that's a full LP loss with no attacker at all.
+
+MEDIUM 6 — FromBtcTrusted /setRefundAddress is dead code; refundable user funds strand permanently
+
+FromBtcTrusted.js:606 looks up getData(paymentHash, null); IntermediaryStorageManager.getData (line 64-66) converts null → sequence 0x0, but every swap is stored with a random 64-bit sequence — so the lookup always
+misses and the endpoint always throws 10001. (The status endpoint at line 515 does it correctly.) Any swap that becomes REFUNDABLE (over-max payment, plugin veto, chain revert, balance failure) without a refund
+address set at creation can never be refunded (refundSwap early-returns without one). User funds sit in the LP wallet forever. One-line fix: pass parsedBody.sequence.
+ */
+
 export type FromBtcTrustedConfig = SwapBaseConfig & {
     doubleSpendCheckInterval: number,
     swapAddressExpiry: number,
@@ -298,7 +321,7 @@ export class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrust
 
             const txns = await chainInterface.txsTransfer(signer.getAddress(), swap.token, swap.adjustedOutput, swap.dstAddress);
 
-            let unlock = swap.lock(30*1000);
+            let unlock = swap.lock(30);
             if(unlock==null) return;
 
             const pluginCheckResult = await PluginManager.onHandlePreFromBtcExecute(
@@ -399,7 +422,7 @@ export class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrust
             try {
                 await this.processPastSwap(swap, txs[0]?.tx, txs[0]?.vout);
             } catch (e) {
-                this.swapLogger.error(swap, "processPastSwaps(): Error ocurred while processing swap: ", e);
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e);
             }
         }
     }

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

@@ -171,7 +171,11 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
         ]);
 
         for(let {obj: swap} of queriedData) {
-            if(await this.processPastSwap(swap)) cancelInvoices.push(swap);
+            try {
+                if(await this.processPastSwap(swap)) cancelInvoices.push(swap);
+            } catch (e) {
+                this.swapLogger.error(swap, "processPastSwap(): Error executing watchdog function: ", e);
+            }
         }
 
         await this.cancelInvoices(cancelInvoices);
@@ -256,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"
@@ -281,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);

package/src/utils/Utils.ts

@@ -150,3 +150,51 @@ export function parsePsbt(btcTx: Transaction): BtcTx {
         })
     };
 }
+
+/**
+ * Returns the minimum Bitcoin block window (in blocks) for which a "fast blocks" safety
+ * factor is genuinely usable: the probability that N consecutive blocks are produced
+ * with an average interval below (blocktime / safetyFactor) is less than `probability`.
+ *
+ * Model: block arrivals are a Poisson process (i.i.d. exponential intervals), so the
+ * production time of N blocks is Erlang/Gamma(shape=N). A Chernoff (Cramer) bound on
+ * the lower tail gives the per-block large-deviation rate I(S) = ln(S) + 1/S - 1, i.e.
+ *     P(N blocks faster than blocktime/S on average) <= exp(-N * I(S))
+ * which this function inverts for N. Conservative: the exact Erlang CDF already
+ * satisfies the bound ~25% earlier. Use for the fast-block tail (e.g. incoming LN
+ * HTLC expiry racing an escrow claim window).
+ *
+ * @param {number|bigint} safetyFactor Assumed max block-speed multiplier (must be > 1)
+ * @param {number} [probability=0.0001] Tolerated failure probability (default 0.01%)
+ * @returns {number} Minimum safe block window in blocks
+ */
+export function getMinSafeBlockWindowFast(safetyFactor: number | bigint, probability: number = 0.0001): bigint {
+    const S = Number(safetyFactor);
+    const rate = Math.log(S) + 1/S - 1;
+    if (!(rate > 0)) throw new RangeError("safetyFactor must be > 1");
+    return BigInt(Math.ceil(Math.log(1/probability) / rate));
+}
+
+/**
+ * Slow-tail mirror of getMinSafeBlockWindowFast(): returns the minimum block window
+ * (in blocks) for which a "slow blocks" safety factor is genuinely usable: the
+ * probability that N consecutive blocks take LONGER than N * blocktime * safetyFactor
+ * is less than `probability`. Chernoff bound on the upper Erlang tail gives the rate
+ * I(S) = S - 1 - ln(S). Use when converting a wall-clock deadline into a block count
+ * (e.g. payout/claim timeouts that must expire before some real-world time even if
+ * blocks come slowly).
+ *
+ * @param {number|bigint} safetyFactor Assumed max block-slowness multiplier (must be > 1)
+ * @param {number} [probability=0.0001] Tolerated failure probability (default 0.01%)
+ * @returns {number} Minimum safe block window in blocks
+ */
+export function getMinSafeBlockWindowSlow(safetyFactor: bigint | number, probability: number = 0.0001): bigint {
+    const S = Number(safetyFactor);
+    const rate = S - 1 - Math.log(S);
+    if (!(rate > 0)) throw new RangeError("safetyFactor must be > 1");
+    return BigInt(Math.ceil(Math.log(1/probability) / rate));
+}
+
+export function bigIntMax(a: bigint, b: bigint): bigint {
+    return a > b ? a : b;
+}

package/src/utils/paramcoders/ParamDecoder.ts

@@ -1,4 +1,11 @@
-import {FieldTypeEnum, parseBigInt, RequestSchema, RequestSchemaResult, verifySchema} from "./SchemaVerifier";
+import {
+    FieldTypeEnum,
+    parseBigInt,
+    RequestSchema,
+    RequestSchemaResult,
+    verifySchema,
+    verifySchemaField
+} from "./SchemaVerifier";
 import {IParamReader} from "./IParamReader";
 
 
@@ -133,41 +140,7 @@ export class ParamDecoder implements IParamReader {
         const resultSchema: any = {};
         for(let fieldName in schema) {
             const val: any = await this.getParam(fieldName);
-            const type: FieldTypeEnum | RequestSchema | ((val: any) => boolean) = schema[fieldName];
-            if(typeof(type)==="function") {
-                const result = type(val);
-                if(result==null) return null;
-                resultSchema[fieldName] = result;
-                continue;
-            }
-
-            if(val==null && (type as number)>=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 as number)) 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 as RequestSchema);
-                if(result==null) return null;
-                resultSchema[fieldName] = result;
-            }
+            if(!verifySchemaField(val, schema[fieldName], fieldName, resultSchema)) return null;
         }
         return resultSchema;
     }
@@ -182,36 +155,7 @@ export class ParamDecoder implements IParamReader {
                 continue;
             }
 
-            const type: FieldTypeEnum | RequestSchema | ((val: any) => boolean) = schema[fieldName];
-            if(typeof(type)==="function") {
-                const result = type(val);
-                if(result==null) return null;
-                resultSchema[fieldName] = result;
-                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 as number)) 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 as RequestSchema);
-                if(result==null) return null;
-                resultSchema[fieldName] = result;
-            }
+            if(!verifySchemaField(val, schema[fieldName], fieldName, resultSchema)) return null;
         }
         return resultSchema;
     }

package/src/utils/paramcoders/SchemaVerifier.ts

@@ -15,25 +15,41 @@ export enum FieldTypeEnum {
     Number=2,
     BigInt=3,
     Any=4,
+    BigIntPositive=5,
+    BigIntNotNegative=6,
+    NumberPositive=7,
+    NumberNotNegative=8,
 
     StringOptional=100,
     BooleanOptional=101,
     NumberOptional=102,
     BigIntOptional=103,
     AnyOptional=104,
+    BigIntPositiveOptional=105,
+    BigIntNotNegativeOptional=106,
+    NumberPositiveOptional=107,
+    NumberNotNegativeOptional=108,
 }
 
 export type FieldType<T extends FieldTypeEnum | RequestSchema | ((val: any) => (string | boolean | number | bigint | any))> =
     T extends FieldTypeEnum.String ? string :
     T extends FieldTypeEnum.Boolean ? boolean :
     T extends FieldTypeEnum.Number ? number :
+    T extends FieldTypeEnum.NumberPositive ? number :
+    T extends FieldTypeEnum.NumberNotNegative ? number :
     T extends FieldTypeEnum.BigInt ? bigint :
     T extends FieldTypeEnum.Any ? any :
+    T extends FieldTypeEnum.BigIntPositive ? bigint :
+    T extends FieldTypeEnum.BigIntNotNegative ? bigint :
     T extends FieldTypeEnum.StringOptional ? string :
     T extends FieldTypeEnum.BooleanOptional ? boolean :
     T extends FieldTypeEnum.NumberOptional ? number :
+    T extends FieldTypeEnum.NumberPositiveOptional ? number :
+    T extends FieldTypeEnum.NumberNotNegativeOptional ? number :
     T extends FieldTypeEnum.BigIntOptional ? bigint :
     T extends FieldTypeEnum.AnyOptional ? any :
+    T extends FieldTypeEnum.BigIntPositiveOptional ? bigint :
+    T extends FieldTypeEnum.BigIntNotNegativeOptional ? bigint :
     T extends RequestSchema ? RequestSchemaResult<T> :
     T extends ((val: any) => string) ? string :
     T extends ((val: any) => boolean) ? boolean :
@@ -50,47 +66,74 @@ export type RequestSchema = {
     [fieldName: string]: FieldTypeEnum | RequestSchema | ((val: any) => any)
 }
 
+export function verifySchemaField(
+    val: any,
+    type: FieldTypeEnum | RequestSchema | ((val: any) => any),
+    fieldName: string,
+    resultSchema: any
+): boolean {
+    if(typeof(type)==="function") {
+        const result = type(val);
+        if(result==null) return false;
+        resultSchema[fieldName] = result;
+        return true;
+    }
+
+    if(val==null && (type as number)>=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 as number)) return false;
+        resultSchema[fieldName] = val;
+    } else if(type===FieldTypeEnum.NumberPositive || type===FieldTypeEnum.NumberPositiveOptional) {
+        if(typeof(val)!=="number") return false;
+        if(isNaN(val as number)) 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 as number)) 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 as RequestSchema);
+        if(result==null) return false;
+        resultSchema[fieldName] = result;
+    }
+    return true;
+}
+
 export function verifySchema<T extends RequestSchema>(req: any, schema: T): RequestSchemaResult<T> {
     if(req==null) return null;
     const resultSchema: any = {};
     for(let fieldName in schema) {
-        const val: any = req[fieldName];
-
-        const type: FieldTypeEnum | RequestSchema | ((val: any) => boolean) = schema[fieldName];
-        if(typeof(type)==="function") {
-            const result = type(val);
-            if(result==null) return null;
-            resultSchema[fieldName] = result;
-            continue;
-        }
-
-        if(val==null && (type as number)>=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 as number)) 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 as RequestSchema);
-            if(result==null) return null;
-            resultSchema[fieldName] = result;
-        }
+        if(!verifySchemaField(req[fieldName], schema[fieldName], fieldName, resultSchema)) return null;
     }
     return resultSchema;
 }