@arkade-os/sdk 0.4.42 → 0.4.43

package/dist/repositories/sqlite/index.js

@@ -1,9 +1,35 @@
-import { scriptFromArkAddress, serializeVtxo, isVtxoForScript, serializeUtxo, serializeAssets, deserializeVtxo, deserializeUtxo, deserializeAssets } from '../../chunk-V3FCNVJE.js';
-import '../../chunk-5X5YMZHB.js';
+import { serializeVtxo, isVtxoForScript, serializeUtxo, serializeAssets, scriptFromArkAddress, deserializeVtxo, deserializeUtxo, deserializeAssets, intentMatchesFilter, intentPageBounds, isTerminalIntentState, mergeChainedTxType } from '../../chunk-B4R36PRN.js';
+export { ChainedTxType } from '../../chunk-B4R36PRN.js';
+import '../../chunk-763XHDAJ.js';
 import '../../chunk-YNEDJTX2.js';
 import '../../chunk-BE5MUB7T.js';
 import '../../chunk-NSBPE2FW.js';
 
+// src/repositories/sqlite/transaction.ts
+var writeChains = /* @__PURE__ */ new WeakMap();
+function runInTransaction(db, fn) {
+  const prev = writeChains.get(db) ?? Promise.resolve();
+  const run = prev.then(async () => {
+    await db.run("BEGIN IMMEDIATE");
+    try {
+      await fn();
+      await db.run("COMMIT");
+    } catch (e) {
+      try {
+        await db.run("ROLLBACK");
+      } catch {
+      }
+      throw e;
+    }
+  });
+  writeChains.set(
+    db,
+    run.catch(() => {
+    })
+  );
+  return run;
+}
+
 // src/repositories/sqlite/walletRepository.ts
 var SQLiteWalletRepository = class {
   constructor(db, options) {
@@ -94,29 +120,31 @@ var SQLiteWalletRepository = class {
    * indexer would have returned — new rows from the indexer always carry a
    * populated `script`, so the migration is idempotent.
    *
-   * The rebuild path is wrapped in a transaction: without it, a crash
-   * between the `DROP TABLE vtxos` and the `RENAME tmp → vtxos` commits
-   * would leave the next startup seeing no `vtxos` table and create a
-   * fresh empty one, silently orphaning every row in the temp table.
+   * The whole check-and-migrate runs inside one transaction, not just the
+   * rebuild: the schema inspection is the decision point, so a second
+   * concurrent init on the same connection must not read a pre-migration
+   * schema and then re-run `ADD COLUMN` (duplicate column) after the first
+   * migration already committed. It also guards the crash window between the
+   * `DROP TABLE vtxos` and the `RENAME tmp → vtxos`, which would otherwise
+   * leave the next startup seeing no `vtxos` table.
    */
   async migrateVtxosTable() {
-    const tableExists = await this.db.get(
-      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
-      [this.tables.vtxos]
-    );
-    if (!tableExists) {
-      await this.db.run(this.vtxosCreateSql(this.tables.vtxos));
-      return;
-    }
-    const cols = await this.db.all(
-      `PRAGMA table_info(${this.tables.vtxos})`
-    );
-    const scriptCol = cols.find((c) => c.name === "script");
-    if (scriptCol && scriptCol.notnull === 1) {
-      return;
-    }
-    await this.db.run("BEGIN IMMEDIATE");
-    try {
+    await runInTransaction(this.db, async () => {
+      const tableExists = await this.db.get(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
+        [this.tables.vtxos]
+      );
+      if (!tableExists) {
+        await this.db.run(this.vtxosCreateSql(this.tables.vtxos));
+        return;
+      }
+      const cols = await this.db.all(
+        `PRAGMA table_info(${this.tables.vtxos})`
+      );
+      const scriptCol = cols.find((c) => c.name === "script");
+      if (scriptCol && scriptCol.notnull === 1) {
+        return;
+      }
       if (!scriptCol) {
         await this.db.run(`ALTER TABLE ${this.tables.vtxos} ADD COLUMN script TEXT`);
       }
@@ -146,14 +174,7 @@ var SQLiteWalletRepository = class {
             `);
       await this.db.run(`DROP TABLE ${this.tables.vtxos}`);
       await this.db.run(`ALTER TABLE ${tempName} RENAME TO ${this.tables.vtxos}`);
-      await this.db.run("COMMIT");
-    } catch (e) {
-      try {
-        await this.db.run("ROLLBACK");
-      } catch {
-      }
-      throw e;
-    }
+    });
   }
   vtxosCreateSql(tableName) {
     return `CREATE TABLE ${tableName} (
@@ -580,6 +601,306 @@ function contractRowToDomain(row) {
   return contract;
 }
 
-export { SQLiteContractRepository, SQLiteWalletRepository };
+// 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.t = `${this.prefix}intents`;
+  }
+  version = 1;
+  initPromise = null;
+  prefix;
+  t;
+  ensureInit() {
+    if (!this.initPromise) this.initPromise = this.init();
+    return this.initPromise;
+  }
+  async init() {
+    await this.db.run(`CREATE TABLE IF NOT EXISTS ${this.t} (
+            intent_tx_id TEXT PRIMARY KEY,
+            intent_id TEXT,
+            state TEXT NOT NULL,
+            valid_from INTEGER,
+            valid_until INTEGER,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL,
+            register_proof TEXT NOT NULL,
+            register_proof_message TEXT NOT NULL,
+            delete_proof TEXT NOT NULL,
+            delete_proof_message TEXT NOT NULL,
+            batch_id TEXT,
+            commitment_txid TEXT,
+            cancellation_reason TEXT,
+            partial_forfeits_json TEXT NOT NULL,
+            signer_descriptor TEXT,
+            intent_vtxos_json TEXT NOT NULL
+        )`);
+    await this.db.run(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_${this.prefix}intent_id ON ${this.t} (intent_id) WHERE intent_id IS NOT NULL`
+    );
+    await this.db.run(
+      `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 this.db.run(`DELETE FROM ${this.t}`);
+    });
+  }
+  async saveIntent(intent) {
+    await this.ensureInit();
+    const now = Date.now();
+    await this.withTx(async () => {
+      await this.db.run(
+        `INSERT INTO ${this.t}
+                 (intent_tx_id, intent_id, state, valid_from, valid_until,
+                  created_at, updated_at, register_proof, register_proof_message,
+                  delete_proof, delete_proof_message, batch_id, commitment_txid,
+                  cancellation_reason, partial_forfeits_json, signer_descriptor,
+                  intent_vtxos_json)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 ON CONFLICT(intent_tx_id) DO UPDATE SET
+                  intent_id = excluded.intent_id,
+                  state = excluded.state,
+                  valid_from = excluded.valid_from,
+                  valid_until = excluded.valid_until,
+                  created_at = excluded.created_at,
+                  updated_at = excluded.updated_at,
+                  register_proof = excluded.register_proof,
+                  register_proof_message = excluded.register_proof_message,
+                  delete_proof = excluded.delete_proof,
+                  delete_proof_message = excluded.delete_proof_message,
+                  batch_id = excluded.batch_id,
+                  commitment_txid = excluded.commitment_txid,
+                  cancellation_reason = excluded.cancellation_reason,
+                  partial_forfeits_json = excluded.partial_forfeits_json,
+                  signer_descriptor = excluded.signer_descriptor,
+                  intent_vtxos_json = excluded.intent_vtxos_json`,
+        [
+          intent.intentTxId,
+          intent.intentId ?? null,
+          intent.state,
+          intent.validFrom ?? null,
+          intent.validUntil ?? null,
+          intent.createdAt,
+          now,
+          intent.registerProof,
+          intent.registerProofMessage,
+          intent.deleteProof,
+          intent.deleteProofMessage,
+          intent.batchId ?? null,
+          intent.commitmentTransactionId ?? null,
+          intent.cancellationReason ?? null,
+          JSON.stringify(intent.partialForfeits),
+          intent.signerDescriptor ?? null,
+          JSON.stringify(intent.intentVtxos)
+        ]
+      );
+    });
+  }
+  async getIntents(filter) {
+    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);
+  }
+  async getLockedVtxoOutpoints() {
+    await this.ensureInit();
+    const rows = await this.db.all(`SELECT * FROM ${this.t}`);
+    const out = [];
+    for (const r of rows) {
+      if (isTerminalIntentState(r.state)) continue;
+      for (const o of JSON.parse(r.intent_vtxos_json)) out.push(o);
+    }
+    return out;
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+function rowToIntent(r) {
+  return {
+    intentTxId: r.intent_tx_id,
+    intentId: r.intent_id ?? void 0,
+    state: r.state,
+    validFrom: r.valid_from ?? void 0,
+    validUntil: r.valid_until ?? void 0,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+    registerProof: r.register_proof,
+    registerProofMessage: r.register_proof_message,
+    deleteProof: r.delete_proof,
+    deleteProofMessage: r.delete_proof_message,
+    batchId: r.batch_id ?? void 0,
+    commitmentTransactionId: r.commitment_txid ?? void 0,
+    cancellationReason: r.cancellation_reason ?? void 0,
+    partialForfeits: JSON.parse(r.partial_forfeits_json),
+    signerDescriptor: r.signer_descriptor ?? void 0,
+    intentVtxos: JSON.parse(r.intent_vtxos_json)
+  };
+}
+
+// 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.tTx = `${this.prefix}virtual_txs`;
+    this.tBranch = `${this.prefix}vtxo_branches`;
+  }
+  version = 1;
+  initPromise = null;
+  prefix;
+  tTx;
+  tBranch;
+  ensureInit() {
+    if (!this.initPromise) this.initPromise = this.init();
+    return this.initPromise;
+  }
+  async init() {
+    await this.db.run(`CREATE TABLE IF NOT EXISTS ${this.tTx} (
+            txid TEXT PRIMARY KEY,
+            psbt TEXT,
+            expires_at INTEGER,
+            type INTEGER NOT NULL DEFAULT 0
+        )`);
+    await this.db.run(`CREATE TABLE IF NOT EXISTS ${this.tBranch} (
+            vtxo_txid TEXT NOT NULL,
+            vtxo_vout INTEGER NOT NULL,
+            virtual_txid TEXT NOT NULL,
+            position INTEGER NOT NULL,
+            PRIMARY KEY (vtxo_txid, vtxo_vout, position)
+        )`);
+    await this.db.run(
+      `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 this.db.run(`DELETE FROM ${this.tTx}`);
+      await this.db.run(`DELETE FROM ${this.tBranch}`);
+    });
+  }
+  async upsertVirtualTxs(txs) {
+    if (txs.length === 0) return;
+    await this.ensureInit();
+    await this.tx(async () => {
+      const placeholders = txs.map(() => "?").join(", ");
+      const existing = await this.db.all(
+        `SELECT * FROM ${this.tTx} WHERE txid IN (${placeholders})`,
+        txs.map((t) => t.txid)
+      );
+      const prevByTxid = new Map(existing.map((r) => [r.txid, r]));
+      for (const t of txs) {
+        const prev = prevByTxid.get(t.txid);
+        const psbt = t.psbt ?? prev?.psbt ?? null;
+        const expires = t.expiresAt ?? prev?.expires_at ?? null;
+        const type = mergeChainedTxType(t.type, prev?.type);
+        await this.db.run(
+          `INSERT OR REPLACE INTO ${this.tTx} (txid, psbt, expires_at, type) VALUES (?, ?, ?, ?)`,
+          [t.txid, psbt, expires, type]
+        );
+        prevByTxid.set(t.txid, { txid: t.txid, psbt, expires_at: expires, type });
+      }
+    });
+  }
+  async getVirtualTx(txid) {
+    await this.ensureInit();
+    const row = await this.db.get(`SELECT * FROM ${this.tTx} WHERE txid = ?`, [txid]);
+    return row ? rowToTx(row) : null;
+  }
+  async setBranch(vtxo, branch) {
+    await this.ensureInit();
+    await this.tx(async () => {
+      await this.db.run(`DELETE FROM ${this.tBranch} WHERE vtxo_txid = ? AND vtxo_vout = ?`, [
+        vtxo.txid,
+        vtxo.vout
+      ]);
+      for (const b of branch) {
+        await this.db.run(
+          `INSERT OR REPLACE INTO ${this.tBranch} (vtxo_txid, vtxo_vout, virtual_txid, position) VALUES (?, ?, ?, ?)`,
+          [b.vtxoTxid, b.vtxoVout, b.virtualTxid, b.position]
+        );
+      }
+    });
+  }
+  async getBranch(vtxo) {
+    await this.ensureInit();
+    const rows = await this.db.all(
+      `SELECT t.txid, t.psbt, t.expires_at, t.type
+             FROM ${this.tBranch} b
+             JOIN ${this.tTx} t ON t.txid = b.virtual_txid
+             WHERE b.vtxo_txid = ? AND b.vtxo_vout = ?
+             ORDER BY b.position ASC`,
+      [vtxo.txid, vtxo.vout]
+    );
+    return rows.map(rowToTx);
+  }
+  async hasBranch(vtxo) {
+    await this.ensureInit();
+    const r = await this.db.get(
+      `SELECT COUNT(*) AS c FROM ${this.tBranch} WHERE vtxo_txid = ? AND vtxo_vout = ?`,
+      [vtxo.txid, vtxo.vout]
+    );
+    return (r?.c ?? 0) > 0;
+  }
+  async pruneForSpentVtxo(vtxo) {
+    await this.ensureInit();
+    await this.tx(async () => {
+      const removed = await this.db.all(
+        `SELECT DISTINCT virtual_txid FROM ${this.tBranch} WHERE vtxo_txid = ? AND vtxo_vout = ?`,
+        [vtxo.txid, vtxo.vout]
+      );
+      await this.db.run(`DELETE FROM ${this.tBranch} WHERE vtxo_txid = ? AND vtxo_vout = ?`, [
+        vtxo.txid,
+        vtxo.vout
+      ]);
+      if (removed.length === 0) return;
+      const placeholders = removed.map(() => "?").join(", ");
+      await this.db.run(
+        `DELETE FROM ${this.tTx}
+                 WHERE txid IN (${placeholders})
+                 AND NOT EXISTS (
+                     SELECT 1 FROM ${this.tBranch} b WHERE b.virtual_txid = ${this.tTx}.txid
+                 )`,
+        removed.map((r) => r.virtual_txid)
+      );
+    });
+  }
+  async [Symbol.asyncDispose]() {
+  }
+};
+function rowToTx(r) {
+  return {
+    txid: r.txid,
+    psbt: r.psbt ?? null,
+    expiresAt: r.expires_at ?? null,
+    type: r.type
+  };
+}
+
+export { SQLiteContractRepository, SQLiteIntentRepository, SQLiteVirtualTxRepository, SQLiteWalletRepository };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map