@arkade-os/sdk 0.4.42 → 0.4.44

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