@arkade-os/sdk 0.4.43 → 0.4.45

package/dist/{chunk-B4R36PRN.js → chunk-TGRJ5WAX.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-763XHDAJ.js';
-import { isMainnetDescriptor, descriptorIsOurs, contractHandlers, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, DefaultVtxo, BoardingContractHandler } from './chunk-YNEDJTX2.js';
-import { VtxoScript, timelockToSequence, DEFAULT_NETWORK, DEFAULT_NETWORK_NAME, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, ArkAddress, CSVMultisigTapscript, getSequence, getNetwork, MultisigTapscript, networks as networks$1, DEFAULT_ARKADE_SERVER_URL } from './chunk-BE5MUB7T.js';
+import { 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';
 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';
@@ -1215,6 +1215,114 @@ var isExplorerTransaction = (tx) => {
     (vout) => typeof vout.scriptpubkey_address === "string" && typeof vout.value === "number"
   ) && typeof tx.status === "object" && typeof tx.status.confirmed === "boolean";
 };
+var getVarIntSize = (n) => {
+  if (n < 253) return 1;
+  if (n <= 65535) return 3;
+  if (n <= 4294967295) return 5;
+  return 9;
+};
+var TxWeightEstimator = class _TxWeightEstimator {
+  static P2PKH_SCRIPT_SIG_SIZE = 1 + 73 + 1 + 33;
+  static INPUT_SIZE = 32 + 4 + 1 + 4;
+  static BASE_CONTROL_BLOCK_SIZE = 1 + 32;
+  static OUTPUT_SIZE = 8 + 1;
+  static P2WPKH_OUTPUT_SIZE = 1 + 1 + 20;
+  static BASE_TX_SIZE = 8 + 2;
+  // Version + LockTime
+  static WITNESS_HEADER_SIZE = 2;
+  // Flag + Marker
+  static WITNESS_SCALE_FACTOR = 4;
+  static P2TR_OUTPUT_SIZE = 1 + 1 + 32;
+  hasWitness;
+  inputCount;
+  outputCount;
+  inputSize;
+  inputWitnessSize;
+  outputSize;
+  constructor(hasWitness, inputCount, outputCount, inputSize, inputWitnessSize, outputSize) {
+    this.hasWitness = hasWitness;
+    this.inputCount = inputCount;
+    this.outputCount = outputCount;
+    this.inputSize = inputSize;
+    this.inputWitnessSize = inputWitnessSize;
+    this.outputSize = outputSize;
+  }
+  static create() {
+    return new _TxWeightEstimator(false, 0, 0, 0, 0, 0);
+  }
+  addP2AInput() {
+    this.inputCount++;
+    this.inputSize += _TxWeightEstimator.INPUT_SIZE;
+    return this;
+  }
+  addKeySpendInput(isDefault = true) {
+    this.inputCount++;
+    this.inputWitnessSize += 64 + 1 + (isDefault ? 0 : 1);
+    this.inputSize += _TxWeightEstimator.INPUT_SIZE;
+    this.hasWitness = true;
+    return this;
+  }
+  addP2PKHInput() {
+    this.inputCount++;
+    this.inputWitnessSize++;
+    this.inputSize += _TxWeightEstimator.INPUT_SIZE + _TxWeightEstimator.P2PKH_SCRIPT_SIG_SIZE;
+    return this;
+  }
+  addTapscriptInput(leafWitnessSize, leafScriptSize, leafControlBlockSize) {
+    const controlBlockWitnessSize = 1 + _TxWeightEstimator.BASE_CONTROL_BLOCK_SIZE + 1 + leafScriptSize + 1 + leafControlBlockSize;
+    this.inputCount++;
+    this.inputWitnessSize += leafWitnessSize + 1 + controlBlockWitnessSize;
+    this.inputSize += _TxWeightEstimator.INPUT_SIZE;
+    this.hasWitness = true;
+    return this;
+  }
+  addP2WPKHOutput() {
+    this.outputCount++;
+    this.outputSize += _TxWeightEstimator.OUTPUT_SIZE + _TxWeightEstimator.P2WPKH_OUTPUT_SIZE;
+    return this;
+  }
+  addP2TROutput() {
+    this.outputCount++;
+    this.outputSize += _TxWeightEstimator.OUTPUT_SIZE + _TxWeightEstimator.P2TR_OUTPUT_SIZE;
+    return this;
+  }
+  /**
+   * Adds an output given a raw script.
+   * Cost = 8 bytes (amount) + varint(scriptLen) + scriptLen
+   */
+  addOutputScript(script) {
+    this.outputCount++;
+    this.outputSize += 8 + getVarIntSize(script.length) + script.length;
+    return this;
+  }
+  /**
+   * Adds an output by decoding the address to get the exact script size.
+   */
+  addOutputAddress(address, network) {
+    const payment = Address(network).decode(address);
+    const script = OutScript.encode(payment);
+    return this.addOutputScript(script);
+  }
+  vsize() {
+    const inputCount = getVarIntSize(this.inputCount);
+    const outputCount = getVarIntSize(this.outputCount);
+    const txSizeStripped = _TxWeightEstimator.BASE_TX_SIZE + inputCount + this.inputSize + outputCount + this.outputSize;
+    let weight = txSizeStripped * _TxWeightEstimator.WITNESS_SCALE_FACTOR;
+    if (this.hasWitness) {
+      weight += _TxWeightEstimator.WITNESS_HEADER_SIZE + this.inputWitnessSize;
+    }
+    return vsize(weight);
+  }
+};
+var vsize = (weight) => {
+  const value = BigInt(Math.ceil(weight / TxWeightEstimator.WITNESS_SCALE_FACTOR));
+  return {
+    value,
+    fee: (feeRate) => feeRate * value
+  };
+};
+
+// src/utils/anchor.ts
 var ANCHOR_VALUE = 0n;
 var ANCHOR_PKSCRIPT = new Uint8Array([81, 2, 78, 115]);
 var P2A = {
@@ -1240,6 +1348,37 @@ function findP2AOutput(tx) {
   }
   throw new Error("P2A output not found");
 }
+var CHILD_DUST_AMOUNT = 546;
+function buildAnchorChild(params) {
+  const { parent, feeRate, fundingCoins, changeAddress, tapInternalKey, network } = params;
+  const child = new Transaction({ version: 3, allowLegacyWitnessUtxo: true });
+  child.addInput(findP2AOutput(parent));
+  const estimator = TxWeightEstimator.create().addP2AInput();
+  for (const _ of fundingCoins) {
+    estimator.addKeySpendInput(true);
+  }
+  estimator.addOutputAddress(changeAddress, network);
+  const childVsize = Number(estimator.vsize().value);
+  const fee = Math.ceil(feeRate * (parent.vsize + childVsize));
+  let total = 0n;
+  for (const coin of fundingCoins) {
+    total += BigInt(coin.value);
+    child.addInput({
+      txid: coin.txid,
+      index: coin.vout,
+      witnessUtxo: { script: params.changeScript, amount: BigInt(coin.value) },
+      tapInternalKey
+    });
+  }
+  const change = total + P2A.amount - BigInt(fee);
+  if (change < BigInt(CHILD_DUST_AMOUNT)) {
+    throw new Error(
+      `insufficient funding for anchor child: need change >= ${CHILD_DUST_AMOUNT}, got ${change}`
+    );
+  }
+  child.addOutputAddress(changeAddress, change, network);
+  return { child, fee };
+}
 
 // src/forfeit.ts
 function buildForfeitTx(inputs, forfeitPkScript, txLocktime) {
@@ -2154,112 +2293,6 @@ function isValidArkAddress(address) {
     return false;
   }
 }
-var getVarIntSize = (n) => {
-  if (n < 253) return 1;
-  if (n <= 65535) return 3;
-  if (n <= 4294967295) return 5;
-  return 9;
-};
-var TxWeightEstimator = class _TxWeightEstimator {
-  static P2PKH_SCRIPT_SIG_SIZE = 1 + 73 + 1 + 33;
-  static INPUT_SIZE = 32 + 4 + 1 + 4;
-  static BASE_CONTROL_BLOCK_SIZE = 1 + 32;
-  static OUTPUT_SIZE = 8 + 1;
-  static P2WPKH_OUTPUT_SIZE = 1 + 1 + 20;
-  static BASE_TX_SIZE = 8 + 2;
-  // Version + LockTime
-  static WITNESS_HEADER_SIZE = 2;
-  // Flag + Marker
-  static WITNESS_SCALE_FACTOR = 4;
-  static P2TR_OUTPUT_SIZE = 1 + 1 + 32;
-  hasWitness;
-  inputCount;
-  outputCount;
-  inputSize;
-  inputWitnessSize;
-  outputSize;
-  constructor(hasWitness, inputCount, outputCount, inputSize, inputWitnessSize, outputSize) {
-    this.hasWitness = hasWitness;
-    this.inputCount = inputCount;
-    this.outputCount = outputCount;
-    this.inputSize = inputSize;
-    this.inputWitnessSize = inputWitnessSize;
-    this.outputSize = outputSize;
-  }
-  static create() {
-    return new _TxWeightEstimator(false, 0, 0, 0, 0, 0);
-  }
-  addP2AInput() {
-    this.inputCount++;
-    this.inputSize += _TxWeightEstimator.INPUT_SIZE;
-    return this;
-  }
-  addKeySpendInput(isDefault = true) {
-    this.inputCount++;
-    this.inputWitnessSize += 64 + 1 + (isDefault ? 0 : 1);
-    this.inputSize += _TxWeightEstimator.INPUT_SIZE;
-    this.hasWitness = true;
-    return this;
-  }
-  addP2PKHInput() {
-    this.inputCount++;
-    this.inputWitnessSize++;
-    this.inputSize += _TxWeightEstimator.INPUT_SIZE + _TxWeightEstimator.P2PKH_SCRIPT_SIG_SIZE;
-    return this;
-  }
-  addTapscriptInput(leafWitnessSize, leafScriptSize, leafControlBlockSize) {
-    const controlBlockWitnessSize = 1 + _TxWeightEstimator.BASE_CONTROL_BLOCK_SIZE + 1 + leafScriptSize + 1 + leafControlBlockSize;
-    this.inputCount++;
-    this.inputWitnessSize += leafWitnessSize + 1 + controlBlockWitnessSize;
-    this.inputSize += _TxWeightEstimator.INPUT_SIZE;
-    this.hasWitness = true;
-    return this;
-  }
-  addP2WPKHOutput() {
-    this.outputCount++;
-    this.outputSize += _TxWeightEstimator.OUTPUT_SIZE + _TxWeightEstimator.P2WPKH_OUTPUT_SIZE;
-    return this;
-  }
-  addP2TROutput() {
-    this.outputCount++;
-    this.outputSize += _TxWeightEstimator.OUTPUT_SIZE + _TxWeightEstimator.P2TR_OUTPUT_SIZE;
-    return this;
-  }
-  /**
-   * Adds an output given a raw script.
-   * Cost = 8 bytes (amount) + varint(scriptLen) + scriptLen
-   */
-  addOutputScript(script) {
-    this.outputCount++;
-    this.outputSize += 8 + getVarIntSize(script.length) + script.length;
-    return this;
-  }
-  /**
-   * Adds an output by decoding the address to get the exact script size.
-   */
-  addOutputAddress(address, network) {
-    const payment = Address(network).decode(address);
-    const script = OutScript.encode(payment);
-    return this.addOutputScript(script);
-  }
-  vsize() {
-    const inputCount = getVarIntSize(this.inputCount);
-    const outputCount = getVarIntSize(this.outputCount);
-    const txSizeStripped = _TxWeightEstimator.BASE_TX_SIZE + inputCount + this.inputSize + outputCount + this.outputSize;
-    let weight = txSizeStripped * _TxWeightEstimator.WITNESS_SCALE_FACTOR;
-    if (this.hasWitness) {
-      weight += _TxWeightEstimator.WITNESS_HEADER_SIZE + this.inputWitnessSize;
-    }
-    return vsize(weight);
-  }
-};
-var vsize = (weight) => {
-  const value = BigInt(Math.ceil(weight / TxWeightEstimator.WITNESS_SCALE_FACTOR));
-  return {
-    value,
-    fee: (feeRate) => feeRate * value
-  };
-};
 var AmountVariableName = "amount";
 var ExpiryVariableName = "expiry";
 var BirthVariableName = "birth";
@@ -4254,17 +4287,603 @@ function wrapHandlerWithIntentPersistence(base, deps) {
     }
   };
 }
-var TxTree = class {
-  constructor(root, children = /* @__PURE__ */ new Map()) {
-    this.root = root;
-    this.children = children;
+
+// 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]) });
+      }
+    }
   }
-  static create(chunks) {
-    if (chunks.length === 0) {
-      throw new Error("empty chunks");
+  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);
+      }
     }
-    const chunksByTxid = /* @__PURE__ */ new Map();
-    for (const chunk of chunks) {
+    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;
+    this.children = children;
+  }
+  static create(chunks) {
+    if (chunks.length === 0) {
+      throw new Error("empty chunks");
+    }
+    const chunksByTxid = /* @__PURE__ */ new Map();
+    for (const chunk of chunks) {
       const decodedChunk = decodeNode(chunk);
       const txid = decodedChunk.tx.id;
       chunksByTxid.set(txid, decodedChunk);
@@ -5363,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;
@@ -7796,66 +8401,9 @@ function dedupeOutpoints(outpoints) {
   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
-      }
-    };
-  });
-}
-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/contracts/contractManager.ts
-function areCoalescibleContractTypes(a, b) {
-  return a === "default" && b === "boarding" || a === "boarding" && b === "default";
+// src/contracts/contractManager.ts
+function areCoalescibleContractTypes(a, b) {
+  return a === "default" && b === "boarding" || a === "boarding" && b === "default";
 }
 var SCAN_MAX_INDEX = 1e4;
 var DEFAULT_SCAN_BATCH = 10;
@@ -7865,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({
@@ -7887,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;
@@ -7895,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) => {
@@ -7949,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;
@@ -8148,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,
@@ -8386,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);
   }
@@ -8476,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) {
@@ -8496,6 +9110,15 @@ var ContractManager = class _ContractManager {
           contract,
           filtered
         );
+        if (this.config.onVtxosPersisted) {
+          try {
+            await this.config.onVtxosPersisted(
+              contract,
+              filtered
+            );
+          } catch {
+          }
+        }
       }
     }
     return result;
@@ -9369,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
@@ -9411,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.
@@ -9545,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;
@@ -9599,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,
@@ -9614,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,
@@ -9649,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;
   }
@@ -9779,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);
   }
   /**
@@ -10198,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();
@@ -10877,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;
@@ -10898,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;
   }
@@ -13415,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({
@@ -14181,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
@@ -14789,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());
   }
@@ -14843,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 = {
@@ -14853,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");
@@ -14881,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 = {
@@ -14994,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 = {
@@ -15003,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(
@@ -15584,42 +16391,11 @@ var OnchainWallet = class _OnchainWallet {
    * @see send
    */
   async bumpP2A(parent) {
-    const parentVsize = parent.vsize;
-    let child = new Transaction({
-      version: 3,
-      allowLegacyWitnessUtxo: true
-    });
-    child.addInput(findP2AOutput(parent));
-    const childVsize = TxWeightEstimator.create().addKeySpendInput(true).addP2AInput().addOutputAddress(this.address, this.network).vsize().value;
-    const packageVSize = parentVsize + Number(childVsize);
     let feeRate = await this.provider.getFeeRate();
     if (!feeRate || feeRate < _OnchainWallet.MIN_FEE_RATE) {
       feeRate = _OnchainWallet.MIN_FEE_RATE;
     }
-    const fee = Math.ceil(feeRate * packageVSize);
-    if (!fee) {
-      throw new Error(
-        `invalid fee, got ${fee} with vsize ${packageVSize}, feeRate ${feeRate}`
-      );
-    }
-    const coins = await this.getCoins();
-    const selected = selectCoins(coins, fee, true);
-    for (const input of selected.inputs) {
-      child.addInput({
-        txid: input.txid,
-        index: input.vout,
-        witnessUtxo: {
-          script: this.onchainP2TR.script,
-          amount: BigInt(input.value)
-        },
-        tapInternalKey: this.onchainP2TR.tapInternalKey
-      });
-    }
-    child.addOutputAddress(this.address, P2A.amount + selected.changeAmount, this.network);
-    child = await this.identity.sign(child);
-    for (let i = 1; i < child.inputsLength; i++) {
-      child.finalizeIdx(i);
-    }
+    const child = await this.buildBumpPackage(parent, feeRate, await this.getCoins());
     try {
       await this.provider.broadcastTransaction(parent.hex, child.hex);
     } catch (error) {
@@ -15628,6 +16404,59 @@ var OnchainWallet = class _OnchainWallet {
       return [parent.hex, child.hex];
     }
   }
+  /**
+   * Build and sign a CPFP fee child for a parent tx (given as raw hex)
+   * carrying a P2A anchor, funding it from this wallet's **confirmed**
+   * coins, and return the 1P1C package hexes WITHOUT broadcasting.
+   *
+   * This is the graph-mode fee source ({@link ExitFeeWallet}): the exit
+   * executor calls it to bump each transported virtual tx at execution
+   * time, so funding can be deferred rather than pre-signed.
+   *
+   * @param parentHex - Finalized parent transaction, raw network hex
+   * @param feeRate - sat/vB floor for the package (raised to MIN_FEE_RATE)
+   * @returns Tuple of parent hex (unchanged) and signed child hex
+   * @throws If the parent has no anchor, or funding cannot be selected/signed
+   */
+  async bumpAnchor(parentHex, feeRate) {
+    const parent = Transaction.fromRaw(hex.decode(parentHex));
+    const coins = (await this.getCoins()).filter((c) => c.status.confirmed);
+    const child = await this.buildBumpPackage(parent, feeRate, coins);
+    return [parent.hex, child.hex];
+  }
+  /**
+   * Shared core of {@link bumpP2A} and {@link bumpAnchor}: probe the package
+   * fee with a single-input child, select coins for it, then build and sign
+   * with the actual selection (the fee grows per extra input).
+   */
+  async buildBumpPackage(parent, feeRate, coins) {
+    let rate = feeRate;
+    if (!rate || rate < _OnchainWallet.MIN_FEE_RATE) {
+      rate = _OnchainWallet.MIN_FEE_RATE;
+    }
+    const probeVsize = TxWeightEstimator.create().addKeySpendInput(true).addP2AInput().addOutputAddress(this.address, this.network).vsize().value;
+    const probeFee = Math.ceil(rate * (parent.vsize + Number(probeVsize)));
+    if (!probeFee) {
+      throw new Error(
+        `invalid fee, got ${probeFee} with vsize ${parent.vsize + Number(probeVsize)}, feeRate ${rate}`
+      );
+    }
+    const selected = selectCoins(coins, probeFee, true);
+    const { child } = buildAnchorChild({
+      parent,
+      feeRate: rate,
+      fundingCoins: selected.inputs,
+      changeAddress: this.address,
+      changeScript: this.onchainP2TR.script,
+      tapInternalKey: this.onchainP2TR.tapInternalKey,
+      network: this.network
+    });
+    const signed = await this.identity.sign(child);
+    for (let i = 1; i < signed.inputsLength; i++) {
+      signed.finalizeIdx(i);
+    }
+    return signed;
+  }
 };
 function selectCoins(coins, targetAmount, forceChange = false) {
   if (isNaN(targetAmount)) {
@@ -16518,7 +17347,85 @@ function craftBIP322ToSignSimple(toSpend, pkScript) {
   });
   return tx;
 }
-function chainTxTypeToChainedExit(t) {
+function finalizeVirtualTx(type, psbtBase64) {
+  const tx = Transaction.fromPSBT(base64.decode(psbtBase64));
+  if (type === "INDEXER_CHAINED_TX_TYPE_TREE" /* TREE */) {
+    const input = tx.getInput(0);
+    if (!input) {
+      throw new Error("Input not found");
+    }
+    const tapKeySig = input.tapKeySig;
+    if (!tapKeySig) {
+      throw new Error("Tap key sig not found");
+    }
+    tx.updateInput(0, {
+      finalScriptWitness: [tapKeySig]
+    });
+    return tx;
+  }
+  tx.finalize();
+  return tx;
+}
+var ExitPathError = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "ExitPathError";
+  }
+};
+function delayWeight(sequence) {
+  const t = sequenceToTimelock(sequence);
+  return t.type === "blocks" ? Number(t.value) : Number(t.value) / 600;
+}
+async function resolveUnilateralPath(params) {
+  const { vtxo, scriptHex, contractRepository } = params;
+  const contract = contractRepository ? (await contractRepository.getContracts({ script: scriptHex }))[0] : void 0;
+  if (contract) {
+    const handler = contractHandlers.get(contract.type);
+    if (!handler) {
+      throw new ExitPathError(
+        "no-handler",
+        `no contract handler registered for type '${contract.type}'`
+      );
+    }
+    const script = handler.createScript(contract.params);
+    const paths = handler.getAllSpendingPaths(script, contract, {
+      collaborative: false,
+      currentTime: params.currentTime,
+      walletDescriptor: params.walletDescriptor,
+      walletPubKey: params.walletPubKeyHex
+    }).filter((p) => p.sequence !== void 0);
+    if (paths.length === 0) {
+      throw new ExitPathError(
+        "no-unilateral-path",
+        `no unilateral path for vtxo ${vtxo.txid}:${vtxo.vout} (type '${contract.type}')`
+      );
+    }
+    paths.sort((a, b) => delayWeight(a.sequence) - delayWeight(b.sequence));
+    return { selection: paths[0], label: `${contract.type}:unilateral` };
+  }
+  const decoded = VtxoScript.decode(vtxo.tapTree);
+  let best;
+  for (const exit of decoded.exitPaths()) {
+    const leaf = decoded.findLeaf(hex.encode(exit.script));
+    if (!leaf) continue;
+    const sequence = timelockToSequence(exit.params.timelock);
+    const weight = delayWeight(sequence);
+    if (!best || weight < best.weight) {
+      best = { selection: { leaf, sequence }, weight };
+    }
+  }
+  if (!best) {
+    throw new ExitPathError(
+      "no-unilateral-path",
+      `no exit path found for vtxo ${vtxo.txid}:${vtxo.vout}`
+    );
+  }
+  return { selection: best.selection, label: "default:exit" };
+}
+
+// src/wallet/unroll.ts
+function chainTxTypeToChainedExit2(t) {
   switch (t) {
     case "INDEXER_CHAINED_TX_TYPE_COMMITMENT" /* COMMITMENT */:
       return 1 /* Commitment */;
@@ -16581,7 +17488,7 @@ var Unroll;
           txid: next.txid,
           psbt,
           expiresAt: null,
-          type: chainTxTypeToChainedExit(next.type)
+          type: chainTxTypeToChainedExit2(next.type)
         };
         try {
           await repo.upsertVirtualTxs([cached]);
@@ -16627,22 +17534,7 @@ var Unroll;
       if (!virtualTxBase64) {
         throw new Error(`Tx ${nextTxToBroadcast.txid} not found`);
       }
-      const tx = Transaction.fromPSBT(base64.decode(virtualTxBase64));
-      if (nextTxToBroadcast.type === "INDEXER_CHAINED_TX_TYPE_TREE" /* TREE */) {
-        const input = tx.getInput(0);
-        if (!input) {
-          throw new Error("Input not found");
-        }
-        const tapKeySig = input.tapKeySig;
-        if (!tapKeySig) {
-          throw new Error("Tap key sig not found");
-        }
-        tx.updateInput(0, {
-          finalScriptWitness: [tapKeySig]
-        });
-      } else {
-        tx.finalize();
-      }
+      const tx = finalizeVirtualTx(nextTxToBroadcast.type, virtualTxBase64);
       const pkg = await this.bumper.bumpP2A(tx);
       return {
         type: 0 /* UNROLL */,
@@ -16696,20 +17588,21 @@ async function prepareUnrollTransaction(wallet, vtxoTxIds, outputAddress) {
     if (!txStatus.confirmed) {
       throw new Error(`tx ${vtxo.txid} is not confirmed`);
     }
-    const exit = availableExitPath(
-      { height: txStatus.blockHeight, time: txStatus.blockTime },
-      chainTip,
-      vtxo
-    );
-    if (!exit) {
+    const resolved = await resolveUnilateralPath({
+      vtxo,
+      scriptHex: hex.encode(VtxoScript.decode(vtxo.tapTree).pkScript),
+      contractRepository: wallet.contractRepository,
+      walletPubKeyHex: hex.encode(await wallet.identity.xOnlyPublicKey()),
+      currentTime: Date.now()
+    });
+    const spendingLeaf = resolved.selection.leaf;
+    const sequence = resolved.selection.sequence;
+    const timelock = sequenceToTimelock(sequence);
+    const elapsed = timelock.type === "blocks" ? chainTip.height >= txStatus.blockHeight + Number(timelock.value) : chainTip.time >= txStatus.blockTime + Number(timelock.value);
+    if (!elapsed) {
       throw new Error(`no available exit path found for vtxo ${vtxo.txid}:${vtxo.vout}`);
     }
-    const spendingLeaf = VtxoScript.decode(vtxo.tapTree).findLeaf(hex.encode(exit.script));
-    if (!spendingLeaf) {
-      throw new Error(`spending leaf not found for vtxo ${vtxo.txid}:${vtxo.vout}`);
-    }
     totalAmount += BigInt(vtxo.value);
-    const sequence = timelockToSequence(exit.params.timelock);
     inputs.push({
       txid: vtxo.txid,
       index: vtxo.vout,
@@ -16773,21 +17666,711 @@ function doWait(onchainProvider, txid) {
     });
   };
 }
-function availableExitPath(confirmedAt, current, vtxo) {
-  const exits = VtxoScript.decode(vtxo.tapTree).exitPaths();
-  for (const exit of exits) {
-    if (exit.params.timelock.type === "blocks") {
-      if (current.height >= confirmedAt.height + Number(exit.params.timelock.value)) {
-        return exit;
+function extraWitnessSize(path) {
+  return (path.extraWitness ?? []).reduce((sum, item) => sum + 1 + item.length, 0);
+}
+function sweepFeeFor(path, outputAddress, network, feeRate) {
+  const [controlBlock, scriptWithVersion] = path.leaf;
+  const estimator = TxWeightEstimator.create().addTapscriptInput(
+    64 + extraWitnessSize(path),
+    scriptWithVersion.length,
+    TaprootControlBlock.encode(controlBlock).length
+  ).addOutputAddress(outputAddress, network);
+  return Number(estimator.vsize().fee(BigInt(Math.ceil(feeRate))));
+}
+async function buildSignedSweep(params) {
+  const { vtxo, path, outputAddress, feeRate, network, identity } = params;
+  const fee = sweepFeeFor(path, outputAddress, network, feeRate);
+  const sendAmount = BigInt(vtxo.value) - BigInt(fee);
+  if (sendAmount < BigInt(DUST_AMOUNT)) {
+    throw new Error(
+      `uneconomic vtxo ${vtxo.txid}:${vtxo.vout}: value ${vtxo.value} - fee ${fee} < dust`
+    );
+  }
+  const tx = new Transaction({ version: 2 });
+  tx.addInput({
+    txid: vtxo.txid,
+    index: vtxo.vout,
+    tapLeafScript: [path.leaf],
+    sequence: path.sequence,
+    witnessUtxo: { amount: BigInt(vtxo.value), script: vtxo.pkScript },
+    sighashType: SigHash.DEFAULT
+  });
+  tx.addOutputAddress(outputAddress, sendAmount, network);
+  const signed = await identity.sign(tx);
+  if (!path.extraWitness || path.extraWitness.length === 0) {
+    signed.finalize();
+    return { tx: signed, fee };
+  }
+  const input = signed.getInput(0);
+  const tapScriptSig = input.tapScriptSig;
+  if (!tapScriptSig || tapScriptSig.length === 0) {
+    throw new Error("exit path requires additional signers");
+  }
+  const [controlBlock] = path.leaf;
+  signed.updateInput(0, {
+    finalScriptWitness: [
+      tapScriptSig[0][1],
+      ...path.extraWitness,
+      scriptFromTapLeafScript(path.leaf),
+      TaprootControlBlock.encode(controlBlock)
+    ]
+  });
+  return { tx: signed, fee };
+}
+
+// src/wallet/exit/estimate.ts
+var CHILD_OUTPUT_DUST = 546;
+function stepFundingAmount(stepFee) {
+  return stepFee + CHILD_OUTPUT_DUST;
+}
+function resolveMode(opts) {
+  return opts.mode ?? "funded";
+}
+function resolveNetworkName(opts) {
+  if (opts.networkName) return opts.networkName;
+  const { bech32 } = opts.wallet.network;
+  if (bech32 === "bc") return "bitcoin";
+  if (bech32 === "bcrt") return "regtest";
+  return "testnet";
+}
+async function resolveFeeRate(opts) {
+  if (opts.feeRate) return Math.ceil(opts.feeRate);
+  const feeRate = await opts.wallet.onchainProvider.getFeeRate();
+  if (!feeRate || feeRate < OnchainWallet.MIN_FEE_RATE) return OnchainWallet.MIN_FEE_RATE;
+  return Math.ceil(feeRate);
+}
+async function selectExitVtxos(opts) {
+  if (!opts.vtxos) return opts.wallet.getVtxos();
+  const res = await opts.wallet.indexerProvider.getVtxos({ outpoints: opts.vtxos });
+  const tapTrees = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const vtxo of res.vtxos) {
+    if (vtxo.isSpent) continue;
+    let tapTree = tapTrees.get(vtxo.script);
+    if (!tapTree) {
+      const [contract] = await opts.wallet.contractRepository.getContracts({
+        script: vtxo.script
+      });
+      if (!contract) {
+        throw new Error(
+          `no contract registered for vtxo script ${vtxo.script} \u2014 register the contract before exiting`
+        );
       }
-    } else {
-      if (current.time >= confirmedAt.time + Number(exit.params.timelock.value)) {
-        return exit;
+      const handler = contractHandlers.get(contract.type);
+      if (!handler) {
+        throw new Error(`no contract handler registered for type '${contract.type}'`);
       }
+      tapTree = handler.createScript(contract.params).encode();
+      tapTrees.set(vtxo.script, tapTree);
     }
+    out.push({ txid: vtxo.txid, vout: vtxo.vout, value: vtxo.value, tapTree });
   }
-  return void 0;
+  return out;
+}
+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,
+    chain: resolver,
+    onchain: wallet.onchainProvider
+  });
+  const pendingNodes = dag.filter((n) => !n.confirmed);
+  const psbts = /* @__PURE__ */ new Map();
+  if (pendingNodes.length > 0) {
+    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(
+    TxWeightEstimator.create().addP2AInput().addKeySpendInput(true).addOutputAddress(onchainWallet.address, wallet.network).vsize().value
+  );
+  const rawSteps = pendingNodes.map((node) => {
+    const psbt = psbts.get(node.txid);
+    if (!psbt) {
+      throw new Error(`indexer did not return virtual tx ${node.txid}`);
+    }
+    const parent = finalizeVirtualTx(node.type, psbt);
+    const stepFee = Math.ceil(feeRate * (parent.vsize + childVsize));
+    return { node, parent, stepFee, funding: stepFundingAmount(stepFee) };
+  });
+  const parentInputTxids = (tx) => {
+    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;
+  };
+  const steps = topoSortByDeps(
+    rawSteps,
+    (s) => s.parent.id,
+    (s) => parentInputTxids(s.parent)
+  );
+  const walletPubKeyHex = hex.encode(await wallet.identity.xOnlyPublicKey());
+  const infos = [];
+  const sweeps = [];
+  for (const vtxo of vtxos) {
+    const outpoint = `${vtxo.txid}:${vtxo.vout}`;
+    try {
+      const resolved = await resolveUnilateralPath({
+        vtxo,
+        scriptHex: hex.encode(VtxoScript.decode(vtxo.tapTree).pkScript),
+        contractRepository: wallet.contractRepository,
+        walletPubKeyHex,
+        currentTime: Date.now()
+      });
+      const sweepFee = sweepFeeFor(
+        resolved.selection,
+        opts.sweepAddress,
+        wallet.network,
+        feeRate
+      );
+      if (vtxo.value - sweepFee < CHILD_OUTPUT_DUST) {
+        infos.push({
+          outpoint,
+          value: vtxo.value,
+          skipped: `uneconomic: value ${vtxo.value} <= sweep fee + dust`
+        });
+        continue;
+      }
+      const t = sequenceToTimelock(resolved.selection.sequence);
+      const delay = { type: t.type, value: Number(t.value) };
+      infos.push({ outpoint, value: vtxo.value, sweepFee, path: resolved.label, delay });
+      sweeps.push({ vtxo, resolved, sweepFee, delay });
+    } catch (e) {
+      if (e instanceof ExitPathError) {
+        infos.push({ outpoint, value: vtxo.value, skipped: e.message });
+        continue;
+      }
+      throw e;
+    }
+  }
+  const coins = (await onchainWallet.getCoins()).filter((c) => c.status.confirmed);
+  const balance = coins.reduce((sum, c) => sum + c.value, 0);
+  const fundingTotal = steps.reduce((sum, s) => sum + s.funding, 0);
+  const splitterFeeFor = (inputCount) => {
+    if (steps.length === 0) return 0;
+    const est = TxWeightEstimator.create();
+    for (let i = 0; i < inputCount; i++) est.addKeySpendInput(true);
+    for (let i = 0; i < steps.length + 1; i++) {
+      est.addOutputAddress(onchainWallet.address, wallet.network);
+    }
+    return Number(est.vsize().fee(BigInt(feeRate)));
+  };
+  const graph = resolveMode(opts) === "graph";
+  let splitterFee = 0;
+  if (!graph) {
+    splitterFee = splitterFeeFor(Math.max(1, coins.length));
+    if (steps.length > 0 && balance < fundingTotal + splitterFee) {
+      splitterFee = splitterFeeFor(coins.length + 1);
+    }
+  }
+  const stepFees = steps.reduce((s, x) => s + x.stepFee, 0);
+  const sweepFees = sweeps.reduce((s, x) => s + x.sweepFee, 0);
+  const totals = {
+    // graph: each unroll step is parent + a live-built child (2 txs), no
+    // splitter. funded: + 1 splitter tx and pre-signed children.
+    txCount: (graph ? 0 : steps.length > 0 ? 1 : 0) + steps.length * 2 + sweeps.length,
+    totalFeeSats: splitterFee + stepFees + sweepFees,
+    // graph funding is what the executor sends to its own fee address:
+    // just the CPFP fees (change recycles); funded also locks the
+    // per-child dust into the splitter.
+    fundingRequiredSats: graph ? stepFees : splitterFee + fundingTotal,
+    recoveredSats: sweeps.reduce((s, x) => s + (x.vtxo.value - x.sweepFee), 0)
+  };
+  const expiries = pendingNodes.map((n) => n.expiresAt).filter((x) => x !== void 0);
+  const validUntil = expiries.length > 0 ? Math.min(...expiries) : void 0;
+  return {
+    vtxos,
+    dag,
+    steps,
+    sweeps,
+    infos,
+    totals,
+    splitterFee,
+    validUntil,
+    balance,
+    coins
+  };
+}
+async function estimate(opts) {
+  const feeRate = await resolveFeeRate(opts);
+  const layout = await computeExitLayout(opts, feeRate);
+  if (resolveMode(opts) === "graph") {
+    return {
+      feeRate,
+      fundingAddress: "",
+      currentBalanceSats: 0,
+      shortfallSats: layout.totals.fundingRequiredSats,
+      validUntil: layout.validUntil,
+      totals: layout.totals,
+      vtxos: layout.infos
+    };
+  }
+  return {
+    feeRate,
+    fundingAddress: opts.onchainWallet.address,
+    currentBalanceSats: layout.balance,
+    shortfallSats: Math.max(0, layout.totals.fundingRequiredSats - layout.balance),
+    validUntil: layout.validUntil,
+    totals: layout.totals,
+    vtxos: layout.infos
+  };
+}
+
+// src/wallet/exit/executor.ts
+var Executor = class {
+  constructor(pkg, provider, opts) {
+    this.pkg = pkg;
+    this.provider = provider;
+    this.pollIntervalMs = opts?.pollIntervalMs ?? 5e3;
+    this.feeWallet = opts?.feeWallet;
+  }
+  pollIntervalMs;
+  feeWallet;
+  sleep() {
+    return new Promise((r) => setTimeout(r, this.pollIntervalMs));
+  }
+  async status(txid) {
+    try {
+      return await this.provider.getTxStatus(txid);
+    } catch {
+      return void 0;
+    }
+  }
+  async waitConfirmed(txid) {
+    for (; ; ) {
+      const s = await this.status(txid);
+      if (s?.confirmed) return s;
+      await this.sleep();
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    const dead = /* @__PURE__ */ new Set();
+    if (this.pkg.validUntil && Date.now() / 1e3 > this.pkg.validUntil) {
+      yield {
+        stepIndex: -1,
+        kind: "broadcast",
+        status: "warning",
+        reason: `package validUntil ${this.pkg.validUntil} has passed; the operator may have swept \u2014 attempting anyway`
+      };
+    }
+    const sweeps = [];
+    for (let i = 0; i < this.pkg.steps.length; i++) {
+      const step = this.pkg.steps[i];
+      if (step.kind === "sweep") {
+        sweeps.push({ index: i, step });
+        continue;
+      }
+      const forVtxos = step.kind === "package" || step.kind === "bump" ? step.forVtxos : void 0;
+      if (forVtxos && forVtxos.every((v) => dead.has(v))) {
+        yield {
+          stepIndex: i,
+          kind: step.kind,
+          status: "skipped",
+          forVtxos,
+          reason: "branch failed earlier"
+        };
+        continue;
+      }
+      const anchorTxid = step.kind === "package" || step.kind === "bump" ? step.parentTxid : step.txid;
+      const existing = await this.status(anchorTxid);
+      if (existing?.confirmed) {
+        yield {
+          stepIndex: i,
+          kind: step.kind,
+          status: "skipped",
+          txid: anchorTxid,
+          forVtxos
+        };
+        continue;
+      }
+      if (!existing) {
+        try {
+          if (step.kind === "package") {
+            await this.provider.broadcastTransaction(step.parentHex, step.childHex);
+          } else if (step.kind === "bump") {
+            if (!this.feeWallet) {
+              throw new Error(
+                "graph package requires a fee wallet (opts.feeWallet) to fund CPFP bumps"
+              );
+            }
+            const [parentHex, childHex] = await this.feeWallet.bumpAnchor(
+              step.parentHex,
+              this.pkg.feeRate
+            );
+            await this.provider.broadcastTransaction(parentHex, childHex);
+          } else {
+            await this.provider.broadcastTransaction(step.hex);
+          }
+          yield {
+            stepIndex: i,
+            kind: step.kind,
+            status: "broadcast",
+            txid: anchorTxid,
+            forVtxos
+          };
+        } catch (e) {
+          const reason = e instanceof Error ? e.message : String(e);
+          if (step.kind === "broadcast") {
+            for (const s of this.pkg.steps) {
+              if (s.kind === "package") s.forVtxos.forEach((v) => dead.add(v));
+            }
+          } else if (step.kind === "package" || step.kind === "bump") {
+            step.forVtxos.forEach((v) => dead.add(v));
+          }
+          yield {
+            stepIndex: i,
+            kind: step.kind,
+            status: "failed",
+            txid: anchorTxid,
+            forVtxos,
+            reason
+          };
+          continue;
+        }
+      }
+      await this.waitConfirmed(anchorTxid);
+      yield {
+        stepIndex: i,
+        kind: step.kind,
+        status: "confirmed",
+        txid: anchorTxid,
+        forVtxos
+      };
+    }
+    for (const { index, step } of sweeps) {
+      if (dead.has(step.vtxo)) {
+        yield {
+          stepIndex: index,
+          kind: "sweep",
+          status: "failed",
+          txid: step.txid,
+          forVtxos: [step.vtxo],
+          reason: "branch failed earlier"
+        };
+      }
+    }
+    const pending = sweeps.filter(({ step }) => !dead.has(step.vtxo));
+    const waitingAnnounced = /* @__PURE__ */ new Set();
+    const done = /* @__PURE__ */ new Set();
+    while (done.size < pending.length) {
+      for (const { index, step } of pending) {
+        if (done.has(index)) continue;
+        const swept = await this.status(step.txid);
+        if (swept?.confirmed) {
+          done.add(index);
+          yield {
+            stepIndex: index,
+            kind: "sweep",
+            status: "confirmed",
+            txid: step.txid,
+            forVtxos: [step.vtxo]
+          };
+          continue;
+        }
+        if (swept) continue;
+        const dep = await this.status(step.dependsOnTxid);
+        if (!dep?.confirmed) continue;
+        const tip = await this.provider.getChainTip();
+        const mature = step.delay.type === "blocks" ? tip.height >= (dep.blockHeight ?? 0) + step.delay.value : tip.time >= (dep.blockTime ?? 0) + step.delay.value;
+        if (!mature) {
+          if (!waitingAnnounced.has(index)) {
+            waitingAnnounced.add(index);
+            yield {
+              stepIndex: index,
+              kind: "sweep",
+              status: "waiting_csv",
+              txid: step.txid,
+              forVtxos: [step.vtxo],
+              ...step.delay.type === "blocks" ? { maturesAtHeight: (dep.blockHeight ?? 0) + step.delay.value } : { maturesAtTime: (dep.blockTime ?? 0) + step.delay.value }
+            };
+          }
+          continue;
+        }
+        try {
+          await this.provider.broadcastTransaction(step.hex);
+          yield {
+            stepIndex: index,
+            kind: "sweep",
+            status: "broadcast",
+            txid: step.txid,
+            forVtxos: [step.vtxo]
+          };
+        } catch (e) {
+          const reason = e instanceof Error ? e.message : String(e);
+          if (/non-?bip68|non-?final|premature/i.test(reason)) {
+            continue;
+          }
+          done.add(index);
+          yield {
+            stepIndex: index,
+            kind: "sweep",
+            status: "failed",
+            txid: step.txid,
+            forVtxos: [step.vtxo],
+            reason
+          };
+        }
+      }
+      if (done.size < pending.length) await this.sleep();
+    }
+  }
+};
+async function prepare(opts) {
+  const { wallet, onchainWallet } = opts;
+  const feeRate = await resolveFeeRate(opts);
+  const mode = resolveMode(opts);
+  if (mode === "funded") {
+    const walletKey = await wallet.identity.xOnlyPublicKey();
+    if (hex.encode(onchainWallet.onchainP2TR.tapInternalKey) !== hex.encode(walletKey)) {
+      throw new Error("onchainWallet must share the wallet identity");
+    }
+  }
+  const layout = await computeExitLayout(opts, feeRate);
+  const sweepSteps = [];
+  const activeOutpoints = /* @__PURE__ */ new Set();
+  for (const sweep of layout.sweeps) {
+    const outpoint = `${sweep.vtxo.txid}:${sweep.vtxo.vout}`;
+    try {
+      const { tx } = await buildSignedSweep({
+        vtxo: {
+          txid: sweep.vtxo.txid,
+          vout: sweep.vtxo.vout,
+          value: sweep.vtxo.value,
+          pkScript: VtxoScript.decode(sweep.vtxo.tapTree).pkScript
+        },
+        path: sweep.resolved.selection,
+        outputAddress: opts.sweepAddress,
+        feeRate,
+        network: wallet.network,
+        identity: wallet.identity
+      });
+      activeOutpoints.add(outpoint);
+      sweepSteps.push({
+        kind: "sweep",
+        vtxo: outpoint,
+        txid: tx.id,
+        hex: tx.hex,
+        dependsOnTxid: sweep.vtxo.txid,
+        delay: sweep.delay
+      });
+    } catch (e) {
+      const info = layout.infos.find((i) => i.outpoint === outpoint);
+      if (info) {
+        info.skipped = e instanceof Error ? e.message : String(e);
+        delete info.sweepFee;
+        delete info.path;
+        delete info.delay;
+      }
+    }
+  }
+  const steps = layout.steps.filter((s) => s.node.forVtxos.some((v) => activeOutpoints.has(v)));
+  if (steps.length === 0 && sweepSteps.length === 0) {
+    throw new Error("no exitable vtxos (all skipped)");
+  }
+  if (mode === "graph") {
+    const bumpSteps = steps.map((step) => ({
+      kind: "bump",
+      parentTxid: step.parent.id,
+      parentHex: step.parent.hex,
+      forVtxos: step.node.forVtxos.filter((v) => activeOutpoints.has(v))
+    }));
+    const stepFees2 = steps.reduce((s, x) => s + x.stepFee, 0);
+    const activeInfos2 = layout.infos.filter((i) => !i.skipped);
+    const sweepFees2 = activeInfos2.reduce((s, i) => s + (i.sweepFee ?? 0), 0);
+    const recovered2 = activeInfos2.reduce((s, i) => s + (i.value ?? 0) - (i.sweepFee ?? 0), 0);
+    return {
+      version: 1,
+      mode: "graph",
+      network: resolveNetworkName(opts),
+      createdAt: Math.floor(Date.now() / 1e3),
+      validUntil: layout.validUntil,
+      feeRate,
+      sweepAddress: opts.sweepAddress,
+      totals: {
+        txCount: bumpSteps.length * 2 + sweepSteps.length,
+        totalFeeSats: stepFees2 + sweepFees2,
+        fundingRequiredSats: stepFees2,
+        recoveredSats: recovered2
+      },
+      vtxos: layout.infos,
+      steps: [...bumpSteps, ...sweepSteps]
+    };
+  }
+  const packageSteps = [];
+  let broadcastStep;
+  let splitterFee = 0;
+  if (steps.length > 0) {
+    const fundingTotal = steps.reduce((sum, s) => sum + s.funding, 0);
+    let selected = { inputs: [], changeAmount: 0n };
+    for (let i = 0; i < 10; i++) {
+      const target = fundingTotal + splitterFee;
+      try {
+        selected = selectCoins(layout.coins, target);
+      } catch {
+        throw new Error(
+          `insufficient confirmed onchain funds: need ${target} sats, have ${layout.balance} (deposit the shortfall to ${onchainWallet.address})`
+        );
+      }
+      const est = TxWeightEstimator.create();
+      for (const _ of selected.inputs) est.addKeySpendInput(true);
+      for (const _ of steps) est.addOutputAddress(onchainWallet.address, wallet.network);
+      if (selected.changeAmount >= BigInt(DUST_AMOUNT)) {
+        est.addOutputAddress(onchainWallet.address, wallet.network);
+      }
+      const newFee = Number(est.vsize().fee(BigInt(feeRate)));
+      if (newFee <= splitterFee) break;
+      splitterFee = newFee;
+    }
+    const splitter = new Transaction({ version: 2 });
+    for (const coin of selected.inputs) {
+      splitter.addInput({
+        txid: coin.txid,
+        index: coin.vout,
+        witnessUtxo: {
+          script: onchainWallet.onchainP2TR.script,
+          amount: BigInt(coin.value)
+        },
+        tapInternalKey: onchainWallet.onchainP2TR.tapInternalKey
+      });
+    }
+    for (const step of steps) {
+      splitter.addOutputAddress(onchainWallet.address, BigInt(step.funding), wallet.network);
+    }
+    const inputSum = selected.inputs.reduce((s, c) => s + c.value, 0);
+    const change = BigInt(inputSum - fundingTotal - splitterFee);
+    if (change < 0n) {
+      throw new Error(
+        `insufficient confirmed onchain funds for the splitter fee: need ${fundingTotal + splitterFee} sats, have ${inputSum} (deposit the shortfall to ${onchainWallet.address})`
+      );
+    }
+    if (change >= BigInt(DUST_AMOUNT)) {
+      splitter.addOutputAddress(onchainWallet.address, change, wallet.network);
+    } else if (change > 0n) {
+      splitterFee += Number(change);
+    }
+    const signedSplitter = await wallet.identity.sign(splitter);
+    signedSplitter.finalize();
+    for (let k = 0; k < steps.length; k++) {
+      const step = steps[k];
+      const { child } = buildAnchorChild({
+        parent: step.parent,
+        feeRate,
+        fundingCoins: [{ txid: signedSplitter.id, vout: k, value: step.funding }],
+        changeAddress: onchainWallet.address,
+        changeScript: onchainWallet.onchainP2TR.script,
+        tapInternalKey: onchainWallet.onchainP2TR.tapInternalKey,
+        network: wallet.network
+      });
+      const signedChild = await wallet.identity.sign(child);
+      for (let i = 1; i < signedChild.inputsLength; i++) {
+        signedChild.finalizeIdx(i);
+      }
+      packageSteps.push({
+        kind: "package",
+        parentTxid: step.parent.id,
+        parentHex: step.parent.hex,
+        childTxid: signedChild.id,
+        childHex: signedChild.hex,
+        forVtxos: step.node.forVtxos.filter((v) => activeOutpoints.has(v))
+      });
+    }
+    broadcastStep = { kind: "broadcast", txid: signedSplitter.id, hex: signedSplitter.hex };
+    await onchainWallet.provider.broadcastTransaction(signedSplitter.hex);
+  }
+  const stepFees = steps.reduce((s, x) => s + x.stepFee, 0);
+  const activeInfos = layout.infos.filter((i) => !i.skipped);
+  const sweepFees = activeInfos.reduce((s, i) => s + (i.sweepFee ?? 0), 0);
+  const recovered = activeInfos.reduce((s, i) => s + (i.value ?? 0) - (i.sweepFee ?? 0), 0);
+  const fundingRequired = splitterFee + steps.reduce((s, x) => s + x.funding, 0);
+  return {
+    version: 1,
+    mode: "funded",
+    network: resolveNetworkName(opts),
+    createdAt: Math.floor(Date.now() / 1e3),
+    validUntil: layout.validUntil,
+    feeRate,
+    sweepAddress: opts.sweepAddress,
+    totals: {
+      txCount: (broadcastStep ? 1 : 0) + packageSteps.length * 2 + sweepSteps.length,
+      totalFeeSats: splitterFee + stepFees + sweepFees,
+      fundingRequiredSats: fundingRequired,
+      recoveredSats: recovered
+    },
+    vtxos: layout.infos,
+    steps: [...broadcastStep ? [broadcastStep] : [], ...packageSteps, ...sweepSteps]
+  };
+}
+
+// src/wallet/exit/types.ts
+function serializeExitPackage(pkg) {
+  return JSON.stringify(pkg);
+}
+function deserializeExitPackage(json) {
+  const data = JSON.parse(json);
+  if (data?.version !== 1) {
+    throw new Error(`unsupported exit package version: ${data?.version}`);
+  }
+  if (typeof data.network !== "string" || typeof data.sweepAddress !== "string") {
+    throw new Error("invalid exit package: missing network or sweepAddress");
+  }
+  if (typeof data.feeRate !== "number" || typeof data.createdAt !== "number") {
+    throw new Error("invalid exit package: missing feeRate or createdAt");
+  }
+  if (!Array.isArray(data.steps) || !Array.isArray(data.vtxos)) {
+    throw new Error("invalid exit package: steps and vtxos must be arrays");
+  }
+  if (!isValidTotals(data.totals)) {
+    throw new Error("invalid exit package: malformed totals");
+  }
+  for (const step of data.steps) {
+    if (!isValidStep(step)) {
+      throw new Error(`invalid step: ${JSON.stringify(step)}`);
+    }
+  }
+  return data;
 }
+function isValidDelay(d) {
+  const delay = d;
+  return !!delay && (delay.type === "blocks" || delay.type === "seconds") && typeof delay.value === "number";
+}
+function isValidTotals(t) {
+  const totals = t;
+  return !!totals && typeof totals === "object" && typeof totals.txCount === "number" && typeof totals.totalFeeSats === "number" && typeof totals.fundingRequiredSats === "number" && typeof totals.recoveredSats === "number";
+}
+function isValidStep(step) {
+  const s = step;
+  if (!s || typeof s !== "object") return false;
+  switch (s.kind) {
+    case "broadcast":
+      return typeof s.txid === "string" && typeof s.hex === "string";
+    case "package":
+      return typeof s.parentTxid === "string" && typeof s.parentHex === "string" && typeof s.childTxid === "string" && typeof s.childHex === "string" && Array.isArray(s.forVtxos);
+    case "bump":
+      return typeof s.parentTxid === "string" && typeof s.parentHex === "string" && Array.isArray(s.forVtxos);
+    case "sweep":
+      return typeof s.vtxo === "string" && typeof s.txid === "string" && typeof s.hex === "string" && typeof s.dependsOnTxid === "string" && isValidDelay(s.delay);
+    default:
+      return false;
+  }
+}
+
+// src/wallet/exit/index.ts
+var UnilateralExit = {
+  estimate,
+  prepare,
+  Executor
+};
 var ARKCONTRACT_PREFIX = "arkcontract";
 function encodeArkContract(contract) {
   const params = new URLSearchParams();
@@ -16847,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, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createDefaultActivityRegistry, decodeArkContract, deserializeAssets, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isExpired, isRecoverable, isSpendable, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, serializeAssets, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-B4R36PRN.js.map
-//# sourceMappingURL=chunk-B4R36PRN.js.map
+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