@arkade-os/sdk 0.4.41 → 0.4.43

package/dist/repositories/sqlite/index.cjs

@@ -1,11 +1,36 @@
 'use strict';
 
-var chunk3MPXMLP4_cjs = require('../../chunk-3MPXMLP4.cjs');
-require('../../chunk-ALISWEQ5.cjs');
+var chunkQGNTDGMN_cjs = require('../../chunk-QGNTDGMN.cjs');
+require('../../chunk-3AQNLQPM.cjs');
 require('../../chunk-32YKLQPS.cjs');
 require('../../chunk-HXDZ2QTW.cjs');
 require('../../chunk-5BLDMQED.cjs');
 
+// 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) {
@@ -96,29 +121,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`);
       }
@@ -126,7 +153,7 @@ var SQLiteWalletRepository = class {
       for (const row of nullRows) {
         await this.db.run(
           `UPDATE ${this.tables.vtxos} SET script = ? WHERE txid = ? AND vout = ?`,
-          [chunk3MPXMLP4_cjs.scriptFromArkAddress(row.address), row.txid, row.vout]
+          [chunkQGNTDGMN_cjs.scriptFromArkAddress(row.address), row.txid, row.vout]
         );
       }
       const tempName = `${this.tables.vtxos}__migrate_tmp`;
@@ -148,14 +175,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} (
@@ -204,7 +224,7 @@ var SQLiteWalletRepository = class {
   async saveVtxos(address, vtxos) {
     await this.ensureInit();
     for (const vtxo of vtxos) {
-      const s = chunk3MPXMLP4_cjs.serializeVtxo(vtxo);
+      const s = chunkQGNTDGMN_cjs.serializeVtxo(vtxo);
       await this.db.run(
         `INSERT OR REPLACE INTO ${this.tables.vtxos}
                     (txid, vout, value, address,
@@ -259,7 +279,7 @@ var SQLiteWalletRepository = class {
       throw new Error("SQLiteWalletRepository requires an address");
     }
     for (const vtxo of vtxos) {
-      if (!chunk3MPXMLP4_cjs.isVtxoForScript(vtxo, key.script)) {
+      if (!chunkQGNTDGMN_cjs.isVtxoForScript(vtxo, key.script)) {
         throw new Error(
           `VTXO ${vtxo.txid}:${vtxo.vout} script mismatch: expected ${key.script}, got ${vtxo.script}`
         );
@@ -283,7 +303,7 @@ var SQLiteWalletRepository = class {
   async saveUtxos(address, utxos) {
     await this.ensureInit();
     for (const utxo of utxos) {
-      const s = chunk3MPXMLP4_cjs.serializeUtxo(utxo);
+      const s = chunkQGNTDGMN_cjs.serializeUtxo(utxo);
       await this.db.run(
         `INSERT OR REPLACE INTO ${this.tables.utxos}
                     (txid, vout, value, address,
@@ -339,7 +359,7 @@ var SQLiteWalletRepository = class {
           tx.amount,
           tx.settled ? 1 : 0,
           tx.createdAt,
-          tx.assets ? JSON.stringify(chunk3MPXMLP4_cjs.serializeAssets(tx.assets)) : null
+          tx.assets ? JSON.stringify(chunkQGNTDGMN_cjs.serializeAssets(tx.assets)) : null
         ]
       );
     }
@@ -413,9 +433,9 @@ function vtxoRowToDomain(row) {
     // Post-migration every row has `script`, but the backfill is
     // idempotent: derive from `address` if the legacy column is still
     // null (e.g. the migration hasn't run yet on this handle).
-    script: row.script ?? chunk3MPXMLP4_cjs.scriptFromArkAddress(row.address)
+    script: row.script ?? chunkQGNTDGMN_cjs.scriptFromArkAddress(row.address)
   };
-  return chunk3MPXMLP4_cjs.deserializeVtxo(serialized);
+  return chunkQGNTDGMN_cjs.deserializeVtxo(serialized);
 }
 function utxoRowToDomain(row) {
   const serialized = {
@@ -434,7 +454,7 @@ function utxoRowToDomain(row) {
     status: JSON.parse(row.status_json),
     extraWitness: row.extra_witness_json ? JSON.parse(row.extra_witness_json) : void 0
   };
-  return chunk3MPXMLP4_cjs.deserializeUtxo(serialized);
+  return chunkQGNTDGMN_cjs.deserializeUtxo(serialized);
 }
 function txRowToDomain(row) {
   const tx = {
@@ -449,7 +469,7 @@ function txRowToDomain(row) {
     createdAt: row.created_at
   };
   if (row.assets_json) {
-    tx.assets = chunk3MPXMLP4_cjs.deserializeAssets(JSON.parse(row.assets_json));
+    tx.assets = chunkQGNTDGMN_cjs.deserializeAssets(JSON.parse(row.assets_json));
   }
   return tx;
 }
@@ -582,7 +602,313 @@ function contractRowToDomain(row) {
   return contract;
 }
 
+// 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) => chunkQGNTDGMN_cjs.intentMatchesFilter(i, filter));
+    const { skip, end } = chunkQGNTDGMN_cjs.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 (chunkQGNTDGMN_cjs.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 = chunkQGNTDGMN_cjs.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
+  };
+}
+
+Object.defineProperty(exports, "ChainedTxType", {
+  enumerable: true,
+  get: function () { return chunkQGNTDGMN_cjs.ChainedTxType; }
+});
 exports.SQLiteContractRepository = SQLiteContractRepository;
+exports.SQLiteIntentRepository = SQLiteIntentRepository;
+exports.SQLiteVirtualTxRepository = SQLiteVirtualTxRepository;
 exports.SQLiteWalletRepository = SQLiteWalletRepository;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map