@atomiqlabs/lp-lib 17.1.2 → 17.3.1

package/dist/swaps/trusted/frombtc_trusted/FromBtcTrusted.js

@@ -7,6 +7,7 @@ const PluginManager_1 = require("../../../plugins/PluginManager");
 const Utils_1 = require("../../../utils/Utils");
 const SchemaVerifier_1 = require("../../../utils/paramcoders/SchemaVerifier");
 const FromBtcAmountAssertions_1 = require("../../assertions/FromBtcAmountAssertions");
+const IPlugin_1 = require("../../../plugins/IPlugin");
 class FromBtcTrusted extends SwapHandler_1.SwapHandler {
     constructor(storageDirectory, path, chains, bitcoin, swapPricing, bitcoinRpc, config) {
         var _a;
@@ -30,42 +31,45 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
         })));
     }
     async refundSwap(swap) {
-        if (swap.refundAddress == null) {
-            if (swap.state !== FromBtcTrustedSwap_1.FromBtcTrustedSwapState.REFUNDABLE) {
-                await swap.setState(FromBtcTrustedSwap_1.FromBtcTrustedSwapState.REFUNDABLE);
-                await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
-            }
-            return;
+        if (swap.state !== FromBtcTrustedSwap_1.FromBtcTrustedSwapState.REFUNDABLE) {
+            await swap.setState(FromBtcTrustedSwap_1.FromBtcTrustedSwapState.REFUNDABLE);
+            await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
         }
-        let unlock = swap.lock(30 * 1000);
+        if (swap.refundAddress == null)
+            return;
+        let unlock = swap.lock(Infinity);
         if (unlock == null)
             return;
-        const feeRate = await this.bitcoin.getFeeRate();
-        const ourOutput = swap.btcTx.outs[swap.vout];
-        const resp = await this.bitcoin.drainAll(swap.refundAddress, [{
-                type: this.bitcoin.getAddressType(),
-                confirmations: swap.btcTx.confirmations,
-                outputScript: Buffer.from(ourOutput.scriptPubKey.hex, "hex"),
-                value: ourOutput.value,
-                txId: swap.btcTx.txid,
-                vout: swap.vout
-            }], feeRate);
-        if (resp == null) {
-            this.swapLogger.error(swap, "refundSwap(): cannot refund swap because of dust limit, txId: " + swap.txId);
+        try {
+            const feeRate = await this.bitcoin.getFeeRate();
+            const ourOutput = swap.btcTx.outs[swap.vout];
+            const resp = await this.bitcoin.drainAll(swap.refundAddress, [{
+                    type: this.bitcoin.getAddressType(),
+                    confirmations: swap.btcTx.confirmations,
+                    outputScript: Buffer.from(ourOutput.scriptPubKey.hex, "hex"),
+                    value: ourOutput.value,
+                    txId: swap.btcTx.txid,
+                    vout: swap.vout
+                }], feeRate);
+            if (resp == null) {
+                this.swapLogger.error(swap, "refundSwap(): cannot refund swap because of dust limit, txId: " + swap.txId);
+                unlock();
+                return;
+            }
+            if (swap.metadata != null)
+                swap.metadata.times.refundSignPSBT = Date.now();
+            this.swapLogger.debug(swap, "refundSwap(): signed raw transaction: " + resp.raw);
+            const refundTxId = resp.txId;
+            swap.refundTxId = refundTxId;
+            //Send the refund TX
+            await this.bitcoin.sendRawTransaction(resp.raw);
+            this.swapLogger.debug(swap, "refundSwap(): sent refund transaction: " + refundTxId);
+            this.refundedSwaps.set(swap.getIdentifierHash(), refundTxId);
+            await this.removeSwapData(swap, FromBtcTrustedSwap_1.FromBtcTrustedSwapState.REFUNDED);
+        }
+        finally {
             unlock();
-            return;
         }
-        if (swap.metadata != null)
-            swap.metadata.times.refundSignPSBT = Date.now();
-        this.swapLogger.debug(swap, "refundSwap(): signed raw transaction: " + resp.raw);
-        const refundTxId = resp.txId;
-        swap.refundTxId = refundTxId;
-        //Send the refund TX
-        await this.bitcoin.sendRawTransaction(resp.raw);
-        this.swapLogger.debug(swap, "refundSwap(): sent refund transaction: " + refundTxId);
-        this.refundedSwaps.set(swap.getIdentifierHash(), refundTxId);
-        await this.removeSwapData(swap, FromBtcTrustedSwap_1.FromBtcTrustedSwapState.REFUNDED);
-        unlock();
     }
     async burn(swap) {
         const ourOutput = swap.btcTx.outs[swap.vout];
@@ -241,10 +245,21 @@ class FromBtcTrusted extends SwapHandler_1.SwapHandler {
             }
             if (swap.state !== FromBtcTrustedSwap_1.FromBtcTrustedSwapState.BTC_CONFIRMED)
                 return;
+            const txns = await chainInterface.txsTransfer(signer.getAddress(), swap.token, swap.adjustedOutput, swap.dstAddress);
             let unlock = swap.lock(30 * 1000);
             if (unlock == null)
                 return;
-            const txns = await chainInterface.txsTransfer(signer.getAddress(), swap.token, swap.adjustedOutput, swap.dstAddress);
+            const pluginCheckResult = await PluginManager_1.PluginManager.onHandlePreFromBtcExecute(SwapHandler_1.SwapHandlerType.FROM_BTC_TRUSTED, swap);
+            if ((0, IPlugin_1.isQuoteThrow)(pluginCheckResult)) {
+                this.swapLogger.error(swap, "processPastSwap(): Error, got negative response from plugin: ", pluginCheckResult);
+                await this.refundSwap(swap);
+                unlock();
+                return;
+            }
+            if (swap.state !== FromBtcTrustedSwap_1.FromBtcTrustedSwapState.BTC_CONFIRMED) {
+                unlock();
+                return;
+            }
             await chainInterface.sendAndConfirm(signer, txns, true, null, false, async (txId, rawTx) => {
                 swap.txIds = { init: txId };
                 swap.scRawTx = rawTx;

package/dist/swaps/trusted/frombtc_trusted/FromBtcTrustedSwap.d.ts

@@ -49,4 +49,5 @@ export declare class FromBtcTrustedSwap extends SwapHandlerSwap<FromBtcTrustedSw
     isInitiated(): boolean;
     isSuccess(): boolean;
     getIdentifierHash(): string;
+    getDestinationAddress(): string;
 }

package/dist/swaps/trusted/frombtc_trusted/FromBtcTrustedSwap.js

@@ -114,5 +114,8 @@ class FromBtcTrustedSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     getIdentifierHash() {
         return (0, crypto_1.createHash)("sha256").update(this.btcAddress).digest().toString("hex");
     }
+    getDestinationAddress() {
+        return this.dstAddress;
+    }
 }
 exports.FromBtcTrustedSwap = FromBtcTrustedSwap;

package/dist/swaps/trusted/frombtcln_trusted/FromBtcLnTrusted.js

@@ -9,6 +9,7 @@ const SchemaVerifier_1 = require("../../../utils/paramcoders/SchemaVerifier");
 const PluginManager_1 = require("../../../plugins/PluginManager");
 const FromBtcAmountAssertions_1 = require("../../assertions/FromBtcAmountAssertions");
 const LightningAssertions_1 = require("../../assertions/LightningAssertions");
+const IPlugin_1 = require("../../../plugins/IPlugin");
 /**
  * Swap handler handling from BTCLN swaps using submarine swaps
  */
@@ -183,6 +184,19 @@ class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
             let unlock = invoiceData.lock(Infinity);
             if (unlock == null)
                 return;
+            const pluginCheckResult = await PluginManager_1.PluginManager.onHandlePreFromBtcExecute(SwapHandler_1.SwapHandlerType.FROM_BTCLN_TRUSTED, invoiceData);
+            if ((0, IPlugin_1.isQuoteThrow)(pluginCheckResult)) {
+                await this.cancelSwapAndInvoice(invoiceData);
+                unlock();
+                throw {
+                    code: 29999,
+                    msg: pluginCheckResult.message
+                };
+            }
+            if (invoiceData.state !== FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.RECEIVED) {
+                unlock();
+                return;
+            }
             const result = await chainInterface.sendAndConfirm(signer, txns, true, null, false, async (txId, rawTx) => {
                 invoiceData.txIds = { init: txId };
                 invoiceData.scRawTx = rawTx;

package/dist/swaps/trusted/frombtcln_trusted/FromBtcLnTrustedSwap.d.ts

@@ -31,4 +31,5 @@ export declare class FromBtcLnTrustedSwap extends SwapHandlerSwap<FromBtcLnTrust
     isInitiated(): boolean;
     isSuccess(): boolean;
     getIdentifierHash(): string;
+    getDestinationAddress(): string;
 }

package/dist/swaps/trusted/frombtcln_trusted/FromBtcLnTrustedSwap.js

@@ -77,5 +77,8 @@ class FromBtcLnTrustedSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     getIdentifierHash() {
         return (0, crypto_1.createHash)("sha256").update(Buffer.from(this.secret, "hex")).digest().toString("hex");
     }
+    getDestinationAddress() {
+        return this.dstAddress;
+    }
 }
 exports.FromBtcLnTrustedSwap = FromBtcLnTrustedSwap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "17.1.2",
+  "version": "17.3.1",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "^13.0.4",
+    "@atomiqlabs/base": "^13.5.0",
     "@atomiqlabs/server-base": "^3.0.0",
     "@scure/btc-signer": "1.6.0",
     "express": "4.21.1",

package/src/info/InfoHandler.ts

@@ -16,7 +16,8 @@ type InfoHandlerResponse = {
     chains: {
         [chainIdentifier: string]: {
             address: string,
-            signature: string
+            signature: string,
+            contractVersion: string
         }
     }
 }
@@ -74,14 +75,16 @@ export class InfoHandler {
             const chains: {
                 [chainIdentifier: string]: {
                     address: string,
-                    signature: string
+                    signature: string,
+                    contractVersion: string
                 }
             } = {};
             for(let chainIdentifier in this.chainData.chains) {
                 const singleChain = this.chainData.chains[chainIdentifier];
                 chains[chainIdentifier] = {
                     address: singleChain.signer.getAddress(),
-                    signature: await singleChain.swapContract.getDataSignature(singleChain.signer, envelopeBuffer)
+                    signature: await singleChain.swapContract.getDataSignature(singleChain.signer, envelopeBuffer),
+                    contractVersion: singleChain.contractVersion ?? "v1"
                 };
             }
 

package/src/plugins/IPlugin.ts

@@ -1,11 +1,12 @@
 import {BitcoinRpc} from "@atomiqlabs/base";
 import {
-    FromBtcLnRequestType,
-    FromBtcRequestType, FromBtcTrustedRequestType,
+    FromBtcLnAbs, FromBtcLnAutoSwap,
+    FromBtcLnRequestType, FromBtcLnSwapAbs, FromBtcLnTrustedSwap,
+    FromBtcRequestType, FromBtcSwapAbs, FromBtcTrustedRequestType, FromBtcTrustedSwap,
     ISwapPrice, MultichainData, RequestData, SpvVaultPostQuote, SpvVaultSwap, SpvVaultSwapRequestType,
     SwapHandler, SwapHandlerType,
-    ToBtcLnRequestType,
-    ToBtcRequestType
+    ToBtcLnRequestType, ToBtcLnSwapAbs,
+    ToBtcRequestType, ToBtcSwapAbs
 } from "..";
 import {SwapHandlerSwap} from "../swaps/SwapHandlerSwap";
 import {Command} from "@atomiqlabs/server-base";
@@ -20,7 +21,7 @@ export type QuoteThrow = {
 }
 
 export function isQuoteThrow(obj: any): obj is QuoteThrow {
-    return obj.type==="throw" && typeof(obj.message)==="string";
+    return obj!=null && obj.type==="throw" && typeof(obj.message)==="string";
 }
 
 export type QuoteSetFees = {
@@ -32,7 +33,8 @@ export type QuoteSetFees = {
 };
 
 export function isQuoteSetFees(obj: any): obj is QuoteSetFees {
-    return obj.type==="fees" &&
+    return obj!=null &&
+        obj.type==="fees" &&
         (obj.baseFee==null || typeof(obj.baseFee) === "bigint") &&
         (obj.feePPM==null || typeof(obj.feePPM) === "bigint") &&
         (obj.securityDepositApyPPM==null || typeof(obj.securityDepositApyPPM) === "bigint") &&
@@ -45,7 +47,7 @@ export type QuoteAmountTooLow = {
 }
 
 export function isQuoteAmountTooLow(obj: any): obj is QuoteAmountTooLow {
-    return obj.type==="low" && typeof(obj.data)==="object" && typeof(obj.data.min)==="bigint" && typeof(obj.data.max)==="bigint";
+    return obj!=null && obj.type==="low" && obj.data!=null && typeof(obj.data)==="object" && typeof(obj.data.min)==="bigint" && typeof(obj.data.max)==="bigint";
 }
 
 export type QuoteAmountTooHigh = {
@@ -54,7 +56,7 @@ export type QuoteAmountTooHigh = {
 }
 
 export function isQuoteAmountTooHigh(obj: any): obj is QuoteAmountTooHigh {
-    return obj.type==="high" && typeof(obj.data)==="object" && typeof(obj.data.min)==="bigint" && typeof(obj.data.max)==="bigint";
+    return obj!=null && obj.type==="high" && obj.data!=null && typeof(obj.data)==="object" && typeof(obj.data.min)==="bigint" && typeof(obj.data.max)==="bigint";
 }
 
 export type PluginQuote = {
@@ -64,9 +66,9 @@ export type PluginQuote = {
 };
 
 export function isPluginQuote(obj: any): obj is PluginQuote {
-    return obj.type==="success" &&
-        typeof(obj.amount)==="object" && typeof(obj.amount.input)==="boolean" && typeof(obj.amount.amount)==="bigint" &&
-        typeof(obj.swapFee)==="object" && typeof(obj.swapFee.inInputTokens)==="bigint" && typeof(obj.swapFee.inOutputTokens)==="bigint";
+    return obj!=null && obj.type==="success" &&
+        obj.amount!=null && typeof(obj.amount)==="object" && typeof(obj.amount.input)==="boolean" && typeof(obj.amount.amount)==="bigint" &&
+        obj.swapFee!=null && typeof(obj.swapFee)==="object" && typeof(obj.swapFee.inInputTokens)==="bigint" && typeof(obj.swapFee.inOutputTokens)==="bigint";
 }
 
 export type ToBtcPluginQuote = PluginQuote & {
@@ -74,7 +76,7 @@ export type ToBtcPluginQuote = PluginQuote & {
 }
 
 export function isToBtcPluginQuote(obj: any): obj is ToBtcPluginQuote {
-    return typeof(obj.networkFee)==="object" && typeof(obj.networkFee.inInputTokens)==="bigint" && typeof(obj.networkFee.inOutputTokens)==="bigint" &&
+    return obj!=null && obj.networkFee!=null && typeof(obj.networkFee)==="object" && typeof(obj.networkFee.inInputTokens)==="bigint" && typeof(obj.networkFee.inOutputTokens)==="bigint" &&
         isPluginQuote(obj);
 }
 
@@ -94,8 +96,8 @@ export interface IPlugin {
 
         swapPricing: ISwapPrice,
         tokens: {
-            [ticker: string]: {
-                [chainId: string]: {
+            [chainId: string]: {
+                [ticker: string]: {
                     address: string,
                     decimals: number
                 }
@@ -133,6 +135,22 @@ export interface IPlugin {
         fees: {baseFeeInBtc: bigint, feePPM: bigint},
         gasTokenAmount?: {input: false, amount: bigint, token: string, pricePrefetch?: Promise<bigint>}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | PluginQuote>;
+    /**
+     * Triggered when the quote is about to get executed, this means:
+     * - FROM_BTCLN - lightning network payment received and the LP is about to sign an authorization allowing the user to settle
+     * - FROM_BTC - triggered on quote request, before the final authorization is given to the user
+     * - FROM_BTCLN_TRUSTED - triggered when the LP receives the funds on the source chain and before destination funds are sent
+     * - FROM_BTC_TRUSTED - triggered when the LP receives the funds on the source chain and before destination funds are sent
+     * - FROM_BTC_SPV - triggered before LP broadcasts the co-signed swap PSBT
+     * - FROM_BTCLN_AUTO - lightning network payment received and the LP is about to offer an HTLC to the user
+     *
+     * @param swapType
+     * @param swap
+     */
+    onHandlePreFromBtcExecute?(
+        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO,
+        swap: FromBtcLnSwapAbs | FromBtcSwapAbs | FromBtcLnTrustedSwap | FromBtcTrustedSwap | SpvVaultSwap | FromBtcLnAutoSwap
+    ): Promise<QuoteThrow | null>;
 
     onHandlePreToBtcQuote?(
         swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
@@ -150,6 +168,10 @@ export interface IPlugin {
         constraints: {minInBtc: bigint, maxInBtc: bigint},
         fees: {baseFeeInBtc: bigint, feePPM: bigint, networkFeeGetter: (amount: bigint) => Promise<bigint>}
     ): Promise<QuoteThrow | QuoteSetFees | QuoteAmountTooLow | QuoteAmountTooHigh | ToBtcPluginQuote>;
+    onHandlePreToBtcExecute?(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
+        swap: ToBtcLnSwapAbs | ToBtcSwapAbs
+    ): Promise<QuoteThrow | null>;
 
     onHandlePostedFromBtcQuote?(
         swapType: SwapHandlerType.FROM_BTC_SPV,

package/src/plugins/PluginManager.ts

@@ -8,12 +8,13 @@ import {
     QuoteThrow, ToBtcPluginQuote
 } from "./IPlugin";
 import {
-    FromBtcLnRequestType,
-    FromBtcRequestType, FromBtcTrustedRequestType,
+    FromBtcLnAutoSwap,
+    FromBtcLnRequestType, FromBtcLnSwapAbs, FromBtcLnTrustedSwap,
+    FromBtcRequestType, FromBtcSwapAbs, FromBtcTrustedRequestType, FromBtcTrustedSwap,
     ISwapPrice, MultichainData, RequestData, SpvVaultPostQuote, SpvVaultSwap, SpvVaultSwapRequestType,
     SwapHandler, SwapHandlerType,
-    ToBtcLnRequestType,
-    ToBtcRequestType
+    ToBtcLnRequestType, ToBtcLnSwapAbs,
+    ToBtcRequestType, ToBtcSwapAbs
 } from "..";
 import {SwapHandlerSwap} from "../swaps/SwapHandlerSwap";
 import * as fs from "fs";
@@ -73,8 +74,8 @@ export class PluginManager {
 
         swapPricing: ISwapPrice,
         tokens: {
-            [ticker: string]: {
-                [chainId: string]: {
+            [chainId: string]: {
+                [ticker: string]: {
                     address: string,
                     decimals: number
                 }
@@ -224,6 +225,23 @@ export class PluginManager {
         return null;
     }
 
+    static async onHandlePreFromBtcExecute(
+        swapType: SwapHandlerType.FROM_BTCLN | SwapHandlerType.FROM_BTC | SwapHandlerType.FROM_BTCLN_TRUSTED | SwapHandlerType.FROM_BTC_TRUSTED | SwapHandlerType.FROM_BTC_SPV | SwapHandlerType.FROM_BTCLN_AUTO,
+        swap: FromBtcLnSwapAbs | FromBtcSwapAbs | FromBtcLnTrustedSwap | FromBtcTrustedSwap | SpvVaultSwap | FromBtcLnAutoSwap
+    ): Promise<QuoteThrow | null> {
+        for(let plugin of PluginManager.plugins.values()) {
+            try {
+                if(plugin.onHandlePreFromBtcExecute!=null) {
+                    const result = await plugin.onHandlePreFromBtcExecute(swapType, swap);
+                    if(result!=null && isQuoteThrow(result)) return result;
+                }
+            } catch (e) {
+                pluginLogger.error(plugin, "onHandlePreFromBtcExecute(): plugin error", e);
+            }
+        }
+        return null;
+    }
+
     static async onHandlePostToBtcQuote<T extends {networkFee: bigint}>(
         swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
         request: RequestData<ToBtcLnRequestType | ToBtcRequestType>,
@@ -291,6 +309,23 @@ export class PluginManager {
         return null;
     }
 
+    static async onHandlePreToBtcExecute(
+        swapType: SwapHandlerType.TO_BTCLN | SwapHandlerType.TO_BTC,
+        swap: ToBtcLnSwapAbs | ToBtcSwapAbs
+    ): Promise<QuoteThrow | null> {
+        for(let plugin of PluginManager.plugins.values()) {
+            try {
+                if(plugin.onHandlePreToBtcExecute!=null) {
+                    const result = await plugin.onHandlePreToBtcExecute(swapType, swap);
+                    if(result!=null && isQuoteThrow(result)) return result;
+                }
+            } catch (e) {
+                pluginLogger.error(plugin, "onHandlePreToBtcExecute(): plugin error", e);
+            }
+        }
+        return null;
+    }
+
     static async onHandlePostedFromBtcQuote(
         swapType: SwapHandlerType.FROM_BTC_SPV,
         request: RequestData<SpvVaultPostQuote>,

package/src/swaps/SwapHandler.ts

@@ -62,7 +62,8 @@ export type ChainData<T extends ChainType = ChainType> = {
     allowedTokens: string[],
     tokenMultipliers?: {[tokenAddress: string]: bigint},
     allowedDepositTokens?: string[],
-    btcRelay?: T["BtcRelay"]
+    btcRelay?: T["BtcRelay"],
+    contractVersion?: string
 }
 
 export type RequestData<T> = {

package/src/swaps/SwapHandlerSwap.ts

@@ -139,4 +139,6 @@ export abstract class SwapHandlerSwap<S = any> extends Lockable implements Stora
      */
     abstract getSwapFee(): {inInputToken: bigint, inOutputToken: bigint};
 
+    abstract getDestinationAddress(): string;
+
 }

package/src/swaps/assertions/FromBtcAmountAssertions.ts

@@ -55,8 +55,8 @@ export class FromBtcAmountAssertions extends AmountAssertions {
             AmountAssertions.handlePluginErrorResponses(res);
             if(isQuoteSetFees(res)) {
                 return {
-                    baseFee: res.baseFee || this.config.baseFee,
-                    feePPM: res.feePPM || this.config.feePPM,
+                    baseFee: res.baseFee ?? this.config.baseFee,
+                    feePPM: res.feePPM ?? this.config.feePPM,
                     securityDepositApyPPM: res.securityDepositApyPPM,
                     securityDepositBaseMultiplierPPM: res.securityDepositBaseMultiplierPPM
                 }

package/src/swaps/assertions/ToBtcAmountAssertions.ts

@@ -33,8 +33,8 @@ export class ToBtcAmountAssertions extends AmountAssertions {
             AmountAssertions.handlePluginErrorResponses(res);
             if(isQuoteSetFees(res)) {
                 return {
-                    baseFee: res.baseFee || this.config.baseFee,
-                    feePPM: res.feePPM || this.config.feePPM
+                    baseFee: res.baseFee ?? this.config.baseFee,
+                    feePPM: res.feePPM ?? this.config.feePPM
                 }
             }
         }

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

@@ -20,6 +20,8 @@ import {IParamReader} from "../../../utils/paramcoders/IParamReader";
 import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamEncoder";
 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,
@@ -409,6 +411,15 @@ export class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSw
             createdSwap.signature = sigData.signature;
             createdSwap.feeRate = sigData.feeRate;
 
+            const pluginCheckResult = await PluginManager.onHandlePreFromBtcExecute(
+                SwapHandlerType.FROM_BTC,
+                createdSwap
+            );
+            if(isQuoteThrow(pluginCheckResult)) throw {
+                code: 29999,
+                msg: pluginCheckResult.message
+            };
+
             await PluginManager.swapCreate(createdSwap);
             await this.saveSwapData(createdSwap);
 

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

@@ -58,4 +58,8 @@ export class FromBtcSwapAbs<T extends SwapData = SwapData> extends FromBtcBaseSw
         return this.amount;
     }
 
+    getDestinationAddress(): string {
+        return this.data.getClaimer();
+    }
+
 }

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

@@ -27,6 +27,8 @@ import {
     LightningNetworkInvoice
 } from "../../../wallets/ILightningWallet";
 import {LightningAssertions} from "../../assertions/LightningAssertions";
+import {isQuoteThrow} from "../../../plugins/IPlugin";
+import {FromBtcLnAutoSwapState} from "../frombtcln_autoinit/FromBtcLnAutoSwap";
 
 export type FromBtcLnConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
@@ -374,6 +376,20 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
         //No need to check abortController anymore since all pending promises are resolved by now
         if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcSwapSigned = Date.now();
 
+        const pluginCheckResult = await PluginManager.onHandlePreFromBtcExecute(
+            SwapHandlerType.FROM_BTCLN,
+            invoiceData
+        );
+        if(isQuoteThrow(pluginCheckResult)) {
+            const error = {
+                code: 29999,
+                msg: pluginCheckResult.message
+            };
+            if(invoiceData.metadata!=null) invoiceData.metadata.htlcReceiveError = error;
+            if(invoiceData.state===FromBtcLnSwapState.CREATED) await this.cancelSwapAndInvoice(invoiceData);
+            throw error;
+        }
+
         //Important to prevent race condition and issuing 2 signed init messages at the same time
         if(invoiceData.state===FromBtcLnSwapState.CREATED) {
             //Re-check right before signing
@@ -836,7 +852,13 @@ export class FromBtcLnAbs extends FromBtcBaseSwapHandler<FromBtcLnSwapAbs, FromB
                 msg: "Invoice already committed"
             };
 
-            res.status(200).json({
+            if (swap.state === FromBtcLnSwapState.CLAIMED) throw {
+                _httpStatus: 200,
+                code: 10005,
+                msg: "Invoice already committed & claimed"
+            };
+
+            if (swap.state === FromBtcLnSwapState.RECEIVED) res.status(200).json({
                 code: 10000,
                 msg: "Success",
                 data: {

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

@@ -138,4 +138,8 @@ export class FromBtcLnSwapAbs<T extends SwapData = SwapData> extends FromBtcBase
         return this.state===FromBtcLnSwapState.SETTLED;
     }
 
+    getDestinationAddress(): string {
+        return this.claimer
+    }
+
 }

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

@@ -19,6 +19,7 @@ import {
     LightningNetworkInvoice
 } from "../../../wallets/ILightningWallet";
 import {LightningAssertions} from "../../assertions/LightningAssertions";
+import {isQuoteThrow} from "../../../plugins/IPlugin";
 
 export type FromBtcLnAutoConfig = FromBtcBaseConfig & {
     invoiceTimeoutSeconds?: number,
@@ -420,6 +421,20 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             signature: invoiceData.signature
         }, true);
 
+        const pluginCheckResult = await PluginManager.onHandlePreFromBtcExecute(
+            SwapHandlerType.FROM_BTCLN_AUTO,
+            invoiceData
+        );
+        if(isQuoteThrow(pluginCheckResult)) {
+            const error = {
+                code: 29999,
+                msg: pluginCheckResult.message
+            };
+            if(invoiceData.metadata!=null) invoiceData.metadata.htlcOfferError = error;
+            if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) await this.cancelSwapAndInvoice(invoiceData);
+            throw error;
+        }
+
         if(invoiceData.state===FromBtcLnAutoSwapState.RECEIVED) {
             //Re-check the current HTLC count
             try {
@@ -821,7 +836,6 @@ export class FromBtcLnAuto extends FromBtcBaseSwapHandler<FromBtcLnAutoSwap, Fro
             };
 
             if (
-                swap.state === FromBtcLnAutoSwapState.RECEIVED ||
                 swap.state === FromBtcLnAutoSwapState.TXS_SENT ||
                 swap.state === FromBtcLnAutoSwapState.COMMITED
             ) {

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

@@ -193,4 +193,8 @@ export class FromBtcLnAutoSwap<T extends SwapData = SwapData> extends FromBtcBas
         return this.state===FromBtcLnAutoSwapState.SETTLED;
     }
 
+    getDestinationAddress(): string {
+        return this.claimer
+    }
+
 }

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

@@ -23,6 +23,8 @@ import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamE
 import {ToBtcBaseConfig, ToBtcBaseSwapHandler} from "../ToBtcBaseSwapHandler";
 import {IBitcoinWallet} from "../../../wallets/IBitcoinWallet";
 import {checkTransactionReplaced} from "../../../utils/BitcoinUtils";
+import {isQuoteThrow} from "../../../plugins/IPlugin";
+import {FromBtcLnAutoSwapState} from "../frombtcln_autoinit/FromBtcLnAutoSwap";
 
 const OUTPUT_SCRIPT_MAX_LENGTH = 200;
 
@@ -435,9 +437,33 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
         }
 
         if(swap.state===ToBtcSwapState.COMMITED) {
-            const unlock: () => boolean = swap.lock(60);
+            const unlock: () => boolean = swap.lock(Infinity);
             if(unlock==null) return;
 
+            const pluginCheckResult = await PluginManager.onHandlePreToBtcExecute(
+                SwapHandlerType.TO_BTC,
+                swap
+            );
+            if(isQuoteThrow(pluginCheckResult)) {
+                const error = {
+                    code: 29999,
+                    msg: pluginCheckResult.message
+                };
+                this.swapLogger.error(swap, "processInitialized(state=COMMITED): setting state to NON_PAYABLE due to send bitcoin payment error", error);
+                if(swap.metadata!=null) swap.metadata.payError = error;
+                unlock();
+                if(swap.state===ToBtcSwapState.COMMITED) {
+                    await swap.setState(ToBtcSwapState.NON_PAYABLE);
+                    await this.saveSwapData(swap);
+                }
+                return;
+            }
+
+            if(swap.state!==ToBtcSwapState.COMMITED) {
+                unlock();
+                return;
+            }
+
             this.swapLogger.debug(swap, "processInitialized(state=COMMITED): sending bitcoin transaction, address: "+swap.address);
 
             try {
@@ -453,9 +479,9 @@ export class ToBtcAbs extends ToBtcBaseSwapHandler<ToBtcSwapAbs, ToBtcSwapState>
                     this.swapLogger.error(swap, "processInitialized(state=COMMITED): send bitcoin payment error", e);
                     throw e;
                 }
+            } finally {
+                unlock();
             }
-
-            unlock();
         }
 
         if(swap.state===ToBtcSwapState.NON_PAYABLE) return;