@arkade-os/swap 0.0.12 → 0.1.0-rc.1

package/dist/node/index.cjs

@@ -0,0 +1,322 @@
+"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/node/index.ts
+var index_exports = {};
+__export(index_exports, {
+  configDir: () => configDir,
+  createNodeSqlExecutor: () => createNodeSqlExecutor,
+  nodeSwapRepository: () => nodeSwapRepository,
+  swapDatabasePath: () => swapDatabasePath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/node/paths.ts
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var NETWORK_PATH_SEGMENT = /^[a-z][a-z0-9-]{0,32}$/;
+var assertSafeNetworkPathSegment = (network) => {
+  if (NETWORK_PATH_SEGMENT.test(network)) return;
+  throw new Error(
+    `Invalid network name for swap database path: ${JSON.stringify(network)}. Use lowercase letters, digits, and hyphens, starting with a letter.`
+  );
+};
+var configDir = (env = process.env) => {
+  if (process.platform === "win32") {
+    return env.APPDATA ?? (0, import_node_path.join)((0, import_node_os.homedir)(), "AppData", "Roaming");
+  }
+  if (process.platform === "darwin") {
+    return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support");
+  }
+  const xdg = env.XDG_CONFIG_HOME;
+  return xdg && xdg.startsWith("/") ? xdg : (0, import_node_path.join)((0, import_node_os.homedir)(), ".config");
+};
+var swapDatabasePath = (network, env = process.env) => {
+  assertSafeNetworkPathSegment(network);
+  return (0, import_node_path.join)(configDir(env), "arkade", "swaps", `swaps-${network}.sqlite`);
+};
+
+// src/node/executor.ts
+var import_node_sqlite = require("node:sqlite");
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// 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.rfqSwaps = `${this.prefix}rfq_swaps`;
+    this.swapRecords = `${this.prefix}swap_records`;
+    this.scanned = `${this.prefix}asset_swap_scanned_txids`;
+    this.markets = `${this.prefix}asset_swap_markets`;
+  }
+  db;
+  version = 5;
+  initPromise = null;
+  prefix;
+  swaps;
+  rfqSwaps;
+  swapRecords;
+  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.rfqSwaps} (
+                rfq_id TEXT PRIMARY KEY,
+                state TEXT NOT NULL,
+                updated_at INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )`);
+      await this.db.run(
+        `CREATE INDEX IF NOT EXISTS idx_${this.prefix}rfq_swaps_state ON ${this.rfqSwaps} (state)`
+      );
+      await this.db.run(`CREATE TABLE IF NOT EXISTS ${this.swapRecords} (
+                id TEXT PRIMARY KEY,
+                family TEXT NOT NULL,
+                updated_at INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )`);
+      await this.db.run(
+        `CREATE INDEX IF NOT EXISTS idx_${this.prefix}swap_records_family ON ${this.swapRecords} (family)`
+      );
+      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 saveRfqSwap(record) {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(
+        `INSERT OR REPLACE INTO ${this.rfqSwaps} (rfq_id, state, updated_at, data)
+                 VALUES (?, ?, ?, ?)`,
+        [record.rfqId, record.state, record.updatedAt, JSON.stringify(record)]
+      );
+    });
+  }
+  async getRfqSwap(rfqId) {
+    await this.ensureInit();
+    const row = await this.db.get(
+      `SELECT data FROM ${this.rfqSwaps} WHERE rfq_id = ?`,
+      [rfqId]
+    );
+    return row ? JSON.parse(row.data) : void 0;
+  }
+  async getAllRfqSwaps() {
+    await this.ensureInit();
+    const rows = await this.db.all(`SELECT data FROM ${this.rfqSwaps}`);
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  async removeRfqSwap(rfqId) {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(`DELETE FROM ${this.rfqSwaps} WHERE rfq_id = ?`, [rfqId]);
+    });
+  }
+  async saveSwapRecord(record) {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(
+        `INSERT OR REPLACE INTO ${this.swapRecords} (id, family, updated_at, data)
+                 VALUES (?, ?, ?, ?)`,
+        [record.id, record.family, record.updatedAt, JSON.stringify(record)]
+      );
+    });
+  }
+  async getSwapRecord(id) {
+    await this.ensureInit();
+    const row = await this.db.get(
+      `SELECT data FROM ${this.swapRecords} WHERE id = ?`,
+      [id]
+    );
+    return row ? JSON.parse(row.data) : void 0;
+  }
+  async getAllSwapRecords() {
+    await this.ensureInit();
+    const rows = await this.db.all(`SELECT data FROM ${this.swapRecords}`);
+    return rows.map((r) => JSON.parse(r.data));
+  }
+  async removeSwapRecord(id) {
+    await this.ensureInit();
+    await this.withTx(async () => {
+      await this.db.run(`DELETE FROM ${this.swapRecords} WHERE id = ?`, [id]);
+    });
+  }
+  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)]
+      );
+    });
+  }
+  /** Every table 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.rfqSwaps}`);
+      await this.db.run(`DELETE FROM ${this.swapRecords}`);
+      await this.db.run(`DELETE FROM ${this.scanned}`);
+      await this.db.run(`DELETE FROM ${this.markets}`);
+    });
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+
+// src/node/executor.ts
+var bindable = (params) => (params ?? []).map((p) => p === void 0 ? null : p);
+var createNodeSqlExecutor = (path) => {
+  (0, import_node_fs.mkdirSync)((0, import_node_path2.dirname)(path), { recursive: true });
+  const db = new import_node_sqlite.DatabaseSync(path);
+  let open = true;
+  return {
+    async run(sql, params) {
+      db.prepare(sql).run(...bindable(params));
+    },
+    async get(sql, params) {
+      return db.prepare(sql).get(...bindable(params)) ?? void 0;
+    },
+    async all(sql, params) {
+      return db.prepare(sql).all(...bindable(params));
+    },
+    async close() {
+      if (!open) return;
+      open = false;
+      db.close();
+    }
+  };
+};
+var nodeSwapRepository = (options) => {
+  const executor = createNodeSqlExecutor(options.path ?? swapDatabasePath(options.network));
+  return new NodeSwapRepository(
+    executor,
+    options.prefix === void 0 ? void 0 : { prefix: options.prefix }
+  );
+};
+var NodeSwapRepository = class extends SQLiteAssetSwapRepository {
+  constructor(executor, options) {
+    super(executor, options);
+    this.executor = executor;
+  }
+  executor;
+  async [Symbol.asyncDispose]() {
+    await this.executor.close();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configDir,
+  createNodeSqlExecutor,
+  nodeSwapRepository,
+  swapDatabasePath
+});