@arkade-os/swap 0.0.4 → 0.0.6

package/dist/repositories/realm/index.d.ts

@@ -0,0 +1,103 @@
+import { RealmLike } from '@arkade-os/sdk/repositories/realm';
+import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.js';
+import '@arkade-os/solver-discovery';
+import '@arkade-os/sdk';
+
+/**
+ * Realm backend for React Native.
+ *
+ * `realm` is not a dependency of this package: consumers open Realm with the
+ * schemas from `./schemas.ts` and pass the instance, validated against the
+ * shared `RealmLike` shape from `@arkade-os/sdk`.
+ *
+ * **Records are serialized as JSON**, whole, into a `data` property —
+ * `status` and `createdAt` are mapped out for querying only, so no field of a
+ * record can be dropped. That holds for JSON-safe values: a consumer-added
+ * `Date` comes back a string and a `bigint` throws on save, unlike the
+ * IndexedDB backend's structured clone. `AssetSwap` itself is JSON-safe by
+ * design.
+ *
+ * Realm creates the schemas on open, so there is nothing to initialise. The
+ * consumer owns the Realm lifecycle — `[Symbol.asyncDispose]` is a no-op.
+ */
+declare class RealmAssetSwapRepository implements AssetSwapRepository {
+    private readonly realm;
+    readonly version: 2;
+    constructor(realm: RealmLike);
+    saveSwap(swap: AssetSwap): Promise<void>;
+    getAllSwaps(): Promise<AssetSwap[]>;
+    getScannedTxids(): Promise<Set<string>>;
+    markTxidsScanned(txids: Iterable<string>): Promise<void>;
+    getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
+    saveCachedMarkets(network: string, registry: string, entry: MarketsCacheEntry): Promise<void>;
+    /** All three schemas in one write: clearing swaps but keeping scanned txids
+     * would leave the restore scan permanently skipping those funding txs, so
+     * a partial clear must not be observable. */
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+/**
+ * Realm object schemas for the asset-swap repository.
+ *
+ * The names land in the **consuming application's** schema namespace, next to
+ * its own models and the SDK's `Ark*` / the Boltz plugin's `Boltz*`, so they
+ * are prefixed with `ArkadeAssetSwap`. Unlike the SQLite backend there is no
+ * prefix option: a Realm schema name is baked into the schema objects the
+ * consumer registers and into every `realm.objects(…)` call here.
+ *
+ * Since `realm` is not a dependency of this package, schemas are plain JS
+ * objects conforming to Realm's ObjectSchema shape. They are new, so a consumer
+ * adds them to its Realm config and bumps its own `schemaVersion`; no migration
+ * helper ships here.
+ */
+declare const ArkadeAssetSwapSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        status: string;
+        createdAt: string;
+        data: string;
+    };
+};
+declare const ArkadeAssetSwapScannedTxidSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        txid: string;
+    };
+};
+declare const ArkadeAssetSwapMarketsCacheSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        key: string;
+        data: string;
+    };
+};
+declare const AssetSwapRealmSchemas: ({
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        status: string;
+        createdAt: string;
+        data: string;
+    };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        txid: string;
+    };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        key: string;
+        data: string;
+    };
+})[];
+
+export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };

package/dist/repositories/realm/index.js

@@ -0,0 +1,108 @@
+import {
+  marketsCacheKey
+} from "../../chunk-WGRU2DBF.js";
+
+// src/repositories/realm/repository.ts
+var SWAPS = "ArkadeAssetSwap";
+var SCANNED = "ArkadeAssetSwapScannedTxid";
+var MARKETS = "ArkadeAssetSwapMarketsCache";
+var RealmAssetSwapRepository = class {
+  constructor(realm) {
+    this.realm = realm;
+  }
+  realm;
+  version = 2;
+  async saveSwap(swap) {
+    this.realm.write(() => {
+      this.realm.create(
+        SWAPS,
+        {
+          id: swap.id,
+          status: swap.status,
+          createdAt: swap.createdAt,
+          data: JSON.stringify(swap)
+        },
+        "modified"
+      );
+    });
+  }
+  async getAllSwaps() {
+    return [...this.realm.objects(SWAPS)].map(
+      (o) => JSON.parse(o.data)
+    );
+  }
+  async getScannedTxids() {
+    return new Set([...this.realm.objects(SCANNED)].map((o) => o.txid));
+  }
+  async markTxidsScanned(txids) {
+    this.realm.write(() => {
+      for (const txid of txids) this.realm.create(SCANNED, { txid }, "modified");
+    });
+  }
+  async getCachedMarkets(network, registry) {
+    const [row] = [
+      ...this.realm.objects(MARKETS).filtered("key == $0", marketsCacheKey(network, registry))
+    ];
+    return row ? JSON.parse(row.data) : void 0;
+  }
+  async saveCachedMarkets(network, registry, entry) {
+    this.realm.write(() => {
+      this.realm.create(
+        MARKETS,
+        { key: marketsCacheKey(network, registry), data: JSON.stringify(entry) },
+        "modified"
+      );
+    });
+  }
+  /** All three schemas in one write: clearing swaps but keeping scanned txids
+   * would leave the restore scan permanently skipping those funding txs, so
+   * a partial clear must not be observable. */
+  async clear() {
+    this.realm.write(() => {
+      for (const name of [SWAPS, SCANNED, MARKETS]) {
+        this.realm.delete(this.realm.objects(name));
+      }
+    });
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+
+// src/repositories/realm/schemas.ts
+var ArkadeAssetSwapSchema = {
+  name: "ArkadeAssetSwap",
+  primaryKey: "id",
+  properties: {
+    id: "string",
+    status: "string",
+    createdAt: "int",
+    data: "string"
+  }
+};
+var ArkadeAssetSwapScannedTxidSchema = {
+  name: "ArkadeAssetSwapScannedTxid",
+  primaryKey: "txid",
+  properties: {
+    txid: "string"
+  }
+};
+var ArkadeAssetSwapMarketsCacheSchema = {
+  name: "ArkadeAssetSwapMarketsCache",
+  primaryKey: "key",
+  properties: {
+    key: "string",
+    data: "string"
+  }
+};
+var AssetSwapRealmSchemas = [
+  ArkadeAssetSwapSchema,
+  ArkadeAssetSwapScannedTxidSchema,
+  ArkadeAssetSwapMarketsCacheSchema
+];
+export {
+  ArkadeAssetSwapMarketsCacheSchema,
+  ArkadeAssetSwapScannedTxidSchema,
+  ArkadeAssetSwapSchema,
+  AssetSwapRealmSchemas,
+  RealmAssetSwapRepository
+};

package/dist/repositories/sqlite/index.cjs

@@ -0,0 +1,163 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/repositories/sqlite/index.ts
+var sqlite_exports = {};
+__export(sqlite_exports, {
+  SQLiteAssetSwapRepository: () => SQLiteAssetSwapRepository
+});
+module.exports = __toCommonJS(sqlite_exports);
+
+// src/repositories/sqlite/repository.ts
+var import_sqlite = require("@arkade-os/sdk/repositories/sqlite");
+
+// src/repository.ts
+var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-${registry}`;
+
+// src/repositories/sqlite/repository.ts
+var DEFAULT_PREFIX = "arkade_";
+var INSERT_CHUNK = 500;
+var SQLiteAssetSwapRepository = class {
+  constructor(db, options) {
+    this.db = db;
+    this.prefix = (0, import_sqlite.sanitizeTablePrefix)(options?.prefix ?? DEFAULT_PREFIX);
+    this.swaps = `${this.prefix}asset_swaps`;
+    this.scanned = `${this.prefix}asset_swap_scanned_txids`;
+    this.markets = `${this.prefix}asset_swap_markets`;
+  }
+  db;
+  version = 2;
+  initPromise = null;
+  prefix;
+  swaps;
+  scanned;
+  markets;
+  /** A rejected init is not cached. The DDL runs in a transaction on a shared
+   * connection, so it can fail for reasons that pass — a `SQLITE_BUSY` on
+   * `BEGIN IMMEDIATE`, a neighbour's rollback — and caching that rejection
+   * would strand the instance unusable for the life of the process. Same rule
+   * as the IndexedDB backend's `ensureDb`. */
+  ensureInit() {
+    return this.initPromise ??= this.init().catch((err) => {
+      this.initPromise = null;
+      throw err;
+    });
+  }
+  /** The DDL is transactional in SQLite too: run raw on a shared connection it
+   * would join a neighbour's open transaction and vanish with its rollback,
+   * while `initPromise` stayed resolved and every later statement failed with
+   * `no such table`. */
+  async init() {
+    await this.withTx(async () => {
+      await this.db.run(`CREATE TABLE IF NOT EXISTS ${this.swaps} (
+                id TEXT PRIMARY KEY,
+                status TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )`);
+      await this.db.run(
+        `CREATE INDEX IF NOT EXISTS idx_${this.prefix}asset_swaps_status ON ${this.swaps} (status)`
+      );
+      await this.db.run(
+        `CREATE INDEX IF NOT EXISTS idx_${this.prefix}asset_swaps_created_at ON ${this.swaps} (created_at)`
+      );
+      await this.db.run(`CREATE TABLE IF NOT EXISTS ${this.scanned} (txid TEXT PRIMARY KEY)`);
+      await this.db.run(
+        `CREATE TABLE IF NOT EXISTS ${this.markets} (cache_key TEXT PRIMARY KEY, data TEXT NOT NULL)`
+      );
+    });
+  }
+  /** Every write, including the single-statement ones. The chain serializes
+   * transaction *blocks*, not bare statements: one issued between a
+   * neighbour's BEGIN IMMEDIATE and its COMMIT becomes part of that
+   * transaction and dies with it. `fn` must issue only raw db calls — no
+   * repository method, no `ensureInit` — since `runInTransaction` cannot
+   * nest. */
+  withTx(fn) {
+    return (0, import_sqlite.runInTransaction)(this.db, fn);
+  }
+  async saveSwap(swap) {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(
+        `INSERT OR REPLACE INTO ${this.swaps} (id, status, created_at, data)
+                 VALUES (?, ?, ?, ?)`,
+        [swap.id, swap.status, swap.createdAt, JSON.stringify(swap)]
+      );
+    });
+  }
+  async getAllSwaps() {
+    await this.ensureInit();
+    const rows = await this.db.all(`SELECT data FROM ${this.swaps}`);
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  async getScannedTxids() {
+    await this.ensureInit();
+    const rows = await this.db.all(`SELECT txid FROM ${this.scanned}`);
+    return new Set(rows.map((r) => r.txid));
+  }
+  async markTxidsScanned(txids) {
+    await this.ensureInit();
+    const all = [...txids];
+    if (all.length === 0) return;
+    await this.withTx(async () => {
+      for (let i = 0; i < all.length; i += INSERT_CHUNK) {
+        const chunk = all.slice(i, i + INSERT_CHUNK);
+        await this.db.run(
+          `INSERT OR IGNORE INTO ${this.scanned} (txid) VALUES ${chunk.map(() => "(?)").join(", ")}`,
+          chunk
+        );
+      }
+    });
+  }
+  async getCachedMarkets(network, registry) {
+    await this.ensureInit();
+    const row = await this.db.get(
+      `SELECT data FROM ${this.markets} WHERE cache_key = ?`,
+      [marketsCacheKey(network, registry)]
+    );
+    return row ? JSON.parse(row.data) : void 0;
+  }
+  async saveCachedMarkets(network, registry, entry) {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(
+        `INSERT OR REPLACE INTO ${this.markets} (cache_key, data) VALUES (?, ?)`,
+        [marketsCacheKey(network, registry), JSON.stringify(entry)]
+      );
+    });
+  }
+  /** All three tables in one transaction: clearing swaps but keeping scanned
+   * txids would leave the restore scan permanently skipping those funding
+   * txs, so a partial clear must not be observable. */
+  async clear() {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(`DELETE FROM ${this.swaps}`);
+      await this.db.run(`DELETE FROM ${this.scanned}`);
+      await this.db.run(`DELETE FROM ${this.markets}`);
+    });
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SQLiteAssetSwapRepository
+});

package/dist/repositories/sqlite/index.d.cts

@@ -0,0 +1,63 @@
+import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
+import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.cjs';
+import '@arkade-os/solver-discovery';
+import '@arkade-os/sdk';
+
+/**
+ * SQLite backend over the SDK's `SQLExecutor`, so any driver plugs in
+ * (expo-sqlite on React Native, better-sqlite3, node:sqlite).
+ *
+ * **Records are serialized as JSON**, whole, into a `data` column — `status`
+ * and `created_at` are mapped out for querying only, so no field of a record
+ * can be dropped. That holds for JSON-safe values: a consumer-added `Date`
+ * comes back a string and a `bigint` throws on save, unlike the IndexedDB
+ * backend's structured clone. `AssetSwap` itself is JSON-safe by design.
+ *
+ * Tables are created lazily on first operation. The consumer owns the
+ * `SQLExecutor` lifecycle — `[Symbol.asyncDispose]` is a no-op — and must pass
+ * the **same executor instance** to every repository on the database: the
+ * write chain is keyed by that object, and a per-repository literal splits it.
+ */
+declare class SQLiteAssetSwapRepository implements AssetSwapRepository {
+    private readonly db;
+    readonly version: 2;
+    private initPromise;
+    private readonly prefix;
+    private readonly swaps;
+    private readonly scanned;
+    private readonly markets;
+    constructor(db: SQLExecutor, options?: {
+        prefix?: string;
+    });
+    /** A rejected init is not cached. The DDL runs in a transaction on a shared
+     * connection, so it can fail for reasons that pass — a `SQLITE_BUSY` on
+     * `BEGIN IMMEDIATE`, a neighbour's rollback — and caching that rejection
+     * would strand the instance unusable for the life of the process. Same rule
+     * as the IndexedDB backend's `ensureDb`. */
+    private ensureInit;
+    /** The DDL is transactional in SQLite too: run raw on a shared connection it
+     * would join a neighbour's open transaction and vanish with its rollback,
+     * while `initPromise` stayed resolved and every later statement failed with
+     * `no such table`. */
+    private init;
+    /** Every write, including the single-statement ones. The chain serializes
+     * transaction *blocks*, not bare statements: one issued between a
+     * neighbour's BEGIN IMMEDIATE and its COMMIT becomes part of that
+     * transaction and dies with it. `fn` must issue only raw db calls — no
+     * repository method, no `ensureInit` — since `runInTransaction` cannot
+     * nest. */
+    private withTx;
+    saveSwap(swap: AssetSwap): Promise<void>;
+    getAllSwaps(): Promise<AssetSwap[]>;
+    getScannedTxids(): Promise<Set<string>>;
+    markTxidsScanned(txids: Iterable<string>): Promise<void>;
+    getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
+    saveCachedMarkets(network: string, registry: string, entry: MarketsCacheEntry): Promise<void>;
+    /** All three tables in one transaction: clearing swaps but keeping scanned
+     * txids would leave the restore scan permanently skipping those funding
+     * txs, so a partial clear must not be observable. */
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+export { SQLiteAssetSwapRepository };

package/dist/repositories/sqlite/index.d.ts

@@ -0,0 +1,63 @@
+import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
+import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.js';
+import '@arkade-os/solver-discovery';
+import '@arkade-os/sdk';
+
+/**
+ * SQLite backend over the SDK's `SQLExecutor`, so any driver plugs in
+ * (expo-sqlite on React Native, better-sqlite3, node:sqlite).
+ *
+ * **Records are serialized as JSON**, whole, into a `data` column — `status`
+ * and `created_at` are mapped out for querying only, so no field of a record
+ * can be dropped. That holds for JSON-safe values: a consumer-added `Date`
+ * comes back a string and a `bigint` throws on save, unlike the IndexedDB
+ * backend's structured clone. `AssetSwap` itself is JSON-safe by design.
+ *
+ * Tables are created lazily on first operation. The consumer owns the
+ * `SQLExecutor` lifecycle — `[Symbol.asyncDispose]` is a no-op — and must pass
+ * the **same executor instance** to every repository on the database: the
+ * write chain is keyed by that object, and a per-repository literal splits it.
+ */
+declare class SQLiteAssetSwapRepository implements AssetSwapRepository {
+    private readonly db;
+    readonly version: 2;
+    private initPromise;
+    private readonly prefix;
+    private readonly swaps;
+    private readonly scanned;
+    private readonly markets;
+    constructor(db: SQLExecutor, options?: {
+        prefix?: string;
+    });
+    /** A rejected init is not cached. The DDL runs in a transaction on a shared
+     * connection, so it can fail for reasons that pass — a `SQLITE_BUSY` on
+     * `BEGIN IMMEDIATE`, a neighbour's rollback — and caching that rejection
+     * would strand the instance unusable for the life of the process. Same rule
+     * as the IndexedDB backend's `ensureDb`. */
+    private ensureInit;
+    /** The DDL is transactional in SQLite too: run raw on a shared connection it
+     * would join a neighbour's open transaction and vanish with its rollback,
+     * while `initPromise` stayed resolved and every later statement failed with
+     * `no such table`. */
+    private init;
+    /** Every write, including the single-statement ones. The chain serializes
+     * transaction *blocks*, not bare statements: one issued between a
+     * neighbour's BEGIN IMMEDIATE and its COMMIT becomes part of that
+     * transaction and dies with it. `fn` must issue only raw db calls — no
+     * repository method, no `ensureInit` — since `runInTransaction` cannot
+     * nest. */
+    private withTx;
+    saveSwap(swap: AssetSwap): Promise<void>;
+    getAllSwaps(): Promise<AssetSwap[]>;
+    getScannedTxids(): Promise<Set<string>>;
+    markTxidsScanned(txids: Iterable<string>): Promise<void>;
+    getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
+    saveCachedMarkets(network: string, registry: string, entry: MarketsCacheEntry): Promise<void>;
+    /** All three tables in one transaction: clearing swaps but keeping scanned
+     * txids would leave the restore scan permanently skipping those funding
+     * txs, so a partial clear must not be observable. */
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+
+export { SQLiteAssetSwapRepository };

package/dist/repositories/sqlite/index.js

@@ -0,0 +1,138 @@
+import {
+  marketsCacheKey
+} from "../../chunk-WGRU2DBF.js";
+
+// src/repositories/sqlite/repository.ts
+import {
+  runInTransaction,
+  sanitizeTablePrefix
+} from "@arkade-os/sdk/repositories/sqlite";
+var DEFAULT_PREFIX = "arkade_";
+var INSERT_CHUNK = 500;
+var SQLiteAssetSwapRepository = class {
+  constructor(db, options) {
+    this.db = db;
+    this.prefix = sanitizeTablePrefix(options?.prefix ?? DEFAULT_PREFIX);
+    this.swaps = `${this.prefix}asset_swaps`;
+    this.scanned = `${this.prefix}asset_swap_scanned_txids`;
+    this.markets = `${this.prefix}asset_swap_markets`;
+  }
+  db;
+  version = 2;
+  initPromise = null;
+  prefix;
+  swaps;
+  scanned;
+  markets;
+  /** A rejected init is not cached. The DDL runs in a transaction on a shared
+   * connection, so it can fail for reasons that pass — a `SQLITE_BUSY` on
+   * `BEGIN IMMEDIATE`, a neighbour's rollback — and caching that rejection
+   * would strand the instance unusable for the life of the process. Same rule
+   * as the IndexedDB backend's `ensureDb`. */
+  ensureInit() {
+    return this.initPromise ??= this.init().catch((err) => {
+      this.initPromise = null;
+      throw err;
+    });
+  }
+  /** The DDL is transactional in SQLite too: run raw on a shared connection it
+   * would join a neighbour's open transaction and vanish with its rollback,
+   * while `initPromise` stayed resolved and every later statement failed with
+   * `no such table`. */
+  async init() {
+    await this.withTx(async () => {
+      await this.db.run(`CREATE TABLE IF NOT EXISTS ${this.swaps} (
+                id TEXT PRIMARY KEY,
+                status TEXT NOT NULL,
+                created_at INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )`);
+      await this.db.run(
+        `CREATE INDEX IF NOT EXISTS idx_${this.prefix}asset_swaps_status ON ${this.swaps} (status)`
+      );
+      await this.db.run(
+        `CREATE INDEX IF NOT EXISTS idx_${this.prefix}asset_swaps_created_at ON ${this.swaps} (created_at)`
+      );
+      await this.db.run(`CREATE TABLE IF NOT EXISTS ${this.scanned} (txid TEXT PRIMARY KEY)`);
+      await this.db.run(
+        `CREATE TABLE IF NOT EXISTS ${this.markets} (cache_key TEXT PRIMARY KEY, data TEXT NOT NULL)`
+      );
+    });
+  }
+  /** Every write, including the single-statement ones. The chain serializes
+   * transaction *blocks*, not bare statements: one issued between a
+   * neighbour's BEGIN IMMEDIATE and its COMMIT becomes part of that
+   * transaction and dies with it. `fn` must issue only raw db calls — no
+   * repository method, no `ensureInit` — since `runInTransaction` cannot
+   * nest. */
+  withTx(fn) {
+    return runInTransaction(this.db, fn);
+  }
+  async saveSwap(swap) {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(
+        `INSERT OR REPLACE INTO ${this.swaps} (id, status, created_at, data)
+                 VALUES (?, ?, ?, ?)`,
+        [swap.id, swap.status, swap.createdAt, JSON.stringify(swap)]
+      );
+    });
+  }
+  async getAllSwaps() {
+    await this.ensureInit();
+    const rows = await this.db.all(`SELECT data FROM ${this.swaps}`);
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  async getScannedTxids() {
+    await this.ensureInit();
+    const rows = await this.db.all(`SELECT txid FROM ${this.scanned}`);
+    return new Set(rows.map((r) => r.txid));
+  }
+  async markTxidsScanned(txids) {
+    await this.ensureInit();
+    const all = [...txids];
+    if (all.length === 0) return;
+    await this.withTx(async () => {
+      for (let i = 0; i < all.length; i += INSERT_CHUNK) {
+        const chunk = all.slice(i, i + INSERT_CHUNK);
+        await this.db.run(
+          `INSERT OR IGNORE INTO ${this.scanned} (txid) VALUES ${chunk.map(() => "(?)").join(", ")}`,
+          chunk
+        );
+      }
+    });
+  }
+  async getCachedMarkets(network, registry) {
+    await this.ensureInit();
+    const row = await this.db.get(
+      `SELECT data FROM ${this.markets} WHERE cache_key = ?`,
+      [marketsCacheKey(network, registry)]
+    );
+    return row ? JSON.parse(row.data) : void 0;
+  }
+  async saveCachedMarkets(network, registry, entry) {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(
+        `INSERT OR REPLACE INTO ${this.markets} (cache_key, data) VALUES (?, ?)`,
+        [marketsCacheKey(network, registry), JSON.stringify(entry)]
+      );
+    });
+  }
+  /** All three tables in one transaction: clearing swaps but keeping scanned
+   * txids would leave the restore scan permanently skipping those funding
+   * txs, so a partial clear must not be observable. */
+  async clear() {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(`DELETE FROM ${this.swaps}`);
+      await this.db.run(`DELETE FROM ${this.scanned}`);
+      await this.db.run(`DELETE FROM ${this.markets}`);
+    });
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+export {
+  SQLiteAssetSwapRepository
+};