refactor: update @arkade-os/boltz-swap to version 0.3.8 and adjust related code

Author: tiero

cli/package.json

@@ -18,7 +18,7 @@
     "dev": "tsx src/index.ts"
   },
   "dependencies": {
-    "@arkade-os/boltz-swap": "^0.2.18",
+    "@arkade-os/boltz-swap": "^0.3.8",
     "@arkade-os/sdk": "^0.4.10",
     "@lendasat/lendaswap-sdk-pure": "^0.0.2",
     "@noble/hashes": "^2.0.1",

cli/src/context.ts

@@ -13,6 +13,7 @@ import {
   SqliteWalletStorage,
   SqliteSwapStorage,
 } from "@lendasat/lendaswap-sdk-pure/node";
+import { SQLiteSwapRepository } from "@arkade-os/boltz-swap/repositories/sqlite";
 import {
   ArkadeBitcoinSkill,
   ArkadeLightningSkill,
@@ -72,6 +73,7 @@ export async function createContext(config: CashConfig, opts?: CreateContextOpts
     wallet,
     network: config.network as NetworkName,
     enableSwapManager: opts?.enableSwapManager,
+    swapRepository: new SQLiteSwapRepository(executor),
   });
 
   // Persistent SQLite storage for LendaSwap

cli/src/daemon.ts

@@ -60,12 +60,13 @@ export async function startDaemonInBackground(port: number): Promise<{ pid: numb
 
   const logFd = openSync(LOG_FILE, "a");
 
-  // Use the same node binary and entrypoint that's currently running
-  // This works both in dev (tsx cli/src/index.ts) and production (node dist/index.js)
+  // Reproduce the exact node invocation that's currently running.
+  // process.execArgv carries tsx loader flags in dev (e.g. --import tsx/esm)
+  // and is empty in production (node dist/index.js).
   const nodeBin = process.execPath;
   const entrypoint = process.argv[1];
 
-  const child = spawn(nodeBin, [entrypoint, "--daemon-internal", "--port", String(port)], {
+  const child = spawn(nodeBin, [...process.execArgv, entrypoint, "--daemon-internal", "--port", String(port)], {
     cwd: process.cwd(),
     env: { ...process.env },
     detached: true,

cli/src/index.ts

@@ -304,18 +304,32 @@ async function runDaemon() {
   const authMonitor = new AuthMonitor();
   const server = createDaemonServer({ port, ctx, monitor, authMonitor, webhookRegistry });
 
-  // Start Lightning SwapManager
-  await ctx.lightning.startSwapManager();
-  console.error("[daemon] lightning swap manager started");
+  // Start HTTP server first — so the parent's /health poll succeeds immediately
+  // (startSwapManager and getDelegatorManager are awaited below in the background)
+  server.listen(port, "127.0.0.1", () => {
+    saveDaemonPid(process.pid, port);
+    console.error(`[daemon] listening on http://127.0.0.1:${port}`);
+  });
 
   // Start LendaSwap poller
   monitor.start();
   console.error("[daemon] lendaswap monitor started");
 
-  // Recover swept VTXOs on startup
-  const wallet = ctx.bitcoin.getWallet();
-  const vtxoManager = new VtxoManager(wallet);
+  let stopVtxoDelegate: (() => void) | undefined;
+
+  // Background init: Lightning swap manager + VTXO recovery + auto-delegation
   void (async () => {
+    // Start Lightning SwapManager
+    try {
+      await ctx.lightning.startSwapManager();
+      console.error("[daemon] lightning swap manager started");
+    } catch (err) {
+      console.error(`[daemon] lightning swap manager error: ${err instanceof Error ? err.message : err}`);
+    }
+
+    // Recover swept VTXOs on startup
+    const wallet = ctx.bitcoin.getWallet();
+    const vtxoManager = new VtxoManager(wallet);
     try {
       const recoverable = await vtxoManager.getRecoverableBalance();
       if (recoverable.recoverable > 0n) {
@@ -326,48 +340,45 @@ async function runDaemon() {
     } catch (err) {
       console.error(`[daemon] vtxo recovery error: ${err instanceof Error ? err.message : err}`);
     }
-  })();
-
-  // Auto-delegate VTXOs when delegator is configured
-  let stopVtxoDelegate: (() => void) | undefined;
-  const delegatorManager = await wallet.getDelegatorManager();
-  if (delegatorManager) {
-    const delegateSettled = async () => {
-      try {
-        const vtxos = (await wallet.getVtxos({ withRecoverable: false })).filter(
-          (v: ExtendedVirtualCoin) => v.virtualStatus.state === "settled"
-        );
-        if (vtxos.length === 0) return;
-        const address = await wallet.getAddress();
-        const result = await delegatorManager.delegate(vtxos, address);
-        if (result.delegated.length > 0) {
-          console.error(`[daemon] delegated ${result.delegated.length} vtxo(s) for auto-renewal`);
-        }
-      } catch (err) {
-        console.error(`[daemon] vtxo delegation error: ${err instanceof Error ? err.message : err}`);
-      }
-    };
 
-    // Delegate any existing settled VTXOs on startup
-    void delegateSettled();
+    // Auto-delegate VTXOs when delegator is configured
+    try {
+      const delegatorManager = await wallet.getDelegatorManager();
+      if (delegatorManager) {
+        const delegateSettled = async () => {
+          try {
+            const vtxos = (await wallet.getVtxos({ withRecoverable: false })).filter(
+              (v: ExtendedVirtualCoin) => v.virtualStatus.state === "settled"
+            );
+            if (vtxos.length === 0) return;
+            const address = await wallet.getAddress();
+            const result = await delegatorManager.delegate(vtxos, address);
+            if (result.delegated.length > 0) {
+              console.error(`[daemon] delegated ${result.delegated.length} vtxo(s) for auto-renewal`);
+            }
+          } catch (err) {
+            console.error(`[daemon] vtxo delegation error: ${err instanceof Error ? err.message : err}`);
+          }
+        };
 
-    // Subscribe and delegate on every incoming VTXO
-    wallet.notifyIncomingFunds((funds: IncomingFunds) => {
-      if (funds.type === "vtxo" && funds.newVtxos.length > 0) {
+        // Delegate any existing settled VTXOs on startup
         void delegateSettled();
-      }
-    }).then((stop: () => void) => { stopVtxoDelegate = stop; }).catch((err: unknown) => {
-      console.error(`[daemon] vtxo delegate subscription error: ${err instanceof Error ? err.message : err}`);
-    });
 
-    console.error("[daemon] vtxo auto-delegation started");
-  }
+        // Subscribe and delegate on every incoming VTXO
+        wallet.notifyIncomingFunds((funds: IncomingFunds) => {
+          if (funds.type === "vtxo" && funds.newVtxos.length > 0) {
+            void delegateSettled();
+          }
+        }).then((stop: () => void) => { stopVtxoDelegate = stop; }).catch((err: unknown) => {
+          console.error(`[daemon] vtxo delegate subscription error: ${err instanceof Error ? err.message : err}`);
+        });
 
-  // Start HTTP server
-  server.listen(port, "127.0.0.1", () => {
-    saveDaemonPid(process.pid, port);
-    console.error(`[daemon] listening on http://127.0.0.1:${port}`);
-  });
+        console.error("[daemon] vtxo auto-delegation started");
+      }
+    } catch (err) {
+      console.error(`[daemon] delegator init error: ${err instanceof Error ? err.message : err}`);
+    }
+  })();
 
   // Graceful shutdown
   const shutdown = async () => {

pnpm-lock.yaml

@@ -10,9 +10,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@clw-cash/sdk": "workspace:*",
+    "@arkade-os/boltz-swap": "^0.3.8",
     "@arkade-os/sdk": "^0.4.10",
-    "@arkade-os/boltz-swap": "^0.2.18",
+    "@clw-cash/sdk": "workspace:*",
     "@lendasat/lendaswap-sdk-pure": "^0.0.2"
   },
   "devDependencies": {

skills/package.json

@@ -1,7 +1,8 @@
 import {
-  ArkadeLightning,
+  ArkadeSwaps,
   BoltzSwapProvider,
   decodeInvoice,
+  type SwapRepository,
   type PendingReverseSwap,
   type PendingSubmarineSwap,
 } from "@arkade-os/boltz-swap";
@@ -36,6 +37,7 @@ export interface ArkadeLightningSkillConfig {
   boltzApiUrl?: string;
   referralId?: string;
   enableSwapManager?: boolean;
+  swapRepository?: SwapRepository;
 }
 
 export class ArkadeLightningSkill implements LightningSkill {
@@ -44,7 +46,7 @@ export class ArkadeLightningSkill implements LightningSkill {
     "Lightning Network payments via Boltz submarine swaps for Arkade wallets";
   readonly version = "1.0.0";
 
-  private readonly arkadeLightning: ArkadeLightning;
+  private readonly arkadeSwaps: ArkadeSwaps;
   private readonly swapProvider: BoltzSwapProvider;
   private readonly network: NetworkName;
   private readonly swapErrors = new Map<string, string>();
@@ -63,20 +65,21 @@ export class ArkadeLightningSkill implements LightningSkill {
       referralId: config.referralId,
     });
 
-    this.arkadeLightning = new ArkadeLightning({
+    this.arkadeSwaps = new ArkadeSwaps({
       wallet: config.wallet as ConstructorParameters<
-        typeof ArkadeLightning
+        typeof ArkadeSwaps
       >[0]["wallet"],
       swapProvider: this.swapProvider,
       arkProvider: config.arkProvider,
       indexerProvider: config.indexerProvider,
+      swapRepository: config.swapRepository,
       swapManager: config.enableSwapManager
-        ? { enableAutoActions: true, autoStart: true }
-        : undefined,
+        ? { autoStart: true }
+        : false,
     });
 
     // Track swap errors from SwapManager for debugging
-    const manager = this.arkadeLightning.getSwapManager?.();
+    const manager = this.arkadeSwaps.getSwapManager?.();
     if (manager) {
       manager.onSwapFailed?.((swap: { id: string }, error: unknown) => {
         const msg = error instanceof Error ? error.message : String(error);
@@ -96,7 +99,7 @@ export class ArkadeLightningSkill implements LightningSkill {
   }
 
   async createInvoice(params: CreateInvoiceParams): Promise<LightningInvoice> {
-    const response = await this.arkadeLightning.createLightningInvoice({
+    const response = await this.arkadeSwaps.createLightningInvoice({
       amount: params.amount,
       description: params.description,
     });
@@ -115,7 +118,7 @@ export class ArkadeLightningSkill implements LightningSkill {
   }
 
   async payInvoice(params: PayInvoiceParams): Promise<PaymentResult> {
-    const response = await this.arkadeLightning.sendLightningPayment({
+    const response = await this.arkadeSwaps.sendLightningPayment({
       invoice: params.bolt11,
     });
 
@@ -127,17 +130,17 @@ export class ArkadeLightningSkill implements LightningSkill {
   }
 
   async getFees(): Promise<LightningFees> {
-    return this.arkadeLightning.getFees();
+    return this.arkadeSwaps.getFees();
   }
 
   async getLimits(): Promise<LightningLimits> {
-    return this.arkadeLightning.getLimits();
+    return this.arkadeSwaps.getLimits();
   }
 
   async getPendingSwaps(): Promise<SwapInfo[]> {
     // Refresh statuses from Boltz API before returning
     try {
-      await this.arkadeLightning.refreshSwapsStatus();
+      await this.arkadeSwaps.refreshSwapsStatus();
     } catch {
       // Non-fatal: return stale data if refresh fails
     }
@@ -147,7 +150,7 @@ export class ArkadeLightningSkill implements LightningSkill {
   }
 
   async getSwapHistory(): Promise<SwapInfo[]> {
-    const history = await this.arkadeLightning.getSwapHistory();
+    const history = await this.arkadeSwaps.getSwapHistory();
     return history.map((swap) =>
       swap.type === "reverse"
         ? this.mapReverseSwap(swap as PendingReverseSwap)
@@ -158,27 +161,27 @@ export class ArkadeLightningSkill implements LightningSkill {
   async waitAndClaim(
     pendingSwap: PendingReverseSwap
   ): Promise<{ txid: string }> {
-    return this.arkadeLightning.waitAndClaim(pendingSwap);
+    return this.arkadeSwaps.waitAndClaim(pendingSwap);
   }
 
-  getArkadeLightning(): ArkadeLightning {
-    return this.arkadeLightning;
+  getArkadeSwaps(): ArkadeSwaps {
+    return this.arkadeSwaps;
   }
 
   getSwapProvider(): BoltzSwapProvider {
     return this.swapProvider;
   }
 
   async startSwapManager(): Promise<void> {
-    await this.arkadeLightning.startSwapManager();
+    await this.arkadeSwaps.startSwapManager();
   }
 
   async stopSwapManager(): Promise<void> {
-    await this.arkadeLightning.stopSwapManager();
+    await this.arkadeSwaps.stopSwapManager();
   }
 
   async dispose(): Promise<void> {
-    await this.arkadeLightning.dispose();
+    await this.arkadeSwaps.dispose();
   }
 
   private mapReverseSwap(swap: PendingReverseSwap): SwapInfo {