@arkade-os/boltz-swap 0.3.29 → 0.3.31

package/README.md

@@ -260,6 +260,21 @@ Custom implementations must set `readonly version = 1` — TypeScript will error
 
 Expo/React Native cannot run a long-lived Service Worker, and background work is executed by the OS for a short window (typically every ~15+ minutes). To enable best-effort background claim/refund for swaps, use `ExpoArkadeLightning` plus a background task defined at global scope.
 
+> [!WARNING]
+> **Change since 0.3.30** — fix for [#136](https://github.com/arkade-os/boltz-swap/issues/136).
+>
+> Background task helpers moved from `@arkade-os/boltz-swap/expo` to
+> `@arkade-os/boltz-swap/expo/background`. OS-level registration is no
+> longer performed by `ExpoArkadeSwaps.setup()` — call it explicitly.
+>
+> | Before | After |
+> | --- | --- |
+> | `import { defineExpoSwapBackgroundTask } from "@arkade-os/boltz-swap/expo"` | `import { defineExpoSwapBackgroundTask } from "@arkade-os/boltz-swap/expo/background"` |
+> | `background: { taskName, taskQueue, minimumBackgroundInterval, foregroundIntervalMs }` | `background: { taskQueue, foregroundIntervalMs }` + explicit `await registerExpoSwapBackgroundTask(taskName, { minimumInterval })` |
+> | `dispose()` unregistered the OS task | Call `unregisterExpoSwapBackgroundTask(taskName)` yourself |
+>
+> TypeScript callers get a compile error on the removed fields. **JS callers must update manually** — the old fields are silently ignored and the OS task will never run.
+
 ### Prerequisites
 
 - Install Expo background task dependencies:
@@ -298,7 +313,7 @@ import * as SecureStore from "expo-secure-store";
 import { SingleKey } from "@arkade-os/sdk";
 import { AsyncStorageTaskQueue } from "@arkade-os/sdk/worker/expo";
 import { IndexedDbSwapRepository } from "@arkade-os/boltz-swap";
-import { defineExpoSwapBackgroundTask } from "@arkade-os/boltz-swap/expo";
+import { defineExpoSwapBackgroundTask } from "@arkade-os/boltz-swap/expo/background";
 
 const swapTaskQueue = new AsyncStorageTaskQueue(AsyncStorage, "ark:swap-queue");
 const swapRepository = new IndexedDbSwapRepository();
@@ -324,6 +339,7 @@ import { ExpoWallet } from "@arkade-os/sdk/wallet/expo";
 import { AsyncStorageTaskQueue } from "@arkade-os/sdk/worker/expo";
 import { BoltzSwapProvider } from "@arkade-os/boltz-swap";
 import { ExpoArkadeLightning } from "@arkade-os/boltz-swap/expo";
+import { registerExpoSwapBackgroundTask } from "@arkade-os/boltz-swap/expo/background";
 
 // Used by ExpoWallet's background task (defined via @arkade-os/sdk/wallet/expo)
 const walletTaskQueue = new AsyncStorageTaskQueue(AsyncStorage, "ark:wallet-queue");
@@ -350,16 +366,31 @@ const arkLn = await ExpoArkadeLightning.setup({
   swapProvider,
   swapRepository, // must match the one used in defineExpoSwapBackgroundTask
   background: {
-    taskName: "ark-swap-poll",
     taskQueue: swapTaskQueue, // must match the one used in defineExpoSwapBackgroundTask
     foregroundIntervalMs: 20_000,
-    minimumBackgroundInterval: 15,
   },
 });
 
+// Activate the OS scheduler (Expo Android/iOS only).
+// Must use the same task name passed to defineExpoSwapBackgroundTask above.
+await registerExpoSwapBackgroundTask("ark-swap-poll", { minimumInterval: 15 });
+
 await arkLn.createLightningInvoice({ amount: 1000 });
+
+// On logout / wallet reset / app teardown:
+import { unregisterExpoSwapBackgroundTask } from "@arkade-os/boltz-swap/expo/background";
+await arkLn.dispose();
+await unregisterExpoSwapBackgroundTask("ark-swap-poll");
 ```
 
+> [!IMPORTANT]
+> The OS-task helpers (`defineExpoSwapBackgroundTask`,
+> `registerExpoSwapBackgroundTask`, `unregisterExpoSwapBackgroundTask`)
+> live under `@arkade-os/boltz-swap/expo/background`. That subpath is
+> the **only** module that imports `expo-task-manager` /
+> `expo-background-task`; keeping it isolated lets react-native-web and
+> Node consumers use `/expo` without those native packages.
+
 ### Error Handling
 
 With SwapManager, refunds are automatic — listen to `onSwapFailed` for notifications. Without it, handle errors manually:

package/dist/{chunk-LWUXSE5N.js → chunk-B3Q4TFWT.js}

@@ -335,7 +335,7 @@ var BoltzSwapProvider = class {
   /** @param config Provider configuration with network and optional API URL. */
   constructor(config) {
     this.network = config.network;
-    this.referralId = config.referralId;
+    this.referralId = config.referralId ?? "arkade-ts-sdk";
     const apiUrl = config.apiUrl || BASE_URLS[config.network];
     if (!apiUrl)
       throw new Error(

package/dist/chunk-NHBWNN6H.js

@@ -0,0 +1,117 @@
+import {
+  ArkadeSwaps,
+  isPendingReverseSwap,
+  isPendingSubmarineSwap,
+  isReverseClaimableStatus,
+  isReverseFinalStatus,
+  isSubmarineFinalStatus,
+  isSubmarineSwapRefundable,
+  logger
+} from "./chunk-B3Q4TFWT.js";
+
+// src/expo/swapsPollProcessor.ts
+var SWAP_POLL_TASK_TYPE = "swap-poll";
+var swapsPollProcessor = {
+  taskType: SWAP_POLL_TASK_TYPE,
+  async execute(item, deps) {
+    const {
+      swapRepository,
+      swapProvider,
+      wallet,
+      arkProvider,
+      indexerProvider
+    } = deps;
+    const allSwaps = await swapRepository.getAllSwaps();
+    const pendingSwaps = allSwaps.filter((swap) => {
+      if (isPendingReverseSwap(swap))
+        return !isReverseFinalStatus(swap.status);
+      if (isPendingSubmarineSwap(swap))
+        return !isSubmarineFinalStatus(swap.status);
+      return false;
+    });
+    let polled = 0;
+    let updated = 0;
+    let claimed = 0;
+    let refunded = 0;
+    let errors = 0;
+    const tempSwaps = new ArkadeSwaps({
+      wallet,
+      arkProvider,
+      indexerProvider,
+      swapProvider,
+      swapManager: false,
+      swapRepository
+    });
+    try {
+      for (const swap of pendingSwaps) {
+        try {
+          const { status: currentStatus } = await swapProvider.getSwapStatus(swap.id);
+          polled++;
+          if (currentStatus !== swap.status) {
+            await swapRepository.saveSwap({
+              ...swap,
+              status: currentStatus
+            });
+            updated++;
+          }
+          if (isPendingReverseSwap(swap) && isReverseClaimableStatus(currentStatus)) {
+            if (!swap.preimage) {
+              logger.warn(
+                `[swap-poll] Skipping claim for ${swap.id}: no preimage`
+              );
+              continue;
+            }
+            try {
+              await tempSwaps.claimVHTLC(swap);
+              claimed++;
+            } catch (claimError) {
+              logger.error(
+                `[swap-poll] Claim failed for ${swap.id}:`,
+                claimError
+              );
+              errors++;
+            }
+          }
+          const swapWithStatus = isPendingSubmarineSwap(swap) ? { ...swap, status: currentStatus } : null;
+          if (isPendingSubmarineSwap(swap) && isSubmarineSwapRefundable(swapWithStatus)) {
+            if (!swap.request.invoice && !swap.preimageHash) {
+              logger.warn(
+                `[swap-poll] Skipping refund for ${swap.id}: no invoice or preimageHash`
+              );
+              continue;
+            }
+            try {
+              await tempSwaps.refundVHTLC(swapWithStatus);
+              refunded++;
+            } catch (refundError) {
+              logger.error(
+                `[swap-poll] Refund failed for ${swap.id}:`,
+                refundError
+              );
+              errors++;
+            }
+          }
+        } catch (swapError) {
+          logger.error(
+            `[swap-poll] Error processing swap ${swap.id}:`,
+            swapError
+          );
+          errors++;
+        }
+      }
+    } finally {
+      await tempSwaps.dispose();
+    }
+    return {
+      taskItemId: item.id,
+      type: SWAP_POLL_TASK_TYPE,
+      status: errors > 0 && polled === 0 ? "failed" : "success",
+      data: { polled, updated, claimed, refunded, errors }
+    };
+  }
+};
+
+export {
+  SWAP_POLL_TASK_TYPE,
+  swapsPollProcessor
+};