Wallet.dispose() is missing an await, so cleanup can finish after it returns

[gringokiwi]

Plain English

wallet.dispose() is supposed to fully shut down before it returns, so callers can safely tear down their own resources (like a database connection) right after. It doesn't: it kicks off the real cleanup but never waits for it, so the promise resolves early. If an event arrives in that gap, the SDK tries to use resources (like the caller's database) that may already be gone.

Root cause

Wallet.dispose() in chunk-DSC3G6QZ.js (~line 479247):

async dispose() {
  const manager = this._contractManager ?? (this._contractManagerInitializing ? await this._contractManagerInitializing.catch(() => void 0) : void 0);
  manager?.dispose();          // <-- missing `await`
  this._contractManager = void 0;
  this._contractManagerInitializing = void 0;
}

ContractManager.dispose() itself is correct — it awaits contractEventsSubscriptionReady and then unsubscribes:

async dispose() {
  this.disposePromise ??= (async () => {
    this.disposed = true;
    ...
    const subscription = await this.contractEventsSubscriptionReady;
    subscription?.();
  })();
  return this.disposePromise;
}

But because Wallet.dispose() never awaits it, await wallet.dispose() resolves before the SSE subscription is actually torn down.

Repro

From demos/intents/swap-to-lightning/mainnet/typescript/index.ts:

console.log("Waiting for the swap to settle or refund...");
const outcome = await manager.waitForSwapCompletion(rfqId);
console.log("Swap finished:", outcome);

await manager.stop();
await transport.close();
await wallet.dispose();
closeDB(); // <-- app-owned SQLite connection, passed in via SQLExecutor

Observed error

The swap itself completes successfully (state: 'settled'), but shutdown throws:

Funded! https://arkade.space/tx/ff3848bac52ab964e334afafaab093b067775316f853cf145fac68af05e0b4eb
Waiting for the swap to settle or refund...
Swap finished: { state: 'settled', txid: undefined }
Error handling contract event: TypeError: The database connection is not open
    at Database.prepare (.../better-sqlite3/lib/methods/wrappers.js:5:21)
    at Object.all (.../index.ts:97:10)
    at SQLiteContractRepository.getContracts (@arkade-os/sdk/dist/repositories/sqlite/index.js:546:32)
    at process.processTicksAndRejections (node:internal/process/task_queues:104:5)
    at async _ContractManager.annotateVtxos (@arkade-os/sdk/dist/chunk-DSC3G6QZ.js:9740:23)
    at async _ContractManager.fetchContractVtxosBulk (@arkade-os/sdk/dist/chunk-DSC3G6QZ.js:10323:23)
    at async _ContractManager.fetchContractVxosFromIndexer (@arkade-os/sdk/dist/chunk-DSC3G6QZ.js:10261:41)
    at async _ContractManager.syncContracts (@arkade-os/sdk/dist/chunk-DSC3G6QZ.js:10168:20)
    at async _ContractManager.handleContractEvent (@arkade-os/sdk/dist/chunk-DSC3G6QZ.js:10115:11)

@arkade-os/sdk@0.4.66.

Suggested fix

Add the missing await in Wallet.dispose():

async dispose() {
  const manager = this._contractManager ?? ...;
  await manager?.dispose();   // was: manager?.dispose();
  this._contractManager = void 0;
  this._contractManagerInitializing = void 0;
}

Separately, ContractManager.handleContractEvent has no disposed guard at its top, so even a fully-awaited dispose() doesn't cover a handler that was already mid-flight (e.g. awaiting a network call) the instant dispose() was called. Worth an early-return check there too for full safety.

Workaround

The demo now awaits contractManager.dispose() directly instead of wallet.dispose(), which sidesteps the missing await:

const contractManager = await wallet.getContractManager();
...
await contractManager.dispose();
closeDB();

[arkana-ai-bot]

Debug analysis

Root cause confirmed in two related spots.

1. Missing await — ReadonlyWallet.dispose()

// packages/ts-sdk/src/wallet/wallet.ts  (ReadonlyWallet.dispose, ~L2212)
async dispose(): Promise<void> {
    const manager = this._contractManager ?? ...;
    manager?.dispose();         // ← missing await
    this._contractManager = undefined;
    this._contractManagerInitializing = undefined;
}

ContractManager.dispose() (contractManager.ts:2457) is currently synchronous so the missing await is harmless in the current build. That is the reason it hasn't been caught by tests. However it is a correctness trap: if dispose() ever becomes async (it already is in vtxo-manager.ts), or if a caller wraps it in a Promise, callers who do await wallet.dispose() will silently get early resolution.

2. Fire-and-forget handler with no drain — contractManager.ts:910

// packages/ts-sdk/src/contracts/contractManager.ts (~L910)
this.stopWatcherFn = await this.watcher.startWatching((event) => {
    this.handleContractEvent(event).catch((error) => {   // ← fire-and-forget
        console.error("Error handling contract event:", error);
    });
});

dispose() sets this.disposed = true synchronously and returns immediately. Any handleContractEvent call already mid-flight (awaiting a network call, for example) will continue executing past the disposed checks scattered through syncContracts (contractManager.ts:1139) — those checks only guard new work from starting, not work already running. This is the direct cause of the database is closed error: the handler resumes after the caller has torn down the DB.

The Wallet subclass's dispose() (wallet.ts:3152) drains its own managers correctly and is unaffected; the gap is in the base ReadonlyWallet.

Suggested fixes

1. Add await in ReadonlyWallet.dispose() ():

   await manager?.dispose();

2. Add a top-of-function disposed guard in handleContractEvent (contractManager.ts:2113):

   private async handleContractEvent(event: ContractEvent) {
       if (this.disposed) return;   // ← drop events that land after dispose
       // ... rest unchanged
   }

   This closes the window for handlers that are queued but haven't started yet. For handlers already mid-flight on an await, the existing mid-function disposed checks (contractManager.ts:1139, 1016, 1045, 1048, 1089) provide best-effort protection, but they can't unwind an already-running await chain without a cancellation token.

3. Optionally: drain in-flight handlers before returning from dispose() — but this requires tracking all outstanding promises, which is a larger change.

Fix 1 + 2 together will close the reported regression. Fix 3 would make the guarantee airtight.