@arkade-os/sdk 0.5.0-rc.2 → 0.5.0-rc.20

package/dist/repositories/sqlite/index.js

@@ -1,9 +1,8 @@
-import { scriptFromArkAddress, serializeVtxo, isVtxoForScript, serializeUtxo, serializeAssets, deserializeVtxo, deserializeUtxo, deserializeAssets, intentMatchesFilter, intentPageBounds, isTerminalIntentState, mergeChainedTxType } from '../../chunk-ZRNQV6HV.js';
-export { ChainedTxType } from '../../chunk-ZRNQV6HV.js';
-import '../../chunk-4PKLULWT.js';
-import '../../chunk-3R476TDV.js';
-import '../../chunk-ISO4TI5J.js';
-import '../../chunk-NSBPE2FW.js';
+import { scriptFromArkAddress, legacyVtxoFacts, serializeVtxo, createdAtToIso, assertPageRequest, pageResult, checkSaveVtxosForScript, utxoEntries, serializeUtxo, assertHistoryPageFilter, serializeAssets, deserializeVtxo, deserializeUtxo, deserializeAssets, contractFilterMatchesNothing, intentMatchesFilter, isTerminalIntentState, mergeChainedTxType } from '../../chunk-O2ZZD5Z6.js';
+export { ChainedTxType } from '../../chunk-O2ZZD5Z6.js';
+import '../../chunk-AARSVV3S.js';
+import '../../chunk-TIVYJIIX.js';
+import { isVtxoSpent } from '../../chunk-NR4XYTN3.js';
 
 // src/repositories/sqlite/transaction.ts
 var writeChains = /* @__PURE__ */ new WeakMap();
@@ -30,11 +29,19 @@ function runInTransaction(db, fn) {
   return run;
 }
 
+// src/repositories/sqlite/prefix.ts
+var SAFE_PREFIX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function sanitizeTablePrefix(p) {
+  if (!SAFE_PREFIX.test(p)) throw new Error(`Invalid table prefix "${p}"`);
+  return p;
+}
+
 // src/repositories/sqlite/walletRepository.ts
+var MAX_BOUND_PARAMETERS = 999;
 var SQLiteWalletRepository = class {
   constructor(db, options) {
     this.db = db;
-    this.prefix = sanitizePrefix(options?.prefix ?? "ark_");
+    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
     this.tables = {
       vtxos: `${this.prefix}vtxos`,
       utxos: `${this.prefix}utxos`,
@@ -43,7 +50,7 @@ var SQLiteWalletRepository = class {
     };
   }
   db;
-  version = 1;
+  version = 2;
   initPromise = null;
   prefix;
   tables;
@@ -99,23 +106,42 @@ var SQLiteWalletRepository = class {
     await this.db.run(
       `CREATE INDEX IF NOT EXISTS idx_${this.prefix}vtxos_script ON ${this.tables.vtxos} (script)`
     );
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_${this.prefix}vtxos_script_page ON ${this.tables.vtxos} (script, address, txid, vout)`
+    );
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_${this.prefix}vtxos_address_page ON ${this.tables.vtxos} (address, txid, vout)`
+    );
+    await this.db.run(`DROP INDEX IF EXISTS idx_${this.prefix}vtxos_live_script`);
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_${this.prefix}vtxos_live_script_page ON ${this.tables.vtxos} (script, address, txid, vout)
+             WHERE ${UNSPENT_VTXO_PREDICATE}`
+    );
     await this.db.run(
       `CREATE INDEX IF NOT EXISTS idx_${this.prefix}utxos_address ON ${this.tables.utxos} (address)`
     );
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_${this.prefix}utxos_address_page ON ${this.tables.utxos} (address, txid, vout)`
+    );
     await this.db.run(
       `CREATE INDEX IF NOT EXISTS idx_${this.prefix}transactions_address ON ${this.tables.transactions} (address)`
     );
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_${this.prefix}transactions_history ON ${this.tables.transactions} (address, created_at, boarding_txid, commitment_txid, ark_txid)`
+    );
   }
   /**
    * Bring the `vtxos` table to the current schema (v1 = `script` NOT NULL).
    *
-   * Three cases:
+   * Four cases:
    *   - Fresh install: create the v1 schema directly.
    *   - Legacy install without a `script` column: add it, backfill from
    *     `address`, then rebuild the table with NOT NULL (SQLite cannot add
    *     the NOT NULL constraint in place).
    *   - Legacy install with a nullable `script` column: backfill the NULLs
    *     and rebuild.
+   *   - 0.4.x install: `script` is already NOT NULL but `virtual_status_json
+   *     NOT NULL` is still there, and `saveVtxos` no longer writes it.
    *
    * The backfill derives `script` from the Ark address, matching what the
    * indexer would have returned — new rows from the indexer always carry a
@@ -143,7 +169,27 @@ var SQLiteWalletRepository = class {
         `PRAGMA table_info(${this.tables.vtxos})`
       );
       const scriptCol = cols.find((c) => c.name === "script");
-      if (scriptCol && scriptCol.notnull === 1) {
+      const nullableCanonicalColumns = [
+        ["is_swept", "INTEGER"],
+        ["is_preconfirmed", "INTEGER"],
+        ["commitment_txids_json", "TEXT"],
+        ["expires_at", "TEXT"],
+        ["expires_at_height", "INTEGER"]
+      ];
+      let addedCanonicalColumns = false;
+      for (const [name, type] of nullableCanonicalColumns) {
+        if (!cols.some((c) => c.name === name)) {
+          await this.db.run(
+            `ALTER TABLE ${this.tables.vtxos} ADD COLUMN ${name} ${type}`
+          );
+          addedCanonicalColumns = true;
+        }
+      }
+      const hasLegacyBlob = cols.some((c) => c.name === "virtual_status_json");
+      if (addedCanonicalColumns && hasLegacyBlob) {
+        await this.backfillCanonicalVtxoColumns();
+      }
+      if (scriptCol && scriptCol.notnull === 1 && !hasLegacyBlob) {
         return;
       }
       if (!scriptCol) {
@@ -163,20 +209,58 @@ var SQLiteWalletRepository = class {
                 INSERT INTO ${tempName}
                     (txid, vout, value, address, tap_tree,
                      forfeit_cb, forfeit_s, intent_cb, intent_s,
-                     status_json, virtual_status_json, created_at,
-                     is_unrolled, is_spent, spent_by, settled_by, ark_tx_id,
-                     extra_witness_json, assets_json, script)
+                     status_json, created_at, is_unrolled, is_spent,
+                     is_swept, is_preconfirmed, commitment_txids_json,
+                     expires_at, expires_at_height,
+                     spent_by, settled_by, ark_tx_id, extra_witness_json, assets_json, script)
                 SELECT txid, vout, value, address, tap_tree,
                        forfeit_cb, forfeit_s, intent_cb, intent_s,
-                       status_json, virtual_status_json, created_at,
-                       is_unrolled, is_spent, spent_by, settled_by, ark_tx_id,
-                       extra_witness_json, assets_json, script
+                       status_json, created_at, is_unrolled, is_spent,
+                       is_swept, is_preconfirmed, commitment_txids_json,
+                       expires_at, expires_at_height,
+                       spent_by, settled_by, ark_tx_id, extra_witness_json, assets_json, script
                 FROM ${this.tables.vtxos}
             `);
       await this.db.run(`DROP TABLE ${this.tables.vtxos}`);
       await this.db.run(`ALTER TABLE ${tempName} RENAME TO ${this.tables.vtxos}`);
     });
   }
+  /**
+   * Copy the canonical VTXO facts out of the legacy `virtual_status_json` blob.
+   *
+   * Scoped to rows that still have `is_swept` NULL, which is what "never backfilled" looks
+   * like: the copy writes 0 or 1 to every row it touches, so a second pass — a later column
+   * addition, say — cannot overwrite what an indexer sync has since corrected. Rows whose blob
+   * is missing or corrupt are left alone: a migration must not be stopped by one bad row, and
+   * the next sync repairs it.
+   */
+  async backfillCanonicalVtxoColumns() {
+    const rows = await this.db.all(
+      `SELECT txid, vout, virtual_status_json FROM ${this.tables.vtxos}
+             WHERE virtual_status_json IS NOT NULL AND is_swept IS NULL`
+    );
+    for (const row of rows) {
+      const facts = legacyVtxoFacts(row.virtual_status_json);
+      if (!facts) continue;
+      await this.db.run(
+        `UPDATE ${this.tables.vtxos}
+                 SET is_swept = ?, is_preconfirmed = ?, commitment_txids_json = ?,
+                     expires_at = ?, expires_at_height = ?,
+                     is_spent = COALESCE(is_spent, ?)
+                 WHERE txid = ? AND vout = ?`,
+        [
+          facts.isSwept ? 1 : 0,
+          facts.isPreconfirmed ? 1 : 0,
+          facts.commitmentTxIds ? JSON.stringify(facts.commitmentTxIds) : null,
+          facts.expiresAt ? facts.expiresAt.toISOString() : null,
+          facts.expiresAtHeight ?? null,
+          facts.isSpent ? 1 : 0,
+          row.txid,
+          row.vout
+        ]
+      );
+    }
+  }
   vtxosCreateSql(tableName) {
     return `CREATE TABLE ${tableName} (
             txid TEXT NOT NULL,
@@ -189,10 +273,14 @@ var SQLiteWalletRepository = class {
             intent_cb TEXT NOT NULL,
             intent_s TEXT NOT NULL,
             status_json TEXT NOT NULL,
-            virtual_status_json TEXT NOT NULL,
             created_at TEXT NOT NULL,
             is_unrolled INTEGER NOT NULL DEFAULT 0,
             is_spent INTEGER,
+            is_swept INTEGER,
+            is_preconfirmed INTEGER,
+            commitment_txids_json TEXT,
+            expires_at TEXT,
+            expires_at_height INTEGER,
             spent_by TEXT,
             settled_by TEXT,
             ark_tx_id TEXT,
@@ -202,6 +290,23 @@ var SQLiteWalletRepository = class {
             PRIMARY KEY (txid, vout)
         )`;
   }
+  /**
+   * `INSERT OR REPLACE` rows, as many to a statement as the parameter budget allows.
+   * No enclosing transaction: on the shared connection it would take in other repos' writes.
+   */
+  async insertOrReplace(table, columns, rows) {
+    const width = columns.split(",").length;
+    const tuple = `(${Array(width).fill("?").join(", ")})`;
+    const rowsPerStatement = Math.floor(MAX_BOUND_PARAMETERS / width);
+    for (let i = 0; i < rows.length; i += rowsPerStatement) {
+      const chunk = rows.slice(i, i + rowsPerStatement);
+      await this.db.run(
+        `INSERT OR REPLACE INTO ${table} (${columns})
+                 VALUES ${chunk.map(() => tuple).join(", ")}`,
+        chunk.flat()
+      );
+    }
+  }
   async [Symbol.asyncDispose]() {
   }
   // ── Clear ──────────────────────────────────────────────────────────
@@ -213,31 +318,22 @@ var SQLiteWalletRepository = class {
     await this.db.run(`DELETE FROM ${this.tables.walletState}`);
   }
   // ── VTXO management ────────────────────────────────────────────────
-  async getVtxos(address) {
-    await this.ensureInit();
-    const rows = await this.db.all(
-      `SELECT * FROM ${this.tables.vtxos} WHERE address = ?`,
-      [address]
-    );
-    return rows.map(vtxoRowToDomain);
+  async getVtxosPage(address, page) {
+    return this.pageByAddress(this.tables.vtxos, address, page, vtxoRowToDomain);
   }
   async saveVtxos(address, vtxos) {
     await this.ensureInit();
-    for (const vtxo of vtxos) {
-      const s = serializeVtxo(vtxo);
-      await this.db.run(
-        `INSERT OR REPLACE INTO ${this.tables.vtxos}
-                    (txid, vout, value, address,
-                     tap_tree, forfeit_cb, forfeit_s, intent_cb, intent_s,
-                     status_json, virtual_status_json, created_at,
-                     is_unrolled, is_spent, spent_by, settled_by, ark_tx_id,
-                     extra_witness_json, assets_json, script)
-                 VALUES (?, ?, ?, ?,
-                         ?, ?, ?, ?, ?,
-                         ?, ?, ?,
-                         ?, ?, ?, ?, ?,
-                         ?, ?, ?)`,
-        [
+    await this.insertOrReplace(
+      this.tables.vtxos,
+      `txid, vout, value, address,
+             tap_tree, forfeit_cb, forfeit_s, intent_cb, intent_s,
+             status_json, created_at, is_unrolled, is_spent,
+             is_swept, is_preconfirmed, commitment_txids_json,
+             expires_at, expires_at_height,
+             spent_by, settled_by, ark_tx_id, extra_witness_json, assets_json, script`,
+      vtxos.map((vtxo) => {
+        const s = serializeVtxo(vtxo);
+        return [
           s.txid,
           s.vout,
           s.value,
@@ -248,71 +344,82 @@ var SQLiteWalletRepository = class {
           s.intentTapLeafScript.cb,
           s.intentTapLeafScript.s,
           JSON.stringify(s.status),
-          JSON.stringify(s.virtualStatus),
-          typeof s.createdAt === "string" ? s.createdAt : s.createdAt instanceof Date ? s.createdAt.toISOString() : new Date(s.createdAt).toISOString(),
+          createdAtToIso(s.createdAt),
           s.isUnrolled ? 1 : 0,
           s.isSpent === void 0 ? null : s.isSpent ? 1 : 0,
+          s.isSwept === void 0 ? null : s.isSwept ? 1 : 0,
+          s.isPreconfirmed === void 0 ? null : s.isPreconfirmed ? 1 : 0,
+          s.commitmentTxIds ? JSON.stringify(s.commitmentTxIds) : null,
+          s.expiresAt === void 0 ? null : new Date(s.expiresAt).toISOString(),
+          s.expiresAtHeight ?? null,
           s.spentBy ?? null,
           s.settledBy ?? null,
           s.arkTxId ?? null,
           s.extraWitness ? JSON.stringify(s.extraWitness) : null,
           s.assets ? JSON.stringify(s.assets) : null,
           s.script ?? null
-        ]
-      );
-    }
+        ];
+      })
+    );
   }
   async deleteVtxos(address) {
     await this.ensureInit();
     await this.db.run(`DELETE FROM ${this.tables.vtxos} WHERE address = ?`, [address]);
   }
-  async getVtxosForScript(script) {
+  async getVtxosForScriptPage(script, page, options) {
+    assertPageRequest(page);
     await this.ensureInit();
+    const after = page.after;
     const rows = await this.db.all(
-      `SELECT * FROM ${this.tables.vtxos} WHERE script = ?`,
-      [script]
+      `SELECT * FROM ${this.tables.vtxos} WHERE script = ?
+             ${options?.unspentOnly ? `AND ${UNSPENT_VTXO_PREDICATE}` : ""}
+             ${after ? "AND (address > ? OR (address = ? AND (txid > ? OR (txid = ? AND vout > ?))))" : ""}
+             ORDER BY address, txid, vout LIMIT ?`,
+      after ? [
+        script,
+        after.address,
+        after.address,
+        after.txid,
+        after.txid,
+        after.vout,
+        page.limit + 1
+      ] : [script, page.limit + 1]
     );
-    return rows.map(vtxoRowToDomain);
+    const result = pageResult(
+      rows.map((row) => ({ address: row.address, vtxo: vtxoRowToDomain(row) })),
+      page.limit,
+      (row) => ({ address: row.address, txid: row.vtxo.txid, vout: row.vtxo.vout })
+    );
+    return options?.unspentOnly ? { ...result, items: result.items.filter((row) => !isVtxoSpent(row.vtxo)) } : result;
   }
   async saveVtxosForScript(key, vtxos) {
-    if (!key.address) {
-      throw new Error("SQLiteWalletRepository requires an address");
-    }
-    for (const vtxo of vtxos) {
-      if (!isVtxoForScript(vtxo, key.script)) {
-        throw new Error(
-          `VTXO ${vtxo.txid}:${vtxo.vout} script mismatch: expected ${key.script}, got ${vtxo.script}`
-        );
-      }
-    }
-    return this.saveVtxos(key.address, vtxos);
+    return this.saveVtxos(checkSaveVtxosForScript("SQLiteWalletRepository", key, vtxos), vtxos);
   }
   async deleteVtxosForScript(script) {
     await this.ensureInit();
     await this.db.run(`DELETE FROM ${this.tables.vtxos} WHERE script = ?`, [script]);
   }
   // ── UTXO management ────────────────────────────────────────────────
-  async getUtxos(address) {
+  async getUtxosPage(address, page) {
+    return this.pageByAddress(this.tables.utxos, address, page, utxoRowToDomain);
+  }
+  async pageByAddress(table, address, page, deserialize) {
+    assertPageRequest(page);
     await this.ensureInit();
     const rows = await this.db.all(
-      `SELECT * FROM ${this.tables.utxos} WHERE address = ?`,
-      [address]
+      `SELECT * FROM ${table} WHERE address = ? AND (txid, vout) > (?, ?)
+             ORDER BY txid, vout LIMIT ?`,
+      [address, page.after?.txid ?? "", page.after?.vout ?? -1, page.limit + 1]
     );
-    return rows.map(utxoRowToDomain);
+    const result = pageResult(rows, page.limit, ({ txid, vout }) => ({ txid, vout }));
+    return { items: result.items.map(deserialize), nextCursor: result.nextCursor };
   }
-  async saveUtxos(address, utxos) {
+  async saveUtxos(addressOrBatch, utxos) {
     await this.ensureInit();
-    for (const utxo of utxos) {
-      const s = serializeUtxo(utxo);
-      await this.db.run(
-        `INSERT OR REPLACE INTO ${this.tables.utxos}
-                    (txid, vout, value, address,
-                     tap_tree, forfeit_cb, forfeit_s, intent_cb, intent_s,
-                     status_json, extra_witness_json)
-                 VALUES (?, ?, ?, ?,
-                         ?, ?, ?, ?, ?,
-                         ?, ?)`,
-        [
+    const rows = utxoEntries(addressOrBatch, utxos).flatMap(
+      ([address, list]) => list.map((utxo) => {
+        const s = serializeUtxo(utxo);
+        return [
           s.txid,
           s.vout,
           s.value,
@@ -324,45 +431,71 @@ var SQLiteWalletRepository = class {
           s.intentTapLeafScript.s,
           JSON.stringify(s.status),
           s.extraWitness ? JSON.stringify(s.extraWitness) : null
-        ]
-      );
-    }
+        ];
+      })
+    );
+    await this.insertOrReplace(
+      this.tables.utxos,
+      `txid, vout, value, address,
+             tap_tree, forfeit_cb, forfeit_s, intent_cb, intent_s,
+             status_json, extra_witness_json`,
+      rows
+    );
   }
   async deleteUtxos(address) {
     await this.ensureInit();
     await this.db.run(`DELETE FROM ${this.tables.utxos} WHERE address = ?`, [address]);
   }
   // ── Transaction history ────────────────────────────────────────────
-  async getTransactionHistory(address) {
+  async getTransactionHistoryPage(filter, page) {
+    assertPageRequest(page);
+    assertHistoryPageFilter(filter);
     await this.ensureInit();
+    const conditions = ["address = ?"];
+    const params = [filter.address];
+    if (filter.since !== void 0) {
+      conditions.push("created_at >= ?");
+      params.push(filter.since);
+    }
+    if (page.after !== void 0) {
+      conditions.push(
+        "(created_at, boarding_txid, commitment_txid, ark_txid) > (?, ?, ?, ?)"
+      );
+      params.push(
+        page.after.createdAt,
+        page.after.key.boardingTxid,
+        page.after.key.commitmentTxid,
+        page.after.key.arkTxid
+      );
+    }
     const rows = await this.db.all(
-      `SELECT * FROM ${this.tables.transactions} WHERE address = ? ORDER BY created_at ASC`,
-      [address]
+      `SELECT * FROM ${this.tables.transactions} WHERE ${conditions.join(" AND ")}
+             ORDER BY created_at, boarding_txid, commitment_txid, ark_txid LIMIT ?`,
+      [...params, page.limit + 1]
     );
-    return rows.map(txRowToDomain);
+    return pageResult(rows.map(txRowToDomain), page.limit, (tx) => ({
+      createdAt: tx.createdAt,
+      key: tx.key
+    }));
   }
   async saveTransactions(address, txs) {
     await this.ensureInit();
-    for (const tx of txs) {
-      await this.db.run(
-        `INSERT OR REPLACE INTO ${this.tables.transactions}
-                    (address, boarding_txid, commitment_txid, ark_txid,
-                     type, amount, settled, created_at, assets_json)
-                 VALUES (?, ?, ?, ?,
-                         ?, ?, ?, ?, ?)`,
-        [
-          address,
-          tx.key.boardingTxid,
-          tx.key.commitmentTxid,
-          tx.key.arkTxid,
-          tx.type,
-          tx.amount,
-          tx.settled ? 1 : 0,
-          tx.createdAt,
-          tx.assets ? JSON.stringify(serializeAssets(tx.assets)) : null
-        ]
-      );
-    }
+    await this.insertOrReplace(
+      this.tables.transactions,
+      `address, boarding_txid, commitment_txid, ark_txid,
+             type, amount, settled, created_at, assets_json`,
+      txs.map((tx) => [
+        address,
+        tx.key.boardingTxid,
+        tx.key.commitmentTxid,
+        tx.key.arkTxid,
+        tx.type,
+        tx.amount,
+        tx.settled ? 1 : 0,
+        tx.createdAt,
+        tx.assets ? JSON.stringify(serializeAssets(tx.assets)) : null
+      ])
+    );
   }
   async deleteTransactions(address) {
     await this.ensureInit();
@@ -397,15 +530,7 @@ var SQLiteWalletRepository = class {
     );
   }
 };
-var SAFE_PREFIX = /^[a-zA-Z0-9_]+$/;
-function sanitizePrefix(prefix) {
-  if (!SAFE_PREFIX.test(prefix)) {
-    throw new Error(
-      `Invalid table prefix "${prefix}": only letters, digits, and underscores are allowed`
-    );
-  }
-  return prefix;
-}
+var UNSPENT_VTXO_PREDICATE = "(is_spent IS NULL OR is_spent = 0) AND (spent_by IS NULL OR spent_by = '') AND (settled_by IS NULL OR settled_by = '')";
 function vtxoRowToDomain(row) {
   const serialized = {
     txid: row.txid,
@@ -421,10 +546,14 @@ function vtxoRowToDomain(row) {
       s: row.intent_s
     },
     status: JSON.parse(row.status_json),
-    virtualStatus: JSON.parse(row.virtual_status_json),
     createdAt: new Date(row.created_at),
     isUnrolled: row.is_unrolled === 1,
     isSpent: row.is_spent === null ? void 0 : row.is_spent === 1,
+    isSwept: row.is_swept == null ? void 0 : row.is_swept === 1,
+    isPreconfirmed: row.is_preconfirmed == null ? void 0 : row.is_preconfirmed === 1,
+    commitmentTxIds: row.commitment_txids_json ? JSON.parse(row.commitment_txids_json) : void 0,
+    expiresAt: row.expires_at ? new Date(row.expires_at) : void 0,
+    expiresAtHeight: row.expires_at_height ?? void 0,
     spentBy: row.spent_by ?? void 0,
     settledBy: row.settled_by ?? void 0,
     arkTxId: row.ark_tx_id ?? void 0,
@@ -475,14 +604,15 @@ function txRowToDomain(row) {
 }
 
 // src/repositories/sqlite/contractRepository.ts
+var WATCH_STATE = "IFNULL(watch, 'watched')";
 var SQLiteContractRepository = class {
   constructor(db, options) {
     this.db = db;
-    this.prefix = sanitizePrefix2(options?.prefix ?? "ark_");
+    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
     this.table = `${this.prefix}contracts`;
   }
   db;
-  version = 2;
+  version = 3;
   initPromise = null;
   prefix;
   table;
@@ -515,6 +645,12 @@ var SQLiteContractRepository = class {
     await this.db.run(
       `CREATE INDEX IF NOT EXISTS idx_${this.prefix}contracts_state ON ${this.table} (state)`
     );
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_${this.prefix}contracts_watch_state ON ${this.table} (${WATCH_STATE}, script)`
+    );
+    await this.db.run(
+      `CREATE INDEX IF NOT EXISTS idx_${this.prefix}contracts_type_watch_state ON ${this.table} (type, ${WATCH_STATE}, script)`
+    );
   }
   async addColumnIfMissing(column, type) {
     const columns = await this.db.all(`PRAGMA table_info(${this.table})`);
@@ -529,22 +665,28 @@ var SQLiteContractRepository = class {
     await this.db.run(`DELETE FROM ${this.table}`);
   }
   // ── Contract management ────────────────────────────────────────────
-  async getContracts(filter) {
+  async getContractsPage(filter, page) {
+    assertPageRequest(page);
     await this.ensureInit();
+    if (contractFilterMatchesNothing(filter)) return { items: [] };
     const conditions = [];
     const params = [];
     if (filter) {
       this.addFilterCondition(conditions, params, "script", filter.script);
       this.addFilterCondition(conditions, params, "state", filter.state);
       this.addFilterCondition(conditions, params, "type", filter.type);
-      this.addWatchCondition(conditions, params, filter.watch);
+      this.addFilterCondition(conditions, params, WATCH_STATE, filter.watch);
     }
-    let sql = `SELECT * FROM ${this.table}`;
-    if (conditions.length > 0) {
-      sql += ` WHERE ${conditions.join(" AND ")}`;
+    if (page.after !== void 0) {
+      conditions.push("script > ?");
+      params.push(page.after);
     }
-    const rows = await this.db.all(sql, params);
-    return rows.map(contractRowToDomain);
+    const where = conditions.length ? ` WHERE ${conditions.join(" AND ")}` : "";
+    const rows = await this.db.all(
+      `SELECT * FROM ${this.table}${where} ORDER BY script LIMIT ?`,
+      [...params, page.limit + 1]
+    );
+    return pageResult(rows.map(contractRowToDomain), page.limit, (contract) => contract.script);
   }
   async saveContract(contract) {
     await this.ensureInit();
@@ -584,29 +726,7 @@ var SQLiteContractRepository = class {
       params.push(value);
     }
   }
-  /**
-   * Same as {@link addFilterCondition}, except a row predating the
-   * column stores NULL and must match `"watched"`.
-   */
-  addWatchCondition(conditions, params, value) {
-    if (value === void 0) return;
-    const wanted = Array.isArray(value) ? value : [value];
-    if (wanted.length === 0) return;
-    const placeholders = wanted.map(() => "?").join(", ");
-    const clause = `watch IN (${placeholders})`;
-    conditions.push(wanted.includes("watched") ? `(${clause} OR watch IS NULL)` : clause);
-    params.push(...wanted);
-  }
 };
-var SAFE_PREFIX2 = /^[a-zA-Z0-9_]+$/;
-function sanitizePrefix2(prefix) {
-  if (!SAFE_PREFIX2.test(prefix)) {
-    throw new Error(
-      `Invalid table prefix "${prefix}": only letters, digits, and underscores are allowed`
-    );
-  }
-  return prefix;
-}
 function contractRowToDomain(row) {
   const contract = {
     script: row.script,
@@ -629,15 +749,10 @@ function contractRowToDomain(row) {
 }
 
 // src/repositories/sqlite/intentRepository.ts
-var SAFE_PREFIX3 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function sanitizePrefix3(p) {
-  if (!SAFE_PREFIX3.test(p)) throw new Error(`Invalid table prefix "${p}"`);
-  return p;
-}
 var SQLiteIntentRepository = class {
   constructor(db, options) {
     this.db = db;
-    this.prefix = sanitizePrefix3(options?.prefix ?? "ark_");
+    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
     this.t = `${this.prefix}intents`;
   }
   db;
@@ -676,19 +791,16 @@ var SQLiteIntentRepository = class {
       `CREATE INDEX IF NOT EXISTS idx_${this.prefix}intent_state ON ${this.t} (state)`
     );
   }
-  withTx(fn) {
-    return runInTransaction(this.db, fn);
-  }
   async clear() {
     await this.ensureInit();
-    await this.withTx(async () => {
+    await runInTransaction(this.db, async () => {
       await this.db.run(`DELETE FROM ${this.t}`);
     });
   }
   async saveIntent(intent) {
     await this.ensureInit();
     const now = Date.now();
-    await this.withTx(async () => {
+    await runInTransaction(this.db, async () => {
       await this.db.run(
         `INSERT INTO ${this.t}
                  (intent_tx_id, intent_id, state, valid_from, valid_until,
@@ -736,15 +848,30 @@ var SQLiteIntentRepository = class {
       );
     });
   }
-  async getIntents(filter) {
+  async getIntentsPage(filter, page) {
+    assertPageRequest(page);
     await this.ensureInit();
-    const rows = await this.db.all(
-      `SELECT * FROM ${this.t} ORDER BY created_at ASC, intent_tx_id ASC`
-    );
-    let out = rows.map(rowToIntent);
-    if (filter) out = out.filter((i) => intentMatchesFilter(i, filter));
-    const { skip, end } = intentPageBounds(filter, out.length);
-    return out.slice(skip, end);
+    if (filter?.states?.length === 0) return { items: [] };
+    const stateSql = filter?.states ? ` AND state IN (${filter.states.map(() => "?").join(", ")})` : "";
+    const stateParams = filter?.states ?? [];
+    const batchSize = Math.max(64, page.limit + 1);
+    const rows = [];
+    let after = page.after;
+    while (rows.length <= page.limit) {
+      const batch = await this.db.all(
+        `SELECT * FROM ${this.t} WHERE intent_tx_id > ?${stateSql} ORDER BY intent_tx_id LIMIT ?`,
+        [after ?? "", ...stateParams, batchSize]
+      );
+      if (batch.length === 0) break;
+      for (const row of batch) {
+        after = row.intent_tx_id;
+        const intent = rowToIntent(row);
+        if (!filter || intentMatchesFilter(intent, filter)) rows.push(intent);
+        if (rows.length > page.limit) break;
+      }
+      if (batch.length < batchSize) break;
+    }
+    return pageResult(rows, page.limit, (intent) => intent.intentTxId);
   }
   async getLockedVtxoOutpoints() {
     await this.ensureInit();
@@ -782,15 +909,10 @@ function rowToIntent(r) {
 }
 
 // src/repositories/sqlite/virtualTxRepository.ts
-var SAFE_PREFIX4 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function sanitizePrefix4(p) {
-  if (!SAFE_PREFIX4.test(p)) throw new Error(`Invalid table prefix "${p}"`);
-  return p;
-}
 var SQLiteVirtualTxRepository = class {
   constructor(db, options) {
     this.db = db;
-    this.prefix = sanitizePrefix4(options?.prefix ?? "ark_");
+    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
     this.tTx = `${this.prefix}virtual_txs`;
     this.tBranch = `${this.prefix}vtxo_branches`;
   }
@@ -822,12 +944,9 @@ var SQLiteVirtualTxRepository = class {
       `CREATE INDEX IF NOT EXISTS idx_${this.prefix}branch_vtxid ON ${this.tBranch} (virtual_txid)`
     );
   }
-  tx(fn) {
-    return runInTransaction(this.db, fn);
-  }
   async clear() {
     await this.ensureInit();
-    await this.tx(async () => {
+    await runInTransaction(this.db, async () => {
       await this.db.run(`DELETE FROM ${this.tTx}`);
       await this.db.run(`DELETE FROM ${this.tBranch}`);
     });
@@ -835,7 +954,7 @@ var SQLiteVirtualTxRepository = class {
   async upsertVirtualTxs(txs) {
     if (txs.length === 0) return;
     await this.ensureInit();
-    await this.tx(async () => {
+    await runInTransaction(this.db, async () => {
       const placeholders = txs.map(() => "?").join(", ");
       const existing = await this.db.all(
         `SELECT * FROM ${this.tTx} WHERE txid IN (${placeholders})`,
@@ -862,7 +981,7 @@ var SQLiteVirtualTxRepository = class {
   }
   async setBranch(vtxo, branch) {
     await this.ensureInit();
-    await this.tx(async () => {
+    await runInTransaction(this.db, async () => {
       await this.db.run(`DELETE FROM ${this.tBranch} WHERE vtxo_txid = ? AND vtxo_vout = ?`, [
         vtxo.txid,
         vtxo.vout
@@ -897,7 +1016,7 @@ var SQLiteVirtualTxRepository = class {
   }
   async pruneForSpentVtxo(vtxo) {
     await this.ensureInit();
-    await this.tx(async () => {
+    await runInTransaction(this.db, async () => {
       const removed = await this.db.all(
         `SELECT DISTINCT virtual_txid FROM ${this.tBranch} WHERE vtxo_txid = ? AND vtxo_vout = ?`,
         [vtxo.txid, vtxo.vout]
@@ -930,13 +1049,6 @@ function rowToTx(r) {
   };
 }
 
-// src/repositories/sqlite/prefix.ts
-var SAFE_PREFIX5 = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-function sanitizeTablePrefix(p) {
-  if (!SAFE_PREFIX5.test(p)) throw new Error(`Invalid table prefix "${p}"`);
-  return p;
-}
-
 export { SQLiteContractRepository, SQLiteIntentRepository, SQLiteVirtualTxRepository, SQLiteWalletRepository, runInTransaction, sanitizeTablePrefix };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map