@arkade-os/sdk 0.5.3 → 0.5.4

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

@@ -1,5 +1,5 @@
-import { W as WalletRepository, P as PageRequest, O as Outpoint, F as PageResult, D as ExtendedVirtualCoin, H as ScriptVtxoCursor, J as ScriptVtxoPageOptions, K as StoredVtxo, L as VtxoRepositoryKey, E as ExtendedCoin, M as TransactionHistoryPageFilter, Q as TransactionHistoryPageCursor, h as ArkTransaction, U as WalletState, C as ContractRepository, X as ContractFilter, B as Contract, Y as IntentRepository, Z as ArkIntent, _ as IntentPageFilter, $ as VirtualTxRepository, a0 as VirtualTx, a1 as VtxoBranch } from '../../index-BURzbRup.js';
-export { a2 as ChainedTxType } from '../../index-BURzbRup.js';
+import { W as WalletRepository, X as AtomicWalletState, P as PageRequest, F as Outpoint, H as PageResult, D as ExtendedVirtualCoin, J as ScriptVtxoCursor, K as ScriptVtxoPageOptions, L as StoredVtxo, M as VtxoRepositoryKey, E as ExtendedCoin, Q as TransactionHistoryPageFilter, U as TransactionHistoryPageCursor, h as ArkTransaction, Y as WalletState, C as ContractRepository, Z as ContractFilter, B as Contract, _ as IntentRepository, $ as ArkIntent, a0 as IntentPageFilter, a1 as VirtualTxRepository, a2 as VirtualTx, a3 as VtxoBranch } from '../../index-DRwe0UDN.js';
+export { a4 as ChainedTxType } from '../../index-DRwe0UDN.js';
 import '@scure/btc-signer/utils.js';
 import '@scure/btc-signer/psbt.js';
 import '@scure/btc-signer';
@@ -8,6 +8,8 @@ import '@scure/btc-signer/transaction.js';
 /**
  * Minimal SQL execution interface that consumers implement
  * to connect their SQLite (or any SQL) database to the SDK.
+ * Share one executor object per connection across SDK repositories; separate wrappers
+ * and direct raw-driver calls bypass the SDK operation queue.
  *
  * Example for expo-sqlite:
  * ```
@@ -27,6 +29,12 @@ interface SQLExecutor {
 interface SQLiteWalletRepositoryOptions {
     /** Table name prefix (default: "ark_") */
     prefix?: string;
+    /** Opt in only with a dedicated connection or all operations coordinated through
+     * getSerializedExecutor/runInTransaction on the same executor object. Default: false.
+     * All read-modify-write callers must use atomic updates; queued legacy updates can still race. */
+    walletStateTransactions?: boolean;
+    /** Caller asserts durable backing; requires walletStateTransactions. No storage detection. */
+    persistentWalletState?: boolean;
 }
 /**
  * SQLite-based implementation of WalletRepository.
@@ -38,8 +46,9 @@ interface SQLiteWalletRepositoryOptions {
  * The consumer owns the SQLExecutor lifecycle — `[Symbol.asyncDispose]` is a no-op.
  */
 declare class SQLiteWalletRepository implements WalletRepository {
-    private readonly db;
     readonly version: 2;
+    readonly atomicWalletState?: AtomicWalletState;
+    private readonly db;
     private initPromise;
     private readonly prefix;
     private readonly tables;
@@ -103,6 +112,7 @@ declare class SQLiteWalletRepository implements WalletRepository {
     getTransactionHistoryPage(filter: TransactionHistoryPageFilter, page: PageRequest<TransactionHistoryPageCursor>): Promise<PageResult<ArkTransaction, TransactionHistoryPageCursor>>;
     saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
     deleteTransactions(address: string): Promise<void>;
+    private readonly atomicState;
     getWalletState(): Promise<WalletState | null>;
     saveWalletState(state: WalletState): Promise<void>;
 }
@@ -121,8 +131,8 @@ interface SQLiteContractRepositoryOptions {
  * The consumer owns the SQLExecutor lifecycle — `[Symbol.asyncDispose]` is a no-op.
  */
 declare class SQLiteContractRepository implements ContractRepository {
-    private readonly db;
     readonly version: 3;
+    private readonly db;
     private initPromise;
     private readonly prefix;
     private readonly table;
@@ -139,8 +149,8 @@ declare class SQLiteContractRepository implements ContractRepository {
 }
 
 declare class SQLiteIntentRepository implements IntentRepository {
-    private readonly db;
     readonly version: 1;
+    private readonly db;
     private initPromise;
     private readonly prefix;
     private readonly t;
@@ -157,8 +167,8 @@ declare class SQLiteIntentRepository implements IntentRepository {
 }
 
 declare class SQLiteVirtualTxRepository implements VirtualTxRepository {
-    private readonly db;
     readonly version: 1;
+    private readonly db;
     private initPromise;
     private readonly prefix;
     private readonly tTx;
@@ -178,14 +188,14 @@ declare class SQLiteVirtualTxRepository implements VirtualTxRepository {
     [Symbol.asyncDispose](): Promise<void>;
 }
 
+/** SDK reads and writes share the transaction queue; direct raw-driver calls do not. */
+declare function getSerializedExecutor(db: SQLExecutor): SQLExecutor;
 /**
- * Run `fn` inside a serialized `BEGIN IMMEDIATE` / `COMMIT` on `db`.
- *
- * `fn` must issue only raw `db.run`/`db.all` calls: calling `runInTransaction`
- * again on the same `db` from within `fn` would wait on the chain it is part of
- * and deadlock.
+ * Run `fn` inside `BEGIN IMMEDIATE` / `COMMIT`, excluding queued SDK reads and writes.
+ * Use only the supplied raw executor inside `fn`; repository calls or nested transactions deadlock.
+ * Existing zero-argument callbacks closing over the original raw executor remain supported.
  */
-declare function runInTransaction(db: SQLExecutor, fn: () => Promise<void>): Promise<void>;
+declare function runInTransaction(db: SQLExecutor, fn: (tx: SQLExecutor) => Promise<void>): Promise<void>;
 
 /**
  * Validate a SQLite table prefix and return it unchanged.
@@ -195,4 +205,4 @@ declare function runInTransaction(db: SQLExecutor, fn: () => Promise<void>): Pro
  */
 declare function sanitizeTablePrefix(p: string): string;
 
-export { type SQLExecutor, SQLiteContractRepository, SQLiteIntentRepository, SQLiteVirtualTxRepository, SQLiteWalletRepository, VirtualTx, VirtualTxRepository, VtxoBranch, runInTransaction, sanitizeTablePrefix };
+export { type SQLExecutor, SQLiteContractRepository, SQLiteIntentRepository, SQLiteVirtualTxRepository, SQLiteWalletRepository, VirtualTx, VirtualTxRepository, VtxoBranch, getSerializedExecutor, runInTransaction, sanitizeTablePrefix };

package/dist/repositories/sqlite/index.js

@@ -1,32 +1,69 @@
-import { scriptFromArkAddress, legacyVtxoFacts, serializeVtxo, createdAtToIso, assertPageRequest, pageResult, checkSaveVtxosForScript, utxoEntries, serializeUtxo, assertHistoryPageFilter, serializeAssets, deserializeVtxo, deserializeUtxo, deserializeAssets, contractFilterMatchesNothing, intentMatchesFilter, isTerminalIntentState, mergeChainedTxType } from '../../chunk-HAQAWBYG.js';
-export { ChainedTxType } from '../../chunk-HAQAWBYG.js';
-import '../../chunk-6FL4N4S2.js';
-import '../../chunk-P7B4LQ3H.js';
-import { isVtxoSpent } from '../../chunk-OPX2HRWM.js';
+import { legacyVtxoFacts, serializeVtxo, createdAtToIso, assertPageRequest, pageResult, checkSaveVtxosForScript, utxoEntries, serializeUtxo, assertHistoryPageFilter, serializeAssets, scriptFromArkAddress, deserializeVtxo, deserializeUtxo, deserializeAssets, contractFilterMatchesNothing, intentMatchesFilter, isTerminalIntentState, applyWalletStateUpdate, mergeChainedTxType } from '../../chunk-ZJHLLDBP.js';
+export { ChainedTxType } from '../../chunk-ZJHLLDBP.js';
+import '../../chunk-BTRCN4JJ.js';
+import '../../chunk-6CUP6ZIF.js';
+import { isVtxoSpent } from '../../chunk-AG4TFD6F.js';
 
 // src/repositories/sqlite/transaction.ts
-var writeChains = /* @__PURE__ */ new WeakMap();
+var executorQueues = /* @__PURE__ */ new WeakMap();
+var STALL_WARN_MS = 1e4;
+function enqueue(queue, operation) {
+  let stall;
+  if (queue.inTransaction) {
+    const site = new Error(
+      `SQLite operation waited ${STALL_WARN_MS / 1e3}s behind a transaction. A repository, getSerializedExecutor or runInTransaction call inside a runInTransaction callback deadlocks; use the callback's tx.`
+    );
+    stall = setTimeout(() => console.warn(site), STALL_WARN_MS);
+  }
+  const run = queue.tail.then(() => {
+    clearTimeout(stall);
+    return operation();
+  });
+  queue.tail = run.catch(() => void 0);
+  return run;
+}
+function queueFor(db) {
+  const existing = executorQueues.get(db);
+  if (existing) return existing;
+  const facade = {
+    run: (sql, params) => enqueue(queue, () => db.run(sql, params)),
+    get: (sql, params) => enqueue(queue, () => db.get(sql, params)),
+    all: (sql, params) => enqueue(queue, () => db.all(sql, params))
+  };
+  const queue = {
+    raw: db,
+    facade,
+    tail: Promise.resolve(),
+    inTransaction: false
+  };
+  executorQueues.set(db, queue);
+  executorQueues.set(facade, queue);
+  return queue;
+}
+function getSerializedExecutor(db) {
+  return queueFor(db).facade;
+}
 function runInTransaction(db, fn) {
-  const prev = writeChains.get(db) ?? Promise.resolve();
-  const run = prev.then(async () => {
-    await db.run("BEGIN IMMEDIATE");
+  const queue = queueFor(db);
+  return enqueue(queue, async () => {
+    const tx = queue.raw;
+    queue.inTransaction = true;
     try {
-      await fn();
-      await db.run("COMMIT");
-    } catch (e) {
+      await tx.run("BEGIN IMMEDIATE");
       try {
-        await db.run("ROLLBACK");
-      } catch {
+        await fn(tx);
+        await tx.run("COMMIT");
+      } catch (e) {
+        try {
+          await tx.run("ROLLBACK");
+        } catch {
+        }
+        throw e;
       }
-      throw e;
+    } finally {
+      queue.inTransaction = false;
     }
   });
-  writeChains.set(
-    db,
-    run.catch(() => {
-    })
-  );
-  return run;
 }
 
 // src/repositories/sqlite/prefix.ts
@@ -39,8 +76,17 @@ function sanitizeTablePrefix(p) {
 // src/repositories/sqlite/walletRepository.ts
 var MAX_BOUND_PARAMETERS = 999;
 var SQLiteWalletRepository = class {
+  version = 2;
+  atomicWalletState;
+  db;
+  initPromise = null;
+  prefix;
+  tables;
   constructor(db, options) {
-    this.db = db;
+    this.db = getSerializedExecutor(db);
+    if (options?.walletStateTransactions === true) {
+      this.atomicWalletState = options.persistentWalletState === true ? { ...this.atomicState, persistent: true } : this.atomicState;
+    }
     this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
     this.tables = {
       vtxos: `${this.prefix}vtxos`,
@@ -49,11 +95,6 @@ var SQLiteWalletRepository = class {
       walletState: `${this.prefix}wallet_state`
     };
   }
-  db;
-  version = 2;
-  initPromise = null;
-  prefix;
-  tables;
   // ── Lifecycle ──────────────────────────────────────────────────────
   ensureInit() {
     if (!this.initPromise) {
@@ -156,16 +197,16 @@ var SQLiteWalletRepository = class {
    * leave the next startup seeing no `vtxos` table.
    */
   async migrateVtxosTable() {
-    await runInTransaction(this.db, async () => {
-      const tableExists = await this.db.get(
+    await runInTransaction(this.db, async (tx) => {
+      const tableExists = await tx.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));
+        await tx.run(this.vtxosCreateSql(this.tables.vtxos));
         return;
       }
-      const cols = await this.db.all(
+      const cols = await tx.all(
         `PRAGMA table_info(${this.tables.vtxos})`
       );
       const scriptCol = cols.find((c) => c.name === "script");
@@ -179,33 +220,31 @@ var SQLiteWalletRepository = class {
       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}`
-          );
+          await tx.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();
+        await this.backfillCanonicalVtxoColumns(tx);
       }
       if (scriptCol && scriptCol.notnull === 1 && !hasLegacyBlob) {
         return;
       }
       if (!scriptCol) {
-        await this.db.run(`ALTER TABLE ${this.tables.vtxos} ADD COLUMN script TEXT`);
+        await tx.run(`ALTER TABLE ${this.tables.vtxos} ADD COLUMN script TEXT`);
       }
-      const nullRows = await this.db.all(`SELECT txid, vout, address FROM ${this.tables.vtxos} WHERE script IS NULL`);
+      const nullRows = await tx.all(`SELECT txid, vout, address FROM ${this.tables.vtxos} WHERE script IS NULL`);
       for (const row of nullRows) {
-        await this.db.run(
+        await tx.run(
           `UPDATE ${this.tables.vtxos} SET script = ? WHERE txid = ? AND vout = ?`,
           [scriptFromArkAddress(row.address), row.txid, row.vout]
         );
       }
       const tempName = `${this.tables.vtxos}__migrate_tmp`;
-      await this.db.run(`DROP TABLE IF EXISTS ${tempName}`);
-      await this.db.run(this.vtxosCreateSql(tempName));
-      await this.db.run(`
+      await tx.run(`DROP TABLE IF EXISTS ${tempName}`);
+      await tx.run(this.vtxosCreateSql(tempName));
+      await tx.run(`
                 INSERT INTO ${tempName}
                     (txid, vout, value, address, tap_tree,
                      forfeit_cb, forfeit_s, intent_cb, intent_s,
@@ -221,8 +260,8 @@ var SQLiteWalletRepository = class {
                        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}`);
+      await tx.run(`DROP TABLE ${this.tables.vtxos}`);
+      await tx.run(`ALTER TABLE ${tempName} RENAME TO ${this.tables.vtxos}`);
     });
   }
   /**
@@ -234,15 +273,15 @@ var SQLiteWalletRepository = class {
    * 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(
+  async backfillCanonicalVtxoColumns(tx) {
+    const rows = await tx.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(
+      await tx.run(
         `UPDATE ${this.tables.vtxos}
                  SET is_swept = ?, is_preconfirmed = ?, commitment_txids_json = ?,
                      expires_at = ?, expires_at_height = ?,
@@ -502,6 +541,32 @@ var SQLiteWalletRepository = class {
     await this.db.run(`DELETE FROM ${this.tables.transactions} WHERE address = ?`, [address]);
   }
   // ── Wallet state ───────────────────────────────────────────────────
+  atomicState = {
+    version: 1,
+    update: async (updater) => {
+      await this.ensureInit();
+      await runInTransaction(this.db, async (tx) => {
+        const row = await tx.get(
+          `SELECT * FROM ${this.tables.walletState} WHERE key = ?`,
+          ["state"]
+        );
+        const current = row ? {
+          settings: row.settings_json ? JSON.parse(row.settings_json) : void 0,
+          lastSyncTime: row.last_sync_time ?? void 0
+        } : {};
+        const state = applyWalletStateUpdate(current, updater);
+        await tx.run(
+          `INSERT OR REPLACE INTO ${this.tables.walletState}
+                        (key, settings_json, last_sync_time) VALUES (?, ?, ?)`,
+          [
+            "state",
+            state.settings ? JSON.stringify(state.settings) : null,
+            state.lastSyncTime ?? null
+          ]
+        );
+      });
+    }
+  };
   async getWalletState() {
     await this.ensureInit();
     const row = await this.db.get(
@@ -606,16 +671,16 @@ 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 = sanitizeTablePrefix(options?.prefix ?? "ark_");
-    this.table = `${this.prefix}contracts`;
-  }
-  db;
   version = 3;
+  db;
   initPromise = null;
   prefix;
   table;
+  constructor(db, options) {
+    this.db = getSerializedExecutor(db);
+    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
+    this.table = `${this.prefix}contracts`;
+  }
   // ── Lifecycle ──────────────────────────────────────────────────────
   ensureInit() {
     if (!this.initPromise) {
@@ -750,16 +815,16 @@ function contractRowToDomain(row) {
 
 // src/repositories/sqlite/intentRepository.ts
 var SQLiteIntentRepository = class {
-  constructor(db, options) {
-    this.db = db;
-    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
-    this.t = `${this.prefix}intents`;
-  }
-  db;
   version = 1;
+  db;
   initPromise = null;
   prefix;
   t;
+  constructor(db, options) {
+    this.db = getSerializedExecutor(db);
+    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
+    this.t = `${this.prefix}intents`;
+  }
   ensureInit() {
     if (!this.initPromise) this.initPromise = this.init();
     return this.initPromise;
@@ -793,15 +858,15 @@ var SQLiteIntentRepository = class {
   }
   async clear() {
     await this.ensureInit();
-    await runInTransaction(this.db, async () => {
-      await this.db.run(`DELETE FROM ${this.t}`);
+    await runInTransaction(this.db, async (tx) => {
+      await tx.run(`DELETE FROM ${this.t}`);
     });
   }
   async saveIntent(intent) {
     await this.ensureInit();
     const now = Date.now();
-    await runInTransaction(this.db, async () => {
-      await this.db.run(
+    await runInTransaction(this.db, async (tx) => {
+      await tx.run(
         `INSERT INTO ${this.t}
                  (intent_tx_id, intent_id, state, valid_from, valid_until,
                   created_at, updated_at, register_proof, register_proof_message,
@@ -910,18 +975,18 @@ function rowToIntent(r) {
 
 // src/repositories/sqlite/virtualTxRepository.ts
 var SQLiteVirtualTxRepository = class {
-  constructor(db, options) {
-    this.db = db;
-    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
-    this.tTx = `${this.prefix}virtual_txs`;
-    this.tBranch = `${this.prefix}vtxo_branches`;
-  }
-  db;
   version = 1;
+  db;
   initPromise = null;
   prefix;
   tTx;
   tBranch;
+  constructor(db, options) {
+    this.db = getSerializedExecutor(db);
+    this.prefix = sanitizeTablePrefix(options?.prefix ?? "ark_");
+    this.tTx = `${this.prefix}virtual_txs`;
+    this.tBranch = `${this.prefix}vtxo_branches`;
+  }
   ensureInit() {
     if (!this.initPromise) this.initPromise = this.init();
     return this.initPromise;
@@ -946,17 +1011,17 @@ var SQLiteVirtualTxRepository = class {
   }
   async clear() {
     await this.ensureInit();
-    await runInTransaction(this.db, async () => {
-      await this.db.run(`DELETE FROM ${this.tTx}`);
-      await this.db.run(`DELETE FROM ${this.tBranch}`);
+    await runInTransaction(this.db, async (tx) => {
+      await tx.run(`DELETE FROM ${this.tTx}`);
+      await tx.run(`DELETE FROM ${this.tBranch}`);
     });
   }
   async upsertVirtualTxs(txs) {
     if (txs.length === 0) return;
     await this.ensureInit();
-    await runInTransaction(this.db, async () => {
+    await runInTransaction(this.db, async (tx) => {
       const placeholders = txs.map(() => "?").join(", ");
-      const existing = await this.db.all(
+      const existing = await tx.all(
         `SELECT * FROM ${this.tTx} WHERE txid IN (${placeholders})`,
         txs.map((t) => t.txid)
       );
@@ -966,7 +1031,7 @@ var SQLiteVirtualTxRepository = class {
         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(
+        await tx.run(
           `INSERT OR REPLACE INTO ${this.tTx} (txid, psbt, expires_at, type) VALUES (?, ?, ?, ?)`,
           [t.txid, psbt, expires, type]
         );
@@ -981,13 +1046,13 @@ var SQLiteVirtualTxRepository = class {
   }
   async setBranch(vtxo, branch) {
     await this.ensureInit();
-    await runInTransaction(this.db, async () => {
-      await this.db.run(`DELETE FROM ${this.tBranch} WHERE vtxo_txid = ? AND vtxo_vout = ?`, [
+    await runInTransaction(this.db, async (tx) => {
+      await tx.run(`DELETE FROM ${this.tBranch} WHERE vtxo_txid = ? AND vtxo_vout = ?`, [
         vtxo.txid,
         vtxo.vout
       ]);
       for (const b of branch) {
-        await this.db.run(
+        await tx.run(
           `INSERT OR REPLACE INTO ${this.tBranch} (vtxo_txid, vtxo_vout, virtual_txid, position) VALUES (?, ?, ?, ?)`,
           [b.vtxoTxid, b.vtxoVout, b.virtualTxid, b.position]
         );
@@ -1016,18 +1081,18 @@ var SQLiteVirtualTxRepository = class {
   }
   async pruneForSpentVtxo(vtxo) {
     await this.ensureInit();
-    await runInTransaction(this.db, async () => {
-      const removed = await this.db.all(
+    await runInTransaction(this.db, async (tx) => {
+      const removed = await tx.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 = ?`, [
+      await tx.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(
+      await tx.run(
         `DELETE FROM ${this.tTx}
                  WHERE txid IN (${placeholders})
                  AND NOT EXISTS (
@@ -1049,6 +1114,6 @@ function rowToTx(r) {
   };
 }
 
-export { SQLiteContractRepository, SQLiteIntentRepository, SQLiteVirtualTxRepository, SQLiteWalletRepository, runInTransaction, sanitizeTablePrefix };
+export { SQLiteContractRepository, SQLiteIntentRepository, SQLiteVirtualTxRepository, SQLiteWalletRepository, getSerializedExecutor, runInTransaction, sanitizeTablePrefix };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map