@arkade-os/sdk 0.4.44 → 0.4.46

package/dist/{chunk-FMI2GKYO.js → chunk-P6VBP3CT.js}

@@ -1,6 +1,6 @@
-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 { 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 { craftToSpendTx, Transaction, OP_RETURN_EMPTY_PKSCRIPT, baseFetch, Intent, getArkPsbtFields, CosignerPublicKey, setArkPsbtField, VtxoTaprootTree, maybeArkError, isArkError, ArkErrorName, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, AssetId, AssetOutput, AssetGroup, AssetInput, Packet, Metadata, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError, BufferReader } from './chunk-CWJ7ZCP7.js';
+import { contractHandlers, isMainnetDescriptor, descriptorIsOurs, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, DefaultVtxo, BoardingContractHandler } from './chunk-QKC2T54O.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-FWG4TSPN.js';
 import { sha256, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr, equalBytes as equalBytes$1 } from '@scure/btc-signer/utils.js';
 import { SigHash, Script, p2tr, RawWitness, Address, OutScript, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$2 } from '@scure/btc-signer';
 import { hex, base58, base64 } from '@scure/base';
@@ -62,6 +62,8 @@ var PartialSig = class _PartialSig {
       throw new PartialSignatureError("Invalid R length");
     }
   }
+  s;
+  R;
   /**
    * Encodes the partial signature into bytes
    * Returns a 32-byte array containing just the s value
@@ -111,6 +113,7 @@ var TreeSignerSession = class _TreeSignerSession {
   constructor(secretKey) {
     this.secretKey = secretKey;
   }
+  secretKey;
   static NOT_INITIALIZED = new Error("session not initialized, call init method");
   myNonces = null;
   aggregateNonces = null;
@@ -337,6 +340,7 @@ var ReadonlySingleKey = class _ReadonlySingleKey {
       throw new Error("Invalid public key length");
     }
   }
+  publicKey;
   /**
    * Create a ReadonlySingleKey from a compressed public key.
    *
@@ -948,6 +952,7 @@ var RestDelegateProvider = class {
   constructor(url) {
     this.url = url;
   }
+  url;
   /**
    * Submit a delegation request to the remote delegation service.
    *
@@ -1017,6 +1022,7 @@ var EsploraProvider = class {
     this.pollingInterval = opts?.pollingInterval ?? 15e3;
     this.forcePolling = opts?.forcePolling ?? false;
   }
+  baseUrl;
   pollingInterval;
   forcePolling;
   async getCoins(address) {
@@ -1496,6 +1502,8 @@ var UnknownPacket = class {
     this.packetType = packetType;
     this.data = data;
   }
+  packetType;
+  data;
   type() {
     return this.packetType;
   }
@@ -1516,6 +1524,7 @@ var Extension = class _Extension {
   constructor(packets) {
     this.packets = packets;
   }
+  packets;
   static create(packets) {
     if (packets.length === 0) {
       throw new Error("missing packets");
@@ -1954,6 +1963,7 @@ function isExpired(vtxo) {
   return expiry <= Date.now();
 }
 function isSubdust(vtxo, dust) {
+  if (typeof vtxo === "bigint") return vtxo < dust;
   return vtxo.value < dust;
 }
 
@@ -2312,6 +2322,7 @@ var FeeAmount = class _FeeAmount {
   constructor(value) {
     this.value = value;
   }
+  value;
   static ZERO = new _FeeAmount(0);
   /** Returns the fee amount rounded up to whole satoshis. */
   get satoshis() {
@@ -2336,6 +2347,7 @@ var Estimator = class {
     this.intentOffchainOutput = config.offchainOutput ? parseProgram(config.offchainOutput, IntentOutputEnv) : void 0;
     this.intentOnchainOutput = config.onchainOutput ? parseProgram(config.onchainOutput, IntentOutputEnv) : void 0;
   }
+  config;
   intentOffchainInput;
   intentOnchainInput;
   intentOffchainOutput;
@@ -2738,6 +2750,8 @@ var VtxoManager = class _VtxoManager {
     }
     this.contractEventsSubscriptionReady = this.initializeSubscription();
   }
+  wallet;
+  renewalConfig;
   settlementConfig;
   contractEventsSubscriptionReady;
   disposePromise;
@@ -3775,7 +3789,7 @@ var VtxoManager = class _VtxoManager {
    */
   extractSpentOutpoint(error) {
     const ark = maybeArkError(error);
-    if (!ark || ark.name !== "VTXO_ALREADY_SPENT") return void 0;
+    if (!isArkError(ark, ArkErrorName.VTXO_ALREADY_SPENT)) return void 0;
     const raw = ark.metadata?.vtxo_outpoint;
     if (typeof raw !== "string") return void 0;
     const [txid, voutStr] = raw.split(":");
@@ -4079,6 +4093,9 @@ var ArkNote = class _ArkNote {
     this.status = { confirmed: true };
     this.extraWitness = [this.preimage];
   }
+  preimage;
+  value;
+  HRP;
   static DefaultHRP = "arknote";
   static PreimageLength = 32;
   // 32 bytes for the preimage
@@ -4287,11 +4304,603 @@ 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;
+  }
+  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;
+  }
+  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;
+  }
+  sources;
+  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;
     this.children = children;
   }
+  root;
+  children;
   static create(chunks) {
     if (chunks.length === 0) {
       throw new Error("empty chunks");
@@ -4763,6 +5372,7 @@ var ReadonlyAssetManager = class {
   constructor(indexer) {
     this.indexer = indexer;
   }
+  indexer;
   async getAssetDetails(assetId) {
     return this.indexer.getAssetDetails(assetId);
   }
@@ -4772,6 +5382,7 @@ var AssetManager = class extends ReadonlyAssetManager {
     super(wallet.indexerProvider);
     this.wallet = wallet;
   }
+  wallet;
   /**
    * Issue a new asset.
    * @param params - Parameters for asset issuance
@@ -5093,6 +5704,9 @@ var DelegateManagerImpl = class {
     this.arkInfoProvider = arkInfoProvider;
     this.identity = identity;
   }
+  delegateProvider;
+  arkInfoProvider;
+  identity;
   async getDelegateInfo() {
     return this.delegateProvider.getDelegateInfo();
   }
@@ -5259,12 +5873,12 @@ async function delegate(identity, delegateProvider, arkInfo, delegateInfo, vtxos
       script: hex.encode(output.script)
     }).satoshis;
   }, 0);
-  if (amount - BigInt(outputFee) <= dust) {
+  if (isSubdust(amount - BigInt(outputFee), dust)) {
     throw new Error("Amount is below dust limit, cannot delegate");
   }
   amount -= BigInt(outputFee);
   amount -= delegateFee;
-  if (amount <= dust) {
+  if (isSubdust(amount, dust)) {
     throw new Error("Amount is below dust limit, cannot delegate");
   }
   outputs.push({
@@ -5396,20 +6010,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;
@@ -5875,6 +6475,7 @@ var IndexedDBVirtualTxRepository = class {
   constructor(dbName = DEFAULT_DB_NAME) {
     this.dbName = dbName;
   }
+  dbName;
   version = 1;
   db = null;
   async getDB() {
@@ -6004,6 +6605,7 @@ var IndexedDBIntentRepository = class {
   constructor(dbName = DEFAULT_DB_NAME) {
     this.dbName = dbName;
   }
+  dbName;
   version = 1;
   db = null;
   async getDB() {
@@ -6314,6 +6916,7 @@ var IndexedDBContractRepository = class {
   constructor(dbName = DEFAULT_DB_NAME) {
     this.dbName = dbName;
   }
+  dbName;
   version = 1;
   db = null;
   async clear() {
@@ -6480,6 +7083,7 @@ var IndexedDBWalletRepository = class {
   constructor(dbName = DEFAULT_DB_NAME) {
     this.dbName = dbName;
   }
+  dbName;
   version = 1;
   db = null;
   async clear() {
@@ -7803,87 +8407,30 @@ async function reconcileIntents(deps) {
       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 (!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 +8445,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 +8471,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 +8499,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 +8559,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 +8764,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 +9008,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 +9116,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 +9142,15 @@ var ContractManager = class _ContractManager {
           contract,
           filtered
         );
+        if (this.config.onVtxosPersisted) {
+          try {
+            await this.config.onVtxosPersisted(
+              contract,
+              filtered
+            );
+          } catch {
+          }
+        }
       }
     }
     return result;
@@ -8607,6 +9229,8 @@ var HDDescriptorProvider = class _HDDescriptorProvider {
     this.identity = identity;
     this.walletRepository = walletRepository;
   }
+  identity;
+  walletRepository;
   /**
    * Construct an HDDescriptorProvider. No I/O is performed here;
    * persisted state is read lazily on the first call to
@@ -8799,6 +9423,7 @@ var WalletReceiveRotator = class _WalletReceiveRotator {
     this.currentTaggedScript = priorTaggedScript;
     this.logger = logger ?? console;
   }
+  provider;
   unsubscribe;
   chain = Promise.resolve();
   /**
@@ -9152,6 +9777,8 @@ var MissingSigningDescriptorError = class extends Error {
     this.contractScript = contractScript;
     this.contractType = contractType;
   }
+  contractScript;
+  contractType;
   name = "MissingSigningDescriptorError";
 };
 var DescriptorSigningProviderMissingError = class extends Error {
@@ -9167,6 +9794,7 @@ var InputSignerRouter = class {
   constructor(deps) {
     this.deps = deps;
   }
+  deps;
   /**
    * Resolve each job to its target signer without invoking signing. The
    * returned plan is the single source of truth for both {@link sign} and
@@ -9385,6 +10013,14 @@ var ReadonlyWallet = class _ReadonlyWallet {
     this._assetManager = new ReadonlyAssetManager(this.indexerProvider);
     this.walletContractTimelocks = walletContractTimelocks && walletContractTimelocks.length > 0 ? dedupeTimelocks(walletContractTimelocks) : [this.offchainTapscript.options.csvTimelock];
   }
+  identity;
+  network;
+  onchainProvider;
+  indexerProvider;
+  dustAmount;
+  walletRepository;
+  contractRepository;
+  delegateProvider;
   _contractManager;
   _contractManagerInitializing;
   watcherConfig;
@@ -9402,6 +10038,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 +10082,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 +10282,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 +10342,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 +10355,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 +10392,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 +10531,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 +10953,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();
@@ -10377,6 +11127,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       boardingPkScript: boardingTapscript.pkScript
     });
   }
+  arkProvider;
+  forfeitOutputScript;
+  forfeitPubkey;
   static MIN_FEE_RATE = 1;
   // sats/vbyte
   identity;
@@ -10910,6 +11663,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 +11692,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;
   }
@@ -11132,7 +11894,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         script: offchainOutputScript
       });
       output.amount -= BigInt(outputFee.satoshis);
-      if (output.amount <= this.dustAmount) {
+      if (isSubdust(output.amount, this.dustAmount)) {
         throw new Error("Output amount is below dust limit");
       }
       params = {
@@ -11380,7 +12142,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         }
         continue;
       }
-      if (isRecoverable(input) || isSubdust(input, this.dustAmount)) {
+      if (isRecoverable(input) || isSubdust({ value: input.value }, this.dustAmount)) {
         continue;
       }
       if (connectorsLeaves.length === 0) {
@@ -12459,6 +13221,8 @@ var MessageBus = class {
     this.debug = debug;
     this.buildServicesFn = buildServices ?? this.buildServices.bind(this);
   }
+  walletRepository;
+  contractRepository;
   handlers;
   tickIntervalMs;
   messageTimeoutMs;
@@ -12960,6 +13724,7 @@ var Ramps = class {
   constructor(wallet) {
     this.wallet = wallet;
   }
+  wallet;
   /**
    * Onboard boarding inputs.
    *
@@ -13448,10 +14213,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 +14987,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
@@ -14297,6 +15071,8 @@ var ServiceWorkerReadonlyAssetManager = class {
     this.sendMessage = sendMessage;
     this.messageTag = messageTag;
   }
+  sendMessage;
+  messageTag;
   async getAssetDetails(assetId) {
     const message = {
       tag: this.messageTag,
@@ -14381,6 +15157,8 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
       messageTag
     );
   }
+  serviceWorker;
+  messageTag;
   walletRepository;
   contractRepository;
   identity;
@@ -14822,6 +15600,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 +15667,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 +15703,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 +15732,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 +15849,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 +15862,11 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
           tag: messageTag,
           payload: { outpoints }
         };
-        await sendContractMessage(message);
+        try {
+          await sendContractMessage(message);
+        } finally {
+          await refreshSyncState();
+        }
       },
       scanContracts() {
         return Promise.reject(
@@ -15081,6 +15911,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
     );
     this.hasDelegate = hasDelegate;
   }
+  serviceWorker;
   walletRepository;
   contractRepository;
   identity;
@@ -15462,6 +16293,7 @@ var OnchainWallet = class _OnchainWallet {
     this.onchainP2TR = onchainP2TR;
     this.provider = provider;
   }
+  identity;
   static MIN_FEE_RATE = 1;
   // sat/vbyte
   onchainP2TR;
@@ -15763,6 +16595,8 @@ var WsElectrumChainSource = class {
     this.ws = ws;
     this.network = network;
   }
+  ws;
+  network;
   // Cached chain tip kept fresh by the headers subscription. Initialized
   // lazily on first call to subscribeHeaders().
   cachedTip = null;
@@ -16045,6 +16879,8 @@ var ElectrumOnchainProvider = class {
     this.network = network;
     this.chain = new WsElectrumChainSource(ws, network);
   }
+  ws;
+  network;
   chain;
   async getCoins(address) {
     const script = this.encodeAddress(address);
@@ -16598,6 +17434,7 @@ var ExitPathError = class extends Error {
     this.reason = reason;
     this.name = "ExitPathError";
   }
+  reason;
 };
 function delayWeight(sequence) {
   const t = sequenceToTimelock(sequence);
@@ -16651,7 +17488,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 */;
@@ -16681,6 +17518,11 @@ var Unroll;
       this.indexer = indexer;
       this.virtualTxRepository = virtualTxRepository;
     }
+    toUnroll;
+    bumper;
+    explorer;
+    indexer;
+    virtualTxRepository;
     /** Create an unroll session by loading the virtual output chain from the indexer. */
     static async create(toUnroll, bumper, explorer, indexer, virtualTxRepository) {
       const { chain } = await indexer.getVtxoChain(toUnroll);
@@ -16714,7 +17556,7 @@ var Unroll;
           txid: next.txid,
           psbt,
           expiresAt: null,
-          type: chainTxTypeToChainedExit(next.type)
+          type: chainTxTypeToChainedExit2(next.type)
         };
         try {
           await repo.upsertVirtualTxs([cached]);
@@ -16892,99 +17734,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 +17840,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(
@@ -17259,6 +18003,8 @@ var Executor = class {
     this.pollIntervalMs = opts?.pollIntervalMs ?? 5e3;
     this.feeWallet = opts?.feeWallet;
   }
+  pkg;
+  provider;
   pollIntervalMs;
   feeWallet;
   sleep() {
@@ -17754,6 +18500,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-P6VBP3CT.js.map
+//# sourceMappingURL=chunk-P6VBP3CT.js.map