@arkade-os/swap 0.0.7 → 0.0.9

package/dist/nostr.cjs

@@ -62,6 +62,7 @@ var import_sdk3 = require("@arkade-os/sdk");
 
 // src/claimPacket.ts
 var import_base2 = require("@scure/base");
+var import_aes = require("@noble/ciphers/aes.js");
 var import_secp256k1 = require("@noble/curves/secp256k1.js");
 var import_hkdf = require("@noble/hashes/hkdf.js");
 var import_sha22 = require("@noble/hashes/sha2.js");

package/dist/nostr.d.cts

@@ -1,4 +1,4 @@
-import { a as RfqTransport } from './rfq-DfT9dAss.cjs';
+import { y as RfqTransport } from './rfq-hbzhTWHT.cjs';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 

package/dist/nostr.d.ts

@@ -1,4 +1,4 @@
-import { a as RfqTransport } from './rfq-DfT9dAss.js';
+import { y as RfqTransport } from './rfq-hbzhTWHT.js';
 import { SimplePool } from 'nostr-tools';
 import '@arkade-os/sdk';
 

package/dist/nostr.js

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

package/dist/repositories/realm/index.cjs

@@ -33,6 +33,7 @@ var marketsCacheKey = (network, registry) => `arkade-intents-markets-${network}-
 
 // src/repositories/realm/repository.ts
 var SWAPS = "ArkadeAssetSwap";
+var RFQ_SWAPS = "ArkadeRfqSwap";
 var SCANNED = "ArkadeAssetSwapScannedTxid";
 var MARKETS = "ArkadeAssetSwapMarketsCache";
 var RealmAssetSwapRepository = class {
@@ -40,7 +41,7 @@ var RealmAssetSwapRepository = class {
     this.realm = realm;
   }
   realm;
-  version = 2;
+  version = 4;
   async saveSwap(swap) {
     this.realm.write(() => {
       this.realm.create(
@@ -60,6 +61,38 @@ var RealmAssetSwapRepository = class {
       (o) => JSON.parse(o.data)
     );
   }
+  async saveRfqSwap(record) {
+    this.realm.write(() => {
+      this.realm.create(
+        RFQ_SWAPS,
+        {
+          rfqId: record.rfqId,
+          state: record.state,
+          updatedAt: record.updatedAt,
+          data: JSON.stringify(record)
+        },
+        "modified"
+      );
+    });
+  }
+  async getRfqSwap(rfqId) {
+    const [found] = [
+      ...this.realm.objects(RFQ_SWAPS).filtered("rfqId == $0", rfqId)
+    ];
+    return found ? JSON.parse(found.data) : void 0;
+  }
+  async getAllRfqSwaps() {
+    return [...this.realm.objects(RFQ_SWAPS)].map(
+      (o) => JSON.parse(o.data)
+    );
+  }
+  async removeRfqSwap(rfqId) {
+    this.realm.write(() => {
+      this.realm.delete(
+        this.realm.objects(RFQ_SWAPS).filtered("rfqId == $0", rfqId)
+      );
+    });
+  }
   async getScannedTxids() {
     return new Set([...this.realm.objects(SCANNED)].map((o) => o.txid));
   }
@@ -83,12 +116,12 @@ var RealmAssetSwapRepository = class {
       );
     });
   }
-  /** 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. */
+  /** Every schema 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]) {
+      for (const name of [SWAPS, RFQ_SWAPS, SCANNED, MARKETS]) {
         this.realm.delete(this.realm.objects(name));
       }
     });
@@ -123,7 +156,18 @@ var ArkadeAssetSwapMarketsCacheSchema = {
     data: "string"
   }
 };
+var ArkadeRfqSwapSchema = {
+  name: "ArkadeRfqSwap",
+  primaryKey: "rfqId",
+  properties: {
+    rfqId: "string",
+    state: "string",
+    updatedAt: "int",
+    data: "string"
+  }
+};
 var AssetSwapRealmSchemas = [
+  ArkadeRfqSwapSchema,
   ArkadeAssetSwapSchema,
   ArkadeAssetSwapScannedTxidSchema,
   ArkadeAssetSwapMarketsCacheSchema

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

@@ -1,7 +1,8 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.cjs';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DEHLtD9l.cjs';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
+import '../../rfq-hbzhTWHT.cjs';
 
 /**
  * Realm backend for React Native.
@@ -15,24 +16,31 @@ import '@arkade-os/sdk';
  * 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.
+ * design, and so is `RfqSwapRecord` — including its corridor `profile`, which is
+ * plain JSON by the handler contract (see `rfqCorridor.ts`). Whole-record
+ * storage is what keeps a nested `profile.hashlock` from being lost the way a
+ * field-mapped backend could lose it.
  *
  * 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;
+    readonly version: 4;
     constructor(realm: RealmLike);
     saveSwap(swap: AssetSwap): Promise<void>;
     getAllSwaps(): Promise<AssetSwap[]>;
+    saveRfqSwap(record: RfqSwapRecord): Promise<void>;
+    getRfqSwap(rfqId: string): Promise<RfqSwapRecord | undefined>;
+    getAllRfqSwaps(): Promise<RfqSwapRecord[]>;
+    removeRfqSwap(rfqId: string): Promise<void>;
     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. */
+    /** Every schema 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>;
 }
@@ -50,6 +58,11 @@ declare class RealmAssetSwapRepository implements AssetSwapRepository {
  * 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.
+ *
+ * `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.
  */
 declare const ArkadeAssetSwapSchema: {
     name: string;
@@ -98,6 +111,15 @@ declare const AssetSwapRealmSchemas: ({
         key: string;
         data: string;
     };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        rfqId: string;
+        state: string;
+        updatedAt: string;
+        data: string;
+    };
 })[];
 
 export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };

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

@@ -1,7 +1,8 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.js';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DIAr5XYk.js';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
+import '../../rfq-hbzhTWHT.js';
 
 /**
  * Realm backend for React Native.
@@ -15,24 +16,31 @@ import '@arkade-os/sdk';
  * 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.
+ * design, and so is `RfqSwapRecord` — including its corridor `profile`, which is
+ * plain JSON by the handler contract (see `rfqCorridor.ts`). Whole-record
+ * storage is what keeps a nested `profile.hashlock` from being lost the way a
+ * field-mapped backend could lose it.
  *
  * 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;
+    readonly version: 4;
     constructor(realm: RealmLike);
     saveSwap(swap: AssetSwap): Promise<void>;
     getAllSwaps(): Promise<AssetSwap[]>;
+    saveRfqSwap(record: RfqSwapRecord): Promise<void>;
+    getRfqSwap(rfqId: string): Promise<RfqSwapRecord | undefined>;
+    getAllRfqSwaps(): Promise<RfqSwapRecord[]>;
+    removeRfqSwap(rfqId: string): Promise<void>;
     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. */
+    /** Every schema 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>;
 }
@@ -50,6 +58,11 @@ declare class RealmAssetSwapRepository implements AssetSwapRepository {
  * 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.
+ *
+ * `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.
  */
 declare const ArkadeAssetSwapSchema: {
     name: string;
@@ -98,6 +111,15 @@ declare const AssetSwapRealmSchemas: ({
         key: string;
         data: string;
     };
+} | {
+    name: string;
+    primaryKey: string;
+    properties: {
+        rfqId: string;
+        state: string;
+        updatedAt: string;
+        data: string;
+    };
 })[];
 
 export { ArkadeAssetSwapMarketsCacheSchema, ArkadeAssetSwapScannedTxidSchema, ArkadeAssetSwapSchema, AssetSwapRealmSchemas, RealmAssetSwapRepository };

package/dist/repositories/realm/index.js

@@ -1,9 +1,10 @@
 import {
   marketsCacheKey
-} from "../../chunk-WGRU2DBF.js";
+} from "../../chunk-6ZUS47GA.js";
 
 // src/repositories/realm/repository.ts
 var SWAPS = "ArkadeAssetSwap";
+var RFQ_SWAPS = "ArkadeRfqSwap";
 var SCANNED = "ArkadeAssetSwapScannedTxid";
 var MARKETS = "ArkadeAssetSwapMarketsCache";
 var RealmAssetSwapRepository = class {
@@ -11,7 +12,7 @@ var RealmAssetSwapRepository = class {
     this.realm = realm;
   }
   realm;
-  version = 2;
+  version = 4;
   async saveSwap(swap) {
     this.realm.write(() => {
       this.realm.create(
@@ -31,6 +32,38 @@ var RealmAssetSwapRepository = class {
       (o) => JSON.parse(o.data)
     );
   }
+  async saveRfqSwap(record) {
+    this.realm.write(() => {
+      this.realm.create(
+        RFQ_SWAPS,
+        {
+          rfqId: record.rfqId,
+          state: record.state,
+          updatedAt: record.updatedAt,
+          data: JSON.stringify(record)
+        },
+        "modified"
+      );
+    });
+  }
+  async getRfqSwap(rfqId) {
+    const [found] = [
+      ...this.realm.objects(RFQ_SWAPS).filtered("rfqId == $0", rfqId)
+    ];
+    return found ? JSON.parse(found.data) : void 0;
+  }
+  async getAllRfqSwaps() {
+    return [...this.realm.objects(RFQ_SWAPS)].map(
+      (o) => JSON.parse(o.data)
+    );
+  }
+  async removeRfqSwap(rfqId) {
+    this.realm.write(() => {
+      this.realm.delete(
+        this.realm.objects(RFQ_SWAPS).filtered("rfqId == $0", rfqId)
+      );
+    });
+  }
   async getScannedTxids() {
     return new Set([...this.realm.objects(SCANNED)].map((o) => o.txid));
   }
@@ -54,12 +87,12 @@ var RealmAssetSwapRepository = class {
       );
     });
   }
-  /** 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. */
+  /** Every schema 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]) {
+      for (const name of [SWAPS, RFQ_SWAPS, SCANNED, MARKETS]) {
         this.realm.delete(this.realm.objects(name));
       }
     });
@@ -94,7 +127,18 @@ var ArkadeAssetSwapMarketsCacheSchema = {
     data: "string"
   }
 };
+var ArkadeRfqSwapSchema = {
+  name: "ArkadeRfqSwap",
+  primaryKey: "rfqId",
+  properties: {
+    rfqId: "string",
+    state: "string",
+    updatedAt: "int",
+    data: "string"
+  }
+};
 var AssetSwapRealmSchemas = [
+  ArkadeRfqSwapSchema,
   ArkadeAssetSwapSchema,
   ArkadeAssetSwapScannedTxidSchema,
   ArkadeAssetSwapMarketsCacheSchema

package/dist/repositories/sqlite/index.cjs

@@ -38,14 +38,16 @@ var SQLiteAssetSwapRepository = class {
     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.scanned = `${this.prefix}asset_swap_scanned_txids`;
     this.markets = `${this.prefix}asset_swap_markets`;
   }
   db;
-  version = 2;
+  version = 4;
   initPromise = null;
   prefix;
   swaps;
+  rfqSwaps;
   scanned;
   markets;
   /** A rejected init is not cached. The DDL runs in a transaction on a shared
@@ -77,6 +79,15 @@ var SQLiteAssetSwapRepository = class {
       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.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)`
@@ -107,6 +118,35 @@ var SQLiteAssetSwapRepository = class {
     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 getScannedTxids() {
     await this.ensureInit();
     const rows = await this.db.all(`SELECT txid FROM ${this.scanned}`);
@@ -143,13 +183,14 @@ var SQLiteAssetSwapRepository = class {
       );
     });
   }
-  /** 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. */
+  /** 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.scanned}`);
       await this.db.run(`DELETE FROM ${this.markets}`);
     });

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

@@ -1,7 +1,8 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.cjs';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DEHLtD9l.cjs';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
+import '../../rfq-hbzhTWHT.cjs';
 
 /**
  * SQLite backend over the SDK's `SQLExecutor`, so any driver plugs in
@@ -11,19 +12,27 @@ import '@arkade-os/sdk';
  * 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.
+ * backend's structured clone. `AssetSwap` itself is JSON-safe by design, and so
+ * is `RfqSwapRecord` — including its corridor `profile`, which is plain JSON by
+ * the handler contract (see `rfqCorridor.ts`). Whole-record storage is what
+ * keeps a nested `profile.hashlock` from being lost the way a field-mapped
+ * backend could lose it.
  *
- * Tables are created lazily on first operation. The consumer owns the
+ * Tables are created lazily on first operation, and `CREATE TABLE IF NOT
+ * EXISTS` runs on every init — so the `rfq_swaps` table appears for an existing
+ * database on its next operation, with no migration and no version to bump.
+ * 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;
+    readonly version: 4;
     private initPromise;
     private readonly prefix;
     private readonly swaps;
+    private readonly rfqSwaps;
     private readonly scanned;
     private readonly markets;
     constructor(db: SQLExecutor, options?: {
@@ -49,13 +58,17 @@ declare class SQLiteAssetSwapRepository implements AssetSwapRepository {
     private withTx;
     saveSwap(swap: AssetSwap): Promise<void>;
     getAllSwaps(): Promise<AssetSwap[]>;
+    saveRfqSwap(record: RfqSwapRecord): Promise<void>;
+    getRfqSwap(rfqId: string): Promise<RfqSwapRecord | undefined>;
+    getAllRfqSwaps(): Promise<RfqSwapRecord[]>;
+    removeRfqSwap(rfqId: string): Promise<void>;
     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. */
+    /** 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. */
     clear(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
 }

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

@@ -1,7 +1,8 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { A as AssetSwapRepository, a as AssetSwap, M as MarketsCacheEntry } from '../../repository-BwnZ8N62.js';
+import { A as AssetSwapRepository, a as AssetSwap, R as RfqSwapRecord, M as MarketsCacheEntry } from '../../repository-DIAr5XYk.js';
 import '@arkade-os/solver-discovery';
 import '@arkade-os/sdk';
+import '../../rfq-hbzhTWHT.js';
 
 /**
  * SQLite backend over the SDK's `SQLExecutor`, so any driver plugs in
@@ -11,19 +12,27 @@ import '@arkade-os/sdk';
  * 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.
+ * backend's structured clone. `AssetSwap` itself is JSON-safe by design, and so
+ * is `RfqSwapRecord` — including its corridor `profile`, which is plain JSON by
+ * the handler contract (see `rfqCorridor.ts`). Whole-record storage is what
+ * keeps a nested `profile.hashlock` from being lost the way a field-mapped
+ * backend could lose it.
  *
- * Tables are created lazily on first operation. The consumer owns the
+ * Tables are created lazily on first operation, and `CREATE TABLE IF NOT
+ * EXISTS` runs on every init — so the `rfq_swaps` table appears for an existing
+ * database on its next operation, with no migration and no version to bump.
+ * 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;
+    readonly version: 4;
     private initPromise;
     private readonly prefix;
     private readonly swaps;
+    private readonly rfqSwaps;
     private readonly scanned;
     private readonly markets;
     constructor(db: SQLExecutor, options?: {
@@ -49,13 +58,17 @@ declare class SQLiteAssetSwapRepository implements AssetSwapRepository {
     private withTx;
     saveSwap(swap: AssetSwap): Promise<void>;
     getAllSwaps(): Promise<AssetSwap[]>;
+    saveRfqSwap(record: RfqSwapRecord): Promise<void>;
+    getRfqSwap(rfqId: string): Promise<RfqSwapRecord | undefined>;
+    getAllRfqSwaps(): Promise<RfqSwapRecord[]>;
+    removeRfqSwap(rfqId: string): Promise<void>;
     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. */
+    /** 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. */
     clear(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
 }

package/dist/repositories/sqlite/index.js

@@ -1,6 +1,6 @@
 import {
   marketsCacheKey
-} from "../../chunk-WGRU2DBF.js";
+} from "../../chunk-6ZUS47GA.js";
 
 // src/repositories/sqlite/repository.ts
 import {
@@ -14,14 +14,16 @@ var SQLiteAssetSwapRepository = class {
     this.db = db;
     this.prefix = sanitizeTablePrefix(options?.prefix ?? DEFAULT_PREFIX);
     this.swaps = `${this.prefix}asset_swaps`;
+    this.rfqSwaps = `${this.prefix}rfq_swaps`;
     this.scanned = `${this.prefix}asset_swap_scanned_txids`;
     this.markets = `${this.prefix}asset_swap_markets`;
   }
   db;
-  version = 2;
+  version = 4;
   initPromise = null;
   prefix;
   swaps;
+  rfqSwaps;
   scanned;
   markets;
   /** A rejected init is not cached. The DDL runs in a transaction on a shared
@@ -53,6 +55,15 @@ var SQLiteAssetSwapRepository = class {
       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.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)`
@@ -83,6 +94,35 @@ var SQLiteAssetSwapRepository = class {
     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 getScannedTxids() {
     await this.ensureInit();
     const rows = await this.db.all(`SELECT txid FROM ${this.scanned}`);
@@ -119,13 +159,14 @@ var SQLiteAssetSwapRepository = class {
       );
     });
   }
-  /** 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. */
+  /** 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.scanned}`);
       await this.db.run(`DELETE FROM ${this.markets}`);
     });