@arkade-os/boltz-swap 0.3.15 → 0.3.17

package/dist/expo/index.cjs

@@ -31,7 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/errors.ts
-var SwapError, InvoiceExpiredError, InvoiceFailedToPayError, NetworkError, SchemaError, SwapExpiredError, TransactionFailedError, TransactionLockupFailedError, TransactionRefundedError;
+var SwapError, InvoiceExpiredError, InvoiceFailedToPayError, NetworkError, SchemaError, SwapExpiredError, TransactionFailedError, TransactionLockupFailedError, TransactionRefundedError, BoltzRefundError;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
@@ -107,6 +107,13 @@ var init_errors = __esm({
         this.name = "TransactionRefundedError";
       }
     };
+    BoltzRefundError = class extends Error {
+      constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "BoltzRefundError";
+      }
+    };
   }
 });
 
@@ -330,6 +337,18 @@ var init_boltz_swap_provider = __esm({
           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(
@@ -410,7 +429,7 @@ var init_boltz_swap_provider = __esm({
           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(
@@ -2659,6 +2678,7 @@ var init_vhtlc = __esm({
     "use strict";
     import_sdk7 = require("@arkade-os/sdk");
     init_logger();
+    init_errors();
     import_base8 = require("@scure/base");
     init_batch();
     import_legacy = require("@noble/hashes/legacy.js");
@@ -2851,10 +2871,22 @@ var init_vhtlc = __esm({
           `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 = import_base8.hex.encode(boltzXOnlyPublicKey);
       const refundLeafHash = (0, import_payment3.tapLeafHash)(
         scriptFromTapLeafScript(input.tapLeafScript)
@@ -3218,10 +3250,14 @@ var init_arkade_swaps = __esm({
        */
       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 = import_base9.hex.decode(pendingSwap.preimage);
         const arkInfo = await this.arkProvider.getInfo();
         const address = await this.wallet.getAddress();
@@ -3249,17 +3285,23 @@ var init_arkade_swaps = __esm({
           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: [import_base9.hex.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,
@@ -3392,7 +3434,9 @@ var init_arkade_swaps = __esm({
       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,
@@ -3462,7 +3506,9 @@ var init_arkade_swaps = __esm({
       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");
@@ -3478,7 +3524,9 @@ var init_arkade_swaps = __esm({
         );
         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(
           import_base9.hex.decode(claimPublicKey),
           "boltz",
@@ -3493,45 +3541,90 @@ var init_arkade_swaps = __esm({
           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 = import_base9.hex.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 = import_sdk8.ArkAddress.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 = (0, import_sdk8.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));
             }
@@ -3550,14 +3643,42 @@ var init_arkade_swaps = __esm({
               )
             );
             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 }
         );
       }
       /**
@@ -3760,14 +3881,22 @@ var init_arkade_swaps = __esm({
        */
       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 = import_btc_signer5.Transaction.fromRaw(
           import_base9.hex.decode(swapStatus.transaction.hex)
         );
@@ -3822,7 +3951,9 @@ var init_arkade_swaps = __esm({
           }
         );
         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([
           [
             import_base9.hex.decode(
@@ -3847,9 +3978,13 @@ var init_arkade_swaps = __esm({
        */
       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(
@@ -3875,12 +4010,12 @@ var init_arkade_swaps = __esm({
         });
         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,
@@ -3891,7 +4026,9 @@ var init_arkade_swaps = __esm({
           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"
@@ -4065,11 +4202,17 @@ var init_arkade_swaps = __esm({
        */
       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 = import_base9.hex.decode(pendingSwap.preimage);
         const address = await this.wallet.getAddress();
@@ -4094,7 +4237,9 @@ var init_arkade_swaps = __esm({
           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"
@@ -4105,7 +4250,9 @@ var init_arkade_swaps = __esm({
           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,
@@ -4145,16 +4292,20 @@ var init_arkade_swaps = __esm({
        */
       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(
@@ -4274,15 +4425,23 @@ var init_arkade_swaps = __esm({
         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;

package/dist/expo/index.d.cts

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

package/dist/expo/index.d.ts

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

package/dist/expo/index.js

@@ -4,10 +4,10 @@ import {
   registerExpoSwapBackgroundTask,
   swapsPollProcessor,
   unregisterExpoSwapBackgroundTask
-} from "../chunk-DPGNWPDB.js";
+} from "../chunk-GSCLW33R.js";
 import {
   ArkadeSwaps
-} from "../chunk-Y6GPJDXY.js";
+} from "../chunk-CS6UXZP6.js";
 import "../chunk-3RG5ZIWI.js";
 
 // src/expo/arkade-lightning.ts
@@ -56,7 +56,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     await instance.seedSwapPollTask();
     if (config.background.minimumBackgroundInterval) {
       try {
-        const { registerExpoSwapBackgroundTask: registerExpoSwapBackgroundTask2 } = await import("../background-646NBLSK.js");
+        const { registerExpoSwapBackgroundTask: registerExpoSwapBackgroundTask2 } = await import("../background-65LGXZHJ.js");
         await registerExpoSwapBackgroundTask2(
           config.background.taskName,
           {
@@ -129,7 +129,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     }
     await this.inner.dispose();
     try {
-      const { unregisterExpoSwapBackgroundTask: unregisterExpoSwapBackgroundTask2 } = await import("../background-646NBLSK.js");
+      const { unregisterExpoSwapBackgroundTask: unregisterExpoSwapBackgroundTask2 } = await import("../background-65LGXZHJ.js");
       await unregisterExpoSwapBackgroundTask2(this.taskName);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);