@arkade-os/sdk 0.4.41 → 0.4.43

package/dist/{chunk-D5MQYYYF.js → chunk-B4R36PRN.js}

@@ -1,4 +1,4 @@
-import { craftToSpendTx, Transaction, OP_RETURN_EMPTY_PKSCRIPT, baseFetch, Intent, getArkPsbtFields, CosignerPublicKey, setArkPsbtField, VtxoTaprootTree, maybeArkError, AssetRef, AssetId, AssetOutput, AssetGroup, AssetInput, Packet, Metadata, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError, BufferReader } from './chunk-5XAYUPK4.js';
+import { craftToSpendTx, Transaction, OP_RETURN_EMPTY_PKSCRIPT, baseFetch, Intent, getArkPsbtFields, CosignerPublicKey, setArkPsbtField, VtxoTaprootTree, maybeArkError, AssetRef, AssetId, AssetOutput, AssetGroup, AssetInput, Packet, Metadata, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError, BufferReader } from './chunk-763XHDAJ.js';
 import { isMainnetDescriptor, descriptorIsOurs, contractHandlers, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, DefaultVtxo, BoardingContractHandler } from './chunk-YNEDJTX2.js';
 import { VtxoScript, timelockToSequence, DEFAULT_NETWORK, DEFAULT_NETWORK_NAME, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, ArkAddress, CSVMultisigTapscript, getSequence, getNetwork, MultisigTapscript, networks as networks$1, DEFAULT_ARKADE_SERVER_URL } from './chunk-BE5MUB7T.js';
 import { sha256, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr, equalBytes as equalBytes$1 } from '@scure/btc-signer/utils.js';
@@ -2644,7 +2644,7 @@ function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount) {
   );
 }
 function isMigrationCapable(wallet) {
-  return "arkProvider" in wallet && "arkServerPublicKey" in wallet && "onchainProvider" in wallet && typeof wallet.rotateServerSigner === "function" && typeof wallet.sendSelectedVtxosToSelf === "function" && typeof wallet.getBoardingUtxosForSigners === "function";
+  return "arkProvider" in wallet && "arkServerPublicKey" in wallet && "onchainProvider" in wallet && typeof wallet.rotateServerSigner === "function" && typeof wallet.refreshDeprecatedSigners === "function" && typeof wallet.sendSelectedVtxosToSelf === "function" && typeof wallet.getBoardingUtxosForSigners === "function";
 }
 function classifiedToRef(c) {
   return {
@@ -3168,6 +3168,7 @@ var VtxoManager = class _VtxoManager {
   async migrateCore(options) {
     const wallet = this.requireMigrationCapableWallet();
     const info = await wallet.arkProvider.getInfo();
+    wallet.refreshDeprecatedSigners(info);
     const signerSet = signerSetFromInfo(info);
     const nowSeconds = Math.floor(Date.now() / 1e3);
     const walletSignerHex = hex.encode(wallet.arkServerPublicKey);
@@ -4136,6 +4137,123 @@ function readUInt32BE(array, offset) {
 function noteTapscript(preimageHash) {
   return Script.encode(["SHA256", preimageHash, "EQUAL"]);
 }
+
+// src/repositories/intentRepository.ts
+var ALL_INTENT_STATES = [
+  "waiting_to_submit",
+  "waiting_for_batch",
+  "batch_in_progress",
+  "batch_failed",
+  "batch_succeeded",
+  "cancelled"
+];
+var INTENT_TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "batch_failed",
+  "batch_succeeded",
+  "cancelled"
+]);
+function isTerminalIntentState(s) {
+  return INTENT_TERMINAL_STATES.has(s);
+}
+function assertIntentIdUnique(intent, existing) {
+  if (intent.intentId === void 0) return;
+  for (const e of existing) {
+    if (e.intentTxId !== intent.intentTxId && e.intentId === intent.intentId) {
+      throw new Error(
+        `intentId "${intent.intentId}" is already used by intent ${e.intentTxId}`
+      );
+    }
+  }
+}
+function intentMatchesFilter(i, f) {
+  if (f.intentTxIds && !f.intentTxIds.includes(i.intentTxId)) return false;
+  if (f.intentIds && (!i.intentId || !f.intentIds.includes(i.intentId))) return false;
+  if (f.states && !f.states.includes(i.state)) return false;
+  if (f.containingInputs) {
+    const keys = new Set(i.intentVtxos.map((o) => `${o.txid}:${o.vout}`));
+    if (!f.containingInputs.some((o) => keys.has(`${o.txid}:${o.vout}`))) return false;
+  }
+  if (f.validAt !== void 0) {
+    if (i.validFrom !== void 0 && f.validAt < i.validFrom) return false;
+    if (i.validUntil !== void 0 && f.validAt > i.validUntil) return false;
+  }
+  if (f.searchText) {
+    const hay = [i.intentId, i.batchId, i.commitmentTransactionId].filter(Boolean).join(" ");
+    if (!hay.includes(f.searchText)) return false;
+  }
+  return true;
+}
+function intentPageBounds(filter, total) {
+  const skip = Math.max(0, filter?.skip ?? 0);
+  const take = filter?.take === void 0 ? total : Math.max(0, filter.take);
+  return { skip, end: skip + take };
+}
+
+// src/wallet/intentStateReducer.ts
+function reduceIntentState(current, event) {
+  if (isTerminalIntentState(current)) return current;
+  switch (event.type) {
+    case "batch_started" /* BatchStarted */:
+      return "batch_in_progress";
+    case "batch_finalized" /* BatchFinalized */:
+      return "batch_succeeded";
+    case "batch_failed" /* BatchFailed */:
+      return "batch_failed";
+    default:
+      return current;
+  }
+}
+function applySettlementEventToIntent(intent, event) {
+  const next = reduceIntentState(intent.state, event);
+  if (next === intent.state) return void 0;
+  const updated = { ...intent, state: next };
+  if ("id" in event && typeof event.id === "string") {
+    updated.batchId = event.id;
+  }
+  if (event.type === "batch_finalized" /* BatchFinalized */) {
+    updated.commitmentTransactionId = event.commitmentTxid;
+  }
+  if (event.type === "batch_failed" /* BatchFailed */) {
+    updated.cancellationReason = event.reason;
+  }
+  return updated;
+}
+
+// src/wallet/intentPersistenceHandler.ts
+async function persistTransition(deps, event) {
+  const repo = deps.intentRepository;
+  if (!repo) return;
+  try {
+    const cur = (await repo.getIntents({ intentTxIds: [deps.intentTxId] }))[0];
+    if (!cur) return;
+    const next = applySettlementEventToIntent(cur, event);
+    if (next) await repo.saveIntent(next);
+  } catch (e) {
+    console.error(`Failed to apply settlement event to intent ${deps.intentTxId}`, e);
+  }
+}
+function wrapHandlerWithIntentPersistence(base, deps) {
+  return {
+    ...base,
+    onBatchStarted: async (event) => {
+      const result = await base.onBatchStarted(event);
+      if (!result.skip) await persistTransition(deps, event);
+      return result;
+    },
+    onBatchFinalized: async (event) => {
+      if (base.onBatchFinalized) await base.onBatchFinalized(event);
+      await persistTransition(deps, event);
+    },
+    onBatchFailed: async (event) => {
+      await persistTransition(deps, event);
+      if (base.onBatchFailed) {
+        await base.onBatchFailed(event);
+        return;
+      }
+      throw new Error(event.reason);
+    }
+  };
+}
 var TxTree = class {
   constructor(root, children = /* @__PURE__ */ new Map()) {
     this.root = root;
@@ -5245,214 +5363,216 @@ function isAnnotated(v) {
   return v.tapTree !== void 0 && v.forfeitTapLeafScript !== void 0 && v.intentTapLeafScript !== void 0;
 }
 
-// src/contracts/vtxoOwnership.ts
-function vtxoOutpoint(vtxo) {
-  return `${vtxo.txid}:${vtxo.vout}`;
-}
-function isVtxoForScript(vtxo, script) {
-  return !!vtxo.script && vtxo.script === script;
-}
-function filterVtxosForScript(vtxos, script) {
-  return vtxos.filter((v) => isVtxoForScript(v, script));
-}
-function warnAndFilterVtxosForScript(vtxos, script, context) {
-  const matches = [];
-  const rejected = [];
-  for (const v of vtxos) {
-    if (isVtxoForScript(v, script)) {
-      matches.push(v);
-    } else {
-      rejected.push(`${vtxoOutpoint(v)}(script=${v.script ?? ""})`);
-    }
-  }
-  if (rejected.length > 0) {
-    console.warn(
-      `${context}: dropped ${rejected.length} wrong-script VTXO(s) for script ${script}: ${rejected.join(", ")}`
-    );
-  }
-  return matches;
-}
-function validateVtxosForScript(vtxos, script, context) {
-  const mismatches = vtxos.filter((v) => !isVtxoForScript(v, script));
-  if (mismatches.length === 0) return;
-  const detail = mismatches.map((v) => `${vtxoOutpoint(v)}(script=${v.script ?? ""})`).join(", ");
-  throw new Error(
-    `${context}: refusing to persist ${mismatches.length} VTXO(s) whose script does not match ${script}: ${detail}`
-  );
-}
-async function getVtxosForContract(repo, contract) {
-  return repo.getVtxosForScript ? repo.getVtxosForScript(contract.script) : filterVtxosForScript(await repo.getVtxos(contract.address), contract.script);
-}
-async function saveVtxosForContract(repo, contract, vtxos) {
-  if (repo.saveVtxosForScript) {
-    return repo.saveVtxosForScript(
-      { script: contract.script, address: contract.address },
-      vtxos
-    );
-  }
-  validateVtxosForScript(vtxos, contract.script, "saveVtxosForContract");
-  return repo.saveVtxos(contract.address, vtxos);
+// src/repositories/virtualTxRepository.ts
+var ChainedTxType = /* @__PURE__ */ ((ChainedTxType2) => {
+  ChainedTxType2[ChainedTxType2["Unspecified"] = 0] = "Unspecified";
+  ChainedTxType2[ChainedTxType2["Commitment"] = 1] = "Commitment";
+  ChainedTxType2[ChainedTxType2["Ark"] = 2] = "Ark";
+  ChainedTxType2[ChainedTxType2["Tree"] = 3] = "Tree";
+  ChainedTxType2[ChainedTxType2["Checkpoint"] = 4] = "Checkpoint";
+  return ChainedTxType2;
+})(ChainedTxType || {});
+function mergeChainedTxType(incoming, prev) {
+  if (incoming !== 0 /* Unspecified */) return incoming;
+  return prev ?? 0 /* Unspecified */;
 }
 
-// src/repositories/inMemory/walletRepository.ts
-var InMemoryWalletRepository = class {
+// src/repositories/inMemory/intentRepository.ts
+var InMemoryIntentRepository = class {
   version = 1;
-  vtxosByAddress = /* @__PURE__ */ new Map();
-  utxosByAddress = /* @__PURE__ */ new Map();
-  txsByAddress = /* @__PURE__ */ new Map();
-  walletState = null;
-  async getVtxos(address) {
-    return this.vtxosByAddress.get(address) ?? [];
-  }
-  async saveVtxos(address, vtxos) {
-    const existing = this.vtxosByAddress.get(address) ?? [];
-    const next = mergeByKey(existing, vtxos, (item) => `${item.txid}:${item.vout}`);
-    this.vtxosByAddress.set(address, next);
+  byId = /* @__PURE__ */ new Map();
+  async clear() {
+    this.byId.clear();
+  }
+  async saveIntent(intent) {
+    assertIntentIdUnique(intent, this.byId.values());
+    this.byId.set(intent.intentTxId, {
+      ...intent,
+      intentVtxos: [...intent.intentVtxos],
+      partialForfeits: [...intent.partialForfeits],
+      updatedAt: Date.now()
+    });
   }
-  async deleteVtxos(address) {
-    this.vtxosByAddress.delete(address);
+  async getIntents(filter) {
+    let out = [...this.byId.values()];
+    if (filter) out = out.filter((i) => intentMatchesFilter(i, filter));
+    out.sort((a, b) => a.createdAt - b.createdAt || a.intentTxId.localeCompare(b.intentTxId));
+    const { skip, end } = intentPageBounds(filter, out.length);
+    return out.slice(skip, end).map(clone);
   }
-  async getVtxosForScript(script) {
-    const allMatches = [];
-    for (const bucket of this.vtxosByAddress.values()) {
-      for (const vtxo of bucket) {
-        if (isVtxoForScript(vtxo, script)) {
-          allMatches.push(vtxo);
-        }
-      }
-    }
-    return mergeByKey([], allMatches, (item) => `${item.txid}:${item.vout}`);
+  async getLockedVtxoOutpoints() {
+    const out = [];
+    for (const i of this.byId.values())
+      if (!isTerminalIntentState(i.state)) for (const o of i.intentVtxos) out.push({ ...o });
+    return out;
   }
-  async saveVtxosForScript(key, vtxos) {
-    if (!key.address) {
-      throw new Error("InMemoryWalletRepository 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);
+  async [Symbol.asyncDispose]() {
   }
-  async deleteVtxosForScript(script) {
-    for (const [address, bucket] of this.vtxosByAddress.entries()) {
-      const next = bucket.filter((v) => !isVtxoForScript(v, script));
-      if (next.length === 0) {
-        this.vtxosByAddress.delete(address);
-      } else {
-        this.vtxosByAddress.set(address, next);
+};
+var clone = (i) => ({
+  ...i,
+  intentVtxos: i.intentVtxos.map((o) => ({ ...o })),
+  partialForfeits: [...i.partialForfeits]
+});
+
+// src/repositories/inMemory/virtualTxRepository.ts
+var opKey = (o) => `${o.txid}:${o.vout}`;
+var InMemoryVirtualTxRepository = class {
+  version = 1;
+  txs = /* @__PURE__ */ new Map();
+  branches = /* @__PURE__ */ new Map();
+  async clear() {
+    this.txs.clear();
+    this.branches.clear();
+  }
+  async upsertVirtualTxs(txs) {
+    for (const t of txs) {
+      const prev = this.txs.get(t.txid);
+      if (!prev) {
+        this.txs.set(t.txid, { ...t });
+        continue;
       }
+      this.txs.set(t.txid, {
+        txid: t.txid,
+        psbt: t.psbt ?? prev.psbt,
+        expiresAt: t.expiresAt ?? prev.expiresAt,
+        type: mergeChainedTxType(t.type, prev.type)
+      });
     }
   }
-  async getUtxos(address) {
-    return this.utxosByAddress.get(address) ?? [];
-  }
-  async saveUtxos(address, utxos) {
-    const existing = this.utxosByAddress.get(address) ?? [];
-    const next = mergeByKey(existing, utxos, (item) => `${item.txid}:${item.vout}`);
-    this.utxosByAddress.set(address, next);
-  }
-  async deleteUtxos(address) {
-    this.utxosByAddress.delete(address);
-  }
-  async getTransactionHistory(address) {
-    return this.txsByAddress.get(address) ?? [];
-  }
-  async saveTransactions(address, txs) {
-    const existing = this.txsByAddress.get(address) ?? [];
-    const next = mergeByKey(existing, txs, serializeTxKey);
-    this.txsByAddress.set(address, next);
+  async getVirtualTx(txid) {
+    const t = this.txs.get(txid);
+    return t ? { ...t } : null;
   }
-  async deleteTransactions(address) {
-    this.txsByAddress.delete(address);
+  async setBranch(vtxo, branch) {
+    this.branches.set(
+      opKey(vtxo),
+      [...branch].sort((a, b) => a.position - b.position)
+    );
   }
-  async getWalletState() {
-    return this.walletState;
+  async getBranch(vtxo) {
+    const b = this.branches.get(opKey(vtxo)) ?? [];
+    return b.map((x) => this.txs.get(x.virtualTxid)).filter((t) => !!t).map((t) => ({ ...t }));
   }
-  async saveWalletState(state) {
-    this.walletState = state;
+  async hasBranch(vtxo) {
+    return (this.branches.get(opKey(vtxo)) ?? []).length > 0;
   }
-  async clear() {
-    this.vtxosByAddress.clear();
-    this.utxosByAddress.clear();
-    this.txsByAddress.clear();
-    this.walletState = null;
+  async pruneForSpentVtxo(vtxo) {
+    const removed = this.branches.get(opKey(vtxo)) ?? [];
+    this.branches.delete(opKey(vtxo));
+    const stillReferenced = /* @__PURE__ */ new Set();
+    for (const b of this.branches.values())
+      for (const e of b) stillReferenced.add(e.virtualTxid);
+    for (const e of removed)
+      if (!stillReferenced.has(e.virtualTxid)) this.txs.delete(e.virtualTxid);
   }
   async [Symbol.asyncDispose]() {
-    return;
   }
 };
-function serializeTxKey(tx) {
-  const key = tx.key;
-  return `${key.boardingTxid}:${key.commitmentTxid}:${key.arkTxid}`;
-}
-function mergeByKey(existing, incoming, toKey) {
-  const next = /* @__PURE__ */ new Map();
-  existing.forEach((item) => {
-    next.set(toKey(item), item);
-  });
-  incoming.forEach((item) => {
-    next.set(toKey(item), item);
-  });
-  return Array.from(next.values());
-}
 
-// src/repositories/inMemory/contractRepository.ts
-var InMemoryContractRepository = class {
-  version = 1;
-  contractData = /* @__PURE__ */ new Map();
-  collections = /* @__PURE__ */ new Map();
-  contractsByScript = /* @__PURE__ */ new Map();
-  async clear() {
-    this.contractData.clear();
-    this.collections.clear();
-    this.contractsByScript.clear();
-  }
-  // Contract entity management methods
-  async getContracts(filter) {
-    const contracts = this.contractsByScript.values();
-    if (!filter) {
-      return [...contracts];
+// src/repositories/indexedDB/idbUtils.ts
+var promisifyRequest = (request) => new Promise((resolve, reject) => {
+  request.onsuccess = () => resolve(request.result);
+  request.onerror = () => reject(request.error);
+});
+var awaitTransaction = (transaction) => new Promise((resolve, reject) => {
+  transaction.oncomplete = () => resolve();
+  transaction.onerror = () => reject(transaction.error);
+  transaction.onabort = () => reject(transaction.error ?? new Error("transaction aborted"));
+});
+
+// src/repositories/indexedDB/manager.ts
+function getGlobalObject() {
+  if (typeof globalThis !== "undefined") {
+    if (typeof globalThis.self === "object" && globalThis.self !== null) {
+      return { globalObject: globalThis.self };
     }
-    const matches = (value, criterion) => {
-      if (criterion === void 0) {
-        return true;
-      }
-      return Array.isArray(criterion) ? criterion.includes(value) : value === criterion;
-    };
-    const results = [];
-    for (const contract of contracts) {
-      if (matches(contract.script, filter.script) && matches(contract.state, filter.state) && matches(contract.type, filter.type)) {
-        results.push(contract);
-      }
+    if (typeof globalThis.window === "object" && globalThis.window !== null) {
+      return { globalObject: globalThis.window };
     }
-    return results;
-  }
-  async saveContract(contract) {
-    this.contractsByScript.set(contract.script, contract);
+    return { globalObject: globalThis };
   }
-  async deleteContract(script) {
-    this.contractsByScript.delete(script);
+  throw new Error("Global object not found");
+}
+var dbCache = /* @__PURE__ */ new Map();
+var refCounts = /* @__PURE__ */ new Map();
+async function openDatabase(dbName, dbVersion, initDatabase2) {
+  const { globalObject } = getGlobalObject();
+  if (!globalObject.indexedDB) {
+    throw new Error("IndexedDB is not available in this environment");
   }
-  async [Symbol.asyncDispose]() {
-    return;
+  const cached = dbCache.get(dbName);
+  if (cached) {
+    if (cached.version !== dbVersion) {
+      throw new Error(
+        `Database "${dbName}" already opened with version ${cached.version}; requested ${dbVersion}`
+      );
+    }
+    refCounts.set(dbName, (refCounts.get(dbName) ?? 0) + 1);
+    return cached.promise;
   }
-};
-function scriptFromArkAddress(address) {
-  return hex.encode(ArkAddress.decode(address).pkScript);
-}
-
-// src/repositories/indexedDB/schema.ts
-var STORE_VTXOS = "vtxos";
-var STORE_UTXOS = "utxos";
-var STORE_TRANSACTIONS = "transactions";
-var STORE_WALLET_STATE = "walletState";
-var STORE_CONTRACTS = "contracts";
-var LEGACY_STORE_CONTRACT_COLLECTIONS = "contractsCollections";
-var DB_VERSION = 3;
-function initDatabase(db, oldVersion, transaction) {
+  const dbPromise = new Promise((resolve, reject) => {
+    const request = globalObject.indexedDB.open(dbName, dbVersion);
+    request.onerror = () => {
+      dbCache.delete(dbName);
+      refCounts.delete(dbName);
+      reject(request.error);
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      db.onversionchange = () => {
+        db.close();
+        dbCache.delete(dbName);
+        refCounts.delete(dbName);
+      };
+      resolve(db);
+    };
+    request.onupgradeneeded = (event) => {
+      const db = request.result;
+      initDatabase2(db, event.oldVersion, request.transaction);
+    };
+    request.onblocked = () => {
+      console.warn("Database upgrade blocked - close other tabs/connections");
+    };
+  });
+  dbCache.set(dbName, { version: dbVersion, promise: dbPromise });
+  refCounts.set(dbName, 1);
+  return dbPromise;
+}
+async function closeDatabase(dbName) {
+  const cachedEntry = dbCache.get(dbName);
+  if (!cachedEntry) return false;
+  const count = (refCounts.get(dbName) ?? 1) - 1;
+  if (count > 0) {
+    refCounts.set(dbName, count);
+    return false;
+  }
+  refCounts.delete(dbName);
+  dbCache.delete(dbName);
+  try {
+    const db = await cachedEntry.promise;
+    db.close();
+  } catch {
+  }
+  return true;
+}
+function scriptFromArkAddress(address) {
+  return hex.encode(ArkAddress.decode(address).pkScript);
+}
+
+// src/repositories/indexedDB/schema.ts
+var STORE_VTXOS = "vtxos";
+var STORE_UTXOS = "utxos";
+var STORE_TRANSACTIONS = "transactions";
+var STORE_WALLET_STATE = "walletState";
+var STORE_CONTRACTS = "contracts";
+var STORE_INTENTS = "intents";
+var STORE_VIRTUAL_TXS = "virtualTxs";
+var STORE_VTXO_BRANCHES = "vtxoBranches";
+var LEGACY_STORE_CONTRACT_COLLECTIONS = "contractsCollections";
+var DB_VERSION = 3;
+var INTENT_DB_VERSION = 5;
+function initDatabase(db, oldVersion, transaction) {
   if (!db.objectStoreNames.contains(STORE_VTXOS)) {
     const vtxosStore = db.createObjectStore(STORE_VTXOS, {
       keyPath: ["address", "txid", "vout"]
@@ -5590,33 +5710,506 @@ function initDatabase(db, oldVersion, transaction) {
       });
     }
   }
-  if (!db.objectStoreNames.contains(LEGACY_STORE_CONTRACT_COLLECTIONS)) {
-    db.createObjectStore(LEGACY_STORE_CONTRACT_COLLECTIONS, {
-      keyPath: "key"
-    });
+  if (!db.objectStoreNames.contains(LEGACY_STORE_CONTRACT_COLLECTIONS)) {
+    db.createObjectStore(LEGACY_STORE_CONTRACT_COLLECTIONS, {
+      keyPath: "key"
+    });
+  }
+  if (oldVersion >= 1 && oldVersion < 3 && transaction) {
+    const vtxosStore = transaction.objectStore(STORE_VTXOS);
+    if (!vtxosStore.indexNames.contains("script")) {
+      vtxosStore.createIndex("script", "script", { unique: false });
+    }
+    backfillVtxoScripts(transaction);
+  }
+}
+function initDatabaseWithIntents(db, oldVersion, transaction) {
+  initDatabase(db, oldVersion, transaction);
+  if (!db.objectStoreNames.contains(STORE_INTENTS)) {
+    const intentsStore = db.createObjectStore(STORE_INTENTS, {
+      keyPath: "intentTxId"
+    });
+    intentsStore.createIndex("intentId", "intentId", { unique: true });
+    intentsStore.createIndex("state", "state", { unique: false });
+  }
+  if (!db.objectStoreNames.contains(STORE_VIRTUAL_TXS)) {
+    db.createObjectStore(STORE_VIRTUAL_TXS, { keyPath: "txid" });
+  }
+  if (!db.objectStoreNames.contains(STORE_VTXO_BRANCHES)) {
+    const branchesStore = db.createObjectStore(STORE_VTXO_BRANCHES, {
+      keyPath: ["vtxoTxid", "vtxoVout", "position"]
+    });
+    branchesStore.createIndex("vtxo", ["vtxoTxid", "vtxoVout"], { unique: false });
+    branchesStore.createIndex("virtualTxid", "virtualTxid", { unique: false });
+  }
+  if (oldVersion === 4 && transaction) {
+    const intentsStore = transaction.objectStore(STORE_INTENTS);
+    if (intentsStore.indexNames.contains("intentId")) {
+      intentsStore.deleteIndex("intentId");
+    }
+    dedupeIntentIds(intentsStore, () => {
+      intentsStore.createIndex("intentId", "intentId", { unique: true });
+    });
+  }
+}
+function dedupeIntentIds(store, onComplete) {
+  const seen = /* @__PURE__ */ new Set();
+  const cursorRequest = store.openCursor();
+  cursorRequest.onsuccess = () => {
+    const cursor = cursorRequest.result;
+    if (!cursor) {
+      onComplete();
+      return;
+    }
+    const id = cursor.value.intentId;
+    if (id != null) {
+      if (seen.has(id)) {
+        cursor.delete();
+      } else {
+        seen.add(id);
+      }
+    }
+    cursor.continue();
+  };
+}
+function backfillVtxoScripts(transaction) {
+  const store = transaction.objectStore(STORE_VTXOS);
+  const cursorRequest = store.openCursor();
+  cursorRequest.onsuccess = () => {
+    const cursor = cursorRequest.result;
+    if (!cursor) return;
+    const value = cursor.value;
+    if (!value.script) {
+      value.script = scriptFromArkAddress(value.address);
+      cursor.update(value);
+    }
+    cursor.continue();
+  };
+}
+
+// src/worker/browser/utils.ts
+var DEFAULT_DB_NAME = "arkade-service-worker";
+var DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS = 1e4;
+function normalizeOptions2(pathOrOptions) {
+  if (typeof pathOrOptions === "string") {
+    return {
+      path: pathOrOptions,
+      activationTimeoutMs: DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS
+    };
+  }
+  return {
+    path: pathOrOptions.path,
+    activationTimeoutMs: pathOrOptions.activationTimeoutMs ?? DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS
+  };
+}
+function waitForServiceWorkerReady(timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Service worker activation timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    navigator.serviceWorker.ready.then((registration) => {
+      clearTimeout(timeoutId);
+      resolve(registration);
+    }).catch((error) => {
+      clearTimeout(timeoutId);
+      reject(error);
+    });
+  });
+}
+async function setupServiceWorker(pathOrOptions) {
+  if (!("serviceWorker" in navigator)) {
+    throw new Error("Service workers are not supported in this browser");
+  }
+  const { path, activationTimeoutMs } = normalizeOptions2(pathOrOptions);
+  const registration = await navigator.serviceWorker.register(path);
+  await registration.update();
+  const serviceWorker = registration.active || registration.waiting || registration.installing;
+  if (!serviceWorker) {
+    throw new Error("Failed to get service worker instance");
+  }
+  if (serviceWorker.state === "activated") {
+    return serviceWorker;
+  }
+  const readyRegistration = await waitForServiceWorkerReady(activationTimeoutMs);
+  if (!readyRegistration.active) {
+    throw new Error("Service worker registration is ready but has no active worker");
+  }
+  return readyRegistration.active;
+}
+
+// src/repositories/indexedDB/virtualTxRepository.ts
+var IndexedDBVirtualTxRepository = class {
+  constructor(dbName = DEFAULT_DB_NAME) {
+    this.dbName = dbName;
+  }
+  version = 1;
+  db = null;
+  async getDB() {
+    if (!this.db)
+      this.db = await openDatabase(this.dbName, INTENT_DB_VERSION, initDatabaseWithIntents);
+    return this.db;
+  }
+  async clear() {
+    const db = await this.getDB();
+    const transaction = db.transaction([STORE_VIRTUAL_TXS, STORE_VTXO_BRANCHES], "readwrite");
+    transaction.objectStore(STORE_VIRTUAL_TXS).clear();
+    transaction.objectStore(STORE_VTXO_BRANCHES).clear();
+    await awaitTransaction(transaction);
+  }
+  async upsertVirtualTxs(txs) {
+    if (txs.length === 0) return;
+    const db = await this.getDB();
+    const merged = /* @__PURE__ */ new Map();
+    for (const tx of txs) {
+      const acc = merged.get(tx.txid);
+      merged.set(
+        tx.txid,
+        acc ? {
+          txid: tx.txid,
+          psbt: tx.psbt ?? acc.psbt,
+          expiresAt: tx.expiresAt ?? acc.expiresAt,
+          type: mergeChainedTxType(tx.type, acc.type)
+        } : tx
+      );
+    }
+    const transaction = db.transaction([STORE_VIRTUAL_TXS], "readwrite");
+    const store = transaction.objectStore(STORE_VIRTUAL_TXS);
+    for (const tx of merged.values()) {
+      const getReq = store.get(tx.txid);
+      getReq.onsuccess = () => {
+        const prev = getReq.result;
+        store.put({
+          txid: tx.txid,
+          psbt: tx.psbt ?? prev?.psbt ?? null,
+          expiresAt: tx.expiresAt ?? prev?.expiresAt ?? null,
+          type: mergeChainedTxType(tx.type, prev?.type)
+        });
+      };
+    }
+    await awaitTransaction(transaction);
+  }
+  async getVirtualTx(txid) {
+    const db = await this.getDB();
+    const store = db.transaction([STORE_VIRTUAL_TXS], "readonly").objectStore(STORE_VIRTUAL_TXS);
+    const r = await promisifyRequest(store.get(txid));
+    return r ?? null;
+  }
+  async setBranch(vtxo, branch) {
+    const db = await this.getDB();
+    const transaction = db.transaction([STORE_VTXO_BRANCHES], "readwrite");
+    const store = transaction.objectStore(STORE_VTXO_BRANCHES);
+    const getAllReq = store.index("vtxo").getAll(IDBKeyRange.only([vtxo.txid, vtxo.vout]));
+    getAllReq.onsuccess = () => {
+      const existing = getAllReq.result;
+      for (const e of existing) store.delete([e.vtxoTxid, e.vtxoVout, e.position]);
+      for (const b of branch) store.put(b);
+    };
+    await awaitTransaction(transaction);
+  }
+  async getBranch(vtxo) {
+    const db = await this.getDB();
+    const transaction = db.transaction([STORE_VTXO_BRANCHES, STORE_VIRTUAL_TXS], "readonly");
+    const branchStore = transaction.objectStore(STORE_VTXO_BRANCHES);
+    const txStore = transaction.objectStore(STORE_VIRTUAL_TXS);
+    const getAllReq = branchStore.index("vtxo").getAll(IDBKeyRange.only([vtxo.txid, vtxo.vout]));
+    const byTxid = /* @__PURE__ */ new Map();
+    let ordered = [];
+    getAllReq.onsuccess = () => {
+      ordered = getAllReq.result.slice().sort((a, b) => a.position - b.position);
+      for (const b of ordered) {
+        const txReq = txStore.get(b.virtualTxid);
+        txReq.onsuccess = () => {
+          const r = txReq.result;
+          if (r) byTxid.set(b.virtualTxid, r);
+        };
+      }
+    };
+    await awaitTransaction(transaction);
+    const out = [];
+    for (const b of ordered) {
+      const tx = byTxid.get(b.virtualTxid);
+      if (tx) out.push(tx);
+    }
+    return out;
+  }
+  async hasBranch(vtxo) {
+    const db = await this.getDB();
+    const vtxoIndex = db.transaction([STORE_VTXO_BRANCHES], "readonly").objectStore(STORE_VTXO_BRANCHES).index("vtxo");
+    const count = await promisifyRequest(
+      vtxoIndex.count(IDBKeyRange.only([vtxo.txid, vtxo.vout]))
+    );
+    return count > 0;
+  }
+  async pruneForSpentVtxo(vtxo) {
+    const db = await this.getDB();
+    const transaction = db.transaction([STORE_VTXO_BRANCHES, STORE_VIRTUAL_TXS], "readwrite");
+    const branches = transaction.objectStore(STORE_VTXO_BRANCHES);
+    const txStore = transaction.objectStore(STORE_VIRTUAL_TXS);
+    const getAllReq = branches.index("vtxo").getAll(IDBKeyRange.only([vtxo.txid, vtxo.vout]));
+    getAllReq.onsuccess = () => {
+      const removed = getAllReq.result;
+      if (removed.length === 0) return;
+      for (const e of removed) branches.delete([e.vtxoTxid, e.vtxoVout, e.position]);
+      for (const e of removed) {
+        const countReq = branches.index("virtualTxid").count(IDBKeyRange.only(e.virtualTxid));
+        countReq.onsuccess = () => {
+          if (countReq.result === 0) txStore.delete(e.virtualTxid);
+        };
+      }
+    };
+    await awaitTransaction(transaction);
+  }
+  async [Symbol.asyncDispose]() {
+    if (!this.db) return;
+    await closeDatabase(this.dbName);
+    this.db = null;
+  }
+};
+
+// src/repositories/indexedDB/intentRepository.ts
+var IndexedDBIntentRepository = class {
+  constructor(dbName = DEFAULT_DB_NAME) {
+    this.dbName = dbName;
+  }
+  version = 1;
+  db = null;
+  async getDB() {
+    if (!this.db)
+      this.db = await openDatabase(this.dbName, INTENT_DB_VERSION, initDatabaseWithIntents);
+    return this.db;
+  }
+  async clear() {
+    const db = await this.getDB();
+    const transaction = db.transaction([STORE_INTENTS], "readwrite");
+    transaction.objectStore(STORE_INTENTS).clear();
+    await awaitTransaction(transaction);
+  }
+  async saveIntent(intent) {
+    const db = await this.getDB();
+    const transaction = db.transaction([STORE_INTENTS], "readwrite");
+    transaction.objectStore(STORE_INTENTS).put({ ...intent, updatedAt: Date.now() });
+    await awaitTransaction(transaction);
+  }
+  async getIntents(filter) {
+    const db = await this.getDB();
+    const store = db.transaction([STORE_INTENTS], "readonly").objectStore(STORE_INTENTS);
+    const all = await promisifyRequest(store.getAll());
+    all.sort((a, b) => a.createdAt - b.createdAt || a.intentTxId.localeCompare(b.intentTxId));
+    const out = filter ? all.filter((i) => intentMatchesFilter(i, filter)) : all;
+    const { skip, end } = intentPageBounds(filter, out.length);
+    return out.slice(skip, end);
+  }
+  async getLockedVtxoOutpoints() {
+    const db = await this.getDB();
+    const store = db.transaction([STORE_INTENTS], "readonly").objectStore(STORE_INTENTS);
+    const all = await promisifyRequest(store.getAll());
+    const out = [];
+    for (const i of all)
+      if (!isTerminalIntentState(i.state)) for (const o of i.intentVtxos) out.push(o);
+    return out;
+  }
+  async [Symbol.asyncDispose]() {
+    if (!this.db) return;
+    await closeDatabase(this.dbName);
+    this.db = null;
+  }
+};
+
+// src/contracts/vtxoOwnership.ts
+function vtxoOutpoint(vtxo) {
+  return `${vtxo.txid}:${vtxo.vout}`;
+}
+function isVtxoForScript(vtxo, script) {
+  return !!vtxo.script && vtxo.script === script;
+}
+function filterVtxosForScript(vtxos, script) {
+  return vtxos.filter((v) => isVtxoForScript(v, script));
+}
+function warnAndFilterVtxosForScript(vtxos, script, context) {
+  const matches = [];
+  const rejected = [];
+  for (const v of vtxos) {
+    if (isVtxoForScript(v, script)) {
+      matches.push(v);
+    } else {
+      rejected.push(`${vtxoOutpoint(v)}(script=${v.script ?? ""})`);
+    }
+  }
+  if (rejected.length > 0) {
+    console.warn(
+      `${context}: dropped ${rejected.length} wrong-script VTXO(s) for script ${script}: ${rejected.join(", ")}`
+    );
+  }
+  return matches;
+}
+function validateVtxosForScript(vtxos, script, context) {
+  const mismatches = vtxos.filter((v) => !isVtxoForScript(v, script));
+  if (mismatches.length === 0) return;
+  const detail = mismatches.map((v) => `${vtxoOutpoint(v)}(script=${v.script ?? ""})`).join(", ");
+  throw new Error(
+    `${context}: refusing to persist ${mismatches.length} VTXO(s) whose script does not match ${script}: ${detail}`
+  );
+}
+async function getVtxosForContract(repo, contract) {
+  return repo.getVtxosForScript ? repo.getVtxosForScript(contract.script) : filterVtxosForScript(await repo.getVtxos(contract.address), contract.script);
+}
+async function saveVtxosForContract(repo, contract, vtxos) {
+  if (repo.saveVtxosForScript) {
+    return repo.saveVtxosForScript(
+      { script: contract.script, address: contract.address },
+      vtxos
+    );
+  }
+  validateVtxosForScript(vtxos, contract.script, "saveVtxosForContract");
+  return repo.saveVtxos(contract.address, vtxos);
+}
+
+// src/repositories/inMemory/walletRepository.ts
+var InMemoryWalletRepository = class {
+  version = 1;
+  vtxosByAddress = /* @__PURE__ */ new Map();
+  utxosByAddress = /* @__PURE__ */ new Map();
+  txsByAddress = /* @__PURE__ */ new Map();
+  walletState = null;
+  async getVtxos(address) {
+    return this.vtxosByAddress.get(address) ?? [];
+  }
+  async saveVtxos(address, vtxos) {
+    const existing = this.vtxosByAddress.get(address) ?? [];
+    const next = mergeByKey(existing, vtxos, (item) => `${item.txid}:${item.vout}`);
+    this.vtxosByAddress.set(address, next);
+  }
+  async deleteVtxos(address) {
+    this.vtxosByAddress.delete(address);
+  }
+  async getVtxosForScript(script) {
+    const allMatches = [];
+    for (const bucket of this.vtxosByAddress.values()) {
+      for (const vtxo of bucket) {
+        if (isVtxoForScript(vtxo, script)) {
+          allMatches.push(vtxo);
+        }
+      }
+    }
+    return mergeByKey([], allMatches, (item) => `${item.txid}:${item.vout}`);
+  }
+  async saveVtxosForScript(key, vtxos) {
+    if (!key.address) {
+      throw new Error("InMemoryWalletRepository 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);
+  }
+  async deleteVtxosForScript(script) {
+    for (const [address, bucket] of this.vtxosByAddress.entries()) {
+      const next = bucket.filter((v) => !isVtxoForScript(v, script));
+      if (next.length === 0) {
+        this.vtxosByAddress.delete(address);
+      } else {
+        this.vtxosByAddress.set(address, next);
+      }
+    }
+  }
+  async getUtxos(address) {
+    return this.utxosByAddress.get(address) ?? [];
+  }
+  async saveUtxos(address, utxos) {
+    const existing = this.utxosByAddress.get(address) ?? [];
+    const next = mergeByKey(existing, utxos, (item) => `${item.txid}:${item.vout}`);
+    this.utxosByAddress.set(address, next);
+  }
+  async deleteUtxos(address) {
+    this.utxosByAddress.delete(address);
+  }
+  async getTransactionHistory(address) {
+    return this.txsByAddress.get(address) ?? [];
+  }
+  async saveTransactions(address, txs) {
+    const existing = this.txsByAddress.get(address) ?? [];
+    const next = mergeByKey(existing, txs, serializeTxKey);
+    this.txsByAddress.set(address, next);
+  }
+  async deleteTransactions(address) {
+    this.txsByAddress.delete(address);
+  }
+  async getWalletState() {
+    return this.walletState;
+  }
+  async saveWalletState(state) {
+    this.walletState = state;
+  }
+  async clear() {
+    this.vtxosByAddress.clear();
+    this.utxosByAddress.clear();
+    this.txsByAddress.clear();
+    this.walletState = null;
+  }
+  async [Symbol.asyncDispose]() {
+    return;
+  }
+};
+function serializeTxKey(tx) {
+  const key = tx.key;
+  return `${key.boardingTxid}:${key.commitmentTxid}:${key.arkTxid}`;
+}
+function mergeByKey(existing, incoming, toKey) {
+  const next = /* @__PURE__ */ new Map();
+  existing.forEach((item) => {
+    next.set(toKey(item), item);
+  });
+  incoming.forEach((item) => {
+    next.set(toKey(item), item);
+  });
+  return Array.from(next.values());
+}
+
+// src/repositories/inMemory/contractRepository.ts
+var InMemoryContractRepository = class {
+  version = 1;
+  contractData = /* @__PURE__ */ new Map();
+  collections = /* @__PURE__ */ new Map();
+  contractsByScript = /* @__PURE__ */ new Map();
+  async clear() {
+    this.contractData.clear();
+    this.collections.clear();
+    this.contractsByScript.clear();
+  }
+  // Contract entity management methods
+  async getContracts(filter) {
+    const contracts = this.contractsByScript.values();
+    if (!filter) {
+      return [...contracts];
+    }
+    const matches = (value, criterion) => {
+      if (criterion === void 0) {
+        return true;
+      }
+      return Array.isArray(criterion) ? criterion.includes(value) : value === criterion;
+    };
+    const results = [];
+    for (const contract of contracts) {
+      if (matches(contract.script, filter.script) && matches(contract.state, filter.state) && matches(contract.type, filter.type)) {
+        results.push(contract);
+      }
+    }
+    return results;
+  }
+  async saveContract(contract) {
+    this.contractsByScript.set(contract.script, contract);
   }
-  if (oldVersion >= 1 && oldVersion < 3 && transaction) {
-    const vtxosStore = transaction.objectStore(STORE_VTXOS);
-    if (!vtxosStore.indexNames.contains("script")) {
-      vtxosStore.createIndex("script", "script", { unique: false });
-    }
-    backfillVtxoScripts(transaction);
+  async deleteContract(script) {
+    this.contractsByScript.delete(script);
   }
-}
-function backfillVtxoScripts(transaction) {
-  const store = transaction.objectStore(STORE_VTXOS);
-  const cursorRequest = store.openCursor();
-  cursorRequest.onsuccess = () => {
-    const cursor = cursorRequest.result;
-    if (!cursor) return;
-    const value = cursor.value;
-    if (!value.script) {
-      value.script = scriptFromArkAddress(value.address);
-      cursor.update(value);
-    }
-    cursor.continue();
-  };
-}
+  async [Symbol.asyncDispose]() {
+    return;
+  }
+};
 var serializeTapLeaf = ([cb, s]) => ({
   cb: hex.encode(TaprootControlBlock.encode(cb)),
   s: hex.encode(s)
@@ -5683,132 +6276,6 @@ var deserializeTransaction = (o) => ({
   assets: deserializeAssets(o.assets)
 });
 
-// src/repositories/indexedDB/manager.ts
-function getGlobalObject() {
-  if (typeof globalThis !== "undefined") {
-    if (typeof globalThis.self === "object" && globalThis.self !== null) {
-      return { globalObject: globalThis.self };
-    }
-    if (typeof globalThis.window === "object" && globalThis.window !== null) {
-      return { globalObject: globalThis.window };
-    }
-    return { globalObject: globalThis };
-  }
-  throw new Error("Global object not found");
-}
-var dbCache = /* @__PURE__ */ new Map();
-var refCounts = /* @__PURE__ */ new Map();
-async function openDatabase(dbName, dbVersion, initDatabase2) {
-  const { globalObject } = getGlobalObject();
-  if (!globalObject.indexedDB) {
-    throw new Error("IndexedDB is not available in this environment");
-  }
-  const cached = dbCache.get(dbName);
-  if (cached) {
-    if (cached.version !== dbVersion) {
-      throw new Error(
-        `Database "${dbName}" already opened with version ${cached.version}; requested ${dbVersion}`
-      );
-    }
-    refCounts.set(dbName, (refCounts.get(dbName) ?? 0) + 1);
-    return cached.promise;
-  }
-  const dbPromise = new Promise((resolve, reject) => {
-    const request = globalObject.indexedDB.open(dbName, dbVersion);
-    request.onerror = () => {
-      dbCache.delete(dbName);
-      refCounts.delete(dbName);
-      reject(request.error);
-    };
-    request.onsuccess = () => {
-      const db = request.result;
-      db.onversionchange = () => {
-        db.close();
-        dbCache.delete(dbName);
-        refCounts.delete(dbName);
-      };
-      resolve(db);
-    };
-    request.onupgradeneeded = (event) => {
-      const db = request.result;
-      initDatabase2(db, event.oldVersion, request.transaction);
-    };
-    request.onblocked = () => {
-      console.warn("Database upgrade blocked - close other tabs/connections");
-    };
-  });
-  dbCache.set(dbName, { version: dbVersion, promise: dbPromise });
-  refCounts.set(dbName, 1);
-  return dbPromise;
-}
-async function closeDatabase(dbName) {
-  const cachedEntry = dbCache.get(dbName);
-  if (!cachedEntry) return false;
-  const count = (refCounts.get(dbName) ?? 1) - 1;
-  if (count > 0) {
-    refCounts.set(dbName, count);
-    return false;
-  }
-  refCounts.delete(dbName);
-  dbCache.delete(dbName);
-  try {
-    const db = await cachedEntry.promise;
-    db.close();
-  } catch {
-  }
-  return true;
-}
-
-// src/worker/browser/utils.ts
-var DEFAULT_DB_NAME = "arkade-service-worker";
-var DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS = 1e4;
-function normalizeOptions2(pathOrOptions) {
-  if (typeof pathOrOptions === "string") {
-    return {
-      path: pathOrOptions,
-      activationTimeoutMs: DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS
-    };
-  }
-  return {
-    path: pathOrOptions.path,
-    activationTimeoutMs: pathOrOptions.activationTimeoutMs ?? DEFAULT_SERVICE_WORKER_ACTIVATION_TIMEOUT_MS
-  };
-}
-function waitForServiceWorkerReady(timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      reject(new Error(`Service worker activation timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    navigator.serviceWorker.ready.then((registration) => {
-      clearTimeout(timeoutId);
-      resolve(registration);
-    }).catch((error) => {
-      clearTimeout(timeoutId);
-      reject(error);
-    });
-  });
-}
-async function setupServiceWorker(pathOrOptions) {
-  if (!("serviceWorker" in navigator)) {
-    throw new Error("Service workers are not supported in this browser");
-  }
-  const { path, activationTimeoutMs } = normalizeOptions2(pathOrOptions);
-  const registration = await navigator.serviceWorker.register(path);
-  await registration.update();
-  const serviceWorker = registration.active || registration.waiting || registration.installing;
-  if (!serviceWorker) {
-    throw new Error("Failed to get service worker instance");
-  }
-  if (serviceWorker.state === "activated") {
-    return serviceWorker;
-  }
-  const readyRegistration = await waitForServiceWorkerReady(activationTimeoutMs);
-  if (!readyRegistration.active) {
-    throw new Error("Service worker registration is ready but has no active worker");
-  }
-  return readyRegistration.active;
-}
-
 // src/repositories/indexedDB/contractRepository.ts
 var IndexedDBContractRepository = class {
   constructor(dbName = DEFAULT_DB_NAME) {
@@ -7116,7 +7583,7 @@ var ContractWatcher = class {
         this.subscriptionId
       );
     } catch (error) {
-      const isStale = error instanceof Error && /subscription\s+\S+\s+not\s+found/i.test(error.message);
+      const isStale = error instanceof Error && /subscription\b.*\bnot\s+found/i.test(error.message);
       if (this.subscriptionId && isStale) {
         this.subscriptionId = void 0;
         this.subscriptionId = await this.config.indexerProvider.subscribeForScripts(scriptsToWatch);
@@ -7246,6 +7713,89 @@ var ContractWatcher = class {
   }
 };
 
+// src/wallet/intentReconciliation.ts
+var NON_TERMINAL_INTENT_STATES = ALL_INTENT_STATES.filter(
+  (s) => !isTerminalIntentState(s)
+);
+function isConsumed(vtxo) {
+  return vtxo !== void 0 && (vtxo.isSpent === true || vtxo.settledBy !== void 0);
+}
+async function classifyIntent(intent, vtxosByOutpoint, now) {
+  if (isTerminalIntentState(intent.state)) return void 0;
+  const inputs = intent.intentVtxos;
+  const consumed = inputs.map((o) => vtxosByOutpoint.get(outpointKey(o)));
+  if (inputs.length > 0 && consumed.every(isConsumed)) {
+    const commitmentTransactionId = intent.commitmentTransactionId ?? consumed.map((v) => v?.settledBy).find((s) => !!s);
+    return terminal(intent, "batch_succeeded", now, { commitmentTransactionId });
+  }
+  if (intent.state === "waiting_to_submit") {
+    return terminal(intent, "cancelled", now, {
+      cancellationReason: "reconciliation: intent was never submitted before restart"
+    });
+  }
+  if (intent.validUntil !== void 0 && intent.validUntil < now) {
+    return terminal(intent, "cancelled", now, {
+      cancellationReason: "reconciliation: intent expired"
+    });
+  }
+  return void 0;
+}
+async function reconcileIntents(deps) {
+  const now = deps.now ?? Date.now;
+  let intents;
+  try {
+    intents = await deps.intentRepository.getIntents({
+      states: [...NON_TERMINAL_INTENT_STATES]
+    });
+  } catch (e) {
+    console.error("reconcileIntents: failed to read non-terminal intents", e);
+    return;
+  }
+  if (intents.length === 0) return;
+  const outpoints = dedupeOutpoints(intents.flatMap((i) => i.intentVtxos));
+  let vtxosByOutpoint = /* @__PURE__ */ new Map();
+  if (outpoints.length > 0) {
+    try {
+      const { vtxos } = await deps.indexerProvider.getVtxos({ outpoints });
+      vtxosByOutpoint = new Map(vtxos.map((v) => [outpointKey(v), v]));
+    } catch (e) {
+      console.error("reconcileIntents: failed to fetch input VTXO state", e);
+      return;
+    }
+  }
+  const nowMs = now();
+  for (const intent of intents) {
+    try {
+      const next = await classifyIntent(intent, vtxosByOutpoint, nowMs);
+      if (!next) continue;
+      const [fresh] = await deps.intentRepository.getIntents({
+        intentTxIds: [intent.intentTxId]
+      });
+      if (!fresh || fresh.state !== intent.state) continue;
+      await deps.intentRepository.saveIntent(next);
+    } catch (e) {
+      console.error(`reconcileIntents: failed to reconcile intent ${intent.intentTxId}`, e);
+    }
+  }
+}
+function terminal(intent, state, now, patch) {
+  return { ...intent, ...patch, state, updatedAt: now };
+}
+function outpointKey(o) {
+  return `${o.txid}:${o.vout}`;
+}
+function dedupeOutpoints(outpoints) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const o of outpoints) {
+    const k = outpointKey(o);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(o);
+  }
+  return out;
+}
+
 // src/utils/syncCursors.ts
 var SAFETY_LAG_MS = 3e4;
 var OVERLAP_MS = 24 * 60 * 60 * 1e3;
@@ -7369,6 +7919,26 @@ var ContractManager = class _ContractManager {
     if (watched.length > 0) {
       await this.reconcilePendingFrontier(watched);
     }
+    await this.reconcileStaleIntents();
+  }
+  /**
+   * Crash-recovery for persisted settlement intents: reconcile any
+   * non-terminal intent left behind by a mid-settle crash against
+   * authoritative indexer state (see {@link reconcileIntents}). Runs on the
+   * online sync path only — boot and subscription reconnect — never from a
+   * wallet read API. Best-effort: intent recovery is not a sync invariant, so
+   * a failure is logged and sync continues. No-op without an intent store.
+   */
+  async reconcileStaleIntents() {
+    if (!this.config.intentRepository) return;
+    try {
+      await reconcileIntents({
+        intentRepository: this.config.intentRepository,
+        indexerProvider: this.config.indexerProvider
+      });
+    } catch (e) {
+      console.error("ContractManager: intent reconciliation failed", e);
+    }
   }
   /**
    * Create and register a new contract.
@@ -8739,6 +9309,22 @@ async function resolveBoardingBootTapscript(contractRepository, serverPubKey, ba
 function hasToReadonly(identity) {
   return typeof identity === "object" && identity !== null && "toReadonly" in identity && typeof identity.toReadonly === "function";
 }
+function excludeLockedOutpoints(vtxos, locked) {
+  if (locked.length === 0) return vtxos;
+  const lockedKeys = new Set(locked.map((o) => `${o.txid}:${o.vout}`));
+  return vtxos.filter((v) => !lockedKeys.has(`${v.txid}:${v.vout}`));
+}
+async function spendableVtxosExcludingLocked(vtxos, intentRepository) {
+  if (!intentRepository) return vtxos;
+  let locked;
+  try {
+    locked = await intentRepository.getLockedVtxoOutpoints();
+  } catch (e) {
+    console.error("getLockedVtxoOutpoints failed; reporting unfiltered balance", e);
+    return vtxos;
+  }
+  return excludeLockedOutpoints(vtxos, locked);
+}
 var ReadonlyWallet = class _ReadonlyWallet {
   constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, walletContractTimelocks) {
     this.identity = identity;
@@ -8769,6 +9355,20 @@ var ReadonlyWallet = class _ReadonlyWallet {
   _contractManager;
   _contractManagerInitializing;
   watcherConfig;
+  /**
+   * Opt-in intent-lifecycle repository. Assigned by the `create()`
+   * factories from `config.storage.intentRepository`; `undefined` ⇒ all
+   * intent-persistence code paths are no-ops (default behaviour unchanged).
+   */
+  intentRepository;
+  /**
+   * **Experimental / inert.** Opt-in virtual-tx / exit-branch repository,
+   * exposed so callers can pass it to {@link Unroll.Session.create} as a
+   * best-effort raw-tx cache. Assigned by `create()` from
+   * `config.storage.virtualTxRepository`. Normal sync never writes it
+   * (ContractManager isn't given it); `undefined` ⇒ no-op.
+   */
+  virtualTxRepository;
   _assetManager;
   walletContractTimelocks;
   // Outpoints ("txid:vout") committed to an in-flight settle/send. Filtered
@@ -8826,9 +9426,12 @@ var ReadonlyWallet = class _ReadonlyWallet {
   _deprecatedSigners = /* @__PURE__ */ new Map();
   /**
    * Refresh the cached deprecated-signer set from a fresh server-info
-   * snapshot. Called by the create() factories at construction and by the
-   * server-info-change handler mid-session. Lenient: a malformed deprecated
-   * entry is skipped, never fatal to wallet creation.
+   * snapshot. Called by the create() factories at construction, by the
+   * server-info-change handler mid-session, and by the deprecated-signer
+   * migration pass (`VtxoManager.migrateDeprecatedSignerVtxos`). This set feeds
+   * {@link pendingRecoveryOutpoints}, which drops EXPIRED (past-cutoff)
+   * deprecated-signer VTXOs from the wallet's own coin selection. Lenient: a
+   * malformed deprecated entry is skipped, never fatal to wallet creation.
    */
   refreshDeprecatedSigners(info) {
     const next = /* @__PURE__ */ new Map();
@@ -9044,6 +9647,8 @@ var ReadonlyWallet = class _ReadonlyWallet {
       config.watcherConfig,
       setup.walletContractTimelocks
     );
+    wallet.intentRepository = config.storage?.intentRepository;
+    wallet.virtualTxRepository = config.storage?.virtualTxRepository;
     wallet.refreshDeprecatedSigners(setup.info);
     return wallet;
   }
@@ -9075,6 +9680,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       this.pendingRecoveryOutpoints()
     ]);
     const isPendingRecovery = (coin) => pendingOutpoints.has(`${coin.txid}:${coin.vout}`);
+    const unlockedVtxos = await spendableVtxosExcludingLocked(vtxos, this.intentRepository);
     let confirmed = 0;
     let unconfirmed = 0;
     for (const utxo of boardingUtxos) {
@@ -9084,14 +9690,15 @@ var ReadonlyWallet = class _ReadonlyWallet {
         unconfirmed += utxo.value;
       }
     }
-    let settled = 0;
-    let preconfirmed = 0;
     let recoverable = 0;
     let pendingRecovery = 0;
-    settled = vtxos.filter((coin) => coin.virtualStatus.state === "settled" && !isPendingRecovery(coin)).reduce((sum, coin) => sum + coin.value, 0);
-    preconfirmed = vtxos.filter(
+    const settled = vtxos.filter((coin) => coin.virtualStatus.state === "settled" && !isPendingRecovery(coin)).reduce((sum, coin) => sum + coin.value, 0);
+    const preconfirmed = vtxos.filter(
       (coin) => coin.virtualStatus.state === "preconfirmed" && !isPendingRecovery(coin)
     ).reduce((sum, coin) => sum + coin.value, 0);
+    const available = unlockedVtxos.filter(
+      (coin) => (coin.virtualStatus.state === "settled" || coin.virtualStatus.state === "preconfirmed") && !isPendingRecovery(coin)
+    ).reduce((sum, coin) => sum + coin.value, 0);
     recoverable = vtxos.filter((coin) => isSpendable(coin) && coin.virtualStatus.state === "swept").reduce((sum, coin) => sum + coin.value, 0);
     pendingRecovery = vtxos.filter(isPendingRecovery).reduce((sum, coin) => sum + coin.value, 0);
     const totalBoarding = confirmed + unconfirmed;
@@ -9118,7 +9725,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       },
       settled,
       preconfirmed,
-      available: settled + preconfirmed,
+      available,
       recoverable,
       pendingRecovery,
       total: totalBoarding + totalOffchain,
@@ -9595,6 +10202,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       indexerProvider: this.indexerProvider,
       contractRepository: this.contractRepository,
       walletRepository: this.walletRepository,
+      intentRepository: this.intentRepository,
       watcherConfig: this.watcherConfig
     });
     const baselinePubkey = await this.identity.xOnlyPublicKey();
@@ -10288,6 +10896,8 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         wallet.setBoardingTapscriptForRotation(resolvedBoarding);
       }
     }
+    wallet.intentRepository = config.storage?.intentRepository;
+    wallet.virtualTxRepository = config.storage?.virtualTxRepository;
     await wallet.getVtxoManager();
     return wallet;
   }
@@ -10567,12 +11177,26 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       ),
       this.makeDeleteIntentSignature(params.inputs)
     ]);
+    let intentTxId;
+    try {
+      intentTxId = Transaction$2.fromPSBT(base64.decode(intent.proof)).id;
+    } catch {
+      intentTxId = params.inputs.map((i) => `${i.txid}:${i.vout}`).sort().join("|");
+    }
+    await this.persistIntentSnapshot(
+      intentTxId,
+      "waiting_to_submit",
+      intent,
+      deleteIntent,
+      params.inputs
+    );
     const topics = [
       ...signingPublicKeys,
       ...params.inputs.map((input) => `${input.txid}:${input.vout}`)
     ];
     const abortController = new AbortController();
     let stream;
+    let committedTxid;
     this._addPendingSpends(params.inputs);
     try {
       stream = this.arkProvider.getEventStream(abortController.signal, topics);
@@ -10587,16 +11211,43 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         yield* stream;
       })();
       const intentId = await this.safeRegisterIntent(intent, params.inputs);
-      const handler = this.createBatchHandler(intentId, params.inputs, recipients, session);
+      await this.persistIntentSnapshot(
+        intentTxId,
+        "waiting_for_batch",
+        intent,
+        deleteIntent,
+        params.inputs,
+        { intentId }
+      );
+      const handler = wrapHandlerWithIntentPersistence(
+        this.createBatchHandler(intentId, params.inputs, recipients, session),
+        { intentRepository: this.intentRepository, intentTxId }
+      );
       const commitmentTxid = await Batch.join(primedStream, handler, {
         abortController,
         skipVtxoTreeSigning: !hasOffchainOutputs,
-        eventCallback: eventCallback ? (event) => Promise.resolve(eventCallback(event)) : void 0
+        // async so a synchronous throw becomes a rejection Batch.join
+        // swallows, keeping the observational callback off the stream path.
+        eventCallback: eventCallback && (async (event) => {
+          await eventCallback(event);
+        })
       });
+      committedTxid = commitmentTxid;
       await this.updateDbAfterSettle(params.inputs, commitmentTxid);
       await this.maybeRotateBoardingAfterBoard(params.inputs);
       return commitmentTxid;
     } catch (error) {
+      if (committedTxid !== void 0) {
+        await this.persistIntentSnapshot(
+          intentTxId,
+          "batch_succeeded",
+          intent,
+          deleteIntent,
+          params.inputs,
+          { commitmentTransactionId: committedTxid }
+        );
+        throw error;
+      }
       const inputIds = params.inputs.map((i) => `${i.txid}:${i.vout}`).join(",");
       await this.arkProvider.deleteIntent(deleteIntent).catch((e) => {
         console.warn(
@@ -10604,6 +11255,16 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           e
         );
       });
+      await this.persistIntentSnapshot(
+        intentTxId,
+        "cancelled",
+        intent,
+        deleteIntent,
+        params.inputs,
+        {
+          cancellationReason: error instanceof Error ? error.message : String(error)
+        }
+      );
       throw error;
     } finally {
       this._removePendingSpends(params.inputs);
@@ -10878,6 +11539,42 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     }
     return jobs;
   }
+  /**
+   * Best-effort upsert of the current settlement intent into the optional
+   * {@link intentRepository}. Never throws into the settle path — intent
+   * persistence is observational and must not break money flow. Preserves
+   * fields already written by the event reducer (state-event ordering).
+   */
+  async persistIntentSnapshot(intentTxId, state, intent, deleteIntent, inputs, patch) {
+    const repo = this.intentRepository;
+    if (!repo) return;
+    try {
+      const now = Date.now();
+      const existing = (await repo.getIntents({ intentTxIds: [intentTxId] }))[0];
+      if (existing && isTerminalIntentState(existing.state)) {
+        return;
+      }
+      await repo.saveIntent({
+        ...existing ?? {},
+        intentTxId,
+        registerProof: intent.proof,
+        registerProofMessage: Intent.encodeMessage(intent.message),
+        deleteProof: deleteIntent.proof,
+        deleteProofMessage: Intent.encodeMessage(deleteIntent.message),
+        intentVtxos: inputs.map((i) => ({
+          txid: i.txid,
+          vout: i.vout
+        })),
+        partialForfeits: existing?.partialForfeits ?? [],
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        state,
+        ...patch
+      });
+    } catch (e) {
+      console.error(`Failed to persist intent ${intentTxId} (state=${state})`, e);
+    }
+  }
   /**
    * @internal Sign an on-chain boarding exit / sweep transaction, routing
    * each input to the correct key by its `witnessUtxo.script`: the identity
@@ -15821,6 +16518,20 @@ function craftBIP322ToSignSimple(toSpend, pkScript) {
   });
   return tx;
 }
+function chainTxTypeToChainedExit(t) {
+  switch (t) {
+    case "INDEXER_CHAINED_TX_TYPE_COMMITMENT" /* COMMITMENT */:
+      return 1 /* Commitment */;
+    case "INDEXER_CHAINED_TX_TYPE_ARK" /* ARK */:
+      return 2 /* Ark */;
+    case "INDEXER_CHAINED_TX_TYPE_TREE" /* TREE */:
+      return 3 /* Tree */;
+    case "INDEXER_CHAINED_TX_TYPE_CHECKPOINT" /* CHECKPOINT */:
+      return 4 /* Checkpoint */;
+    default:
+      return 0 /* Unspecified */;
+  }
+}
 var Unroll;
 ((Unroll2) => {
   ((StepType2) => {
@@ -15830,16 +16541,54 @@ var Unroll;
   })(Unroll2.StepType || (Unroll2.StepType = {}));
   class Session2 {
     /** Create an unroll session from a virtual output outpoint and its dependency chain. */
-    constructor(toUnroll, bumper, explorer, indexer) {
+    constructor(toUnroll, bumper, explorer, indexer, virtualTxRepository) {
       this.toUnroll = toUnroll;
       this.bumper = bumper;
       this.explorer = explorer;
       this.indexer = indexer;
+      this.virtualTxRepository = virtualTxRepository;
     }
     /** Create an unroll session by loading the virtual output chain from the indexer. */
-    static async create(toUnroll, bumper, explorer, indexer) {
+    static async create(toUnroll, bumper, explorer, indexer, virtualTxRepository) {
       const { chain } = await indexer.getVtxoChain(toUnroll);
-      return new Session2({ ...toUnroll, chain }, bumper, explorer, indexer);
+      return new Session2(
+        { ...toUnroll, chain },
+        bumper,
+        explorer,
+        indexer,
+        virtualTxRepository
+      );
+    }
+    /**
+     * Resolve a chain tx's raw PSBT (base64). Repo first when configured;
+     * indexer on a miss, then best-effort cached so a later exit doesn't
+     * re-fetch. Never throws from the cache
+     * write — exit correctness must not depend on persistence.
+     */
+    async resolveVirtualTxBase64(next) {
+      const repo = this.virtualTxRepository;
+      if (repo) {
+        try {
+          const stored = await repo.getVirtualTx(next.txid);
+          if (stored?.psbt) return stored.psbt;
+        } catch {
+        }
+      }
+      const fetched = await this.indexer.getVirtualTxs([next.txid]);
+      const psbt = fetched.txs[0];
+      if (psbt && repo) {
+        const cached = {
+          txid: next.txid,
+          psbt,
+          expiresAt: null,
+          type: chainTxTypeToChainedExit(next.type)
+        };
+        try {
+          await repo.upsertVirtualTxs([cached]);
+        } catch {
+        }
+      }
+      return psbt;
     }
     /**
      * Get the next step to be executed
@@ -15874,11 +16623,11 @@ var Unroll;
           do: () => Promise.resolve()
         };
       }
-      const virtualTxs = await this.indexer.getVirtualTxs([nextTxToBroadcast.txid]);
-      if (virtualTxs.txs.length === 0) {
+      const virtualTxBase64 = await this.resolveVirtualTxBase64(nextTxToBroadcast);
+      if (!virtualTxBase64) {
         throw new Error(`Tx ${nextTxToBroadcast.txid} not found`);
       }
-      const tx = Transaction.fromPSBT(base64.decode(virtualTxs.txs[0]));
+      const tx = Transaction.fromPSBT(base64.decode(virtualTxBase64));
       if (nextTxToBroadcast.type === "INDEXER_CHAINED_TX_TYPE_TREE" /* TREE */) {
         const input = tx.getInput(0);
         if (!input) {
@@ -16098,6 +16847,6 @@ function isArkContract(str) {
   return str.startsWith(ARKCONTRACT_PREFIX + "=");
 }
 
-export { ActivityRegistry, ArkNote, AssetManager, BIP322, Batch, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EsploraProvider, Estimator, HDDescriptorProvider, InMemoryContractRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createDefaultActivityRegistry, decodeArkContract, deserializeAssets, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isExpired, isRecoverable, isSpendable, isSubdust, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, serializeAssets, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-D5MQYYYF.js.map
-//# sourceMappingURL=chunk-D5MQYYYF.js.map
+export { ActivityRegistry, ArkNote, AssetManager, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EsploraProvider, Estimator, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createDefaultActivityRegistry, decodeArkContract, deserializeAssets, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isExpired, isRecoverable, isSpendable, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, serializeAssets, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
+//# sourceMappingURL=chunk-B4R36PRN.js.map
+//# sourceMappingURL=chunk-B4R36PRN.js.map