@arkade-os/boltz-swap 0.3.15 → 0.3.17

package/dist/{arkade-swaps-DkM_5yuv.d.cts → arkade-swaps-BlK0ASlg.d.cts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { m as BoltzSwapProvider, V as SwapManager, j as SwapRepository, X as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, k as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, h as ArkToBtcResponse, a as BoltzChainSwap, i as BtcToArkResponse, d as Chain, F as FeesResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-C-2sBQWJ.cjs';
+import { m as BoltzSwapProvider, V as SwapManager, j as SwapRepository, X as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, k as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, h as ArkToBtcResponse, a as BoltzChainSwap, i as BtcToArkResponse, d as Chain, F as FeesResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-CKxFfdEH.cjs';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**

package/dist/{arkade-swaps-DRMB_apa.d.ts → arkade-swaps-CM-UQ9-5.d.ts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { m as BoltzSwapProvider, V as SwapManager, j as SwapRepository, X as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, k as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, h as ArkToBtcResponse, a as BoltzChainSwap, i as BtcToArkResponse, d as Chain, F as FeesResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-C-2sBQWJ.js';
+import { m as BoltzSwapProvider, V as SwapManager, j as SwapRepository, X as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, k as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, h as ArkToBtcResponse, a as BoltzChainSwap, i as BtcToArkResponse, d as Chain, F as FeesResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-CKxFfdEH.js';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**

package/dist/{background-646NBLSK.js → background-65LGXZHJ.js}

@@ -2,8 +2,8 @@ import {
   defineExpoSwapBackgroundTask,
   registerExpoSwapBackgroundTask,
   unregisterExpoSwapBackgroundTask
-} from "./chunk-DPGNWPDB.js";
-import "./chunk-Y6GPJDXY.js";
+} from "./chunk-GSCLW33R.js";
+import "./chunk-CS6UXZP6.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   defineExpoSwapBackgroundTask,

package/dist/{chunk-Y6GPJDXY.js → chunk-CS6UXZP6.js}

@@ -86,6 +86,13 @@ var TransactionRefundedError = class extends SwapError {
     this.name = "TransactionRefundedError";
   }
 };
+var BoltzRefundError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "BoltzRefundError";
+  }
+};
 
 // src/boltz-swap-provider.ts
 import { Transaction } from "@arkade-os/sdk";
@@ -366,6 +373,18 @@ var BoltzSwapProvider = class {
       max: response.ARK.BTC.limits.maximal
     };
   }
+  /** Returns the current BTC chain tip height from Boltz. */
+  async getChainHeight() {
+    const response = await this.request(
+      "/v2/chain/heights",
+      "GET"
+    );
+    if (typeof response?.BTC !== "number")
+      throw new SchemaError({
+        message: "error fetching chain heights"
+      });
+    return response.BTC;
+  }
   /** Gets the lockup transaction ID for a reverse swap. */
   async getReverseSwapTxId(id) {
     const res = await this.request(
@@ -446,7 +465,7 @@ var BoltzSwapProvider = class {
       invoiceAmount,
       claimPublicKey,
       preimageHash,
-      ...description?.trim() ? { description: description.trim() } : {},
+      description: description?.trim() || "Send to Arkade address",
       ...this.referralId ? { referralId: this.referralId } : {}
     };
     const response = await this.request(
@@ -2869,10 +2888,22 @@ var refundVHTLCwithOffchainTx = async (swapId, identity, arkProvider, boltzXOnly
       `Expected one checkpoint transaction, got ${checkpointPtxs.length}`
     );
   const unsignedCheckpointTx = checkpointPtxs[0];
-  const {
-    transaction: boltzSignedRefundTx,
-    checkpoint: boltzSignedCheckpointTx
-  } = await refundFunc(swapId, unsignedRefundTx, unsignedCheckpointTx);
+  let boltzSignedRefundTx;
+  let boltzSignedCheckpointTx;
+  try {
+    const result = await refundFunc(
+      swapId,
+      unsignedRefundTx,
+      unsignedCheckpointTx
+    );
+    boltzSignedRefundTx = result.transaction;
+    boltzSignedCheckpointTx = result.checkpoint;
+  } catch (error) {
+    throw new BoltzRefundError(
+      `Boltz rejected refund for swap ${swapId}`,
+      error
+    );
+  }
   const boltzXOnlyPublicKeyHex = hex7.encode(boltzXOnlyPublicKey);
   const refundLeafHash = tapLeafHash3(
     scriptFromTapLeafScript(input.tapLeafScript)
@@ -3213,10 +3244,14 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimVHTLC(pendingSwap) {
     if (!pendingSwap.preimage)
-      throw new Error("Preimage is required to claim VHTLC");
+      throw new Error(
+        `Swap ${pendingSwap.id}: preimage is required to claim VHTLC`
+      );
     const { refundPublicKey, lockupAddress, timeoutBlockHeights } = pendingSwap.response;
     if (!refundPublicKey || !lockupAddress || !timeoutBlockHeights)
-      throw new Error("Incomplete reverse swap response");
+      throw new Error(
+        `Swap ${pendingSwap.id}: incomplete reverse swap response`
+      );
     const preimage = hex8.decode(pendingSwap.preimage);
     const arkInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
@@ -3244,17 +3279,23 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights
     });
     if (!vhtlcScript.claimScript)
-      throw new Error("Failed to create VHTLC script for reverse swap");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to create VHTLC script for reverse swap`
+      );
     if (vhtlcAddress !== lockupAddress)
-      throw new Error("Boltz is trying to scam us");
+      throw new Error(
+        `Swap ${pendingSwap.id}: VHTLC address mismatch. Expected ${lockupAddress}, got ${vhtlcAddress}`
+      );
     const { vtxos } = await this.indexerProvider.getVtxos({
       scripts: [hex8.encode(vhtlcScript.pkScript)]
     });
     if (vtxos.length === 0)
-      throw new Error("No spendable virtual coins found");
+      throw new Error(
+        `Swap ${pendingSwap.id}: no spendable virtual coins found`
+      );
     const vtxo = vtxos[0];
     if (vtxo.isSpent) {
-      throw new Error("VHTLC is already spent");
+      throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
     }
     const input = {
       ...vtxo,
@@ -3387,7 +3428,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async sendLightningPayment(args) {
     const pendingSwap = await this.createSubmarineSwap(args);
     if (!pendingSwap.response.address)
-      throw new Error("Missing address in submarine swap response");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing address in submarine swap response`
+      );
     await this.savePendingSubmarineSwap(pendingSwap);
     const txid = await this.wallet.send({
       address: pendingSwap.response.address,
@@ -3457,7 +3500,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async refundVHTLC(pendingSwap) {
     const preimageHash = pendingSwap.request.invoice ? getInvoicePaymentHash(pendingSwap.request.invoice) : pendingSwap.preimageHash;
     if (!preimageHash)
-      throw new Error("Preimage hash is required to refund VHTLC");
+      throw new Error(
+        `Swap ${pendingSwap.id}: preimage hash is required to refund VHTLC`
+      );
     const arkInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
     if (!address) throw new Error("Failed to get ark address from wallet");
@@ -3473,7 +3518,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
     );
     const { claimPublicKey, timeoutBlockHeights } = pendingSwap.response;
     if (!claimPublicKey || !timeoutBlockHeights)
-      throw new Error("Incomplete submarine swap response");
+      throw new Error(
+        `Swap ${pendingSwap.id}: incomplete submarine swap response`
+      );
     const boltzXOnlyPublicKey = normalizeToXOnlyKey(
       hex8.decode(claimPublicKey),
       "boltz",
@@ -3488,45 +3535,90 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights
     });
     if (!vhtlcScript.claimScript)
-      throw new Error("Failed to create VHTLC script for submarine swap");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to create VHTLC script for submarine swap`
+      );
     if (vhtlcAddress !== pendingSwap.response.address)
       throw new Error(
         `VHTLC address mismatch for swap ${pendingSwap.id}: expected ${pendingSwap.response.address}, got ${vhtlcAddress}`
       );
     const vhtlcPkScriptHex = hex8.encode(vhtlcScript.pkScript);
-    const { vtxos: spendableVtxos } = await this.indexerProvider.getVtxos({
-      scripts: [vhtlcPkScriptHex],
-      spendableOnly: true
-    });
-    if (spendableVtxos.length === 0) {
+    const [spendableResult, recoverableResult] = await Promise.all([
+      this.indexerProvider.getVtxos({
+        scripts: [vhtlcPkScriptHex],
+        spendableOnly: true
+      }),
+      this.indexerProvider.getVtxos({
+        scripts: [vhtlcPkScriptHex],
+        recoverableOnly: true
+      })
+    ]);
+    const refundableVtxos = [
+      ...new Map(
+        [...spendableResult.vtxos, ...recoverableResult.vtxos].map(
+          (vtxo) => [`${vtxo.txid}:${vtxo.vout}`, vtxo]
+        )
+      ).values()
+    ];
+    if (refundableVtxos.length === 0) {
       const { vtxos: allVtxos } = await this.indexerProvider.getVtxos({
         scripts: [vhtlcPkScriptHex]
       });
+      if (allVtxos.length === 0) {
+        throw new Error(
+          `Swap ${pendingSwap.id}: VHTLC not found for address ${pendingSwap.response.address}`
+        );
+      }
+      if (allVtxos.every((vtxo) => vtxo.isSpent)) {
+        throw new Error(
+          `Swap ${pendingSwap.id}: VHTLC is already spent`
+        );
+      }
       throw new Error(
-        allVtxos.length > 0 ? "VHTLC is already spent" : `VHTLC not found for address ${pendingSwap.response.address}`
+        `Swap ${pendingSwap.id}: VHTLC has no refundable VTXOs yet`
       );
     }
     const outputScript = ArkAddress2.decode(address).pkScript;
+    const refundWithoutReceiverLeaf = vhtlcScript.refundWithoutReceiver();
+    const refundLocktime = BigInt(timeoutBlockHeights.refund);
+    const currentBlockHeight = await this.swapProvider.getChainHeight();
+    const cltvSatisfied = BigInt(currentBlockHeight) >= refundLocktime;
     let boltzCallCount = 0;
-    for (const vtxo of spendableVtxos) {
+    let skippedCount = 0;
+    for (const vtxo of refundableVtxos) {
       const isRecoverableVtxo = isRecoverable(vtxo);
-      const input = {
-        ...vtxo,
-        tapLeafScript: isRecoverableVtxo ? vhtlcScript.refundWithoutReceiver() : vhtlcScript.refund(),
-        tapTree: vhtlcScript.encode()
-      };
       const output = {
         amount: BigInt(vtxo.value),
         script: outputScript
       };
-      if (isRecoverableVtxo) {
+      if (cltvSatisfied) {
+        const input2 = {
+          ...vtxo,
+          tapLeafScript: refundWithoutReceiverLeaf,
+          tapTree: vhtlcScript.encode()
+        };
         await this.joinBatch(
           this.wallet.identity,
-          input,
+          input2,
           output,
-          arkInfo
+          arkInfo,
+          isRecoverableVtxo
+        );
+        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=${timeoutBlockHeights.refund}, currentBlockHeight=${currentBlockHeight}). Refund will be retried after locktime.`
         );
-      } else {
+        skippedCount++;
+        continue;
+      }
+      const input = {
+        ...vtxo,
+        tapLeafScript: vhtlcScript.refund(),
+        tapTree: vhtlcScript.encode()
+      };
+      try {
         if (boltzCallCount > 0) {
           await new Promise((r) => setTimeout(r, 2e3));
         }
@@ -3545,14 +3637,42 @@ var ArkadeSwaps = class _ArkadeSwaps {
           )
         );
         boltzCallCount++;
+      } catch (error) {
+        if (!(error instanceof BoltzRefundError)) {
+          throw error;
+        }
+        const tipNow = await this.swapProvider.getChainHeight();
+        if (BigInt(tipNow) < refundLocktime) {
+          logger.error(
+            `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentBlockHeight=${tipNow}, locktime=${timeoutBlockHeights.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
+        );
       }
     }
+    const fullyRefunded = skippedCount === 0;
     await updateSubmarineSwapStatus(
       pendingSwap,
       pendingSwap.status,
       // Keep current status
       this.savePendingSubmarineSwap.bind(this),
-      { refundable: true, refunded: true }
+      { refundable: true, refunded: fullyRefunded }
     );
   }
   /**
@@ -3755,14 +3875,22 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimBtc(pendingSwap) {
     if (!pendingSwap.toAddress)
-      throw new Error("Destination address is required");
+      throw new Error(
+        `Swap ${pendingSwap.id}: destination address is required`
+      );
     if (!pendingSwap.response.claimDetails.swapTree)
-      throw new Error("Missing swap tree in claim details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing swap tree in claim details`
+      );
     if (!pendingSwap.response.claimDetails.serverPublicKey)
-      throw new Error("Missing server public key in claim details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing server public key in claim details`
+      );
     const swapStatus = await this.getSwapStatus(pendingSwap.id);
     if (!swapStatus.transaction?.hex)
-      throw new Error("BTC transaction hex is required");
+      throw new Error(
+        `Swap ${pendingSwap.id}: BTC transaction hex is required`
+      );
     const lockupTx = Transaction6.fromRaw(
       hex8.decode(swapStatus.transaction.hex)
     );
@@ -3817,7 +3945,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       }
     );
     if (!signedTxData.pubNonce || !signedTxData.partialSignature)
-      throw new Error("Invalid signature data from server");
+      throw new Error(
+        `Swap ${pendingSwap.id}: invalid signature data from server`
+      );
     const musigSession = musigMessage.aggregateNonces([
       [
         hex8.decode(
@@ -3842,9 +3972,13 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async refundArk(pendingSwap) {
     if (!pendingSwap.response.lockupDetails.serverPublicKey)
-      throw new Error("Missing server public key in lockup details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing server public key in lockup details`
+      );
     if (!pendingSwap.response.lockupDetails.timeouts)
-      throw new Error("Missing timeouts in lockup details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing timeouts in lockup details`
+      );
     const arkInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
     const ourXOnlyPublicKey = normalizeToXOnlyKey(
@@ -3870,12 +4004,12 @@ var ArkadeSwaps = class _ArkadeSwaps {
     });
     if (vtxos.length === 0) {
       throw new Error(
-        `VHTLC not found for address ${pendingSwap.response.lockupDetails.lockupAddress}`
+        `Swap ${pendingSwap.id}: VHTLC not found for address ${pendingSwap.response.lockupDetails.lockupAddress}`
       );
     }
     const vtxo = vtxos[0];
     if (vtxo.isSpent) {
-      throw new Error("VHTLC is already spent");
+      throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
     }
     const { vhtlcAddress, vhtlcScript } = this.createVHTLCScript({
       network: arkInfo.network,
@@ -3886,7 +4020,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights: pendingSwap.response.lockupDetails.timeouts
     });
     if (!vhtlcScript.refundScript)
-      throw new Error("Failed to create VHTLC script for chain swap");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`
+      );
     if (pendingSwap.response.lockupDetails.lockupAddress !== vhtlcAddress) {
       throw new SwapError({
         message: "Unable to claim: invalid VHTLC address"
@@ -4060,11 +4196,17 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimArk(pendingSwap) {
     if (!pendingSwap.toAddress)
-      throw new Error("Destination address is required");
+      throw new Error(
+        `Swap ${pendingSwap.id}: destination address is required`
+      );
     if (!pendingSwap.response.claimDetails.serverPublicKey)
-      throw new Error("Missing server public key in claim details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing server public key in claim details`
+      );
     if (!pendingSwap.response.claimDetails.timeouts)
-      throw new Error("Missing timeouts in claim details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing timeouts in claim details`
+      );
     const arkInfo = await this.arkProvider.getInfo();
     const preimage = hex8.decode(pendingSwap.preimage);
     const address = await this.wallet.getAddress();
@@ -4089,7 +4231,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights: pendingSwap.response.claimDetails.timeouts
     });
     if (!vhtlcScript.claimScript)
-      throw new Error("Failed to create VHTLC script for chain swap");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`
+      );
     if (pendingSwap.response.claimDetails.lockupAddress !== vhtlcAddress) {
       throw new SwapError({
         message: "Unable to claim: invalid VHTLC address"
@@ -4100,7 +4244,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       spendableOnly: true
     });
     if (spendableVtxos.vtxos.length === 0)
-      throw new Error("No spendable virtual coins found");
+      throw new Error(
+        `Swap ${pendingSwap.id}: no spendable virtual coins found`
+      );
     const vtxo = spendableVtxos.vtxos[0];
     const input = {
       ...vtxo,
@@ -4140,16 +4286,20 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async signCooperativeClaimForServer(pendingSwap) {
     if (!pendingSwap.response.lockupDetails.swapTree)
-      throw new Error("Missing swap tree in lockup details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing swap tree in lockup details`
+      );
     if (!pendingSwap.response.lockupDetails.serverPublicKey)
-      throw new Error("Missing server public key in lockup details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing server public key in lockup details`
+      );
     const claimDetails = await this.swapProvider.getChainClaimDetails(
       pendingSwap.id
     );
     const serverPubKey = pendingSwap.response.lockupDetails.serverPublicKey;
     if (claimDetails.publicKey !== serverPubKey) {
       throw new Error(
-        `Server public key mismatch: claim response has ${claimDetails.publicKey}, expected ${serverPubKey}`
+        `Swap ${pendingSwap.id}: server public key mismatch \u2014 claim response has ${claimDetails.publicKey}, expected ${serverPubKey}`
       );
     }
     const musig = tweakMusig(
@@ -4269,15 +4419,23 @@ var ArkadeSwaps = class _ArkadeSwaps {
     const { to, from, swap, arkInfo } = args;
     if (from === "ARK") {
       if (!swap.response.lockupDetails.serverPublicKey)
-        throw new Error("Missing serverPublicKey in lockup details");
+        throw new Error(
+          `Swap ${swap.id}: missing serverPublicKey in lockup details`
+        );
       if (!swap.response.lockupDetails.timeouts)
-        throw new Error("Missing timeouts in lockup details");
+        throw new Error(
+          `Swap ${swap.id}: missing timeouts in lockup details`
+        );
     }
     if (to === "ARK") {
       if (!swap.response.claimDetails.serverPublicKey)
-        throw new Error("Missing serverPublicKey in claim details");
+        throw new Error(
+          `Swap ${swap.id}: missing serverPublicKey in claim details`
+        );
       if (!swap.response.claimDetails.timeouts)
-        throw new Error("Missing timeouts in claim details");
+        throw new Error(
+          `Swap ${swap.id}: missing timeouts in claim details`
+        );
     }
     const lockupAddress = to === "ARK" ? swap.response.claimDetails.lockupAddress : swap.response.lockupDetails.lockupAddress;
     const receiverPubkey = to === "ARK" ? swap.request.claimPublicKey : swap.response.lockupDetails.serverPublicKey;
@@ -4643,6 +4801,7 @@ export {
   SwapExpiredError,
   TransactionFailedError,
   PreimageFetchError,
+  BoltzRefundError,
   isSubmarineFailedStatus,
   isSubmarineFinalStatus,
   isSubmarinePendingStatus,

package/dist/{chunk-DPGNWPDB.js → chunk-GSCLW33R.js}

@@ -8,7 +8,7 @@ import {
   isSubmarineFinalStatus,
   isSubmarineSwapRefundable,
   logger
-} from "./chunk-Y6GPJDXY.js";
+} from "./chunk-CS6UXZP6.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";