@arkade-os/boltz-swap 0.3.29 → 0.3.31

package/dist/expo/background.d.cts

@@ -0,0 +1,61 @@
+import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-BF3uTFae.cjs';
+export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-BF3uTFae.cjs';
+import '@arkade-os/sdk/worker/expo';
+import '@arkade-os/sdk';
+import '../types-BBI7-KJ0.cjs';
+
+/**
+ * Define the Expo background task handler for swap polling.
+ *
+ * **Must be called at module/global scope** (before React mounts) so
+ * Expo's TaskManager can resume the task on cold start.
+ *
+ * Pair with {@link registerExpoSwapBackgroundTask} to activate the OS
+ * scheduler — `ExpoArkadeSwaps.setup()` no longer registers the task
+ * for you.
+ *
+ * @example
+ * ```ts
+ * // App entry (e.g. _layout.tsx) — module scope
+ * import { defineExpoSwapBackgroundTask } from "@arkade-os/boltz-swap/expo/background";
+ * import { AsyncStorageTaskQueue } from "@arkade-os/sdk/worker/expo";
+ * import AsyncStorage from "@react-native-async-storage/async-storage";
+ *
+ * const taskQueue = new AsyncStorageTaskQueue(AsyncStorage, "ark:swap-queue");
+ * defineExpoSwapBackgroundTask("ark-swap-poll", {
+ *     taskQueue,
+ *     swapRepository,
+ *     identityFactory: async () => {
+ *         const key = await SecureStore.getItemAsync("ark-private-key");
+ *         return SingleKey.fromHex(key!);
+ *     },
+ * });
+ * ```
+ */
+declare function defineExpoSwapBackgroundTask(taskName: string, options: DefineSwapBackgroundTaskOptions): void;
+/**
+ * Activate the OS-level background task scheduler.
+ *
+ * Call once after {@link defineExpoSwapBackgroundTask} — typically right
+ * after `ExpoArkadeSwaps.setup()`. Safe to call again to update the
+ * interval.
+ *
+ * @param taskName - The task name passed to {@link defineExpoSwapBackgroundTask}.
+ * @param options.minimumInterval - Minimum interval in **minutes** (default
+ *   15, the floor enforced by `expo-background-task`).
+ *
+ * @see https://docs.expo.dev/versions/latest/sdk/background-task/#backgroundtaskoptions
+ */
+declare function registerExpoSwapBackgroundTask(taskName: string, options?: {
+    minimumInterval?: number;
+}): Promise<void>;
+/**
+ * Unregister the swap background task from the OS scheduler.
+ *
+ * `ExpoArkadeSwaps.dispose()` does **not** call this — the OS-level
+ * task lifecycle is the consumer's responsibility, matching the explicit
+ * `register` step.
+ */
+declare function unregisterExpoSwapBackgroundTask(taskName: string): Promise<void>;
+
+export { DefineSwapBackgroundTaskOptions, defineExpoSwapBackgroundTask, registerExpoSwapBackgroundTask, unregisterExpoSwapBackgroundTask };

package/dist/expo/background.d.ts

@@ -0,0 +1,61 @@
+import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-wYOMzldd.js';
+export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-wYOMzldd.js';
+import '@arkade-os/sdk/worker/expo';
+import '@arkade-os/sdk';
+import '../types-BBI7-KJ0.js';
+
+/**
+ * Define the Expo background task handler for swap polling.
+ *
+ * **Must be called at module/global scope** (before React mounts) so
+ * Expo's TaskManager can resume the task on cold start.
+ *
+ * Pair with {@link registerExpoSwapBackgroundTask} to activate the OS
+ * scheduler — `ExpoArkadeSwaps.setup()` no longer registers the task
+ * for you.
+ *
+ * @example
+ * ```ts
+ * // App entry (e.g. _layout.tsx) — module scope
+ * import { defineExpoSwapBackgroundTask } from "@arkade-os/boltz-swap/expo/background";
+ * import { AsyncStorageTaskQueue } from "@arkade-os/sdk/worker/expo";
+ * import AsyncStorage from "@react-native-async-storage/async-storage";
+ *
+ * const taskQueue = new AsyncStorageTaskQueue(AsyncStorage, "ark:swap-queue");
+ * defineExpoSwapBackgroundTask("ark-swap-poll", {
+ *     taskQueue,
+ *     swapRepository,
+ *     identityFactory: async () => {
+ *         const key = await SecureStore.getItemAsync("ark-private-key");
+ *         return SingleKey.fromHex(key!);
+ *     },
+ * });
+ * ```
+ */
+declare function defineExpoSwapBackgroundTask(taskName: string, options: DefineSwapBackgroundTaskOptions): void;
+/**
+ * Activate the OS-level background task scheduler.
+ *
+ * Call once after {@link defineExpoSwapBackgroundTask} — typically right
+ * after `ExpoArkadeSwaps.setup()`. Safe to call again to update the
+ * interval.
+ *
+ * @param taskName - The task name passed to {@link defineExpoSwapBackgroundTask}.
+ * @param options.minimumInterval - Minimum interval in **minutes** (default
+ *   15, the floor enforced by `expo-background-task`).
+ *
+ * @see https://docs.expo.dev/versions/latest/sdk/background-task/#backgroundtaskoptions
+ */
+declare function registerExpoSwapBackgroundTask(taskName: string, options?: {
+    minimumInterval?: number;
+}): Promise<void>;
+/**
+ * Unregister the swap background task from the OS scheduler.
+ *
+ * `ExpoArkadeSwaps.dispose()` does **not** call this — the OS-level
+ * task lifecycle is the consumer's responsibility, matching the explicit
+ * `register` step.
+ */
+declare function unregisterExpoSwapBackgroundTask(taskName: string): Promise<void>;
+
+export { DefineSwapBackgroundTaskOptions, defineExpoSwapBackgroundTask, registerExpoSwapBackgroundTask, unregisterExpoSwapBackgroundTask };

package/dist/expo/background.js

@@ -0,0 +1,127 @@
+import {
+  SWAP_POLL_TASK_TYPE,
+  swapsPollProcessor
+} from "../chunk-NHBWNN6H.js";
+import {
+  BoltzSwapProvider
+} from "../chunk-B3Q4TFWT.js";
+
+// src/expo/background.ts
+import * as TaskManager from "expo-task-manager";
+import * as BackgroundTask from "expo-background-task";
+import { runTasks } from "@arkade-os/sdk/worker/expo";
+import {
+  ExpoArkProvider,
+  ExpoIndexerProvider
+} from "@arkade-os/sdk/adapters/expo";
+function getRandomId() {
+  return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+function createBackgroundWalletShim(args) {
+  const notImplemented = (method) => {
+    throw new Error(
+      `[boltz-swap] Background wallet shim: "${String(method)}" is not implemented`
+    );
+  };
+  return {
+    identity: args.identity,
+    getAddress: args.getAddress,
+    getBoardingAddress: async () => notImplemented("getBoardingAddress"),
+    getBalance: async () => notImplemented("getBalance"),
+    getVtxos: async () => notImplemented("getVtxos"),
+    getBoardingUtxos: async () => notImplemented("getBoardingUtxos"),
+    getTransactionHistory: async () => notImplemented("getTransactionHistory"),
+    getContractManager: async () => notImplemented("getContractManager"),
+    getDelegatorManager: async () => notImplemented("getDelegatorManager"),
+    sendBitcoin: async () => notImplemented("sendBitcoin"),
+    send: async () => notImplemented("send"),
+    settle: async () => notImplemented("settle"),
+    assetManager: new Proxy({}, {
+      get: () => notImplemented("assetManager")
+    })
+  };
+}
+function defineExpoSwapBackgroundTask(taskName, options) {
+  const { taskQueue, swapRepository, identityFactory } = options;
+  TaskManager.defineTask(taskName, async () => {
+    try {
+      const config = await taskQueue.loadConfig();
+      if (!config) {
+        return BackgroundTask.BackgroundTaskResult.Success;
+      }
+      const identity = await identityFactory();
+      const arkProvider = new ExpoArkProvider(config.arkServerUrl);
+      const indexerProvider = new ExpoIndexerProvider(
+        config.arkServerUrl
+      );
+      const swapProvider = new BoltzSwapProvider({
+        network: config.network,
+        apiUrl: config.boltzApiUrl
+      });
+      const wallet = createBackgroundWalletShim({
+        identity,
+        getAddress: async () => {
+          const { ArkAddress } = await import("@arkade-os/sdk");
+          const { hex } = await import("@scure/base");
+          const info = await arkProvider.getInfo();
+          const pubkey = await identity.xOnlyPublicKey();
+          const serverPubKey = hex.decode(info.signerPubkey);
+          const xOnlyServerPubKey = serverPubKey.length === 33 ? serverPubKey.slice(1) : serverPubKey;
+          const hrp = info.network === "bitcoin" ? "ark" : "tark";
+          return new ArkAddress(
+            xOnlyServerPubKey,
+            pubkey,
+            hrp
+          ).encode();
+        }
+      });
+      const deps = {
+        swapRepository,
+        swapProvider,
+        arkProvider,
+        indexerProvider,
+        identity,
+        wallet
+      };
+      await runTasks(taskQueue, [swapsPollProcessor], deps);
+      const results = await taskQueue.getResults();
+      if (results.length > 0) {
+        await taskQueue.acknowledgeResults(
+          results.map((r) => r.id)
+        );
+      }
+      const existing = await taskQueue.getTasks(SWAP_POLL_TASK_TYPE);
+      if (existing.length === 0) {
+        const task = {
+          id: getRandomId(),
+          type: SWAP_POLL_TASK_TYPE,
+          data: {},
+          createdAt: Date.now()
+        };
+        await taskQueue.addTask(task);
+      }
+      return BackgroundTask.BackgroundTaskResult.Success;
+    } catch (error) {
+      console.error(
+        "[boltz-swap] Background task failed:",
+        error instanceof Error ? error.message : error
+      );
+      return BackgroundTask.BackgroundTaskResult.Failed;
+    }
+  });
+}
+async function registerExpoSwapBackgroundTask(taskName, options) {
+  await BackgroundTask.registerTaskAsync(taskName, {
+    minimumInterval: options?.minimumInterval ?? 15
+  });
+}
+async function unregisterExpoSwapBackgroundTask(taskName) {
+  await BackgroundTask.unregisterTaskAsync(taskName);
+}
+export {
+  SWAP_POLL_TASK_TYPE,
+  defineExpoSwapBackgroundTask,
+  registerExpoSwapBackgroundTask,
+  swapsPollProcessor,
+  unregisterExpoSwapBackgroundTask
+};