@arkade-os/boltz-swap 0.3.42 → 0.3.44

package/dist/index.cjs

@@ -85,6 +85,7 @@ __export(index_exports, {
   logger: () => logger,
   migrateToSwapRepository: () => migrateToSwapRepository,
   saveSwap: () => saveSwap,
+  sdkVersion: () => sdkVersion,
   setLogger: () => setLogger,
   updateChainSwapStatus: () => updateChainSwapStatus,
   updateReverseSwapStatus: () => updateReverseSwapStatus,
@@ -93,6 +94,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// package.json
+var version = "0.3.44";
+
 // src/errors.ts
 var SwapError = class extends Error {
   /** Whether the swap can still be claimed (default: false). */
@@ -3182,6 +3186,40 @@ var claimVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKe
   await arkProvider.finalizeTx(arkTxid, finalCheckpoints);
   return arkTxid;
 };
+var refundWithoutReceiverVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKey, input, output, arkInfo, arkProvider) => {
+  const rawCheckpointTapscript = import_base8.hex.decode(arkInfo.checkpointTapscript);
+  const serverUnrollScript = import_sdk7.CSVMultisigTapscript.decode(rawCheckpointTapscript);
+  const { arkTx, checkpoints } = (0, import_sdk7.buildOffchainTx)([input], [output], serverUnrollScript);
+  const signedArkTx = await identity.sign(arkTx);
+  const { arkTxid, finalArkTx, signedCheckpointTxs } = await arkProvider.submitTx(
+    import_base8.base64.encode(signedArkTx.toPSBT()),
+    checkpoints.map((c) => import_base8.base64.encode(c.toPSBT()))
+  );
+  const finalTx = import_sdk7.Transaction.fromPSBT(import_base8.base64.decode(finalArkTx));
+  const serverPubkeyHex = import_base8.hex.encode(serverXOnlyPublicKey);
+  const refundLeafHash = (0, import_payment3.tapLeafHash)(
+    scriptFromTapLeafScript(vhtlcScript.refundWithoutReceiver())
+  );
+  for (let i = 0; i < finalTx.inputsLength; i++) {
+    if (!verifySignatures(finalTx, i, [serverPubkeyHex], refundLeafHash)) {
+      throw new Error("Invalid final Ark transaction");
+    }
+  }
+  const finalCheckpoints = await Promise.all(
+    signedCheckpointTxs.map(async (c, idx) => {
+      const tx = import_sdk7.Transaction.fromPSBT(import_base8.base64.decode(c));
+      const checkpointLeaf = checkpoints[idx].getInput(0).tapLeafScript[0];
+      const cpLeafHash = (0, import_payment3.tapLeafHash)(scriptFromTapLeafScript(checkpointLeaf));
+      if (!verifySignatures(tx, 0, [serverPubkeyHex], cpLeafHash)) {
+        throw new Error("Invalid server signature in checkpoint transaction");
+      }
+      const signedCheckpoint = await identity.sign(tx, [0]);
+      return import_base8.base64.encode(signedCheckpoint.toPSBT());
+    })
+  );
+  await arkProvider.finalizeTx(arkTxid, finalCheckpoints);
+  return arkTxid;
+};
 var refundVHTLCwithOffchainTx = async (swapId, identity, arkProvider, boltzXOnlyPublicKey, ourXOnlyPublicKey, serverXOnlyPublicKey, input, output, arkInfo, refundFunc) => {
   const rawCheckpointTapscript = import_base8.hex.decode(arkInfo.checkpointTapscript);
   const serverUnrollScript = import_sdk7.CSVMultisigTapscript.decode(rawCheckpointTapscript);
@@ -3936,85 +3974,22 @@ var ArkadeSwaps = class _ArkadeSwaps {
     }
     const outputScript = import_sdk8.ArkAddress.decode(address).pkScript;
     const refundWithoutReceiverLeaf = vhtlcScript.refundWithoutReceiver();
-    const cltvSatisfied = isSubmarineRefundLocktimeReached(vhtlcTimeouts.refund);
-    let boltzCallCount = 0;
-    let sweptCount = 0;
-    let skippedCount = 0;
-    for (const vtxo of refundableVtxos) {
-      const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
-      const output = {
-        amount: BigInt(vtxo.value),
-        script: outputScript
-      };
-      if (cltvSatisfied) {
-        const input2 = {
-          ...vtxo,
-          tapLeafScript: refundWithoutReceiverLeaf,
-          tapTree: vhtlcScript.encode()
-        };
-        await this.joinBatch(
-          this.wallet.identity,
-          input2,
-          output,
-          arkInfo,
-          isRecoverableVtxo
-        );
-        sweptCount++;
-        continue;
-      }
-      if (isRecoverableVtxo) {
-        logger.error(
-          `Swap ${pendingSwap.id}: recoverable VTXO ${vtxo.txid}:${vtxo.vout} cannot be refunded yet \u2014 refundWithoutReceiver locktime has not passed (refundLocktime=${vhtlcTimeouts.refund}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
-        );
-        skippedCount++;
-        continue;
-      }
-      const input = {
-        ...vtxo,
-        tapLeafScript: vhtlcScript.refund(),
-        tapTree: vhtlcScript.encode()
-      };
-      try {
-        if (boltzCallCount > 0) {
-          await new Promise((r) => setTimeout(r, 2e3));
-        }
-        boltzCallCount++;
-        await refundVHTLCwithOffchainTx(
-          pendingSwap.id,
-          this.wallet.identity,
-          this.arkProvider,
-          boltzXOnlyPublicKey,
-          ourXOnlyPublicKey,
-          serverXOnlyPublicKey,
-          input,
-          output,
-          arkInfo,
-          this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
-        );
-        sweptCount++;
-      } catch (error) {
-        if (!(error instanceof BoltzRefundError)) {
-          throw error;
-        }
-        if (!isSubmarineRefundLocktimeReached(vhtlcTimeouts.refund)) {
-          logger.error(
-            `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentTimestamp=${Math.floor(Date.now() / 1e3)}, locktime=${vhtlcTimeouts.refund}). Refund will be retried after locktime.`
-          );
-          skippedCount++;
-          continue;
-        }
-        logger.warn(
-          `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver via joinBatch`
-        );
-        const fallbackInput = {
-          ...vtxo,
-          tapLeafScript: refundWithoutReceiverLeaf,
-          tapTree: vhtlcScript.encode()
-        };
-        await this.joinBatch(this.wallet.identity, fallbackInput, output, arkInfo, false);
-        sweptCount++;
-      }
-    }
+    const refundContext = {
+      arkInfo,
+      vhtlcScript,
+      serverXOnlyPublicKey,
+      refundWithoutReceiverLeaf,
+      outputScript
+    };
+    const { swept: sweptCount, skipped: skippedCount } = await this.refundVtxos({
+      swapId: pendingSwap.id,
+      vtxos: refundableVtxos,
+      refundLocktime: vhtlcTimeouts.refund,
+      refundContext,
+      boltzXOnlyPublicKey,
+      ourXOnlyPublicKey,
+      refundViaBoltz: this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
+    });
     if (!isSubmarineSuccessStatus(pendingSwap.status)) {
       const fullyRefunded = skippedCount === 0;
       await updateSubmarineSwapStatus(
@@ -4572,7 +4547,10 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * swap's ARK lockup address.
    *
    * Path selection per VTXO:
-   * - CLTV has elapsed → `refundWithoutReceiver` via `joinBatch` (no Boltz).
+   * - CLTV elapsed, live VTXO → `refundWithoutReceiver` offchain (sender +
+   *   server, no Boltz, no batch round).
+   * - CLTV elapsed, swept VTXO → `refundWithoutReceiver` via `joinBatch`
+   *   (a swept VTXO is no longer a live leaf).
    * - Pre-CLTV recoverable → skipped (Boltz can't co-sign swept-batch refund).
    * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz.
    *
@@ -4629,84 +4607,22 @@ var ArkadeSwaps = class _ArkadeSwaps {
     const outputScript = import_sdk8.ArkAddress.decode(address).pkScript;
     const refundWithoutReceiverLeaf = vhtlcScript.refundWithoutReceiver();
     const refundLocktime = pendingSwap.response.lockupDetails.timeouts.refund;
-    let boltzCallCount = 0;
-    let sweptCount = 0;
-    let skippedCount = 0;
-    for (const vtxo of unspentVtxos) {
-      const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
-      const output = {
-        amount: BigInt(vtxo.value),
-        script: outputScript
-      };
-      if (isSubmarineRefundLocktimeReached(refundLocktime)) {
-        const input2 = {
-          ...vtxo,
-          tapLeafScript: refundWithoutReceiverLeaf,
-          tapTree: vhtlcScript.encode()
-        };
-        await this.joinBatch(
-          this.wallet.identity,
-          input2,
-          output,
-          arkInfo,
-          isRecoverableVtxo
-        );
-        sweptCount++;
-        continue;
-      }
-      if (isRecoverableVtxo) {
-        logger.error(
-          `Swap ${pendingSwap.id}: recoverable VTXO ${vtxo.txid}:${vtxo.vout} cannot be refunded yet \u2014 refundWithoutReceiver locktime has not passed (refundLocktime=${refundLocktime}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
-        );
-        skippedCount++;
-        continue;
-      }
-      const input = {
-        ...vtxo,
-        tapLeafScript: vhtlcScript.refund(),
-        tapTree: vhtlcScript.encode()
-      };
-      try {
-        if (boltzCallCount > 0) {
-          await new Promise((r) => setTimeout(r, 2e3));
-        }
-        boltzCallCount++;
-        await refundVHTLCwithOffchainTx(
-          pendingSwap.id,
-          this.wallet.identity,
-          this.arkProvider,
-          boltzXOnlyPublicKey,
-          ourXOnlyPublicKey,
-          serverXOnlyPublicKey,
-          input,
-          output,
-          arkInfo,
-          this.swapProvider.refundChainSwap.bind(this.swapProvider)
-        );
-        sweptCount++;
-      } catch (error) {
-        if (!(error instanceof BoltzRefundError)) {
-          throw error;
-        }
-        if (!isSubmarineRefundLocktimeReached(refundLocktime)) {
-          logger.error(
-            `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentTimestamp=${Math.floor(Date.now() / 1e3)}, locktime=${refundLocktime}). Refund will be retried after locktime.`
-          );
-          skippedCount++;
-          continue;
-        }
-        logger.warn(
-          `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver via joinBatch`
-        );
-        const fallbackInput = {
-          ...vtxo,
-          tapLeafScript: refundWithoutReceiverLeaf,
-          tapTree: vhtlcScript.encode()
-        };
-        await this.joinBatch(this.wallet.identity, fallbackInput, output, arkInfo, false);
-        sweptCount++;
-      }
-    }
+    const refundContext = {
+      arkInfo,
+      vhtlcScript,
+      serverXOnlyPublicKey,
+      refundWithoutReceiverLeaf,
+      outputScript
+    };
+    const { swept: sweptCount, skipped: skippedCount } = await this.refundVtxos({
+      swapId: pendingSwap.id,
+      vtxos: unspentVtxos,
+      refundLocktime,
+      refundContext,
+      boltzXOnlyPublicKey,
+      ourXOnlyPublicKey,
+      refundViaBoltz: this.swapProvider.refundChainSwap.bind(this.swapProvider)
+    });
     const finalStatus = await this.getSwapStatus(pendingSwap.id);
     await this.savePendingChainSwap({
       ...pendingSwap,
@@ -5239,6 +5155,120 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async joinBatch(identity, input, output, arkInfo, isRecoverable2 = true) {
     return joinBatch(this.arkProvider, identity, input, output, arkInfo, isRecoverable2);
   }
+  /**
+   * Settle a `refundWithoutReceiver` (sender + server, no Boltz) refund for a
+   * single VTXO whose CLTV refund locktime has elapsed.
+   *
+   * A live VTXO settles the leaf with an offchain Ark tx — no batch round. A
+   * swept (recoverable) VTXO is no longer a live leaf, so it can only be
+   * reclaimed by re-registering it into a batch.
+   */
+  async settleRefundWithoutReceiver(ctx, vtxo) {
+    const input = {
+      ...vtxo,
+      tapLeafScript: ctx.refundWithoutReceiverLeaf,
+      tapTree: ctx.vhtlcScript.encode()
+    };
+    const output = { amount: BigInt(vtxo.value), script: ctx.outputScript };
+    if ((0, import_sdk8.isRecoverable)(vtxo)) {
+      await this.joinBatch(this.wallet.identity, input, output, ctx.arkInfo, true);
+    } else {
+      await refundWithoutReceiverVHTLCwithOffchainTx(
+        this.wallet.identity,
+        ctx.vhtlcScript,
+        ctx.serverXOnlyPublicKey,
+        input,
+        output,
+        ctx.arkInfo,
+        this.arkProvider
+      );
+    }
+  }
+  /**
+   * Refund every VTXO at a swap's VHTLC address back to the wallet, shared by
+   * {@link ArkadeSwaps.refundVHTLC} (submarine) and {@link ArkadeSwaps.refundArk}
+   * (chain). Path selection per VTXO:
+   * - CLTV elapsed → `refundWithoutReceiver` (offchain for a live VTXO, via a
+   *   batch round for a swept one — see {@link settleRefundWithoutReceiver}).
+   * - Pre-CLTV recoverable → skipped (Boltz can't co-sign a swept-batch refund).
+   * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz, falling
+   *   back to `refundWithoutReceiver` offchain if Boltz rejects after the
+   *   locktime has since elapsed.
+   *
+   * @returns Counts of VTXOs swept vs. deferred.
+   */
+  async refundVtxos(params) {
+    const {
+      swapId,
+      vtxos,
+      refundLocktime,
+      refundContext,
+      boltzXOnlyPublicKey,
+      ourXOnlyPublicKey,
+      refundViaBoltz
+    } = params;
+    const { vhtlcScript, serverXOnlyPublicKey, arkInfo, outputScript } = refundContext;
+    let boltzCallCount = 0;
+    let sweptCount = 0;
+    let skippedCount = 0;
+    for (const vtxo of vtxos) {
+      const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
+      const output = { amount: BigInt(vtxo.value), script: outputScript };
+      if (isSubmarineRefundLocktimeReached(refundLocktime)) {
+        await this.settleRefundWithoutReceiver(refundContext, vtxo);
+        sweptCount++;
+        continue;
+      }
+      if (isRecoverableVtxo) {
+        logger.error(
+          `Swap ${swapId}: recoverable VTXO ${vtxo.txid}:${vtxo.vout} cannot be refunded yet \u2014 refundWithoutReceiver locktime has not passed (refundLocktime=${refundLocktime}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
+        );
+        skippedCount++;
+        continue;
+      }
+      const input = {
+        ...vtxo,
+        tapLeafScript: vhtlcScript.refund(),
+        tapTree: vhtlcScript.encode()
+      };
+      try {
+        if (boltzCallCount > 0) {
+          await new Promise((r) => setTimeout(r, 2e3));
+        }
+        boltzCallCount++;
+        await refundVHTLCwithOffchainTx(
+          swapId,
+          this.wallet.identity,
+          this.arkProvider,
+          boltzXOnlyPublicKey,
+          ourXOnlyPublicKey,
+          serverXOnlyPublicKey,
+          input,
+          output,
+          arkInfo,
+          refundViaBoltz
+        );
+        sweptCount++;
+      } catch (error) {
+        if (!(error instanceof BoltzRefundError)) {
+          throw error;
+        }
+        if (!isSubmarineRefundLocktimeReached(refundLocktime)) {
+          logger.error(
+            `Swap ${swapId}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentTimestamp=${Math.floor(Date.now() / 1e3)}, locktime=${refundLocktime}). Refund will be retried after locktime.`
+          );
+          skippedCount++;
+          continue;
+        }
+        logger.warn(
+          `Swap ${swapId}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver offchain`
+        );
+        await this.settleRefundWithoutReceiver(refundContext, vtxo);
+        sweptCount++;
+      }
+    }
+    return { swept: sweptCount, skipped: skippedCount };
+  }
   /**
    * Creates a VHTLC script for the swap.
    * Works for submarine, reverse, and chain swaps.
@@ -7043,6 +7073,9 @@ var InMemorySwapRepository = class {
     await this.clear();
   }
 };
+
+// src/index.ts
+var sdkVersion = `boltz-swap/${version}`;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArkadeLightningMessageHandler,
@@ -7100,6 +7133,7 @@ var InMemorySwapRepository = class {
   logger,
   migrateToSwapRepository,
   saveSwap,
+  sdkVersion,
   setLogger,
   updateChainSwapStatus,
   updateReverseSwapStatus,

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-C3sUFr5f.cjs';
-export { A as ArkadeSwaps } from './arkade-swaps-C3sUFr5f.cjs';
+import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-DwgfLCMY.cjs';
+export { A as ArkadeSwaps } from './arkade-swaps-DwgfLCMY.cjs';
 import { B as BoltzSwap, D as DecodedInvoice, a as BoltzChainSwap, b as BoltzReverseSwap, c as BoltzSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, O as OptimisticSendLightningPaymentResponse, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, j as ArkToBtcResponse, k as BtcToArkResponse, l as ChainArkRefundOutcome, m as SwapRepository, n as SwapManagerClient, o as SendLightningPaymentResponse, p as GetSwapsFilter } from './types-8NrCdOpS.cjs';
 export { q as ArkadeSwapsCreateConfig, r as BoltzSwapProvider, s as BoltzSwapStatus, I as IncomingPaymentSubscription, P as PendingChainSwap, t as PendingReverseSwap, u as PendingSubmarineSwap, v as PendingSwap, w as SubmarineProgressionStatus, x as SubmarineRecoveryStatus, y as SwapManager, z as SwapManagerCallbacks, E as SwapManagerConfig, H as SwapManagerEvents, V as Vtxo, J as hasSubmarineStatusReached, K as isChainClaimableStatus, M as isChainFailedStatus, Q as isChainFinalStatus, R as isChainPendingStatus, T as isChainRefundableStatus, U as isChainSignableStatus, W as isChainSuccessStatus, X as isChainSwapClaimable, Y as isChainSwapRefundable, Z as isPendingChainSwap, _ as isPendingReverseSwap, $ as isPendingSubmarineSwap, a0 as isReverseClaimableStatus, a1 as isReverseFailedStatus, a2 as isReverseFinalStatus, a3 as isReversePendingStatus, a4 as isReverseSuccessStatus, a5 as isReverseSwapClaimable, a6 as isSubmarineFailedStatus, a7 as isSubmarineFinalStatus, a8 as isSubmarinePendingStatus, a9 as isSubmarineRefundableStatus, aa as isSubmarineSuccessStatus, ab as isSubmarineSwapRefundable } from './types-8NrCdOpS.cjs';
 import { Transaction } from '@scure/btc-signer';
@@ -891,4 +891,10 @@ declare class InMemorySwapRepository implements SwapRepository {
     [Symbol.asyncDispose](): Promise<void>;
 }
 
-export { ArkToBtcResponse, ArkadeSwapsMessageHandler as ArkadeLightningMessageHandler, ArkadeSwapsConfig, ArkadeSwapsMessageHandler, BoltzChainSwap, BoltzRefundError, BoltzReverseSwap, BoltzSubmarineSwap, BoltzSwap, BtcToArkResponse, Chain, ChainFeesResponse, CreateLightningInvoiceRequest, CreateLightningInvoiceResponse, DecodedInvoice, FeesResponse, InMemorySwapRepository, IndexedDbSwapRepository, InsufficientFundsError, InvoiceExpiredError, InvoiceFailedToPayError, LimitsResponse, type Logger, Network, NetworkError, OptimisticSendLightningPaymentResponse, PreimageFetchError, QuoteRejectedError, type QuoteRejectionReason, QuoteSwapOptions, SchemaError, SendLightningPaymentRequest, SendLightningPaymentResponse, ServiceWorkerArkadeSwaps as ServiceWorkerArkadeLightning, ServiceWorkerArkadeSwaps, SubmarineRecoveryInfo, SubmarineRecoveryResult, SubmarineRefundOutcome, SwapError, SwapExpiredError, SwapManagerClient, SwapNotFoundError, SwapRepository, type SwapSaver, TransactionFailedError, decodeInvoice, enrichReverseSwapPreimage, enrichSubmarineSwapInvoice, getInvoicePaymentHash, getInvoiceSatoshis, isValidArkAddress, logger, migrateToSwapRepository, saveSwap, setLogger, updateChainSwapStatus, updateReverseSwapStatus, updateSubmarineSwapStatus, verifySignatures };
+/**
+ * This SDK plugin's own version string, sourced from package.json, and scoped
+ * by plugin name.
+ */
+declare const sdkVersion: string;
+
+export { ArkToBtcResponse, ArkadeSwapsMessageHandler as ArkadeLightningMessageHandler, ArkadeSwapsConfig, ArkadeSwapsMessageHandler, BoltzChainSwap, BoltzRefundError, BoltzReverseSwap, BoltzSubmarineSwap, BoltzSwap, BtcToArkResponse, Chain, ChainFeesResponse, CreateLightningInvoiceRequest, CreateLightningInvoiceResponse, DecodedInvoice, FeesResponse, InMemorySwapRepository, IndexedDbSwapRepository, InsufficientFundsError, InvoiceExpiredError, InvoiceFailedToPayError, LimitsResponse, type Logger, Network, NetworkError, OptimisticSendLightningPaymentResponse, PreimageFetchError, QuoteRejectedError, type QuoteRejectionReason, QuoteSwapOptions, SchemaError, SendLightningPaymentRequest, SendLightningPaymentResponse, ServiceWorkerArkadeSwaps as ServiceWorkerArkadeLightning, ServiceWorkerArkadeSwaps, SubmarineRecoveryInfo, SubmarineRecoveryResult, SubmarineRefundOutcome, SwapError, SwapExpiredError, SwapManagerClient, SwapNotFoundError, SwapRepository, type SwapSaver, TransactionFailedError, decodeInvoice, enrichReverseSwapPreimage, enrichSubmarineSwapInvoice, getInvoicePaymentHash, getInvoiceSatoshis, isValidArkAddress, logger, migrateToSwapRepository, saveSwap, sdkVersion, setLogger, updateChainSwapStatus, updateReverseSwapStatus, updateSubmarineSwapStatus, verifySignatures };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-LvsGHtre.js';
-export { A as ArkadeSwaps } from './arkade-swaps-LvsGHtre.js';
+import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-2q3VSgb4.js';
+export { A as ArkadeSwaps } from './arkade-swaps-2q3VSgb4.js';
 import { B as BoltzSwap, D as DecodedInvoice, a as BoltzChainSwap, b as BoltzReverseSwap, c as BoltzSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, O as OptimisticSendLightningPaymentResponse, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, j as ArkToBtcResponse, k as BtcToArkResponse, l as ChainArkRefundOutcome, m as SwapRepository, n as SwapManagerClient, o as SendLightningPaymentResponse, p as GetSwapsFilter } from './types-8NrCdOpS.js';
 export { q as ArkadeSwapsCreateConfig, r as BoltzSwapProvider, s as BoltzSwapStatus, I as IncomingPaymentSubscription, P as PendingChainSwap, t as PendingReverseSwap, u as PendingSubmarineSwap, v as PendingSwap, w as SubmarineProgressionStatus, x as SubmarineRecoveryStatus, y as SwapManager, z as SwapManagerCallbacks, E as SwapManagerConfig, H as SwapManagerEvents, V as Vtxo, J as hasSubmarineStatusReached, K as isChainClaimableStatus, M as isChainFailedStatus, Q as isChainFinalStatus, R as isChainPendingStatus, T as isChainRefundableStatus, U as isChainSignableStatus, W as isChainSuccessStatus, X as isChainSwapClaimable, Y as isChainSwapRefundable, Z as isPendingChainSwap, _ as isPendingReverseSwap, $ as isPendingSubmarineSwap, a0 as isReverseClaimableStatus, a1 as isReverseFailedStatus, a2 as isReverseFinalStatus, a3 as isReversePendingStatus, a4 as isReverseSuccessStatus, a5 as isReverseSwapClaimable, a6 as isSubmarineFailedStatus, a7 as isSubmarineFinalStatus, a8 as isSubmarinePendingStatus, a9 as isSubmarineRefundableStatus, aa as isSubmarineSuccessStatus, ab as isSubmarineSwapRefundable } from './types-8NrCdOpS.js';
 import { Transaction } from '@scure/btc-signer';
@@ -891,4 +891,10 @@ declare class InMemorySwapRepository implements SwapRepository {
     [Symbol.asyncDispose](): Promise<void>;
 }
 
-export { ArkToBtcResponse, ArkadeSwapsMessageHandler as ArkadeLightningMessageHandler, ArkadeSwapsConfig, ArkadeSwapsMessageHandler, BoltzChainSwap, BoltzRefundError, BoltzReverseSwap, BoltzSubmarineSwap, BoltzSwap, BtcToArkResponse, Chain, ChainFeesResponse, CreateLightningInvoiceRequest, CreateLightningInvoiceResponse, DecodedInvoice, FeesResponse, InMemorySwapRepository, IndexedDbSwapRepository, InsufficientFundsError, InvoiceExpiredError, InvoiceFailedToPayError, LimitsResponse, type Logger, Network, NetworkError, OptimisticSendLightningPaymentResponse, PreimageFetchError, QuoteRejectedError, type QuoteRejectionReason, QuoteSwapOptions, SchemaError, SendLightningPaymentRequest, SendLightningPaymentResponse, ServiceWorkerArkadeSwaps as ServiceWorkerArkadeLightning, ServiceWorkerArkadeSwaps, SubmarineRecoveryInfo, SubmarineRecoveryResult, SubmarineRefundOutcome, SwapError, SwapExpiredError, SwapManagerClient, SwapNotFoundError, SwapRepository, type SwapSaver, TransactionFailedError, decodeInvoice, enrichReverseSwapPreimage, enrichSubmarineSwapInvoice, getInvoicePaymentHash, getInvoiceSatoshis, isValidArkAddress, logger, migrateToSwapRepository, saveSwap, setLogger, updateChainSwapStatus, updateReverseSwapStatus, updateSubmarineSwapStatus, verifySignatures };
+/**
+ * This SDK plugin's own version string, sourced from package.json, and scoped
+ * by plugin name.
+ */
+declare const sdkVersion: string;
+
+export { ArkToBtcResponse, ArkadeSwapsMessageHandler as ArkadeLightningMessageHandler, ArkadeSwapsConfig, ArkadeSwapsMessageHandler, BoltzChainSwap, BoltzRefundError, BoltzReverseSwap, BoltzSubmarineSwap, BoltzSwap, BtcToArkResponse, Chain, ChainFeesResponse, CreateLightningInvoiceRequest, CreateLightningInvoiceResponse, DecodedInvoice, FeesResponse, InMemorySwapRepository, IndexedDbSwapRepository, InsufficientFundsError, InvoiceExpiredError, InvoiceFailedToPayError, LimitsResponse, type Logger, Network, NetworkError, OptimisticSendLightningPaymentResponse, PreimageFetchError, QuoteRejectedError, type QuoteRejectionReason, QuoteSwapOptions, SchemaError, SendLightningPaymentRequest, SendLightningPaymentResponse, ServiceWorkerArkadeSwaps as ServiceWorkerArkadeLightning, ServiceWorkerArkadeSwaps, SubmarineRecoveryInfo, SubmarineRecoveryResult, SubmarineRefundOutcome, SwapError, SwapExpiredError, SwapManagerClient, SwapNotFoundError, SwapRepository, type SwapSaver, TransactionFailedError, decodeInvoice, enrichReverseSwapPreimage, enrichSubmarineSwapInvoice, getInvoicePaymentHash, getInvoiceSatoshis, isValidArkAddress, logger, migrateToSwapRepository, saveSwap, sdkVersion, setLogger, updateChainSwapStatus, updateReverseSwapStatus, updateSubmarineSwapStatus, verifySignatures };

package/dist/index.js

@@ -53,12 +53,15 @@ import {
   updateReverseSwapStatus,
   updateSubmarineSwapStatus,
   verifySignatures
-} from "./chunk-UXYHW7KV.js";
+} from "./chunk-QVXFEX5F.js";
 import {
   applyCreatedAtOrder,
   applySwapsFilter
 } from "./chunk-SJQJQO7P.js";
 
+// package.json
+var version = "0.3.44";
+
 // src/serviceWorker/arkade-swaps-message-handler.ts
 import { RestArkProvider, RestIndexerProvider } from "@arkade-os/sdk";
 function toQuoteTransportError(error) {
@@ -1554,6 +1557,9 @@ var InMemorySwapRepository = class {
     await this.clear();
   }
 };
+
+// src/index.ts
+var sdkVersion = `boltz-swap/${version}`;
 export {
   ArkadeSwapsMessageHandler as ArkadeLightningMessageHandler,
   ArkadeSwaps,
@@ -1610,6 +1616,7 @@ export {
   logger,
   migrateToSwapRepository,
   saveSwap,
+  sdkVersion,
   setLogger,
   updateChainSwapStatus,
   updateReverseSwapStatus,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/boltz-swap",
-  "version": "0.3.42",
+  "version": "0.3.44",
   "type": "module",
   "description": "A production-ready TypeScript package that brings Boltz submarine-swaps to Arkade.",
   "main": "./dist/index.js",
@@ -76,7 +76,7 @@
     "@scure/btc-signer": "2.0.1",
     "bip68": "1.0.4",
     "light-bolt11-decoder": "3.2.0",
-    "@arkade-os/sdk": "0.4.37"
+    "@arkade-os/sdk": "0.4.39"
   },
   "peerDependencies": {
     "expo-task-manager": ">=3.0.0",