@arkade-os/sdk 0.4.44 → 0.4.45

package/dist/{chunk-FMI2GKYO.js → chunk-TGRJ5WAX.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-LJ35HPJW.js';
+import { craftToSpendTx, Transaction, OP_RETURN_EMPTY_PKSCRIPT, baseFetch, Intent, getArkPsbtFields, CosignerPublicKey, setArkPsbtField, VtxoTaprootTree, maybeArkError, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, AssetId, AssetOutput, AssetGroup, AssetInput, Packet, Metadata, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError, BufferReader } from './chunk-YBQV7XBC.js';
 import { contractHandlers, isMainnetDescriptor, descriptorIsOurs, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, DefaultVtxo, BoardingContractHandler } from './chunk-YNEDJTX2.js';
 import { VtxoScript, sequenceToTimelock, 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';
@@ -4287,6 +4287,592 @@ function wrapHandlerWithIntentPersistence(base, deps) {
     }
   };
 }
+
+// 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/wallet/exit/chain.ts
+var isCommitment = (t) => t === "INDEXER_CHAINED_TX_TYPE_COMMITMENT" /* COMMITMENT */ || t === "INDEXER_CHAINED_TX_TYPE_UNSPECIFIED" /* UNSPECIFIED */;
+async function buildExitDag(params) {
+  const byTxid = /* @__PURE__ */ new Map();
+  for (const vtxo of params.vtxos) {
+    const outpoint = `${vtxo.txid}:${vtxo.vout}`;
+    const chain = await params.chain.getVtxoChain({ txid: vtxo.txid, vout: vtxo.vout });
+    for (const chainTx of chain) {
+      const existing = byTxid.get(chainTx.txid);
+      if (existing) {
+        existing.forVtxos.add(outpoint);
+      } else {
+        byTxid.set(chainTx.txid, { ...chainTx, forVtxos: /* @__PURE__ */ new Set([outpoint]) });
+      }
+    }
+  }
+  const pending = new Map(
+    [...byTxid.values()].filter((tx) => !isCommitment(tx.type)).map((tx) => [tx.txid, tx])
+  );
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const tx of pending.values()) {
+    const parents = tx.spends.filter((p) => pending.has(p));
+    inDegree.set(tx.txid, parents.length);
+  }
+  const order = [];
+  const queue = [...pending.values()].filter((tx) => inDegree.get(tx.txid) === 0).sort((a, b) => a.txid.localeCompare(b.txid));
+  while (queue.length > 0) {
+    const tx = queue.shift();
+    order.push(tx);
+    const children = [...pending.values()].filter((c) => c.spends.includes(tx.txid)).sort((a, b) => a.txid.localeCompare(b.txid));
+    for (const child of children) {
+      const deg = inDegree.get(child.txid) - 1;
+      inDegree.set(child.txid, deg);
+      if (deg === 0) queue.push(child);
+    }
+  }
+  if (order.length !== pending.size) {
+    throw new Error("inconsistent vtxo chain from indexer (cycle detected)");
+  }
+  const nodes = [];
+  for (const tx of order) {
+    let confirmed = false;
+    try {
+      const status = await params.onchain.getTxStatus(tx.txid);
+      confirmed = status.confirmed;
+    } catch {
+      confirmed = false;
+    }
+    const expires = Number(tx.expiresAt);
+    nodes.push({
+      txid: tx.txid,
+      type: tx.type,
+      expiresAt: Number.isFinite(expires) && expires > 0 ? expires : void 0,
+      forVtxos: [...tx.forVtxos].sort(),
+      confirmed
+    });
+  }
+  return nodes;
+}
+function topoSortByDeps(items, idOf, depsOf) {
+  const produced = new Set(items.map(idOf));
+  const emitted = /* @__PURE__ */ new Set();
+  const ordered = [];
+  let remaining = items;
+  while (remaining.length > 0) {
+    const next = [];
+    let progress = false;
+    for (const item of remaining) {
+      if (depsOf(item).every((d) => !produced.has(d) || emitted.has(d))) {
+        ordered.push(item);
+        emitted.add(idOf(item));
+        progress = true;
+      } else {
+        next.push(item);
+      }
+    }
+    if (!progress) {
+      throw new Error("topological sort: cycle or unsatisfiable dependency");
+    }
+    remaining = next;
+  }
+  return ordered;
+}
+
+// src/wallet/exit/capture.ts
+var DEFAULT_MIN_EXIT_WORTH_SATS = 1e3;
+var DEFAULT_EXIT_CAPTURE_MODE = "lite";
+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 */;
+  }
+}
+function orderAncestryFirst(chain) {
+  const ids = new Set(chain.map((c) => c.txid));
+  return topoSortByDeps(
+    chain,
+    (c) => c.txid,
+    (c) => c.spends.filter((s) => ids.has(s))
+  );
+}
+async function captureExitBranch(params) {
+  const { resolver, repository, vtxo, value, mode, minExitWorthSats } = params;
+  if (value < minExitWorthSats) return;
+  if (await repository.hasBranch(vtxo)) return;
+  const ordered = orderAncestryFirst(await resolver.getVtxoChain(vtxo));
+  const psbtByTxid = /* @__PURE__ */ new Map();
+  if (mode === "full") {
+    const nonCommitment = ordered.filter((c) => chainTxTypeToChainedExit(c.type) !== 1 /* Commitment */).map((c) => c.txid);
+    if (nonCommitment.length > 0) {
+      for (const psbt of await resolver.getVirtualTxs(nonCommitment)) {
+        psbtByTxid.set(Transaction.fromPSBT(base64.decode(psbt)).id, psbt);
+      }
+    }
+  }
+  const virtualTxs = ordered.map((c) => {
+    const expires = Number(c.expiresAt);
+    return {
+      txid: c.txid,
+      psbt: psbtByTxid.get(c.txid) ?? null,
+      expiresAt: Number.isFinite(expires) && expires > 0 ? expires : null,
+      type: chainTxTypeToChainedExit(c.type)
+    };
+  });
+  const branch = ordered.map((c, i) => ({
+    vtxoTxid: vtxo.txid,
+    vtxoVout: vtxo.vout,
+    virtualTxid: c.txid,
+    position: i
+  }));
+  await repository.upsertVirtualTxs(virtualTxs);
+  await repository.setBranch(vtxo, branch);
+}
+async function pruneExitBranches(repository, outpoints) {
+  for (const outpoint of outpoints) {
+    try {
+      await repository.pruneForSpentVtxo(outpoint);
+    } catch {
+    }
+  }
+}
+var IndexerExitDataSource = class {
+  constructor(indexer) {
+    this.indexer = indexer;
+  }
+  name = "indexer";
+  async getVtxoChain(vtxo) {
+    const chain = [];
+    let pageIndex = 0;
+    let hasMore = true;
+    while (hasMore) {
+      const { chain: page, page: meta } = await this.indexer.getVtxoChain(
+        { txid: vtxo.txid, vout: vtxo.vout },
+        { pageIndex, pageSize: DEFAULT_PAGE_SIZE }
+      );
+      chain.push(...page);
+      hasMore = meta ? page.length === DEFAULT_PAGE_SIZE : false;
+      pageIndex++;
+    }
+    return chain;
+  }
+  async getVirtualTxs(txids) {
+    const out = /* @__PURE__ */ new Map();
+    let pageIndex = 0;
+    let hasMore = true;
+    while (hasMore) {
+      const { txs, page } = await this.indexer.getVirtualTxs(txids, {
+        pageIndex,
+        pageSize: DEFAULT_PAGE_SIZE
+      });
+      for (const psbt of txs) {
+        out.set(Transaction.fromPSBT(base64.decode(psbt)).id, psbt);
+      }
+      hasMore = page ? txs.length === DEFAULT_PAGE_SIZE : false;
+      pageIndex++;
+    }
+    return out;
+  }
+};
+function chainedTxTypeToChainTxType(t) {
+  switch (t) {
+    case 1 /* Commitment */:
+      return "INDEXER_CHAINED_TX_TYPE_COMMITMENT" /* COMMITMENT */;
+    case 2 /* Ark */:
+      return "INDEXER_CHAINED_TX_TYPE_ARK" /* ARK */;
+    case 3 /* Tree */:
+      return "INDEXER_CHAINED_TX_TYPE_TREE" /* TREE */;
+    case 4 /* Checkpoint */:
+      return "INDEXER_CHAINED_TX_TYPE_CHECKPOINT" /* CHECKPOINT */;
+    default:
+      return "INDEXER_CHAINED_TX_TYPE_UNSPECIFIED" /* UNSPECIFIED */;
+  }
+}
+function psbtInputTxids(psbtBase64) {
+  const tx = Transaction.fromPSBT(base64.decode(psbtBase64));
+  const ids = [];
+  for (let i = 0; i < tx.inputsLength; i++) {
+    const txid = tx.getInput(i).txid;
+    if (txid) ids.push(hex.encode(txid));
+  }
+  return ids;
+}
+var RepositoryExitDataSource = class {
+  constructor(repo) {
+    this.repo = repo;
+  }
+  name = "repository";
+  async getVtxoChain(vtxo) {
+    const branch = await this.repo.getBranch(vtxo);
+    if (branch.length === 0) return null;
+    const chain = [];
+    for (const v of branch) {
+      const type = chainedTxTypeToChainTxType(v.type);
+      let spends = [];
+      if (v.type !== 1 /* Commitment */) {
+        if (!v.psbt) return null;
+        spends = psbtInputTxids(v.psbt);
+      }
+      chain.push({
+        txid: v.txid,
+        type,
+        expiresAt: v.expiresAt != null ? String(v.expiresAt) : "",
+        spends
+      });
+    }
+    return chain;
+  }
+  async getVirtualTxs(txids) {
+    const out = /* @__PURE__ */ new Map();
+    for (const txid of txids) {
+      const stored = await this.repo.getVirtualTx(txid);
+      if (stored?.psbt) out.set(txid, stored.psbt);
+    }
+    return out;
+  }
+};
+
+// src/wallet/exit/resolver.ts
+var OrderedExitChainResolver = class {
+  constructor(sources, persist) {
+    this.sources = sources;
+    this.persist = persist;
+  }
+  async getVtxoChain(vtxo) {
+    let lastErr;
+    for (const source of this.sources) {
+      try {
+        const chain = await source.getVtxoChain(vtxo);
+        if (chain) return chain;
+      } catch (e) {
+        lastErr = e;
+      }
+    }
+    if (lastErr) throw lastErr;
+    throw new Error(`no exit-data source resolved the chain for ${vtxo.txid}:${vtxo.vout}`);
+  }
+  async getVirtualTxs(txids) {
+    const found = /* @__PURE__ */ new Map();
+    let remaining = txids;
+    for (const [i, source] of this.sources.entries()) {
+      if (remaining.length === 0) break;
+      let got;
+      try {
+        got = await source.getVirtualTxs(remaining);
+      } catch {
+        continue;
+      }
+      const fresh = [];
+      for (const [txid, psbt] of got) {
+        if (found.has(txid)) continue;
+        found.set(txid, psbt);
+        fresh.push({ txid, psbt, expiresAt: null, type: 0 /* Unspecified */ });
+      }
+      if (i > 0 && this.persist && fresh.length > 0) {
+        try {
+          await this.persist.upsertVirtualTxs(fresh);
+        } catch {
+        }
+      }
+      remaining = txids.filter((t) => !found.has(t));
+    }
+    return [...found.values()];
+  }
+};
+function createExitChainResolver(params) {
+  const sources = [];
+  if (params.repository) sources.push(new RepositoryExitDataSource(params.repository));
+  if (params.extraSources) sources.push(...params.extraSources);
+  sources.push(new IndexerExitDataSource(params.indexer));
+  return new OrderedExitChainResolver(sources, params.repository);
+}
+
+// src/providers/availability.ts
+function isRetryableProviderError(error) {
+  return error instanceof ProviderUnavailableError || error instanceof FetchError || isFetchTimeoutError(error);
+}
+
+// src/utils/syncCursors.ts
+var SAFETY_LAG_MS = 3e4;
+var OVERLAP_MS = 24 * 60 * 60 * 1e3;
+var walletStateLocks = /* @__PURE__ */ new WeakMap();
+async function updateWalletState(repo, updater) {
+  const prev = walletStateLocks.get(repo) ?? Promise.resolve();
+  const op = prev.then(async () => {
+    const state = await repo.getWalletState() ?? {};
+    await repo.saveWalletState(updater(state));
+  });
+  walletStateLocks.set(
+    repo,
+    op.catch(() => {
+    })
+  );
+  return op;
+}
+var CURSOR_MIGRATED_KEY = "vtxoCursorMigrated";
+function hasMigrationMarker(state) {
+  return state?.settings?.[CURSOR_MIGRATED_KEY] === true;
+}
+async function getSyncCursor(repo) {
+  const state = await repo.getWalletState();
+  if (!hasMigrationMarker(state)) return 0;
+  return state?.lastSyncTime ?? 0;
+}
+async function advanceSyncCursor(repo, lastUpdatedAt) {
+  await updateWalletState(repo, (state) => {
+    const current = hasMigrationMarker(state) ? state.lastSyncTime ?? 0 : 0;
+    return {
+      ...state,
+      lastSyncTime: Math.max(current, lastUpdatedAt),
+      settings: {
+        ...state.settings ?? {},
+        [CURSOR_MIGRATED_KEY]: true
+      }
+    };
+  });
+}
+async function clearSyncCursor(repo) {
+  await updateWalletState(repo, (state) => {
+    const { [CURSOR_MIGRATED_KEY]: _, ...restSettings } = state.settings ?? {};
+    return {
+      ...state,
+      lastSyncTime: void 0,
+      settings: restSettings
+    };
+  });
+}
+function computeSyncWindow(cursor) {
+  const after = Math.max(0, cursor - OVERLAP_MS);
+  return { after };
+}
+function cursorCutoff(requestStartedAt) {
+  return (requestStartedAt ?? Date.now()) - SAFETY_LAG_MS;
+}
+
+// src/wallet/arkInfoSnapshot.ts
+var ARK_INFO_SNAPSHOT_KEY = "arkInfoSnapshot";
+var MalformedArkInfoSnapshotError = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "MalformedArkInfoSnapshotError";
+  }
+};
+var CURRENT_VERSION = 1;
+function serializeArkInfoSnapshot(info, savedAt) {
+  return {
+    version: CURRENT_VERSION,
+    savedAt,
+    source: "arkade.getInfo",
+    arkInfo: {
+      network: info.network,
+      signerPubkey: info.signerPubkey,
+      checkpointTapscript: info.checkpointTapscript,
+      forfeitAddress: info.forfeitAddress,
+      forfeitPubkey: info.forfeitPubkey,
+      unilateralExitDelay: info.unilateralExitDelay.toString(),
+      boardingExitDelay: info.boardingExitDelay.toString(),
+      sessionDuration: info.sessionDuration.toString(),
+      dust: info.dust.toString(),
+      fees: info.fees,
+      digest: info.digest,
+      version: info.version,
+      vtxoMinAmount: info.vtxoMinAmount.toString(),
+      vtxoMaxAmount: info.vtxoMaxAmount.toString(),
+      utxoMinAmount: info.utxoMinAmount.toString(),
+      utxoMaxAmount: info.utxoMaxAmount.toString(),
+      deprecatedSigners: info.deprecatedSigners.map((s) => ({
+        pubkey: s.pubkey,
+        cutoffDate: s.cutoffDate.toString()
+      })),
+      scheduledSession: info.scheduledSession ? {
+        duration: info.scheduledSession.duration.toString(),
+        fees: info.scheduledSession.fees,
+        nextEndTime: info.scheduledSession.nextEndTime.toString(),
+        nextStartTime: info.scheduledSession.nextStartTime.toString(),
+        period: info.scheduledSession.period.toString()
+      } : void 0
+    }
+  };
+}
+function hydrateArkInfo(snapshot) {
+  const a = snapshot.arkInfo;
+  return {
+    boardingExitDelay: BigInt(a.boardingExitDelay),
+    checkpointTapscript: a.checkpointTapscript,
+    deprecatedSigners: a.deprecatedSigners.map((s) => ({
+      cutoffDate: BigInt(s.cutoffDate),
+      pubkey: s.pubkey
+    })),
+    digest: a.digest,
+    dust: BigInt(a.dust),
+    fees: a.fees,
+    forfeitAddress: a.forfeitAddress,
+    forfeitPubkey: a.forfeitPubkey,
+    network: a.network,
+    scheduledSession: a.scheduledSession ? {
+      duration: BigInt(a.scheduledSession.duration),
+      fees: a.scheduledSession.fees,
+      nextEndTime: BigInt(a.scheduledSession.nextEndTime),
+      nextStartTime: BigInt(a.scheduledSession.nextStartTime),
+      period: BigInt(a.scheduledSession.period)
+    } : void 0,
+    serviceStatus: {},
+    sessionDuration: BigInt(a.sessionDuration),
+    signerPubkey: a.signerPubkey,
+    unilateralExitDelay: BigInt(a.unilateralExitDelay),
+    utxoMaxAmount: BigInt(a.utxoMaxAmount),
+    utxoMinAmount: BigInt(a.utxoMinAmount),
+    version: a.version,
+    vtxoMaxAmount: BigInt(a.vtxoMaxAmount),
+    vtxoMinAmount: BigInt(a.vtxoMinAmount)
+  };
+}
+var DECIMAL_STRING = /^-?\d+$/;
+function assertString(value, path) {
+  if (typeof value !== "string") {
+    throw new MalformedArkInfoSnapshotError(`${path} must be a string`);
+  }
+}
+function assertDecimalString(value, path) {
+  assertString(value, path);
+  if (!DECIMAL_STRING.test(value)) {
+    throw new MalformedArkInfoSnapshotError(`${path} must be a decimal integer string`);
+  }
+}
+function assertFeeInfo(value, path) {
+  if (typeof value !== "object" || value === null) {
+    throw new MalformedArkInfoSnapshotError(`${path} must be an object`);
+  }
+  const fees = value;
+  assertString(fees.txFeeRate, `${path}.txFeeRate`);
+  if (typeof fees.intentFee !== "object" || fees.intentFee === null) {
+    throw new MalformedArkInfoSnapshotError(`${path}.intentFee must be an object`);
+  }
+}
+function parseStoredArkInfoSnapshot(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new MalformedArkInfoSnapshotError("snapshot must be an object");
+  }
+  const snap = raw;
+  if (snap.version !== CURRENT_VERSION) {
+    throw new MalformedArkInfoSnapshotError(
+      `unsupported snapshot version: ${String(snap.version)}`
+    );
+  }
+  if (typeof snap.savedAt !== "number") {
+    throw new MalformedArkInfoSnapshotError("savedAt must be a number");
+  }
+  if (snap.source !== "arkade.getInfo") {
+    throw new MalformedArkInfoSnapshotError(`unexpected source: ${String(snap.source)}`);
+  }
+  if (typeof snap.arkInfo !== "object" || snap.arkInfo === null) {
+    throw new MalformedArkInfoSnapshotError("arkInfo must be an object");
+  }
+  const a = snap.arkInfo;
+  for (const field of [
+    "network",
+    "signerPubkey",
+    "checkpointTapscript",
+    "forfeitAddress",
+    "forfeitPubkey",
+    "digest",
+    "version"
+  ]) {
+    assertString(a[field], `arkInfo.${field}`);
+  }
+  for (const field of [
+    "unilateralExitDelay",
+    "boardingExitDelay",
+    "sessionDuration",
+    "dust",
+    "vtxoMinAmount",
+    "vtxoMaxAmount",
+    "utxoMinAmount",
+    "utxoMaxAmount"
+  ]) {
+    assertDecimalString(a[field], `arkInfo.${field}`);
+  }
+  assertFeeInfo(a.fees, "arkInfo.fees");
+  if (!Array.isArray(a.deprecatedSigners)) {
+    throw new MalformedArkInfoSnapshotError("arkInfo.deprecatedSigners must be an array");
+  }
+  a.deprecatedSigners.forEach((s, i) => {
+    if (typeof s !== "object" || s === null) {
+      throw new MalformedArkInfoSnapshotError(
+        `arkInfo.deprecatedSigners[${i}] must be an object`
+      );
+    }
+    const signer = s;
+    assertString(signer.pubkey, `arkInfo.deprecatedSigners[${i}].pubkey`);
+    assertDecimalString(signer.cutoffDate, `arkInfo.deprecatedSigners[${i}].cutoffDate`);
+  });
+  if (a.scheduledSession !== void 0) {
+    if (typeof a.scheduledSession !== "object" || a.scheduledSession === null) {
+      throw new MalformedArkInfoSnapshotError("arkInfo.scheduledSession must be an object");
+    }
+    const s = a.scheduledSession;
+    for (const field of ["duration", "nextEndTime", "nextStartTime", "period"]) {
+      assertDecimalString(s[field], `arkInfo.scheduledSession.${field}`);
+    }
+    assertFeeInfo(s.fees, "arkInfo.scheduledSession.fees");
+  }
+  return raw;
+}
+async function loadArkInfoSnapshot(repo) {
+  const state = await repo.getWalletState();
+  const raw = state?.settings?.[ARK_INFO_SNAPSHOT_KEY];
+  if (raw === void 0 || raw === null) return null;
+  return parseStoredArkInfoSnapshot(raw);
+}
+async function saveArkInfoSnapshot(repo, info, savedAt) {
+  const snapshot = serializeArkInfoSnapshot(info, savedAt);
+  await updateWalletState(repo, (state) => ({
+    ...state,
+    settings: {
+      ...state.settings ?? {},
+      [ARK_INFO_SNAPSHOT_KEY]: snapshot
+    }
+  }));
+}
+async function resolveArkInfo(arkProvider, walletRepository) {
+  let info;
+  try {
+    info = await arkProvider.getInfo();
+  } catch (err) {
+    if (!isRetryableProviderError(err)) throw err;
+    const snapshot = await loadArkInfoSnapshot(walletRepository);
+    if (!snapshot) {
+      throw new ProviderUnavailableError(
+        "Arkade server info is unavailable and no cached snapshot exists",
+        { cause: err }
+      );
+    }
+    return { info: hydrateArkInfo(snapshot), source: "cache", lastOnlineAt: snapshot.savedAt };
+  }
+  return { info, source: "live" };
+}
+async function saveValidatedArkInfoSnapshot(repo, info, savedAt) {
+  try {
+    await saveArkInfoSnapshot(repo, info, savedAt);
+  } catch (err) {
+    console.warn("Failed to persist Ark info snapshot", err);
+  }
+}
 var TxTree = class {
   constructor(root, children = /* @__PURE__ */ new Map()) {
     this.root = root;
@@ -5396,20 +5982,6 @@ function isAnnotated(v) {
   return v.tapTree !== void 0 && v.forfeitTapLeafScript !== void 0 && v.intentTapLeafScript !== void 0;
 }
 
-// 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/intentRepository.ts
 var InMemoryIntentRepository = class {
   version = 1;
@@ -7784,106 +8356,49 @@ async function reconcileIntents(deps) {
     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;
-var walletStateLocks = /* @__PURE__ */ new WeakMap();
-async function updateWalletState(repo, updater) {
-  const prev = walletStateLocks.get(repo) ?? Promise.resolve();
-  const op = prev.then(async () => {
-    const state = await repo.getWalletState() ?? {};
-    await repo.saveWalletState(updater(state));
-  });
-  walletStateLocks.set(
-    repo,
-    op.catch(() => {
-    })
-  );
-  return op;
-}
-var CURSOR_MIGRATED_KEY = "vtxoCursorMigrated";
-function hasMigrationMarker(state) {
-  return state?.settings?.[CURSOR_MIGRATED_KEY] === true;
-}
-async function getSyncCursor(repo) {
-  const state = await repo.getWalletState();
-  if (!hasMigrationMarker(state)) return 0;
-  return state?.lastSyncTime ?? 0;
-}
-async function advanceSyncCursor(repo, lastUpdatedAt) {
-  await updateWalletState(repo, (state) => {
-    const current = hasMigrationMarker(state) ? state.lastSyncTime ?? 0 : 0;
-    return {
-      ...state,
-      lastSyncTime: Math.max(current, lastUpdatedAt),
-      settings: {
-        ...state.settings ?? {},
-        [CURSOR_MIGRATED_KEY]: true
-      }
-    };
-  });
+  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);
+    }
+  }
 }
-async function clearSyncCursor(repo) {
-  await updateWalletState(repo, (state) => {
-    const { [CURSOR_MIGRATED_KEY]: _, ...restSettings } = state.settings ?? {};
-    return {
-      ...state,
-      lastSyncTime: void 0,
-      settings: restSettings
-    };
-  });
+function terminal(intent, state, now, patch) {
+  return { ...intent, ...patch, state, updatedAt: now };
 }
-function computeSyncWindow(cursor) {
-  const after = Math.max(0, cursor - OVERLAP_MS);
-  return { after };
+function outpointKey(o) {
+  return `${o.txid}:${o.vout}`;
 }
-function cursorCutoff(requestStartedAt) {
-  return (requestStartedAt ?? Date.now()) - SAFETY_LAG_MS;
+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/contracts/contractManager.ts
@@ -7898,6 +8413,10 @@ var ContractManager = class _ContractManager {
   initialized = false;
   eventCallbacks = /* @__PURE__ */ new Set();
   stopWatcherFn;
+  /** `undefined` while online; the failure reason once a sync degrades. */
+  syncDegradedReason;
+  /** Epoch-ms of the last successful provider sync, if any. */
+  lastSyncedAt;
   constructor(config) {
     this.config = config;
     this.watcher = new ContractWatcher({
@@ -7920,6 +8439,26 @@ var ContractManager = class _ContractManager {
     await cm.initialize();
     return cm;
   }
+  /**
+   * Latest provider-sync health. See {@link ContractSyncState}. Degradation is
+   * recorded by {@link initialize}, {@link getContractsWithVtxos}, and
+   * {@link createContract}; it flips back to `online` on the next successful
+   * sync. Purely a freshness signal — not a source of truth for wallet data.
+   */
+  getSyncState() {
+    return this.syncDegradedReason === void 0 ? { mode: "online", lastSyncedAt: this.lastSyncedAt } : {
+      mode: "degraded",
+      reason: this.syncDegradedReason,
+      lastSyncedAt: this.lastSyncedAt
+    };
+  }
+  markSyncOnline() {
+    this.syncDegradedReason = void 0;
+    this.lastSyncedAt = Date.now();
+  }
+  markSyncDegraded(err) {
+    this.syncDegradedReason = err instanceof Error ? err.message : String(err);
+  }
   async initialize() {
     if (this.initialized) {
       return;
@@ -7928,7 +8467,13 @@ var ContractManager = class _ContractManager {
     for (const contract of contracts) {
       await this.watcher.addContract(contract);
     }
-    await this.reconcileWatched();
+    try {
+      await this.reconcileWatched();
+      this.markSyncOnline();
+    } catch (err) {
+      if (!isRetryableProviderError(err)) throw err;
+      this.markSyncDegraded(err);
+    }
     this.initialized = true;
     this.stopWatcherFn = await this.watcher.startWatching((event) => {
       this.handleContractEvent(event).catch((error) => {
@@ -7982,7 +8527,13 @@ var ContractManager = class _ContractManager {
   async createContract(params) {
     const { contract, persisted } = await this.upsertContract(params);
     if (persisted) {
-      await this.fetchContractVxosFromIndexer([contract]);
+      try {
+        await this.fetchContractVxosFromIndexer([contract]);
+        this.markSyncOnline();
+      } catch (err) {
+        if (!isRetryableProviderError(err)) throw err;
+        this.markSyncDegraded(err);
+      }
       await this.watcher.addContract(contract);
     }
     return contract;
@@ -8181,7 +8732,13 @@ var ContractManager = class _ContractManager {
   }
   async getContractsWithVtxos(filter, pageSize) {
     const contracts = await this.getContracts(filter);
-    await this.syncContracts({ contracts, pageSize });
+    try {
+      await this.syncContracts({ contracts, pageSize });
+      this.markSyncOnline();
+    } catch (err) {
+      if (!isRetryableProviderError(err)) throw err;
+      this.markSyncDegraded(err);
+    }
     const vtxos = await this.getVtxosForContracts(contracts);
     return contracts.map((contract) => ({
       contract,
@@ -8419,15 +8976,33 @@ var ContractManager = class _ContractManager {
    * Handle events from the watcher.
    */
   async handleContractEvent(event) {
-    switch (event.type) {
-      // Delta-sync only the changed virtual outputs for this contract.
-      case "vtxo_received":
-      case "vtxo_spent":
-        await this.syncContracts({ contracts: [event.contract] });
-        break;
-      case "connection_reset":
-        await this.reconcileWatched();
-        break;
+    try {
+      switch (event.type) {
+        // Delta-sync only the changed virtual outputs for this contract.
+        case "vtxo_received":
+          await this.syncContracts({ contracts: [event.contract] });
+          this.markSyncOnline();
+          break;
+        case "vtxo_spent":
+          await this.syncContracts({ contracts: [event.contract] });
+          this.markSyncOnline();
+          if (this.config.onVtxosSpent) {
+            try {
+              await this.config.onVtxosSpent(
+                event.vtxos.map((v) => ({ txid: v.txid, vout: v.vout }))
+              );
+            } catch {
+            }
+          }
+          break;
+        case "connection_reset":
+          await this.reconcileWatched();
+          this.markSyncOnline();
+          break;
+      }
+    } catch (err) {
+      if (!isRetryableProviderError(err)) throw err;
+      this.markSyncDegraded(err);
     }
     this.emitEvent(event);
   }
@@ -8509,6 +9084,12 @@ var ContractManager = class _ContractManager {
         contract,
         filtered
       );
+      if (this.config.onVtxosPersisted) {
+        try {
+          await this.config.onVtxosPersisted(contract, filtered);
+        } catch {
+        }
+      }
     }
   }
   async fetchContractVxosFromIndexer(contracts, pageSize, syncWindow) {
@@ -8529,6 +9110,15 @@ var ContractManager = class _ContractManager {
           contract,
           filtered
         );
+        if (this.config.onVtxosPersisted) {
+          try {
+            await this.config.onVtxosPersisted(
+              contract,
+              filtered
+            );
+          } catch {
+          }
+        }
       }
     }
     return result;
@@ -9402,6 +9992,8 @@ var ReadonlyWallet = class _ReadonlyWallet {
    * (ContractManager isn't given it); `undefined` ⇒ no-op.
    */
   virtualTxRepository;
+  /** Opt-in exit-data capture settings; see {@link StorageConfig.exitDataCapture}. */
+  exitDataCapture;
   _assetManager;
   walletContractTimelocks;
   // Outpoints ("txid:vout") committed to an in-flight settle/send. Filtered
@@ -9444,6 +10036,72 @@ var ReadonlyWallet = class _ReadonlyWallet {
    * construction-time snapshot for their lifetime.
    */
   _arkServerPublicKey;
+  /**
+   * Whether this wallet was constructed from live operator server-info
+   * (`"live"`) or from a cached snapshot because the operator was unreachable
+   * (`"cache"`). Freshness signal for {@link getProviderConnectionState}.
+   */
+  _serverInfoSource = "live";
+  /**
+   * Epoch-ms of the last known live operator contact: construction time on the
+   * `live` boot path, the cached snapshot's `savedAt` on the `cache` path.
+   */
+  _serverInfoLastOnlineAt;
+  /** @see {@link _serverInfoSource} */
+  get serverInfoSource() {
+    return this._serverInfoSource;
+  }
+  /**
+   * Composed provider-connection freshness: the boot server-info source
+   * (Arkade) combined with the contract-manager's indexer-sync health, if the
+   * manager has been initialized. Reads no live provider state — it never
+   * forces a `ContractManager` to construct — so it is safe for readonly
+   * callers that only use address/balance APIs.
+   *
+   *  - Boot fell back to a cached snapshot → degraded on `arkade` (`cache`).
+   *  - Otherwise, if the contract manager has degraded to repository data →
+   *    degraded on `indexer` (`repository`).
+   *  - Otherwise online.
+   *
+   * This only describes sync freshness; wallet balances/VTXOs are always read
+   * from the repository regardless of this state.
+   */
+  getProviderConnectionState() {
+    if (this._serverInfoSource === "cache") {
+      return {
+        mode: "degraded",
+        source: "cache",
+        provider: "arkade",
+        reason: "constructed from cached server-info; operator was unreachable at boot",
+        lastOnlineAt: this._serverInfoLastOnlineAt
+      };
+    }
+    const sync = this._contractManager?.getSyncState();
+    if (sync?.mode === "degraded") {
+      return {
+        mode: "degraded",
+        source: "repository",
+        provider: "indexer",
+        reason: sync.reason,
+        lastOnlineAt: sync.lastSyncedAt ?? this._serverInfoLastOnlineAt
+      };
+    }
+    return {
+      mode: "online",
+      source: "live",
+      lastOnlineAt: sync?.lastSyncedAt ?? this._serverInfoLastOnlineAt ?? 0
+    };
+  }
+  /**
+   * The contract-manager's current provider-sync health **without forcing it
+   * to initialize** — reads the already-constructed manager, or reports
+   * `online` when none exists yet. Unlike {@link getContractManager}, this
+   * never triggers a remote sync, so it is safe on a pure diagnostics path
+   * (e.g. the service-worker sync-state message).
+   */
+  getContractSyncState() {
+    return this._contractManager?.getSyncState() ?? { mode: "online" };
+  }
   /**
    * x-only hex of the operator's deprecated signer keys (from
    * `ArkInfo.deprecatedSigners`), cached for the OFFLINE read/watch paths.
@@ -9578,7 +10236,13 @@ var ReadonlyWallet = class _ReadonlyWallet {
       }
       indexerProvider = new RestIndexerProvider(indexerUrl);
     }
-    const info = await arkProvider.getInfo();
+    const walletRepository = config.storage?.walletRepository ?? new IndexedDBWalletRepository();
+    const contractRepository = config.storage?.contractRepository ?? new IndexedDBContractRepository();
+    const {
+      info,
+      source: serverInfoSource,
+      lastOnlineAt: serverInfoLastOnlineAt
+    } = await resolveArkInfo(arkProvider, walletRepository);
     const network = getNetwork(info.network);
     if ("descriptor" in config.identity) {
       const descriptor = config.identity.descriptor;
@@ -9632,8 +10296,6 @@ var ReadonlyWallet = class _ReadonlyWallet {
       serverPubKey: hex.encode(serverPubKey),
       csvTimelock: timelockToSequence(boardingTimelock).toString()
     });
-    const walletRepository = config.storage?.walletRepository ?? new IndexedDBWalletRepository();
-    const contractRepository = config.storage?.contractRepository ?? new IndexedDBContractRepository();
     return {
       arkProvider,
       indexerProvider,
@@ -9647,6 +10309,8 @@ var ReadonlyWallet = class _ReadonlyWallet {
       walletRepository,
       contractRepository,
       info,
+      serverInfoSource,
+      serverInfoLastOnlineAt,
       delegateProvider: config.delegateProvider || config.delegatorProvider,
       /** @deprecated alias for `delegateProvider` */
       delegatorProvider: config.delegateProvider || config.delegatorProvider,
@@ -9682,6 +10346,15 @@ var ReadonlyWallet = class _ReadonlyWallet {
     );
     wallet.intentRepository = config.storage?.intentRepository;
     wallet.virtualTxRepository = config.storage?.virtualTxRepository;
+    wallet.exitDataCapture = config.storage?.exitDataCapture;
+    wallet._serverInfoSource = setup.serverInfoSource;
+    if (setup.serverInfoSource === "live") {
+      const now = Date.now();
+      await saveValidatedArkInfoSnapshot(setup.walletRepository, setup.info, now);
+      wallet._serverInfoLastOnlineAt = now;
+    } else {
+      wallet._serverInfoLastOnlineAt = setup.serverInfoLastOnlineAt;
+    }
     wallet.refreshDeprecatedSigners(setup.info);
     return wallet;
   }
@@ -9812,7 +10485,10 @@ var ReadonlyWallet = class _ReadonlyWallet {
     const response = await contractManager.getContractsWithVtxos();
     const allVtxos = response.flatMap((_) => _.vtxos);
     const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
-    const getTxCreatedAt = (txid) => this.indexerProvider.getVtxos({ outpoints: [{ txid, vout: 0 }] }).then((res) => res.vtxos[0]?.createdAt.getTime());
+    const getTxCreatedAt = (txid) => this.indexerProvider.getVtxos({ outpoints: [{ txid, vout: 0 }] }).then((res) => res.vtxos[0]?.createdAt.getTime()).catch((err) => {
+      if (isRetryableProviderError(err)) return void 0;
+      throw err;
+    });
     return buildTransactionHistory(allVtxos, boardingTxs, commitmentsToIgnore, getTxCreatedAt);
   }
   /**
@@ -10231,11 +10907,39 @@ var ReadonlyWallet = class _ReadonlyWallet {
     }
   }
   async initializeContractManager() {
+    const virtualTxRepository = this.virtualTxRepository;
+    let onVtxosPersisted;
+    let onVtxosSpent;
+    if (virtualTxRepository) {
+      const capture = this.exitDataCapture;
+      const resolver = createExitChainResolver({
+        indexer: this.indexerProvider,
+        repository: virtualTxRepository,
+        extraSources: capture?.sources
+      });
+      onVtxosPersisted = async (_contract, vtxos) => {
+        for (const v of vtxos) {
+          if (v.virtualStatus.state === "spent") continue;
+          await captureExitBranch({
+            resolver,
+            repository: virtualTxRepository,
+            vtxo: { txid: v.txid, vout: v.vout },
+            value: v.value,
+            mode: capture?.mode ?? DEFAULT_EXIT_CAPTURE_MODE,
+            minExitWorthSats: capture?.minExitWorthSats ?? DEFAULT_MIN_EXIT_WORTH_SATS
+          }).catch(() => {
+          });
+        }
+      };
+      onVtxosSpent = (vtxos) => pruneExitBranches(virtualTxRepository, vtxos);
+    }
     const manager = await ContractManager.create({
       indexerProvider: this.indexerProvider,
       contractRepository: this.contractRepository,
       walletRepository: this.walletRepository,
       intentRepository: this.intentRepository,
+      onVtxosPersisted,
+      onVtxosSpent,
       watcherConfig: this.watcherConfig
     });
     const baselinePubkey = await this.identity.xOnlyPublicKey();
@@ -10910,6 +11614,14 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       boot?.rotator,
       boot?.provider
     );
+    wallet._serverInfoSource = setup.serverInfoSource;
+    if (setup.serverInfoSource === "live") {
+      const now = Date.now();
+      await saveValidatedArkInfoSnapshot(setup.walletRepository, setup.info, now);
+      wallet._serverInfoLastOnlineAt = now;
+    } else {
+      wallet._serverInfoLastOnlineAt = setup.serverInfoLastOnlineAt;
+    }
     wallet.refreshDeprecatedSigners(setup.info);
     {
       const ap = setup.arkProvider;
@@ -10931,6 +11643,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     }
     wallet.intentRepository = config.storage?.intentRepository;
     wallet.virtualTxRepository = config.storage?.virtualTxRepository;
+    wallet.exitDataCapture = config.storage?.exitDataCapture;
     await wallet.getVtxoManager();
     return wallet;
   }
@@ -13448,10 +14161,18 @@ var WalletMessageHandler = class {
             type: "WALLET_STATUS",
             payload: {
               walletInitialized: true,
-              xOnlyPublicKey: pubKey
+              xOnlyPublicKey: pubKey,
+              providerConnectionState: this.readonlyWallet.getProviderConnectionState()
             }
           });
         }
+        case "GET_CONTRACT_SYNC_STATE": {
+          return this.tagged({
+            id,
+            type: "CONTRACT_SYNC_STATE",
+            payload: { syncState: this.readonlyWallet.getContractSyncState() }
+          });
+        }
         case "CLEAR": {
           await this.clear();
           return this.tagged({
@@ -14214,6 +14935,7 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
   GET_BALANCE: 1e4,
   GET_BOARDING_ADDRESS: 1e4,
   GET_STATUS: 1e4,
+  GET_CONTRACT_SYNC_STATE: 1e4,
   GET_DELEGATE_INFO: 1e4,
   IS_CONTRACT_MANAGER_WATCHING: 1e4,
   // Medium reads — may involve indexer queries
@@ -14822,6 +15544,19 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
       throw new Error(`Failed to get status: ${error}`);
     }
   }
+  /**
+   * Wallet-level provider-connection freshness, delegated to the worker via
+   * `GET_STATUS`. Async by necessity (the worker boundary is asynchronous); no
+   * synchronous variant is offered because it would have the same transport
+   * mismatch as the contract-manager proxy's cached `getSyncState()`.
+   */
+  async getProviderConnectionState() {
+    const { providerConnectionState } = await this.getStatus();
+    if (!providerConnectionState) {
+      throw new Error("Worker did not report provider connection state");
+    }
+    return providerConnectionState;
+  }
   async getActivityHistory() {
     return buildActivities(await this.getTransactionHistory(), this.activity.all());
   }
@@ -14876,6 +15611,32 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
       return wallet.sendMessage(message);
     };
     const messageTag = this.messageTag;
+    const fetchSyncState = async () => {
+      const message = {
+        type: "GET_CONTRACT_SYNC_STATE",
+        id: getRandomId(),
+        tag: messageTag
+      };
+      const response = await sendContractMessage(message);
+      return response.payload.syncState;
+    };
+    const UNKNOWN_STATE = {
+      mode: "degraded",
+      reason: "contract sync state unavailable from the worker"
+    };
+    let syncState = UNKNOWN_STATE;
+    let everProbed = false;
+    const refreshSyncState = async () => {
+      try {
+        syncState = await fetchSyncState();
+        everProbed = true;
+      } catch {
+        if (!everProbed) {
+          syncState = UNKNOWN_STATE;
+        }
+      }
+    };
+    await refreshSyncState();
     const manager = {
       async createContract(params) {
         const message = {
@@ -14886,6 +15647,7 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
         };
         try {
           const response = await sendContractMessage(message);
+          await refreshSyncState();
           return response.payload.contract;
         } catch (e) {
           throw new Error("Failed to create contract");
@@ -14914,11 +15676,15 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
         };
         try {
           const response = await sendContractMessage(message);
+          await refreshSyncState();
           return response.payload.contracts;
         } catch (e) {
           throw new Error("Failed to get contracts with vtxos");
         }
       },
+      getSyncState() {
+        return syncState;
+      },
       async annotateVtxos(vtxos) {
         if (vtxos.length === 0) return [];
         const message = {
@@ -15027,7 +15793,11 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
           tag: messageTag,
           payload: opts
         };
-        await sendContractMessage(message);
+        try {
+          await sendContractMessage(message);
+        } finally {
+          await refreshSyncState();
+        }
       },
       async refreshOutpoints(outpoints) {
         const message = {
@@ -15036,7 +15806,11 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
           tag: messageTag,
           payload: { outpoints }
         };
-        await sendContractMessage(message);
+        try {
+          await sendContractMessage(message);
+        } finally {
+          await refreshSyncState();
+        }
       },
       scanContracts() {
         return Promise.reject(
@@ -16651,7 +17425,7 @@ async function resolveUnilateralPath(params) {
 }
 
 // src/wallet/unroll.ts
-function chainTxTypeToChainedExit(t) {
+function chainTxTypeToChainedExit2(t) {
   switch (t) {
     case "INDEXER_CHAINED_TX_TYPE_COMMITMENT" /* COMMITMENT */:
       return 1 /* Commitment */;
@@ -16714,7 +17488,7 @@ var Unroll;
           txid: next.txid,
           psbt,
           expiresAt: null,
-          type: chainTxTypeToChainedExit(next.type)
+          type: chainTxTypeToChainedExit2(next.type)
         };
         try {
           await repo.upsertVirtualTxs([cached]);
@@ -16892,99 +17666,6 @@ function doWait(onchainProvider, txid) {
     });
   };
 }
-
-// src/wallet/exit/chain.ts
-var isCommitment = (t) => t === "INDEXER_CHAINED_TX_TYPE_COMMITMENT" /* COMMITMENT */ || t === "INDEXER_CHAINED_TX_TYPE_UNSPECIFIED" /* UNSPECIFIED */;
-async function buildExitDag(params) {
-  const byTxid = /* @__PURE__ */ new Map();
-  for (const vtxo of params.vtxos) {
-    const outpoint = `${vtxo.txid}:${vtxo.vout}`;
-    let pageIndex = 0;
-    let hasMore = true;
-    while (hasMore) {
-      const { chain, page } = await params.indexer.getVtxoChain(
-        { txid: vtxo.txid, vout: vtxo.vout },
-        { pageIndex, pageSize: DEFAULT_PAGE_SIZE }
-      );
-      for (const chainTx of chain) {
-        const existing = byTxid.get(chainTx.txid);
-        if (existing) {
-          existing.forVtxos.add(outpoint);
-        } else {
-          byTxid.set(chainTx.txid, { ...chainTx, forVtxos: /* @__PURE__ */ new Set([outpoint]) });
-        }
-      }
-      hasMore = page ? chain.length === DEFAULT_PAGE_SIZE : false;
-      pageIndex++;
-    }
-  }
-  const pending = new Map(
-    [...byTxid.values()].filter((tx) => !isCommitment(tx.type)).map((tx) => [tx.txid, tx])
-  );
-  const inDegree = /* @__PURE__ */ new Map();
-  for (const tx of pending.values()) {
-    const parents = tx.spends.filter((p) => pending.has(p));
-    inDegree.set(tx.txid, parents.length);
-  }
-  const order = [];
-  const queue = [...pending.values()].filter((tx) => inDegree.get(tx.txid) === 0).sort((a, b) => a.txid.localeCompare(b.txid));
-  while (queue.length > 0) {
-    const tx = queue.shift();
-    order.push(tx);
-    const children = [...pending.values()].filter((c) => c.spends.includes(tx.txid)).sort((a, b) => a.txid.localeCompare(b.txid));
-    for (const child of children) {
-      const deg = inDegree.get(child.txid) - 1;
-      inDegree.set(child.txid, deg);
-      if (deg === 0) queue.push(child);
-    }
-  }
-  if (order.length !== pending.size) {
-    throw new Error("inconsistent vtxo chain from indexer (cycle detected)");
-  }
-  const nodes = [];
-  for (const tx of order) {
-    let confirmed = false;
-    try {
-      const status = await params.onchain.getTxStatus(tx.txid);
-      confirmed = status.confirmed;
-    } catch {
-      confirmed = false;
-    }
-    const expires = Number(tx.expiresAt);
-    nodes.push({
-      txid: tx.txid,
-      type: tx.type,
-      expiresAt: Number.isFinite(expires) && expires > 0 ? expires : void 0,
-      forVtxos: [...tx.forVtxos].sort(),
-      confirmed
-    });
-  }
-  return nodes;
-}
-function topoSortByDeps(items, idOf, depsOf) {
-  const produced = new Set(items.map(idOf));
-  const emitted = /* @__PURE__ */ new Set();
-  const ordered = [];
-  let remaining = items;
-  while (remaining.length > 0) {
-    const next = [];
-    let progress = false;
-    for (const item of remaining) {
-      if (depsOf(item).every((d) => !produced.has(d) || emitted.has(d))) {
-        ordered.push(item);
-        emitted.add(idOf(item));
-        progress = true;
-      } else {
-        next.push(item);
-      }
-    }
-    if (!progress) {
-      throw new Error("topological sort: cycle or unsatisfiable dependency");
-    }
-    remaining = next;
-  }
-  return ordered;
-}
 function extraWitnessSize(path) {
   return (path.extraWitness ?? []).reduce((sum, item) => sum + 1 + item.length, 0);
 }
@@ -17091,27 +17772,22 @@ async function computeExitLayout(opts, feeRate) {
   const { wallet, onchainWallet } = opts;
   const vtxos = await selectExitVtxos(opts);
   if (vtxos.length === 0) throw new Error("no vtxos to exit");
+  const resolver = createExitChainResolver({
+    indexer: wallet.indexerProvider,
+    repository: wallet.virtualTxRepository,
+    extraSources: wallet.exitDataCapture?.sources
+  });
   const dag = await buildExitDag({
     vtxos,
-    indexer: wallet.indexerProvider,
+    chain: resolver,
     onchain: wallet.onchainProvider
   });
   const pendingNodes = dag.filter((n) => !n.confirmed);
   const psbts = /* @__PURE__ */ new Map();
   if (pendingNodes.length > 0) {
-    const txids = pendingNodes.map((n) => n.txid);
-    let pageIndex = 0;
-    let hasMore = true;
-    while (hasMore) {
-      const { txs, page } = await wallet.indexerProvider.getVirtualTxs(txids, {
-        pageIndex,
-        pageSize: DEFAULT_PAGE_SIZE
-      });
-      for (const psbt of txs) {
-        psbts.set(Transaction.fromPSBT(base64.decode(psbt)).id, psbt);
-      }
-      hasMore = page ? txs.length === DEFAULT_PAGE_SIZE : false;
-      pageIndex++;
+    const txs = await resolver.getVirtualTxs(pendingNodes.map((n) => n.txid));
+    for (const psbt of txs) {
+      psbts.set(Transaction.fromPSBT(base64.decode(psbt)).id, psbt);
     }
   }
   const childVsize = Number(
@@ -17754,6 +18430,6 @@ function isArkContract(str) {
   return str.startsWith(ARKCONTRACT_PREFIX + "=");
 }
 
-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, UnilateralExit, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createDefaultActivityRegistry, decodeArkContract, deserializeAssets, deserializeExitPackage, 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, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-FMI2GKYO.js.map
-//# sourceMappingURL=chunk-FMI2GKYO.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, UnilateralExit, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createDefaultActivityRegistry, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isExpired, isRecoverable, isRetryableProviderError, isSpendable, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
+//# sourceMappingURL=chunk-TGRJ5WAX.js.map
+//# sourceMappingURL=chunk-TGRJ5WAX.js.map