@atomiqlabs/lp-lib 17.1.2 → 17.3.1

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

@@ -105,4 +105,8 @@ export class ToBtcSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T
         return this.state===ToBtcSwapState.CLAIMED;
     }
 
+    getDestinationAddress(): string {
+        return this.address;
+    }
+
 }

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

@@ -28,6 +28,8 @@ import {
     routesMatch
 } from "../../../wallets/ILightningWallet";
 import { LightningAssertions } from "../../assertions/LightningAssertions";
+import {isQuoteThrow} from "../../../plugins/IPlugin";
+import {ToBtcSwapState} from "../tobtc_abstract/ToBtcSwapAbs";
 
 export type ToBtcLnConfig = ToBtcBaseConfig & {
     routingFeeMultiplier: bigint,
@@ -305,7 +307,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
         return true;
     }
 
-    private async sendLightningPayment(swap: ToBtcLnSwapAbs): Promise<void> {
+    private async sendLightningPayment(swap: ToBtcLnSwapAbs): Promise<boolean> {
         const decodedPR = await this.lightning.parsePaymentRequest(swap.pr);
         const expiryTimestamp: bigint = swap.data.getExpiry();
         const currentTimestamp: bigint = BigInt(Math.floor(Date.now()/1000));
@@ -336,6 +338,19 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
 
         const blockHeight = await this.lightning.getBlockheight();
 
+        const pluginCheckResult = await PluginManager.onHandlePreToBtcExecute(
+            SwapHandlerType.TO_BTCLN,
+            swap
+        );
+        if(isQuoteThrow(pluginCheckResult)) {
+            throw {
+                code: 29999,
+                msg: pluginCheckResult.message
+            };
+        }
+
+        if(swap.state!==ToBtcLnSwapState.COMMITED) return false;
+
         swap.payInitiated = true;
         await this.saveSwapData(swap);
         try {
@@ -354,6 +369,8 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             }
         }
         if(swap.metadata!=null) swap.metadata.times.payComplete = Date.now();
+
+        return true;
     }
 
     /**
@@ -404,7 +421,7 @@ export class ToBtcLnAbs extends ToBtcBaseSwapHandler<ToBtcLnSwapAbs, ToBtcLnSwap
             await swap.setState(ToBtcLnSwapState.COMMITED);
             await this.saveSwapData(swap);
             try {
-                await this.sendLightningPayment(swap);
+                if(!await this.sendLightningPayment(swap)) return;
             } catch (e) {
                 this.swapLogger.error(swap, "processInitialized(): lightning payment error", e);
                 if(isDefinedRuntimeError(e)) {

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

@@ -78,4 +78,8 @@ export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap
         return this.state===ToBtcLnSwapState.CLAIMED;
     }
 
+    getDestinationAddress(): string {
+        return this.pr;
+    }
+
 }

package/src/swaps/spv_vault_swap/SpvVaultSwap.ts

@@ -225,4 +225,8 @@ export class SpvVaultSwap extends SwapHandlerSwap<SpvVaultSwapState> {
         return this.state===SpvVaultSwapState.CLAIMED;
     }
 
+    getDestinationAddress(): string {
+        return this.recipient;
+    }
+
 }

package/src/swaps/spv_vault_swap/SpvVaultSwapHandler.ts

@@ -37,6 +37,7 @@ import {Transaction} from "@scure/btc-signer";
 import {SpvVaults, VAULT_DUST_AMOUNT} from "./SpvVaults";
 import {isLegacyInput} from "../../utils/BitcoinUtils";
 import {AmountAssertions} from "../assertions/AmountAssertions";
+import {isQuoteThrow} from "../../plugins/IPlugin";
 
 export type SpvVaultSwapHandlerConfig = SwapBaseConfig & {
     vaultsCheckInterval: number,
@@ -599,7 +600,7 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
             if(swap.vaultUtxo!==vault.getLatestUtxo()) {
                 throw {
                     code: 20510,
-                    msg: "Vault UTXO already spent, please try again!"
+                    msg: "Vault UTXO already spent, please get another quote and try again!"
                 };
             }
 
@@ -624,11 +625,25 @@ export class SpvVaultSwapHandler extends SwapHandler<SpvVaultSwap, SpvVaultSwapS
                 msg: "Bitcoin transaction size too large, maximum: "+TX_MAX_VSIZE+" actual: "+txVsize
             };
 
+            const pluginCheckResult = await PluginManager.onHandlePreFromBtcExecute(
+                SwapHandlerType.FROM_BTC_SPV,
+                swap
+            );
+            if(isQuoteThrow(pluginCheckResult)) {
+                const error = {
+                    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);
             if(swap.vaultUtxo!==vault.getLatestUtxo()) {
                 throw {
                     code: 20510,
-                    msg: "Vault UTXO already spent, please try again!"
+                    msg: "Vault UTXO already spent, please get another quote and try again!"
                 };
             }
 

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

@@ -11,6 +11,7 @@ import {ServerParamEncoder} from "../../../utils/paramcoders/server/ServerParamE
 import {FieldTypeEnum, verifySchema} from "../../../utils/paramcoders/SchemaVerifier";
 import {IBitcoinWallet} from "../../../wallets/IBitcoinWallet";
 import {FromBtcAmountAssertions} from "../../assertions/FromBtcAmountAssertions";
+import {isQuoteThrow} from "../../../plugins/IPlugin";
 
 export type FromBtcTrustedConfig = SwapBaseConfig & {
     doubleSpendCheckInterval: number,
@@ -67,49 +68,51 @@ export class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrust
     }
 
     private async refundSwap(swap: FromBtcTrustedSwap) {
-        if(swap.refundAddress==null) {
-            if(swap.state!==FromBtcTrustedSwapState.REFUNDABLE) {
-                await swap.setState(FromBtcTrustedSwapState.REFUNDABLE);
-                await this.storageManager.saveData(swap.getIdentifierHash(), swap.getSequence(), swap);
-            }
-            return;
+        if(swap.state!==FromBtcTrustedSwapState.REFUNDABLE) {
+            await swap.setState(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();
+        try {
+            const feeRate = await this.bitcoin.getFeeRate();
 
-        const ourOutput = swap.btcTx.outs[swap.vout];
+            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);
+            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(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);
+            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;
+            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);
+            //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, FromBtcTrustedSwapState.REFUNDED);
-        unlock();
+            this.refundedSwaps.set(swap.getIdentifierHash(), refundTxId);
+            await this.removeSwapData(swap, FromBtcTrustedSwapState.REFUNDED);
+        } finally {
+            unlock();
+        }
     }
 
     private async burn(swap: FromBtcTrustedSwap) {
@@ -293,10 +296,27 @@ export class FromBtcTrusted extends SwapHandler<FromBtcTrustedSwap, FromBtcTrust
 
             if(swap.state!==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.onHandlePreFromBtcExecute(
+                SwapHandlerType.FROM_BTC_TRUSTED,
+                swap
+            );
+            if(isQuoteThrow(pluginCheckResult)) {
+                this.swapLogger.error(swap, "processPastSwap(): Error, got negative response from plugin: ", pluginCheckResult);
+                await this.refundSwap(swap);
+                unlock();
+                return;
+            }
+
+            if(swap.state!==FromBtcTrustedSwapState.BTC_CONFIRMED) {
+                unlock();
+                return;
+            }
+
             await chainInterface.sendAndConfirm(signer, txns, true, null, false, async (txId: string, rawTx: string) => {
                 swap.txIds = {init: txId};
                 swap.scRawTx = rawTx;

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

@@ -183,4 +183,8 @@ export class FromBtcTrustedSwap extends SwapHandlerSwap<FromBtcTrustedSwapState>
         return createHash("sha256").update(this.btcAddress).digest().toString("hex");
     }
 
+    getDestinationAddress(): string {
+        return this.dstAddress;
+    }
+
 }

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

@@ -16,7 +16,8 @@ import {
     LightningNetworkInvoice
 } from "../../../wallets/ILightningWallet";
 import {FromBtcAmountAssertions} from "../../assertions/FromBtcAmountAssertions";
-import { LightningAssertions } from "../../assertions/LightningAssertions";
+import {LightningAssertions} from "../../assertions/LightningAssertions";
+import {isQuoteThrow} from "../../../plugins/IPlugin";
 
 export type SwapForGasServerConfig = SwapBaseConfig & {
     minCltv: bigint,
@@ -227,6 +228,24 @@ export class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcL
             let unlock = invoiceData.lock(Infinity);
             if(unlock==null) return;
 
+            const pluginCheckResult = await PluginManager.onHandlePreFromBtcExecute(
+                SwapHandlerType.FROM_BTCLN_TRUSTED,
+                invoiceData
+            );
+            if(isQuoteThrow(pluginCheckResult)) {
+                await this.cancelSwapAndInvoice(invoiceData);
+                unlock();
+                throw {
+                    code: 29999,
+                    msg: pluginCheckResult.message
+                };
+            }
+
+            if(invoiceData.state!==FromBtcLnTrustedSwapState.RECEIVED) {
+                unlock();
+                return;
+            }
+
             const result = await chainInterface.sendAndConfirm(signer, txns, true, null, false, async (txId: string, rawTx: string) => {
                 invoiceData.txIds = {init: txId};
                 invoiceData.scRawTx = rawTx;

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

@@ -118,4 +118,8 @@ export class FromBtcLnTrustedSwap extends SwapHandlerSwap<FromBtcLnTrustedSwapSt
         return createHash("sha256").update(Buffer.from(this.secret, "hex")).digest().toString("hex");
     }
 
+    getDestinationAddress(): string {
+        return this.dstAddress;
+    }
+
 }