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

package/dist/node/index.js

@@ -0,0 +1,295 @@
+// src/node/paths.ts
+import { homedir } from "node:os";
+import { join } from "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 ?? join(homedir(), "AppData", "Roaming");
+  }
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Application Support");
+  }
+  const xdg = env.XDG_CONFIG_HOME;
+  return xdg && xdg.startsWith("/") ? xdg : join(homedir(), ".config");
+};
+var swapDatabasePath = (network, env = process.env) => {
+  assertSafeNetworkPathSegment(network);
+  return join(configDir(env), "arkade", "swaps", `swaps-${network}.sqlite`);
+};
+
+// src/node/executor.ts
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+// src/repositories/sqlite/repository.ts
+import {
+  runInTransaction,
+  sanitizeTablePrefix
+} from "@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 = 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 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) => {
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new 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();
+  }
+};
+export {
+  configDir,
+  createNodeSqlExecutor,
+  nodeSwapRepository,
+  swapDatabasePath
+};

package/dist/nostr.cjs

@@ -82,11 +82,14 @@ var LIGHTNING_RECEIVE_PAIR = rfqPair(LIGHTNING_BTC, ARKADE_BTC);
 var ONCHAIN_SEND_PAIR = rfqPair(ARKADE_BTC, ONCHAIN_BTC);
 var ONCHAIN_RECEIVE_PAIR = rfqPair(ONCHAIN_BTC, ARKADE_BTC);
 var SwapRefusal = class extends Error {
+  /** Literal-typed so the v2 error taxonomy's union discriminates on `name`
+   * — a `string` here collapses the discriminant for every member. Same value
+   * the constructor has always set, moved to a field initializer. */
+  name = "SwapRefusal";
   reason;
   rfqId;
   constructor(reason, rfqId) {
     super(`solver refused: ${reason}`);
-    this.name = "SwapRefusal";
     this.reason = reason;
     this.rfqId = rfqId;
   }

package/dist/nostr.d.cts

@@ -1,4 +1,4 @@
-import { R as RfqTransport } from './rfq-DzsmhXX3.cjs';
+import { R as RfqTransport } from './rfq-D0KGjmnn.cjs';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 

package/dist/nostr.d.ts

@@ -1,4 +1,4 @@
-import { R as RfqTransport } from './rfq-DzsmhXX3.js';
+import { R as RfqTransport } from './rfq-D0KGjmnn.js';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 

package/dist/nostr.js

@@ -1,7 +1,7 @@
 import {
   expectQuote,
   pairOf
-} from "./chunk-XXWOODUE.js";
+} from "./chunk-OEKSNYJW.js";
 
 // src/nostr.ts
 import {

package/dist/repositories/realm/index.cjs

@@ -23,6 +23,8 @@ __export(realm_exports, {
   ArkadeAssetSwapMarketsCacheSchema: () => ArkadeAssetSwapMarketsCacheSchema,
   ArkadeAssetSwapScannedTxidSchema: () => ArkadeAssetSwapScannedTxidSchema,
   ArkadeAssetSwapSchema: () => ArkadeAssetSwapSchema,
+  ArkadeRfqSwapSchema: () => ArkadeRfqSwapSchema,
+  ArkadeSwapRecordSchema: () => ArkadeSwapRecordSchema,
   AssetSwapRealmSchemas: () => AssetSwapRealmSchemas,
   RealmAssetSwapRepository: () => RealmAssetSwapRepository
 });
@@ -34,6 +36,7 @@ var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-
 // src/repositories/realm/repository.ts
 var SWAPS = "ArkadeAssetSwap";
 var RFQ_SWAPS = "ArkadeRfqSwap";
+var SWAP_RECORDS = "ArkadeSwapRecord";
 var SCANNED = "ArkadeAssetSwapScannedTxid";
 var MARKETS = "ArkadeAssetSwapMarketsCache";
 var RealmAssetSwapRepository = class {
@@ -41,7 +44,7 @@ var RealmAssetSwapRepository = class {
     this.realm = realm;
   }
   realm;
-  version = 4;
+  version = 5;
   async saveSwap(swap) {
     this.realm.write(() => {
       this.realm.create(
@@ -93,6 +96,38 @@ var RealmAssetSwapRepository = class {
       );
     });
   }
+  async saveSwapRecord(record) {
+    this.realm.write(() => {
+      this.realm.create(
+        SWAP_RECORDS,
+        {
+          id: record.id,
+          family: record.family,
+          updatedAt: record.updatedAt,
+          data: JSON.stringify(record)
+        },
+        "modified"
+      );
+    });
+  }
+  async getSwapRecord(id) {
+    const [found] = [
+      ...this.realm.objects(SWAP_RECORDS).filtered("id == $0", id)
+    ];
+    return found ? JSON.parse(found.data) : void 0;
+  }
+  async getAllSwapRecords() {
+    return [...this.realm.objects(SWAP_RECORDS)].map(
+      (o) => JSON.parse(o.data)
+    );
+  }
+  async removeSwapRecord(id) {
+    this.realm.write(() => {
+      this.realm.delete(
+        this.realm.objects(SWAP_RECORDS).filtered("id == $0", id)
+      );
+    });
+  }
   async getScannedTxids() {
     return new Set([...this.realm.objects(SCANNED)].map((o) => o.txid));
   }
@@ -121,7 +156,7 @@ var RealmAssetSwapRepository = class {
    * partial clear must not be observable. */
   async clear() {
     this.realm.write(() => {
-      for (const name of [SWAPS, RFQ_SWAPS, SCANNED, MARKETS]) {
+      for (const name of [SWAPS, RFQ_SWAPS, SWAP_RECORDS, SCANNED, MARKETS]) {
         this.realm.delete(this.realm.objects(name));
       }
     });
@@ -166,8 +201,19 @@ var ArkadeRfqSwapSchema = {
     data: "string"
   }
 };
+var ArkadeSwapRecordSchema = {
+  name: "ArkadeSwapRecord",
+  primaryKey: "id",
+  properties: {
+    id: "string",
+    family: "string",
+    updatedAt: "int",
+    data: "string"
+  }
+};
 var AssetSwapRealmSchemas = [
   ArkadeRfqSwapSchema,
+  ArkadeSwapRecordSchema,
   ArkadeAssetSwapSchema,
   ArkadeAssetSwapScannedTxidSchema,
   ArkadeAssetSwapMarketsCacheSchema
@@ -177,6 +223,8 @@ var AssetSwapRealmSchemas = [
   ArkadeAssetSwapMarketsCacheSchema,
   ArkadeAssetSwapScannedTxidSchema,
   ArkadeAssetSwapSchema,
+  ArkadeRfqSwapSchema,
+  ArkadeSwapRecordSchema,
   AssetSwapRealmSchemas,
   RealmAssetSwapRepository
 });

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

@@ -1,8 +1,8 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DaK1RzRq.cjs';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, b as SwapRecord, M as MarketsCacheEntry } from '../../repository-oeW8KZo1.cjs';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-DzsmhXX3.cjs';
+import '../../rfq-D0KGjmnn.cjs';
 
 /**
  * Realm backend for React Native.
@@ -26,7 +26,7 @@ import '../../rfq-DzsmhXX3.cjs';
  */
 declare class RealmAssetSwapRepository implements AssetSwapRepository {
     private readonly realm;
-    readonly version: 4;
+    readonly version: 5;
     constructor(realm: RealmLike);
     saveSwap(swap: AssetSwap): Promise<void>;
     getAllSwaps(): Promise<AssetSwap[]>;
@@ -34,6 +34,10 @@ declare class RealmAssetSwapRepository implements AssetSwapRepository {
     getRfqSwap(rfqId: string): Promise<RfqSwapRecord | undefined>;
     getAllRfqSwaps(): Promise<RfqSwapRecord[]>;
     removeRfqSwap(rfqId: string): Promise<void>;
+    saveSwapRecord(record: SwapRecord): Promise<void>;
+    getSwapRecord(id: string): Promise<SwapRecord | undefined>;
+    getAllSwapRecords(): Promise<SwapRecord[]>;
+    removeSwapRecord(id: string): Promise<void>;
     getScannedTxids(): Promise<Set<string>>;
     markTxidsScanned(txids: Iterable<string>): Promise<void>;
     getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
@@ -49,8 +53,8 @@ declare class RealmAssetSwapRepository implements AssetSwapRepository {
  * 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
+ * its own models and the SDK's `Ark*`, 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.
  *
@@ -59,10 +63,12 @@ declare class RealmAssetSwapRepository implements AssetSwapRepository {
  * adds them to its Realm config and bumps its own `schemaVersion`; no migration
  * helper ships here.
  *
- * `ArkadeRfqSwap` arrived after the first three. A consumer already shipping
- * those has to add it and bump `schemaVersion` again — Realm creates schemas on
- * open, so a config that lists three while the code reads four fails on the
- * fourth `realm.objects(…)` rather than at open.
+ * `ArkadeRfqSwap` arrived after the first three, and `ArkadeSwapRecord` after
+ * that. A consumer already shipping the earlier set has to add the new one and
+ * bump `schemaVersion` again — Realm creates schemas on open, so a config that
+ * lists four while the code reads five fails on the fifth `realm.objects(…)`
+ * rather than at open. Export {@link AssetSwapRealmSchemas} into the config
+ * rather than listing names by hand and the mismatch cannot happen.
  */
 declare const ArkadeAssetSwapSchema: {
     name: string;
@@ -89,6 +95,36 @@ declare const ArkadeAssetSwapMarketsCacheSchema: {
         data: string;
     };
 };
+/** Monitored RFQ swaps, keyed by `rfqId`. `state` and `updatedAt` are mapped out
+ * for querying and for the retention sweep (`shouldRetainRfqSwap`); the record
+ * itself goes in whole, `profile` included. */
+declare const ArkadeRfqSwapSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        rfqId: string;
+        state: string;
+        updatedAt: string;
+        data: string;
+    };
+};
+/**
+ * The v2 client's accept records, keyed by the client-minted quote id.
+ *
+ * `family` and `updatedAt` are mapped out for querying; the record itself goes
+ * in whole, which is what keeps a nested corridor `profile` from being lost the
+ * way a field-mapped schema could lose it.
+ */
+declare const ArkadeSwapRecordSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        family: string;
+        updatedAt: string;
+        data: string;
+    };
+};
 declare const AssetSwapRealmSchemas: ({
     name: string;
     primaryKey: string;
@@ -120,6 +156,15 @@ declare const AssetSwapRealmSchemas: ({
         updatedAt: string;
         data: string;
     };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        family: string;
+        updatedAt: string;
+        data: string;
+    };
 })[];
 
-export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };
+export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, ArkadeRfqSwapSchema, ArkadeSwapRecordSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };

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

@@ -1,8 +1,8 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DlLvj_y6.js';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, b as SwapRecord, M as MarketsCacheEntry } from '../../repository-DoR-ahHc.js';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
-import '../../rfq-DzsmhXX3.js';
+import '../../rfq-D0KGjmnn.js';
 
 /**
  * Realm backend for React Native.
@@ -26,7 +26,7 @@ import '../../rfq-DzsmhXX3.js';
  */
 declare class RealmAssetSwapRepository implements AssetSwapRepository {
     private readonly realm;
-    readonly version: 4;
+    readonly version: 5;
     constructor(realm: RealmLike);
     saveSwap(swap: AssetSwap): Promise<void>;
     getAllSwaps(): Promise<AssetSwap[]>;
@@ -34,6 +34,10 @@ declare class RealmAssetSwapRepository implements AssetSwapRepository {
     getRfqSwap(rfqId: string): Promise<RfqSwapRecord | undefined>;
     getAllRfqSwaps(): Promise<RfqSwapRecord[]>;
     removeRfqSwap(rfqId: string): Promise<void>;
+    saveSwapRecord(record: SwapRecord): Promise<void>;
+    getSwapRecord(id: string): Promise<SwapRecord | undefined>;
+    getAllSwapRecords(): Promise<SwapRecord[]>;
+    removeSwapRecord(id: string): Promise<void>;
     getScannedTxids(): Promise<Set<string>>;
     markTxidsScanned(txids: Iterable<string>): Promise<void>;
     getCachedMarkets(network: string, registry: string): Promise<MarketsCacheEntry | undefined>;
@@ -49,8 +53,8 @@ declare class RealmAssetSwapRepository implements AssetSwapRepository {
  * 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
+ * its own models and the SDK's `Ark*`, 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.
  *
@@ -59,10 +63,12 @@ declare class RealmAssetSwapRepository implements AssetSwapRepository {
  * adds them to its Realm config and bumps its own `schemaVersion`; no migration
  * helper ships here.
  *
- * `ArkadeRfqSwap` arrived after the first three. A consumer already shipping
- * those has to add it and bump `schemaVersion` again — Realm creates schemas on
- * open, so a config that lists three while the code reads four fails on the
- * fourth `realm.objects(…)` rather than at open.
+ * `ArkadeRfqSwap` arrived after the first three, and `ArkadeSwapRecord` after
+ * that. A consumer already shipping the earlier set has to add the new one and
+ * bump `schemaVersion` again — Realm creates schemas on open, so a config that
+ * lists four while the code reads five fails on the fifth `realm.objects(…)`
+ * rather than at open. Export {@link AssetSwapRealmSchemas} into the config
+ * rather than listing names by hand and the mismatch cannot happen.
  */
 declare const ArkadeAssetSwapSchema: {
     name: string;
@@ -89,6 +95,36 @@ declare const ArkadeAssetSwapMarketsCacheSchema: {
         data: string;
     };
 };
+/** Monitored RFQ swaps, keyed by `rfqId`. `state` and `updatedAt` are mapped out
+ * for querying and for the retention sweep (`shouldRetainRfqSwap`); the record
+ * itself goes in whole, `profile` included. */
+declare const ArkadeRfqSwapSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        rfqId: string;
+        state: string;
+        updatedAt: string;
+        data: string;
+    };
+};
+/**
+ * The v2 client's accept records, keyed by the client-minted quote id.
+ *
+ * `family` and `updatedAt` are mapped out for querying; the record itself goes
+ * in whole, which is what keeps a nested corridor `profile` from being lost the
+ * way a field-mapped schema could lose it.
+ */
+declare const ArkadeSwapRecordSchema: {
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        family: string;
+        updatedAt: string;
+        data: string;
+    };
+};
 declare const AssetSwapRealmSchemas: ({
     name: string;
     primaryKey: string;
@@ -120,6 +156,15 @@ declare const AssetSwapRealmSchemas: ({
         updatedAt: string;
         data: string;
     };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        id: string;
+        family: string;
+        updatedAt: string;
+        data: string;
+    };
 })[];
 
-export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };
+export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, ArkadeRfqSwapSchema, ArkadeSwapRecordSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };