@arkade-os/sdk 0.4.66 → 0.4.68

package/dist/{chunk-DSC3G6QZ.js → chunk-VBHXBI7F.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-2JZGPXU4.js';
-import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, toXOnly, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, parseHDDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler, identityDescriptor } from './chunk-CYOI4PEA.js';
-import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, resolveEmulatorPubkey, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, toVirtualStatus, ArkError, TapTreeCoder, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-J33ZEM3A.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-33Q2RFET.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, toXOnly, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-45FKMOJH.js';
+import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, resolveEmulatorPubkey, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, assertAllowedSighashTypes, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, formatSighash, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, toVirtualStatus, ArkError, TapTreeCoder, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, PrevoutTxField, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-4CMXV5SF.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { sha256 as sha256$1, equalBytes, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr } from '@scure/btc-signer/utils.js';
 import { SigHash, Script, OP, OutScript, Address, RawWitness, p2tr, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$2 } from '@scure/btc-signer';
@@ -272,7 +272,7 @@ function getPrevOutput(finalKey, graph, sharedOutputAmount, tx) {
     script: pkScript
   };
 }
-var ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
+var ALLOWED_SIGHASH = [SigHash.DEFAULT, SigHash.ALL, SigHash.ALL_ANYONECANPAY];
 var SingleKey = class _SingleKey {
   key;
   constructor(key) {
@@ -301,8 +301,9 @@ var SingleKey = class _SingleKey {
   async sign(tx, inputIndexes) {
     const txCpy = tx.clone();
     if (!inputIndexes) {
+      assertAllowedSighashTypes(txCpy, ALLOWED_SIGHASH);
       try {
-        if (!txCpy.sign(this.key, ALL_SIGHASH)) {
+        if (!txCpy.sign(this.key, ALLOWED_SIGHASH)) {
           throw new Error("Failed to sign transaction");
         }
       } catch (e) {
@@ -313,7 +314,7 @@ var SingleKey = class _SingleKey {
       return txCpy;
     }
     for (const inputIndex of inputIndexes) {
-      if (!txCpy.signIdx(this.key, inputIndex, ALL_SIGHASH)) {
+      if (!txCpy.signIdx(this.key, inputIndex, ALLOWED_SIGHASH)) {
         throw new Error(`Failed to sign input #${inputIndex}`);
       }
     }
@@ -378,7 +379,7 @@ var ReadonlySingleKey = class _ReadonlySingleKey {
     return Promise.resolve(this.publicKey);
   }
 };
-var ALL_SIGHASH2 = Object.values(SigHash).filter((x) => typeof x === "number");
+var ALLOWED_SIGHASH2 = [SigHash.DEFAULT, SigHash.ALL, SigHash.ALL_ANYONECANPAY];
 var seedBytes = /* @__PURE__ */ new WeakMap();
 var mnemonicMeta = /* @__PURE__ */ new WeakMap();
 var SeedIdentity = class _SeedIdentity {
@@ -581,8 +582,9 @@ var SeedIdentity = class _SeedIdentity {
   signTxWithKey(tx, key, inputIndexes) {
     const txCpy = tx.clone();
     if (!inputIndexes) {
+      assertAllowedSighashTypes(txCpy, ALLOWED_SIGHASH2);
       try {
-        if (!txCpy.sign(key, ALL_SIGHASH2)) {
+        if (!txCpy.sign(key, ALLOWED_SIGHASH2)) {
           throw new Error("Failed to sign transaction");
         }
       } catch (e) {
@@ -592,7 +594,7 @@ var SeedIdentity = class _SeedIdentity {
       }
     } else {
       for (const idx of inputIndexes) {
-        if (!txCpy.signIdx(key, idx, ALL_SIGHASH2)) {
+        if (!txCpy.signIdx(key, idx, ALLOWED_SIGHASH2)) {
           throw new Error(`Failed to sign input #${idx}`);
         }
       }
@@ -917,6 +919,12 @@ var ForeignDescriptorError = class extends Error {
   descriptor;
   name = "ForeignDescriptorError";
 };
+var WalletCannotAllocateAddressError = class extends Error {
+  name = "WalletCannotAllocateAddressError";
+  constructor(reason, options) {
+    super(`cannot allocate a fresh address: ${reason}`, options);
+  }
+};
 async function resolveDescriptorSigner(descriptor, identity, provider) {
   const owner = provider?.isOurs(descriptor) ? provider : isHDCapableIdentity(identity) && identity.isOurs(descriptor) ? identity : void 0;
   if (owner && parseHDDescriptor(descriptor)) {
@@ -941,6 +949,10 @@ function isHDAllocationCapable(value) {
   const v = value;
   return typeof v.getNextSigningDescriptor === "function" && typeof v.advanceSigningDescriptorWatermark === "function";
 }
+function isAddressAllocationCapable(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return typeof value.getNewAddresses === "function";
+}
 
 // ../../node_modules/@noble/hashes/utils.js
 function isBytes(a) {
@@ -1302,15 +1314,26 @@ async function provisionDescriptor(wallet) {
   return allocated ?? await identityDescriptor(wallet.identity);
 }
 async function provisionRefundKey(wallet) {
-  const descriptor = await provisionDescriptor(wallet);
+  const descriptor = await identityDescriptor(wallet.identity);
   const signer = await contractSigner(wallet, descriptor);
-  return { descriptor, pubkey: await signer.xOnlyPublicKey() };
+  const pubkey = await signer.xOnlyPublicKey();
+  const identityPubkey = await wallet.identity.xOnlyPublicKey();
+  if (!equalBytes(pubkey, identityPubkey)) {
+    throw new Error(
+      "provisionRefundKey: descriptor pubkey does not match wallet identity \u2014 the refund key and the refund address would be on different keys"
+    );
+  }
+  const address = await wallet.getAddress();
+  const { pkScript } = ArkAddress.decode(address);
+  return { descriptor, pubkey, pkScript, address };
 }
 async function provisionClaimSecret(wallet, opts = {}) {
   if (opts.preimage && opts.preimage.length !== 32) {
     throw new Error(`preimage must be 32 bytes, got ${opts.preimage.length}`);
   }
-  const { descriptor, pubkey } = await provisionRefundKey(wallet);
+  const descriptor = await provisionDescriptor(wallet);
+  const signer = await contractSigner(wallet, descriptor);
+  const pubkey = await signer.xOnlyPublicKey();
   const claim = async () => {
     if (opts.preimage) return { preimage: opts.preimage, mustPersistPreimage: true };
     if (isPerArtifactDescriptor(descriptor)) {
@@ -1610,8 +1633,6 @@ var RestDelegatorProvider = RestDelegateProvider;
 function isDelegateInfo(data) {
   return !!data && typeof data === "object" && "pubkey" in data && "fee" in data && typeof data.pubkey === "string" && typeof data.fee === "string" && data.pubkey !== "" && data.fee !== "" && (typeof data.delegateAddress === "string" && data.delegateAddress !== "" || typeof data.delegatorAddress === "string" && data.delegatorAddress !== "");
 }
-
-// src/providers/onchain.ts
 var ESPLORA_URL = {
   bitcoin: "https://mempool.arkade.sh/api",
   testnet: "https://mempool.space/testnet/api",
@@ -1672,6 +1693,14 @@ var EsploraProvider = class {
     }
     return response.json();
   }
+  async getRawTransaction(txid) {
+    const response = await baseFetch(`${this.baseUrl}/tx/${txid}/hex`);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to get raw transaction ${txid}: ${error}`);
+    }
+    return hex.decode((await response.text()).trim());
+  }
   async getTxStatus(txid) {
     const txresponse = await baseFetch(`${this.baseUrl}/tx/${txid}`);
     if (!txresponse.ok) {
@@ -1795,7 +1824,9 @@ var EsploraProvider = class {
       const error = await response.text();
       throw new Error(`Failed to broadcast package: ${error}`);
     }
-    return response.json();
+    const result = await response.json();
+    assertPackageAccepted(result);
+    return result;
   }
   async broadcastTx(tx) {
     const response = await baseFetch(`${this.baseUrl}/tx`, {
@@ -1812,6 +1843,24 @@ var EsploraProvider = class {
     return response.text();
   }
 };
+function assertPackageAccepted(result) {
+  if (!result || typeof result !== "object") return;
+  const r = result;
+  const msg = typeof r.package_msg === "string" ? r.package_msg : void 0;
+  if (msg === void 0 || msg === "success") return;
+  const reasons = [];
+  const results = r["tx-results"];
+  if (results && typeof results === "object") {
+    for (const entry of Object.values(results)) {
+      if (!entry || typeof entry !== "object" || entry.error === void 0) continue;
+      const txid = typeof entry.txid === "string" ? entry.txid : "unknown tx";
+      reasons.push(`${txid}: ${String(entry.error)}`);
+    }
+  }
+  throw new Error(
+    reasons.length > 0 ? `Package rejected (${msg}) \u2014 ${reasons.join("; ")}` : `Package rejected (${msg})`
+  );
+}
 function isValidBlocksTip(tip) {
   return Array.isArray(tip) && tip.every((t) => {
     return t && typeof t === "object" && typeof t.id === "string" && t.id.length > 0 && typeof t.height === "number" && t.height >= 0 && typeof t.mediantime === "number" && t.mediantime > 0;
@@ -3038,9 +3087,6 @@ function hasBoardingTxExpired(coin, boardingTimelock, chainTipHeight) {
   const blockTime = BigInt(Math.floor(coin.status.block_time));
   return blockTime + boardingTimelock.value <= now;
 }
-function formatSighash(type) {
-  return `0x${type.toString(16).padStart(2, "0")}`;
-}
 function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, excludePubkeys = [], allowedSighashTypes = [SigHash.DEFAULT], expectedLeafHash) {
   const input = tx.getInput(inputIndex);
   const prevoutScripts = [];
@@ -3258,6 +3304,15 @@ async function submitOffchainTx(provider, offchainTx, signer, hooks, options) {
   assertSubmittedArkTxid(response, signedArkTx, "submitTx");
   const { arkTxid, signedCheckpointTxs } = response;
   const matched = matchServerCheckpoints(signedCheckpointTxs, offchainTx.checkpoints, "submitTx");
+  matched.forEach(({ server }, index) => {
+    try {
+      assertAllowedSighashTypes(server);
+    } catch (error) {
+      throw new ServerResponseMismatchError(
+        `submitTx checkpoint ${index}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  });
   const verify = options?.verifyServerSignatures;
   if (verify) {
     if (response.finalArkTx === void 0) {
@@ -3709,7 +3764,9 @@ function selectPendingRecoveryOutpoints(contractsWithVtxos, signerSet, nowSecond
       continue;
     }
     for (const v of vtxos) {
-      if (!hasTerminalSpend(v) && !v.isSwept) out.add(`${v.txid}:${v.vout}`);
+      if (!hasTerminalSpend(v) && !v.isSwept && !v.isUnrolled) {
+        out.add(`${v.txid}:${v.vout}`);
+      }
     }
   }
   return out;
@@ -3857,6 +3914,7 @@ function getRecoverableWithSubdust(vtxos, dustAmount, now) {
   };
 }
 function isVtxoExpiringSoon(vtxo, thresholdMs) {
+  if (vtxo.isUnrolled) return false;
   const realThresholdMs = thresholdMs <= 100 ? DEFAULT_THRESHOLD_MS : thresholdMs;
   const expiresAt = normalizeVtxo(vtxo).expiresAt;
   if (expiresAt === void 0) return false;
@@ -3867,7 +3925,9 @@ function isVtxoExpiringSoon(vtxo, thresholdMs) {
 }
 function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount, now) {
   return vtxos.filter(
-    (vtxo) => isVtxoExpiringSoon(vtxo, thresholdMs) || canRecoverOnchain(vtxo, now) || isSubdust(vtxo, dustAmount)
+    // The leading exclusion covers the `isSubdust` arm too, which is a value
+    // property and would otherwise re-admit an exited coin on its own.
+    (vtxo) => !vtxo.isUnrolled && (isVtxoExpiringSoon(vtxo, thresholdMs) || canRecoverOnchain(vtxo, now) || isSubdust(vtxo, dustAmount))
   );
 }
 function isMigrationCapable(wallet) {
@@ -4518,6 +4578,7 @@ var VtxoManager = class _VtxoManager {
   async getDeprecatedSignerStatus() {
     const wallet = this.requireMigrationCapableWallet();
     const info = await wallet.arkProvider.getInfo();
+    await wallet.settleServerInfoChanges?.();
     const { reports: vtxoReports } = await this.classifyDeprecatedSignerContracts(info);
     const { reports: boardingReports } = await this.classifyDeprecatedSignerBoarding(info);
     return mergeSignerReports(vtxoReports, boardingReports);
@@ -4531,26 +4592,33 @@ var VtxoManager = class _VtxoManager {
    */
   async migrateCore(options) {
     const wallet = this.requireMigrationCapableWallet();
+    const signerBeforeRefresh = hex.encode(wallet.arkServerPublicKey);
     const info = await wallet.arkProvider.getInfo();
+    await wallet.settleServerInfoChanges?.();
+    const rotatedOnRefresh = signerBeforeRefresh !== hex.encode(wallet.arkServerPublicKey);
     wallet.refreshDeprecatedSigners(info);
     const signerSet = signerSetFromInfo(info);
     const nowSeconds = Math.floor(Date.now() / 1e3);
     const walletSignerHex = hex.encode(wallet.arkServerPublicKey);
     const walletClass = classifyAgainstSignerSet(walletSignerHex, signerSet, nowSeconds);
     if (signerSet.deprecated.size === 0 && walletClass.status === "CURRENT") {
-      return { rotated: false, expired: [], signers: [] };
+      return { rotated: rotatedOnRefresh, expired: [], signers: [] };
     }
     if (walletClass.status === "UNKNOWN_SIGNER") {
       const { reports: vtxoReports2 } = await this.classifyDeprecatedSignerContracts(info);
       const { reports: boardingReports2 } = await this.classifyDeprecatedSignerBoarding(info);
       return {
-        rotated: false,
+        // Normally false here — a drained rotation targets the active
+        // signer, which classifies CURRENT, not UNKNOWN. It is true only
+        // when a second rotation landed inside the drain, leaving us on a
+        // signer newer than `info`: still a rotation this pass applied.
+        rotated: rotatedOnRefresh,
         expired: [],
         signers: mergeSignerReports(vtxoReports2, boardingReports2),
         skipped: "unknown-wallet-signer"
       };
     }
-    const rotated = await this.ensureReceiveOnActiveSigner(info);
+    const rotated = await this.ensureReceiveOnActiveSigner(info) || rotatedOnRefresh;
     const {
       reports: vtxoReports,
       migratable: vtxoMigratable,
@@ -4719,8 +4787,9 @@ var VtxoManager = class _VtxoManager {
       if (!serverPubKey) continue;
       const cls = classifyAgainstSignerSet(serverPubKey, signerSet, nowSeconds);
       if (cls.status === "CURRENT") continue;
-      const recoverable = vtxos.filter((v) => v.isSwept && !hasTerminalSpend(v));
-      const spendable = vtxos.filter((v) => !hasTerminalSpend(v) && !v.isSwept);
+      const live = vtxos.filter((v) => !v.isUnrolled);
+      const recoverable = live.filter((v) => v.isSwept && !hasTerminalSpend(v));
+      const spendable = live.filter((v) => !hasTerminalSpend(v) && !v.isSwept);
       const value = spendable.reduce((sum, v) => sum + v.value, 0);
       let recoverableCount = 0;
       let recoverableValue = 0;
@@ -6390,6 +6459,13 @@ var TxTree = class {
     if (nbOfInputs !== 1) {
       throw new Error(`unexpected number of inputs: ${nbOfInputs}, expected 1`);
     }
+    if (this.root.lockTime !== 0) {
+      throw new Error(`unexpected locktime: ${this.root.lockTime}, expected 0`);
+    }
+    const sequence = this.root.getInput(0).sequence;
+    if (sequence !== void 0 && sequence !== DEFAULT_SEQUENCE) {
+      throw new Error(`unexpected sequence: ${sequence}, expected ${DEFAULT_SEQUENCE}`);
+    }
     if (this.children.size > nbOfOutputs - 1) {
       throw new Error(
         `unexpected number of children: ${this.children.size}, expected maximum ${nbOfOutputs - 1}`
@@ -8985,7 +9061,7 @@ 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);
+  return vtxo !== void 0 && hasTerminalSpend(vtxo);
 }
 async function classifyIntent(intent, vtxosByOutpoint, now) {
   if (isTerminalIntentState(intent.state)) return void 0;
@@ -8995,6 +9071,11 @@ async function classifyIntent(intent, vtxosByOutpoint, now) {
     const commitmentTransactionId = intent.commitmentTransactionId ?? consumed.map((v) => v?.settledBy).find((s) => !!s);
     return terminal(intent, "batch_succeeded", now, { commitmentTransactionId });
   }
+  if (consumed.some((vtxo) => vtxo?.isUnrolled)) {
+    return terminal(intent, "cancelled", now, {
+      cancellationReason: "reconciliation: an input was unilaterally exited"
+    });
+  }
   if (intent.state === "waiting_to_submit") {
     return terminal(intent, "cancelled", now, {
       cancellationReason: "reconciliation: intent was never submitted before restart"
@@ -11604,7 +11685,9 @@ var WalletReceiveRotator = class _WalletReceiveRotator {
     const { tapscript: newTapscript, params } = buildReceiveContract(
       wallet.offchainTapscript,
       descriptor,
-      wallet.network.hrp);
+      wallet.network.hrp,
+      true
+    );
     const newScript = params.script;
     const manager = await wallet.getContractManager();
     await manager.createContract(params);
@@ -11646,7 +11729,7 @@ function buildReceiveContract(current, descriptor, hrp, tagSource) {
     // index-0 key. Without it, spends produce unsigned PSBTs that the
     // server rejects with `INVALID_PSBT_INPUT (5): missing tapscript spend sig`.
     metadata: {
-      ...{ source: WALLET_RECEIVE_SOURCE },
+      ...tagSource && { source: WALLET_RECEIVE_SOURCE },
       signingDescriptor: descriptor
     }
   };
@@ -11730,6 +11813,7 @@ function computeOffchainBalance(vtxos, caps) {
   let intentLocked = 0;
   let recoverable = 0;
   let pendingRecovery = 0;
+  let unrolled = 0;
   const owned = /* @__PURE__ */ new Map();
   const spendable = /* @__PURE__ */ new Map();
   const addAssets = (into, vtxo) => {
@@ -11740,6 +11824,10 @@ function computeOffchainBalance(vtxos, caps) {
   for (const vtxo of vtxos) {
     if (hasTerminalSpend(vtxo)) continue;
     addAssets(owned, vtxo);
+    if (vtxo.isUnrolled) {
+      unrolled += vtxo.value;
+      continue;
+    }
     if (isPendingRecovery(vtxo)) {
       pendingRecovery += vtxo.value;
       continue;
@@ -11772,7 +11860,8 @@ function computeOffchainBalance(vtxos, caps) {
     intentLocked,
     recoverable,
     pendingRecovery,
-    total: settled + preconfirmed + recoverable + pendingRecovery,
+    unrolled,
+    total: settled + preconfirmed + recoverable + pendingRecovery + unrolled,
     assets: toAssets(owned),
     availableAssets: toAssets(spendable)
   };
@@ -11995,16 +12084,20 @@ function filterSnapshotVtxos(snapshot, filter, pendingSpendOutpoints) {
     if (pendingSpendOutpoints.has(`${vtxo.txid}:${vtxo.vout}`)) {
       return false;
     }
-    if (!hasTerminalSpend(vtxo)) {
-      if (!f.withRecoverable && canRecoverOnchain(vtxo, now)) {
-        return false;
-      }
-      return true;
+    if (vtxo.isUnrolled) {
+      return !!f.withUnrolled;
+    }
+    if (hasTerminalSpend(vtxo)) {
+      return false;
+    }
+    if (!f.withRecoverable && canRecoverOnchain(vtxo, now)) {
+      return false;
     }
-    return !!(f.withUnrolled && vtxo.isUnrolled);
+    return true;
   });
 }
 var PENDING_RECOVERY_REASON = "is past its operator signer's rotation cutoff \u2014 the operator will not co-sign it until it recovers";
+var UNROLLED_REASON = "was unilaterally exited and lives onchain \u2014 `Unroll.completeUnroll` is the only spend that reaches it";
 function omittedOutpoints(before, after) {
   if (before.length === after.length) return /* @__PURE__ */ new Set();
   const kept = new Set(after.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`));
@@ -12504,7 +12597,11 @@ var ReadonlyWallet = class _ReadonlyWallet {
       this.getBoardingUtxos(),
       this.contractSnapshot()
     ]);
-    const vtxos = filterSnapshotVtxos(snapshot, void 0, this._pendingSpendOutpoints);
+    const vtxos = filterSnapshotVtxos(
+      snapshot,
+      { withRecoverable: true, withUnrolled: true },
+      this._pendingSpendOutpoints
+    );
     let confirmed = 0;
     let unconfirmed = 0;
     for (const utxo of boardingUtxos) {
@@ -12532,6 +12629,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       intentLocked: offchain.intentLocked,
       recoverable: offchain.recoverable,
       pendingRecovery: offchain.pendingRecovery,
+      unrolled: offchain.unrolled,
       total: totalBoarding + offchain.total,
       assets: offchain.assets,
       availableAssets: offchain.availableAssets
@@ -12572,6 +12670,13 @@ var ReadonlyWallet = class _ReadonlyWallet {
         "is locked by an in-flight settlement intent"
       )
     ]);
+    if (!filter?.withUnrolled) {
+      logExcludedVtxos(
+        "getSpendableVtxos",
+        snapshot.flatMap((contract) => contract.vtxos).filter((vtxo) => vtxo.isUnrolled && !hasTerminalSpend(vtxo)),
+        [() => UNROLLED_REASON]
+      );
+    }
     return unlocked;
   }
   /**
@@ -13391,6 +13496,27 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       console.warn("server-signer rotation on info change failed", e);
     }
   }
+  /**
+   * Await an `onServerInfoChanged` handler still applying a rotation.
+   *
+   * The provider emits synchronously but {@link handleServerInfoChanged} runs
+   * off the emit, so between the two a caller can observe a half-applied
+   * rotation: {@link rotateServerSigner} persists the active signer's contract
+   * rows *before* committing the tapscripts, so `arkServerPublicKey` still
+   * reads the old key while the new key's rows are already in the repository.
+   * A path that refreshes server info and then reads signer-derived state must
+   * drain the chain first, or it both reads that torn state and races the
+   * handler for the rotation itself.
+   *
+   * Resolves once the chain is idle; a handler that threw already logged, and
+   * its rejection is swallowed here.
+   *
+   * @internal Invoked by {@link dispose} and the {@link VtxoManager} migration
+   * pass; not part of the stable public API.
+   */
+  async settleServerInfoChanges() {
+    await this._serverInfoInFlight?.catch(() => void 0);
+  }
   _receiveRotatorInstalled = false;
   /**
    * Descriptor-aware signer used by {@link _signerRouter} to sign
@@ -13525,43 +13651,250 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    * provider and keeps a single index-0 boarding address for its lifetime,
    * so this returns the existing {@link getBoardingAddress} unchanged
    * (no rotation, no index burned).
+   *
+   * **Behaviour change.** A wallet configured with a custom
+   * {@link DescriptorProvider} (`walletMode: <provider>`) now rotates here.
+   * It previously did not: allocation went through the contract manager,
+   * which only wires an `allocate` hook for {@link HDDescriptorProvider}, so
+   * such a wallet read as "declined to allocate" and silently kept its
+   * index-0 boarding address forever. Those wallets now burn an index per
+   * call — including via {@link maybeRotateBoardingAfterBoard}, which fires
+   * on every settle that consumes a boarding UTXO. Funds at retired
+   * addresses stay reachable: each rotation persists its `boarding` contract
+   * before swapping, and {@link getBoardingUtxos} fans out over the full
+   * historical set.
+   *
+   * @deprecated Use {@link getNewAddresses} — it mints any combination of
+   * address types at one shared index, and reports the contract row behind
+   * each. Note the difference in display behaviour: this method *swaps* the
+   * advertised boarding address, where `getNewAddresses` mints side
+   * addresses and leaves {@link getBoardingAddress} alone. To keep this
+   * method's behaviour, keep calling this method.
    */
   async getNewBoardingAddress() {
-    const provider = this._descriptorProvider;
-    if (!provider) {
-      return this.getBoardingAddress();
+    const [minted] = await this.allocateAddresses(["boarding"], false, true);
+    if (!minted?.allocated) return this.getBoardingAddress();
+    if (minted.type === "boarding") this.setBoardingTapscriptForRotation(minted.tapscript);
+    return minted.address;
+  }
+  /**
+   * Allocate a *fresh* address of each requested type, all derived from one
+   * newly allocated HD index.
+   *
+   * This is the explicit allocator the receive path otherwise lacks:
+   * {@link getAddress} and {@link getBoardingAddress} are stable reads of the
+   * wallet's display addresses, and the display receive address only advances
+   * when a payment arrives ({@link WalletReceiveRotator} rotates on
+   * `vtxo_received`). Issuing a second address before the first is paid — one
+   * invoice for Alice, another for Bob — has to go through here.
+   *
+   * Each call:
+   *
+   * - allocates **one** index from the shared HD stream, however many types
+   *   were asked for, so a `default` + `boarding` pair are siblings rather
+   *   than two burnt indices;
+   * - builds each requested script at that index, preserving every other
+   *   option of the wallet's current script for that flavour (including a
+   *   delegate wallet's `delegate` shape);
+   * - persists each as an `active` contract carrying its `signingDescriptor`,
+   *   so the ContractWatcher monitors it, the balance counts it, and
+   *   {@link signerForDescriptor} can recover the key;
+   * - slides the look-ahead band, since the watermark moved past indices an
+   *   external issuer may still be handing out.
+   *
+   * The minted rows are deliberately left **untagged**: the boot lookups
+   * adopt the newest {@link WALLET_RECEIVE_SOURCE}-tagged row as the display
+   * address, and a side address issued to one counterparty must not become
+   * the address the wallet advertises to everyone else. {@link getAddress}
+   * and {@link getBoardingAddress} are unchanged by this call.
+   *
+   * A wallet with no HD stream (`walletMode: 'static'` / `'auto'`) has one
+   * address per flavour for its lifetime. Without `forceNew` it returns those
+   * — the real persisted rows, no index burned; with `forceNew` it throws
+   * {@link WalletCannotAllocateAddressError} rather than hand back an address
+   * that is not in fact fresh.
+   *
+   * @example
+   * ```typescript
+   * const [invoice] = await wallet.getNewAddresses({ forceNew: true });
+   * // hand `invoice.address` to Alice, keep the descriptor with the invoice
+   * const signer = await wallet.signerForDescriptor(invoice.signingDescriptor);
+   * ```
+   */
+  async getNewAddresses(opts) {
+    const minted = await this.allocateAddresses(
+      opts?.types ?? ["default"],
+      opts?.forceNew ?? false,
+      false
+    );
+    return minted.map(({ address, signingDescriptor, contract }) => ({
+      address,
+      signingDescriptor,
+      contract
+    }));
+  }
+  /**
+   * Shared allocation core behind {@link getNewAddresses} and the deprecated
+   * {@link getNewBoardingAddress}, so the two cannot drift on what an
+   * allocation costs or what gets persisted.
+   *
+   * @param tagSource - Tag the persisted rows {@link WALLET_RECEIVE_SOURCE},
+   * making the next boot adopt them as the display address. Only the
+   * deprecated boarding allocator passes `true`; `getNewAddresses` mints side
+   * addresses and must not hijack what the wallet advertises.
+   */
+  async allocateAddresses(types, forceNew, tagSource) {
+    if (types.length === 0) {
+      throw new Error("getNewAddresses: `types` must name at least one address type");
     }
     const manager = await this.getContractManager();
-    const descriptor = await manager.getNextSigningDescriptor();
-    if (!descriptor) return this.getBoardingAddress();
-    const pubKey = deriveDescriptorLeafPubKey(descriptor);
-    const newBoarding = new DefaultVtxo.Script({
+    const provider = this._descriptorProvider;
+    const descriptor = !provider ? void 0 : provider instanceof HDDescriptorProvider ? await manager.getNextSigningDescriptor() : await provider.getNextSigningDescriptor();
+    if (!descriptor) {
+      if (forceNew) {
+        throw new WalletCannotAllocateAddressError(
+          provider ? "the descriptor provider declined to allocate an index" : "this wallet has no HD stream (walletMode 'static' / 'auto')"
+        );
+      }
+      return this.currentAddresses(manager, types);
+    }
+    const allocated = [];
+    try {
+      for (const type of types) {
+        allocated.push(await this.mintAddress(manager, type, descriptor, tagSource, true));
+      }
+    } finally {
+      try {
+        await manager.refillLookAhead();
+      } catch (e) {
+        console.warn("look-ahead refill after address allocation failed", e);
+      }
+    }
+    return allocated;
+  }
+  /**
+   * The wallet's existing display addresses, as persisted contract rows —
+   * the honest answer for a wallet with no index to burn.
+   *
+   * Each type is minted from the descriptor that already owns its display
+   * script ({@link displayDescriptor}), not from the identity key, so the
+   * returned `signingDescriptor` is the one that signs for the returned
+   * `address` even on a wallet that has rotated.
+   */
+  async currentAddresses(manager, types) {
+    const out = [];
+    for (const type of types) {
+      const descriptor = await this.displayDescriptor(manager, type);
+      out.push(await this.mintAddress(manager, type, descriptor, false, false));
+    }
+    return out;
+  }
+  /**
+   * The descriptor that owns the wallet's current display script for `type`,
+   * read off the row the wallet persisted when it adopted that script.
+   *
+   * Deriving it from the identity instead is only correct for a wallet that
+   * never rotates. On one that has — an HD wallet whose provider later
+   * declines to allocate — the display script belongs to an HD child, and
+   * pairing its address with the identity descriptor hands the caller a
+   * {@link NewAddress} whose `signingDescriptor` resolves, via
+   * {@link signerForDescriptor}, to a signer holding the wrong key.
+   *
+   * Falls back to the identity's pathless `tr(pubkey)` when no row carries a
+   * descriptor: the static / `auto` case, where the identity key genuinely
+   * owns the display script and this is what `getNextSigningDescriptor`
+   * answers too. (The index-0 baselines registered at construction carry no
+   * `signingDescriptor` metadata, so those wallets take this path.)
+   */
+  async displayDescriptor(manager, type) {
+    const display = type === "boarding" ? this._boardingTapscript : this.offchainTapscript;
+    const [row] = await manager.getContracts({ script: hex.encode(display.pkScript) });
+    const persisted = row?.metadata?.signingDescriptor;
+    if (typeof persisted === "string") return persisted;
+    return identityDescriptor(this.identity);
+  }
+  /**
+   * Build, persist and shape one address of `type` owned by `descriptor` —
+   * the single build-and-register path behind both {@link allocateAddresses}
+   * and {@link currentAddresses}, so a freshly allocated address and a
+   * re-registered display address cannot disagree on what gets written.
+   *
+   * The descriptor is the sole source of the script's owner key in both
+   * branches. Deriving one flavour from the descriptor and the other from a
+   * tapscript field is what lets `address` and `signingDescriptor` drift
+   * apart.
+   */
+  async mintAddress(manager, type, descriptor, tagSource, allocated) {
+    if (type === "boarding") {
+      const built2 = this.buildBoardingContract(
+        deriveDescriptorLeafPubKey(descriptor),
+        descriptor,
+        tagSource
+      );
+      const contract2 = await manager.createContract(built2.params);
+      return {
+        type,
+        // `built.tapscript` is a `DefaultVtxo.Script` here without a
+        // cast — the branch, not a widened local, does the narrowing.
+        tapscript: built2.tapscript,
+        // A boarding row persists the *ark* encoding of its script, so
+        // `contract.address` is unusable for an onchain sender: the
+        // onchain form has to be re-derived.
+        address: built2.tapscript.onchainAddress(this.network),
+        signingDescriptor: descriptor,
+        contract: contract2,
+        allocated
+      };
+    }
+    const built = buildReceiveContract(
+      this.offchainTapscript,
+      descriptor,
+      this.network.hrp,
+      tagSource
+    );
+    const contract = await manager.createContract(built.params);
+    return {
+      type,
+      tapscript: built.tapscript,
+      // Offchain rows already store the address they advertise, and
+      // reading it back keeps a coalesced row (`createContract` is
+      // first-wins on script) honest about what was actually persisted.
+      address: contract.address,
+      signingDescriptor: descriptor,
+      contract,
+      allocated
+    };
+  }
+  /**
+   * Build the boarding contract owned by `pubKey`, keeping every other option
+   * of the wallet's current boarding tapscript (notably the boarding-exit
+   * CSV, which is index-independent). The offchain analogue lives in
+   * {@link buildReceiveContract}.
+   */
+  buildBoardingContract(pubKey, descriptor, tagSource) {
+    const tapscript = new DefaultVtxo.Script({
       ...this._boardingTapscript.options,
       pubKey
     });
-    const csvTimelock = newBoarding.options.csvTimelock ?? DefaultVtxo.Script.DEFAULT_TIMELOCK;
-    await manager.createContract({
-      type: "boarding",
+    const csvTimelock = tapscript.options.csvTimelock ?? DefaultVtxo.Script.DEFAULT_TIMELOCK;
+    return {
+      tapscript,
       params: {
-        pubKey: hex.encode(pubKey),
-        serverPubKey: hex.encode(newBoarding.options.serverPubKey),
-        csvTimelock: timelockToSequence(csvTimelock).toString()
-      },
-      script: hex.encode(newBoarding.pkScript),
-      address: newBoarding.address(this.network.hrp, this.arkServerPublicKey).encode(),
-      state: "active",
-      metadata: {
-        source: WALLET_RECEIVE_SOURCE,
-        signingDescriptor: descriptor
+        type: "boarding",
+        params: {
+          pubKey: hex.encode(pubKey),
+          serverPubKey: hex.encode(tapscript.options.serverPubKey),
+          csvTimelock: timelockToSequence(csvTimelock).toString()
+        },
+        script: hex.encode(tapscript.pkScript),
+        address: tapscript.address(this.network.hrp, this.arkServerPublicKey).encode(),
+        state: "active",
+        metadata: {
+          ...tagSource && { source: WALLET_RECEIVE_SOURCE },
+          signingDescriptor: descriptor
+        }
       }
-    });
-    this.setBoardingTapscriptForRotation(newBoarding);
-    try {
-      await manager.refillLookAhead();
-    } catch (e) {
-      console.warn("look-ahead refill after boarding allocation failed", e);
-    }
-    return newBoarding.onchainAddress(this.network);
+    };
   }
   /**
    * @see HDWalletCapable.getCurrentSigningDescriptor
@@ -13946,7 +14279,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     await this._restoreInFlight?.catch(() => void 0);
     this._serverInfoUnsub?.();
     this._serverInfoUnsub = void 0;
-    await this._serverInfoInFlight?.catch(() => void 0);
+    await this.settleServerInfoChanges();
     let rotatorError;
     try {
       await this._receiveRotator?.dispose();
@@ -14478,7 +14811,10 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    * `typeof` guard skips the arknote strings settle also accepts.
    *
    * No-ops for static / `auto` wallets (no descriptor provider — boarding
-   * stays on its fixed index-0 address). Best-effort and non-fatal: the
+   * stays on its fixed index-0 address). Wallets on a custom
+   * {@link DescriptorProvider} DO rotate here now, where they previously
+   * no-opped — see the behaviour-change note on {@link
+   * getNewBoardingAddress}. Best-effort and non-fatal: the
    * settle has already committed and its txid must be returned, so a
    * rotation failure is logged and swallowed rather than thrown. Funds at
    * the retired boarding address remain discoverable — the old `boarding`
@@ -14893,9 +15229,11 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           seen.add(pendingTx.arkTxid);
           batchPending.push(pendingTx.arkTxid);
           try {
-            const checkpointTxs = pendingTx.signedCheckpointTxs.map(
-              (c) => Transaction$2.fromPSBT(base64.decode(c))
-            );
+            const checkpointTxs = pendingTx.signedCheckpointTxs.map((c) => {
+              const tx = Transaction$2.fromPSBT(base64.decode(c));
+              assertAllowedSighashTypes(tx);
+              return tx;
+            });
             assertCheckpointsMatchInputs(
               checkpointTxs,
               checkpointInputs,
@@ -15063,7 +15401,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     const myPkScript = ArkAddress.decode(await this.getAddress()).pkScript;
     let { spendable, unclaimed } = this.classifyCashVtxos(vtxos);
     let swept = 0;
-    const drainable = vtxos.filter((vtxo) => !isSubdust(vtxo, this.dustAmount));
+    const drainable = vtxos.filter(
+      (vtxo) => !isSubdust(vtxo, this.dustAmount) && !vtxo.isUnrolled
+    );
     if (drainable.length > 0) {
       let drained = { count: 0, swept: 0, claimed: /* @__PURE__ */ new Set() };
       try {
@@ -15136,6 +15476,8 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     for (const vtxo of vtxos) {
       if (hasTerminalSpend(vtxo)) {
         unclaimed.push(cashReport(vtxo, "already-spent"));
+      } else if (vtxo.isUnrolled) {
+        unclaimed.push(cashReport(vtxo, "exited"));
       } else if (isSubdust(vtxo, this.dustAmount)) {
         unclaimed.push(cashReport(vtxo, "subdust"));
       } else if (vtxo.isSwept) {
@@ -15221,9 +15563,11 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     const unrollCandidates = this.checkpointUnrollCandidates(await this.arkProvider.getInfo());
     for (const pendingTx of pendingTxs) {
       try {
-        const checkpointTxs = pendingTx.signedCheckpointTxs.map(
-          (checkpoint) => Transaction$2.fromPSBT(base64.decode(checkpoint))
-        );
+        const checkpointTxs = pendingTx.signedCheckpointTxs.map((checkpoint) => {
+          const tx = Transaction$2.fromPSBT(base64.decode(checkpoint));
+          assertAllowedSighashTypes(tx);
+          return tx;
+        });
         assertCheckpointsMatchInputs(
           checkpointTxs,
           inputs.map((input) => ({
@@ -16026,6 +16370,11 @@ var MessageBus = class {
   buildServicesFn;
   boundOnMessage = this.onMessage.bind(this);
   intentRepository;
+  /** Pending broadcasts, drained FIFO by a single {@link drain} loop. */
+  broadcastQueue = [];
+  draining = false;
+  /** Bumped wherever the generation owning the queued broadcasts ends. */
+  broadcastEpoch = 0;
   /** Start the message bus and attach service-worker event listeners. */
   async start() {
     if (this.running) return;
@@ -16048,6 +16397,7 @@ var MessageBus = class {
     this.running = false;
     this.tickInProgress = false;
     this.initialized = false;
+    this.invalidateBroadcasts();
     if (this.tickTimeout !== null) {
       self.clearTimeout(this.tickTimeout);
       this.tickTimeout = null;
@@ -16060,6 +16410,78 @@ var MessageBus = class {
     self.removeEventListener("message", this.boundOnMessage);
     await Promise.all(Array.from(this.handlers.values()).map((updater) => updater.stop()));
   }
+  /** Invalidate every broadcast belonging to the outgoing generation. */
+  invalidateBroadcasts() {
+    this.broadcastEpoch++;
+    this.broadcastQueue.length = 0;
+  }
+  broadcastToClients(responses) {
+    this.broadcastQueue.push(...responses);
+    void this.drain();
+  }
+  /**
+   * Single fan-out loop, so pushes and tick responses keep one FIFO order.
+   * A helper posting per response would race: `clients.matchAll()` gives no
+   * cross-call resolution order, and it would de-batch `runTick`.
+   */
+  async drain() {
+    if (this.draining) return;
+    this.draining = true;
+    try {
+      while (this.broadcastQueue.length) {
+        const epoch = this.broadcastEpoch;
+        const batch = this.broadcastQueue.splice(0);
+        if (!this.running) {
+          this.logDroppedBroadcasts(batch, "bus stopped");
+          return;
+        }
+        let clients;
+        try {
+          clients = await self.clients.matchAll({
+            includeUncontrolled: true,
+            type: "window"
+          });
+        } catch (err) {
+          this.logDroppedBroadcasts(batch, "clients.matchAll failed", err);
+          continue;
+        }
+        if (!this.running) {
+          this.logDroppedBroadcasts(batch, "bus stopped during matchAll");
+          return;
+        }
+        if (this.broadcastEpoch !== epoch) {
+          this.logDroppedBroadcasts(batch, "re-init landed during matchAll");
+          continue;
+        }
+        for (const message of batch) {
+          for (const client of clients) {
+            try {
+              client.postMessage(message);
+            } catch (err) {
+              if (this.debug)
+                console.warn(`[${message.tag}] broadcast to client failed`, err);
+            }
+          }
+        }
+      }
+    } catch {
+    } finally {
+      this.draining = false;
+      if (this.running && this.broadcastQueue.length) void this.drain();
+    }
+  }
+  /**
+   * A dropped batch has no periodic recovery to fall back on now that events
+   * no longer ride the tick, so name the loss under {@link Options.debug}.
+   */
+  logDroppedBroadcasts(batch, reason, ...error) {
+    if (!this.debug) return;
+    console.warn(
+      `dropping ${batch.length} broadcast(s): ${reason}`,
+      batch.map((response) => response.tag),
+      ...error
+    );
+  }
   scheduleNextTick() {
     if (!this.running) return;
     if (this.tickTimeout !== null) return;
@@ -16088,16 +16510,7 @@ var MessageBus = class {
           if (this.debug)
             console.log(`[${updater.messageTag}] outgoing tick response:`, response);
           if (response && response.length > 0) {
-            self.clients.matchAll({
-              includeUncontrolled: true,
-              type: "window"
-            }).then((clients) => {
-              for (const message of response) {
-                clients.forEach((client) => {
-                  client.postMessage(message);
-                });
-              }
-            });
+            this.broadcastToClients(response);
           }
         } catch (err) {
           if (this.debug) console.error(`[${updater.messageTag}] tick failed`, err);
@@ -16136,6 +16549,14 @@ var MessageBus = class {
       self.clearTimeout(this.tickTimeout);
       this.tickTimeout = null;
     }
+    this.invalidateBroadcasts();
+    const epoch = this.broadcastEpoch;
+    const channel = {
+      broadcast: (response) => {
+        if (epoch !== this.broadcastEpoch) return;
+        this.broadcastToClients([response]);
+      }
+    };
     if (this.initialized) {
       this.initialized = false;
       await Promise.all(
@@ -16152,9 +16573,7 @@ var MessageBus = class {
     try {
       for (const updater of this.handlers.values()) {
         if (this.debug) console.log(`Starting updater: ${updater.messageTag}`);
-        await updater.start(services, {
-          walletRepository: this.walletRepository
-        });
+        await updater.start(services, { walletRepository: this.walletRepository }, channel);
         started.push(updater);
       }
     } catch (err) {
@@ -16824,6 +17243,17 @@ var WalletMessageHandler = class {
   incomingFundsSubscription;
   contractEventsSubscription;
   onNextTick = [];
+  channel;
+  // One counter per subscription field, bumped exactly where that field is
+  // dropped — never where a neighbour's is. They cannot be merged:
+  // `onWalletInitialized` re-subscribes incoming funds while
+  // `ensureContractEventBroadcasting` deliberately keeps its subscription, so
+  // a shared bump would leave the live contract-event emitter permanently
+  // stale, and folding requests in would truncate an in-flight settle.
+  incomingFundsEpoch = 0;
+  contractEventsEpoch = 0;
+  /** Per-request progress callbacks: ends with the handler, not with a re-init. */
+  requestEpoch = 0;
   /**
    * Instantiate a new WalletUpdater.
    * Can override the default `messageTag` allowing more than one updater to run in parallel.
@@ -16834,13 +17264,20 @@ var WalletMessageHandler = class {
   }
   // lifecycle methods
   async start(...params) {
-    const [services, repositories] = params;
+    const [services, repositories, channel] = params;
     this.readonlyWallet = services.readonlyWallet;
     this.wallet = services.wallet;
     this.arkProvider = services.arkProvider;
     this.walletRepository = repositories.walletRepository;
+    this.channel = channel;
+    this.onNextTick = [];
   }
   async stop() {
+    this.requestEpoch++;
+    this.incomingFundsEpoch++;
+    this.contractEventsEpoch++;
+    this.channel = void 0;
+    this.onNextTick = [];
     if (this.incomingFundsSubscription) {
       this.incomingFundsSubscription();
       this.incomingFundsSubscription = void 0;
@@ -16863,8 +17300,8 @@ var WalletMessageHandler = class {
     this.indexerProvider = void 0;
   }
   async tick(_now) {
-    const results = await Promise.allSettled(this.onNextTick.map((fn) => fn()));
-    this.onNextTick = [];
+    const pending = this.onNextTick.splice(0);
+    const results = await Promise.allSettled(pending.map((fn) => fn()));
     return results.map((result) => {
       if (result.status === "fulfilled") {
         return result.value;
@@ -16874,8 +17311,46 @@ var WalletMessageHandler = class {
       }
     }).filter((response) => response !== null);
   }
-  scheduleForNextTick(callback) {
-    this.onNextTick.push(callback);
+  epochOf(scope) {
+    switch (scope) {
+      case "incomingFunds":
+        return this.incomingFundsEpoch;
+      case "contractEvents":
+        return this.contractEventsEpoch;
+      case "request":
+        return this.requestEpoch;
+      default: {
+        const _exhaustive = scope;
+        throw new Error(`Unknown scope: ${_exhaustive}`);
+      }
+    }
+  }
+  newGeneration(scope) {
+    const born = this.epochOf(scope);
+    const stale = () => born !== this.epochOf(scope);
+    return {
+      get stale() {
+        return stale();
+      }
+    };
+  }
+  /**
+   * A handle rather than a `broadcast(response, epoch)` call, because it can
+   * only be written where the closure it guards is created — an epoch passed
+   * at the call site reads identically whether it guards anything or not.
+   */
+  newEmitter(scope) {
+    const gen = this.newGeneration(scope);
+    return {
+      get stale() {
+        return gen.stale;
+      },
+      emit: (response) => {
+        if (!response || gen.stale) return;
+        if (this.channel) return this.channel.broadcast(response);
+        this.onNextTick.push(() => response);
+      }
+    };
   }
   requireWallet() {
     if (!this.wallet) {
@@ -16904,6 +17379,7 @@ var WalletMessageHandler = class {
   }
   async handleMessage(message) {
     const id = message.id;
+    const emitter = this.newEmitter("request");
     if (message.type === "INIT_WALLET") {
       await this.handleInitWallet(message);
       return this.tagged({
@@ -17172,6 +17648,18 @@ var WalletMessageHandler = class {
             payload: { descriptor }
           });
         }
+        case "GET_NEW_ADDRESSES": {
+          const wallet = this.wallet;
+          if (!wallet) throw new WalletNotInitializedError();
+          const addresses = await wallet.getNewAddresses(
+            message.payload
+          );
+          return this.tagged({
+            id,
+            type: "NEW_ADDRESSES",
+            payload: { addresses }
+          });
+        }
         case "GET_USED_SIGNING_DESCRIPTORS": {
           const wallet = this.wallet;
           const descriptors = isHDWalletCapable(wallet) ? await wallet.getUsedSigningDescriptors(
@@ -17262,8 +17750,8 @@ var WalletMessageHandler = class {
           const wallet = this.requireWallet();
           const vtxoManager = await wallet.getVtxoManager();
           const txid = await vtxoManager.recoverVtxos((e) => {
-            this.scheduleForNextTick(
-              () => this.tagged({
+            emitter.emit(
+              this.tagged({
                 id,
                 type: "RECOVER_VTXOS_EVENT",
                 payload: e
@@ -17307,8 +17795,8 @@ var WalletMessageHandler = class {
           const wallet = this.requireWallet();
           const vtxoManager = await wallet.getVtxoManager();
           const txid = await vtxoManager.renewVtxos((e) => {
-            this.scheduleForNextTick(
-              () => this.tagged({
+            emitter.emit(
+              this.tagged({
                 id,
                 type: "RENEW_VTXOS_EVENT",
                 payload: e
@@ -17346,8 +17834,8 @@ var WalletMessageHandler = class {
           const vtxoManager = await wallet.getVtxoManager();
           const report = await vtxoManager.migrateDeprecatedSignerVtxos({
             eventCallback: (e) => {
-              this.scheduleForNextTick(
-                () => this.tagged({
+              emitter.emit(
+                this.tagged({
                   id,
                   type: "MIGRATE_DEPRECATED_SIGNER_VTXOS_EVENT",
                   payload: e
@@ -17450,6 +17938,7 @@ var WalletMessageHandler = class {
       intentLocked: offchain.intentLocked,
       recoverable: offchain.recoverable,
       pendingRecovery: offchain.pendingRecovery,
+      unrolled: offchain.unrolled,
       total: totalBoarding + offchain.total,
       assets: offchain.assets,
       availableAssets: offchain.availableAssets
@@ -17460,11 +17949,15 @@ var WalletMessageHandler = class {
     return this.readonlyWallet.getBoardingUtxos();
   }
   async onWalletInitialized() {
-    if (!this.readonlyWallet || !this.arkProvider || !this.indexerProvider || !this.walletRepository) {
+    const wallet = this.readonlyWallet;
+    if (!wallet || !this.arkProvider || !this.indexerProvider || !this.walletRepository) {
       return;
     }
+    const init = this.newGeneration("incomingFunds");
     await this.ensureContractEventBroadcasting();
+    if (init.stale) return;
     await this.refreshCachedData();
+    if (init.stale) return;
     if (this.wallet) {
       try {
         const vtxos = await this.getVtxosFromRepo();
@@ -17477,72 +17970,81 @@ var WalletMessageHandler = class {
       } catch (error) {
         console.error("Error recovering pending transactions:", error);
       }
+      if (init.stale) return;
     }
     if (this.incomingFundsSubscription) this.incomingFundsSubscription();
-    const address = await this.readonlyWallet.getAddress();
-    this.incomingFundsSubscription = await this.readonlyWallet.notifyIncomingFunds(
-      async (funds) => {
-        if (funds.type === "vtxo") {
-          const { newVtxos, spentVtxos } = funds;
-          if (newVtxos.length + spentVtxos.length === 0) return;
-          const byScript = /* @__PURE__ */ new Map();
-          for (const v of [...newVtxos, ...spentVtxos]) {
-            if (!v.script) {
-              console.warn(
-                `WalletMessageHandler.notifyIncomingFunds: dropping VTXO without script ${v.txid}:${v.vout}`
-              );
-              continue;
-            }
-            const arr = byScript.get(v.script) ?? [];
-            arr.push(v);
-            byScript.set(v.script, arr);
-          }
-          let walletScript;
-          try {
-            walletScript = scriptFromArkAddress(address);
-          } catch {
-            walletScript = void 0;
-          }
-          const cm = await this.readonlyWallet.getContractManager();
-          const contracts = await cm.getContracts();
-          const addrByScript = new Map(contracts.map((c) => [c.script, c.address]));
-          for (const [script, vtxos] of byScript) {
-            const filtered = warnAndFilterVtxosForScript(
-              vtxos,
-              script,
-              "WalletMessageHandler.notifyIncomingFunds"
+    this.incomingFundsSubscription = void 0;
+    this.incomingFundsEpoch++;
+    const emitter = this.newEmitter("incomingFunds");
+    const address = await wallet.getAddress();
+    const unsubscribe = await wallet.notifyIncomingFunds(async (funds) => {
+      if (emitter.stale) return;
+      if (funds.type === "vtxo") {
+        const { newVtxos, spentVtxos } = funds;
+        if (newVtxos.length + spentVtxos.length === 0) return;
+        const byScript = /* @__PURE__ */ new Map();
+        for (const v of [...newVtxos, ...spentVtxos]) {
+          if (!v.script) {
+            console.warn(
+              `WalletMessageHandler.notifyIncomingFunds: dropping VTXO without script ${v.txid}:${v.vout}`
             );
-            if (filtered.length === 0) continue;
-            const targetAddress = script === walletScript ? address : addrByScript.get(script);
-            if (!targetAddress) continue;
-            if (this.walletRepository) {
-              await saveVtxosForContract(
-                this.walletRepository,
-                { script, address: targetAddress },
-                filtered
-              );
-            }
+            continue;
           }
-          this.scheduleForNextTick(
-            () => this.tagged({
-              type: "VTXO_UPDATE",
-              broadcast: true,
-              payload: { newVtxos, spentVtxos }
-            })
-          );
+          const arr = byScript.get(v.script) ?? [];
+          arr.push(v);
+          byScript.set(v.script, arr);
         }
-        if (funds.type === "utxo") {
-          const utxos = await this.readonlyWallet.getBoardingUtxos();
-          this.scheduleForNextTick(
-            () => this.tagged({
-              type: "UTXO_UPDATE",
-              broadcast: true,
-              payload: { coins: utxos }
-            })
+        let walletScript;
+        try {
+          walletScript = scriptFromArkAddress(address);
+        } catch {
+          walletScript = void 0;
+        }
+        const cm = await wallet.getContractManager();
+        if (emitter.stale) return;
+        const contracts = await cm.getContracts();
+        if (emitter.stale) return;
+        const addrByScript = new Map(contracts.map((c) => [c.script, c.address]));
+        for (const [script, vtxos] of byScript) {
+          const filtered = warnAndFilterVtxosForScript(
+            vtxos,
+            script,
+            "WalletMessageHandler.notifyIncomingFunds"
           );
+          if (filtered.length === 0) continue;
+          const targetAddress = script === walletScript ? address : addrByScript.get(script);
+          if (!targetAddress) continue;
+          if (this.walletRepository) {
+            if (emitter.stale) return;
+            await saveVtxosForContract(
+              this.walletRepository,
+              { script, address: targetAddress },
+              filtered
+            );
+          }
         }
+        emitter.emit(
+          this.tagged({
+            type: "VTXO_UPDATE",
+            broadcast: true,
+            payload: { newVtxos, spentVtxos }
+          })
+        );
       }
-    );
+      if (funds.type === "utxo") {
+        if (emitter.stale) return;
+        const utxos = await wallet.getBoardingUtxos();
+        emitter.emit(
+          this.tagged({
+            type: "UTXO_UPDATE",
+            broadcast: true,
+            payload: { coins: utxos }
+          })
+        );
+      }
+    });
+    if (emitter.stale) return unsubscribe();
+    this.incomingFundsSubscription = unsubscribe;
     if (this.wallet) {
       try {
         await this.wallet.getVtxoManager();
@@ -17587,10 +18089,11 @@ var WalletMessageHandler = class {
     await this.refreshCachedData();
   }
   async handleSettle(message) {
+    const emitter = this.newEmitter("request");
     const wallet = this.requireWallet();
     const txid = await wallet.settle(message.payload.params, (e) => {
-      this.scheduleForNextTick(
-        () => this.tagged({
+      emitter.emit(
+        this.tagged({
           id: message.id,
           type: "SETTLE_EVENT",
           payload: e
@@ -17667,10 +18170,19 @@ var WalletMessageHandler = class {
       throw new WalletNotInitializedError();
     }
     const allVtxos = await this.getVtxosFromRepo();
-    const vtxos = allVtxos.filter((v) => !hasTerminalSpend(v));
     const dustAmount = this.readonlyWallet.dustAmount;
+    const withUnrolled = message.payload.filter?.withUnrolled ?? false;
     const includeRecoverable = message.payload.filter?.withRecoverable ?? false;
-    const filteredVtxos = includeRecoverable ? vtxos : vtxos.filter((v) => {
+    return allVtxos.filter((v) => {
+      if (v.isUnrolled) {
+        return withUnrolled;
+      }
+      if (hasTerminalSpend(v)) {
+        return false;
+      }
+      if (includeRecoverable) {
+        return true;
+      }
       if (dustAmount != null && isSubdust(v, dustAmount)) {
         return false;
       }
@@ -17682,15 +18194,15 @@ var WalletMessageHandler = class {
       }
       return true;
     });
-    if (!message.payload.filter?.withUnrolled) {
-      return filteredVtxos;
-    }
-    return filteredVtxos.concat(allVtxos.filter((v) => hasTerminalSpend(v) && v.isUnrolled));
   }
   /** Tear down handler subscriptions, then delegate the full wipe to the wallet. */
   async clear() {
     const wallet = this.wallet ?? this.readonlyWallet;
     if (!wallet) return;
+    this.requestEpoch++;
+    this.incomingFundsEpoch++;
+    this.contractEventsEpoch++;
+    this.onNextTick = [];
     if (this.incomingFundsSubscription) {
       this.incomingFundsSubscription();
       this.incomingFundsSubscription = void 0;
@@ -17779,13 +18291,17 @@ var WalletMessageHandler = class {
     return buildTransactionHistory(vtxos, boardingTxs, commitmentsToIgnore, resolveTxCreatedAt);
   }
   async ensureContractEventBroadcasting() {
-    if (!this.readonlyWallet) return;
+    const wallet = this.readonlyWallet;
+    if (!wallet) return;
     if (this.contractEventsSubscription) return;
+    const gen = this.newGeneration("contractEvents");
     try {
-      const manager = await this.readonlyWallet.getContractManager();
+      const manager = await wallet.getContractManager();
+      if (gen.stale || this.contractEventsSubscription) return;
+      const emitter = this.newEmitter("contractEvents");
       this.contractEventsSubscription = manager.onContractEvent((event) => {
-        this.scheduleForNextTick(
-          () => this.tagged({
+        emitter.emit(
+          this.tagged({
             type: "CONTRACT_EVENT",
             broadcast: true,
             payload: { event }
@@ -17816,6 +18332,9 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
   // Allocation is a local repository write plus a fire-and-forget band
   // slide — no indexer round trip on the request path.
   GET_NEXT_SIGNING_DESCRIPTOR: 1e4,
+  // Same shape as the bare allocation above, plus one contract write per
+  // requested type — still local, still no indexer round trip.
+  GET_NEW_ADDRESSES: 1e4,
   GET_USED_SIGNING_DESCRIPTORS: 2e4,
   ADVANCE_SIGNING_DESCRIPTOR_WATERMARK: 1e4,
   // Medium reads — may involve indexer queries
@@ -18961,6 +19480,35 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
       throw new Error(`Failed to allocate next signing descriptor: ${error}`);
     }
   }
+  /**
+   * @see Wallet.getNewAddresses
+   *
+   * Proxied as a single request rather than rebuilt page-side out of
+   * {@link getNextSigningDescriptor}: the worker owns the HD watermark *and*
+   * the contract repository, so splitting the operation would let a page burn
+   * an index and then fail to register the script, leaving an address nothing
+   * watches.
+   *
+   * Note the error shape — `WalletCannotAllocateAddressError` is thrown
+   * worker-side and cannot cross the message boundary as a class, so a
+   * `forceNew` refusal surfaces here as a plain `Error` carrying its message
+   * (and the worker-side error as `cause`). Callers that must branch on the
+   * refusal match the message rather than `instanceof`.
+   */
+  async getNewAddresses(opts) {
+    const message = {
+      id: getRandomId(),
+      tag: this.messageTag,
+      type: "GET_NEW_ADDRESSES",
+      ...opts ? { payload: opts } : {}
+    };
+    try {
+      const response = await this.sendMessage(message);
+      return response.payload.addresses;
+    } catch (error) {
+      throw new Error(`Failed to allocate new addresses: ${error}`, { cause: error });
+    }
+  }
   /** @see HDWalletCapable.getUsedSigningDescriptors */
   async getUsedSigningDescriptors(opts) {
     const message = {
@@ -19927,6 +20475,10 @@ var ElectrumOnchainProvider = class {
     }
     throw new Error("Only 1 or 1P1C package can be broadcast");
   }
+  async getRawTransaction(txid) {
+    const [tx] = await this.chain.fetchTransactions([txid]);
+    return hex.decode(tx.hex);
+  }
   async getTxOutspends(txid) {
     const [txResult] = await this.chain.fetchTransactions([txid]);
     const tx = Transaction$2.fromRaw(hex.decode(txResult.hex), {
@@ -20232,6 +20784,183 @@ function childTxidFromHex(txHex) {
   });
   return tx.id;
 }
+
+// src/providers/cachingArk.ts
+var DEFAULT_TTL_MS = 6e4;
+var CachingArkProvider = class {
+  constructor(inner, ttlMs = DEFAULT_TTL_MS) {
+    this.inner = inner;
+    this.ttlMs = ttlMs;
+    this.unsubscribe = inner.onServerInfoChanged?.((info) => {
+      this.cached = info;
+      this.expiresAt = Date.now() + this.ttlMs;
+      this.generation++;
+    }) ?? (() => {
+    });
+  }
+  inner;
+  ttlMs;
+  cached;
+  expiresAt = 0;
+  inflight;
+  /** Bumped on every event-driven cache write; see {@link getInfo}. */
+  generation = 0;
+  unsubscribe;
+  /** Releases the inner provider's server-info subscription. */
+  dispose() {
+    this.unsubscribe();
+  }
+  get serverUrl() {
+    const url = this.inner.serverUrl;
+    return typeof url === "string" ? url : void 0;
+  }
+  async getInfo() {
+    if (this.cached && Date.now() < this.expiresAt) return this.cached;
+    if (!this.inflight) {
+      const generation = this.generation;
+      this.inflight = this.inner.getInfo().then((info) => {
+        if (this.generation !== generation) return this.cached ?? info;
+        this.cached = info;
+        this.expiresAt = Date.now() + this.ttlMs;
+        return info;
+      }).finally(() => {
+        this.inflight = void 0;
+      });
+    }
+    return this.inflight;
+  }
+  submitTx(signedArkTx, checkpointTxs) {
+    return this.inner.submitTx(signedArkTx, checkpointTxs);
+  }
+  finalizeTx(arkTxid, finalCheckpointTxs) {
+    return this.inner.finalizeTx(arkTxid, finalCheckpointTxs);
+  }
+  registerIntent(intent) {
+    return this.inner.registerIntent(intent);
+  }
+  deleteIntent(intent) {
+    return this.inner.deleteIntent(intent);
+  }
+  confirmRegistration(intentId) {
+    return this.inner.confirmRegistration(intentId);
+  }
+  submitTreeNonces(batchId, pubkey, nonces) {
+    return this.inner.submitTreeNonces(batchId, pubkey, nonces);
+  }
+  submitTreeSignatures(batchId, pubkey, signatures) {
+    return this.inner.submitTreeSignatures(batchId, pubkey, signatures);
+  }
+  submitSignedForfeitTxs(signedForfeitTxs, signedCommitmentTx) {
+    return this.inner.submitSignedForfeitTxs(signedForfeitTxs, signedCommitmentTx);
+  }
+  getEventStream(signal, topics) {
+    return this.inner.getEventStream(signal, topics);
+  }
+  getTransactionsStream(signal) {
+    return this.inner.getTransactionsStream(signal);
+  }
+  getPendingTxs(intent) {
+    return this.inner.getPendingTxs(intent);
+  }
+  onServerInfoChanged(listener) {
+    return this.inner.onServerInfoChanged?.(listener) ?? (() => {
+    });
+  }
+};
+var PrevTxUnavailableError = class extends Error {
+  constructor(message, txids = []) {
+    super(message);
+    this.txids = txids;
+    this.name = "PrevTxUnavailableError";
+  }
+  txids;
+};
+async function resolvePrevTxs(txids, source, onchain) {
+  const resolved = /* @__PURE__ */ new Map();
+  const wanted = [...new Set(txids)];
+  if (wanted.length === 0) return resolved;
+  try {
+    const { txs } = await source.getVirtualTxs(wanted);
+    for (const psbt of txs) {
+      const tx = Transaction.fromPSBT(base64.decode(psbt));
+      resolved.set(tx.id, tx.toBytes());
+    }
+  } catch (err) {
+    if (!onchain) throw err;
+  }
+  let missing = wanted.filter((txid) => !resolved.has(txid));
+  if (missing.length > 0 && onchain) {
+    const raw = await Promise.all(
+      missing.map(async (txid) => {
+        try {
+          return await onchain.getRawTransaction(txid);
+        } catch {
+          return void 0;
+        }
+      })
+    );
+    for (const [i, bytes] of raw.entries()) {
+      if (bytes) resolved.set(missing[i], bytes);
+    }
+    missing = missing.filter((txid) => !resolved.has(txid));
+  }
+  if (missing.length > 0) {
+    throw new PrevTxUnavailableError(
+      `cannot resolve the previous transaction of ${missing.join(", ")}` + (onchain ? "" : " (no onchain source configured)"),
+      missing
+    );
+  }
+  return resolved;
+}
+async function attachPrevArkTxs(tx, txids, source, onchain) {
+  const pending = [];
+  for (let i = 0; i < tx.inputsLength; i++) {
+    if (getArkPsbtFields(tx, i, PrevArkTxField).length === 0) pending.push(i);
+  }
+  if (pending.length === 0) return;
+  const resolved = await resolvePrevTxs(
+    pending.map((i) => txidAt(txids, i)),
+    source,
+    onchain
+  );
+  for (const i of pending) {
+    setArkPsbtField(tx, i, PrevArkTxField, resolved.get(txidAt(txids, i)));
+  }
+}
+async function attachPrevoutTxs(tx, source) {
+  const pending = [];
+  for (let i = 0; i < tx.inputsLength; i++) {
+    if (getArkPsbtFields(tx, i, PrevoutTxField).length > 0) continue;
+    const input = tx.getInput(i);
+    if (!input?.txid) throw new PrevTxUnavailableError(`input ${i} has no outpoint`);
+    pending.push({ index: i, txid: hex.encode(input.txid) });
+  }
+  if (pending.length === 0) return;
+  const resolved = /* @__PURE__ */ new Map();
+  for (const txid of new Set(pending.map((p) => p.txid))) {
+    resolved.set(txid, await source.getRawTransaction(txid));
+  }
+  for (const { index, txid } of pending) {
+    setArkPsbtField(tx, index, PrevoutTxField, resolved.get(txid));
+  }
+}
+async function withPrevTxs(coins, source, onchain) {
+  const pending = coins.filter((c) => !c.prevTx);
+  if (pending.length === 0) return coins;
+  const resolved = await resolvePrevTxs(
+    pending.map((c) => c.txid),
+    source,
+    onchain
+  );
+  return coins.map((c) => c.prevTx ? c : { ...c, prevTx: resolved.get(c.txid) });
+}
+function txidAt(txids, index) {
+  const txid = txids[index];
+  if (txid === void 0) {
+    throw new PrevTxUnavailableError(`no source txid supplied for input ${index}`);
+  }
+  return txid;
+}
 var TAG_BIP322 = "BIP0322-signed-message";
 var BIP322;
 ((BIP3222) => {
@@ -20609,6 +21338,22 @@ async function resolveUnilateralPath(params) {
   return { selection: best.selection, label: "default:exit" };
 }
 
+// src/wallet/exitObserver.ts
+function exitObserverFor(manager) {
+  return (outpoint) => manager.refreshOutpoints([outpoint]);
+}
+async function notifyExitObserved(onExitObserved, outpoint) {
+  if (!onExitObserved) return;
+  try {
+    await onExitObserved(outpoint);
+  } catch (e) {
+    console.error(
+      `exit observer failed for ${outpoint.txid}:${outpoint.vout} \u2014 the exit is unaffected`,
+      e
+    );
+  }
+}
+
 // src/wallet/unroll.ts
 function chainTxTypeToChainedExit2(t) {
   switch (t) {
@@ -20633,27 +21378,30 @@ 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, virtualTxRepository) {
+    constructor(toUnroll, bumper, explorer, indexer, virtualTxRepository, onExitObserved) {
       this.toUnroll = toUnroll;
       this.bumper = bumper;
       this.explorer = explorer;
       this.indexer = indexer;
       this.virtualTxRepository = virtualTxRepository;
+      this.onExitObserved = onExitObserved;
     }
     toUnroll;
     bumper;
     explorer;
     indexer;
     virtualTxRepository;
+    onExitObserved;
     /** Create an unroll session by loading the virtual output chain from the indexer. */
-    static async create(toUnroll, bumper, explorer, indexer, virtualTxRepository) {
+    static async create(toUnroll, bumper, explorer, indexer, virtualTxRepository, onExitObserved) {
       const { chain } = await indexer.getVtxoChain(toUnroll);
       return new Session2(
         { ...toUnroll, chain },
         bumper,
         explorer,
         indexer,
-        virtualTxRepository
+        virtualTxRepository,
+        onExitObserved
       );
     }
     /**
@@ -20689,6 +21437,14 @@ var Unroll;
     }
     /**
      * Get the next step to be executed
+     *
+     * @remarks
+     * `do()` is the step, not a formality: every effect lives there, and at
+     * `StepType.DONE` that includes firing {@link onExitObserved}. A caller
+     * driving `next()` by hand must always await it — the async iterator
+     * below does. Reading `type` and skipping `do()` leaves the exit
+     * unobserved, and on the other step kinds unbroadcast.
+     *
      * @returns The next step to be executed + the function to execute it
      */
     async next() {
@@ -20717,7 +21473,12 @@ var Unroll;
         return {
           type: 2 /* DONE */,
           vtxoTxid: this.toUnroll.txid,
-          do: () => Promise.resolve()
+          // The observation rides on `do` rather than the iterator so
+          // a caller driving `next()` by hand fires it too.
+          do: () => notifyExitObserved(this.onExitObserved, {
+            txid: this.toUnroll.txid,
+            vout: this.toUnroll.vout
+          })
         };
       }
       const virtualTxBase64 = await this.resolveVirtualTxBase64(nextTxToBroadcast);
@@ -20751,9 +21512,22 @@ var Unroll;
     }
   }
   Unroll2.Session = Session2;
+  async function sessionFor(wallet, toUnroll, bumper) {
+    const manager = await wallet.getContractManager();
+    return Session2.create(
+      toUnroll,
+      bumper,
+      wallet.onchainProvider,
+      wallet.indexerProvider,
+      wallet.virtualTxRepository,
+      exitObserverFor(manager)
+    );
+  }
+  Unroll2.sessionFor = sessionFor;
   async function completeUnroll(wallet, vtxoTxids, outputAddress) {
     const signedTx = await prepareUnrollTransaction(wallet, vtxoTxids, outputAddress);
     await wallet.onchainProvider.broadcastTransaction(signedTx.hex);
+    await refreshSpentExitOutputs(wallet, signedTx);
     return signedTx.id;
   }
   Unroll2.completeUnroll = completeUnroll;
@@ -20769,9 +21543,9 @@ async function prepareUnrollTransaction(wallet, vtxoTxIds, outputAddress) {
   let totalAmount = 0n;
   const txWeightEstimator = TxWeightEstimator.create();
   for (const vtxo of vtxos) {
-    if (!vtxo.isUnrolled) {
+    if (!canSweepOnchain(vtxo)) {
       throw new Error(
-        `Vtxo ${vtxo.txid}:${vtxo.vout} is not fully unrolled, use unroll first`
+        `Vtxo ${vtxo.txid}:${vtxo.vout} cannot be swept onchain: it is not fully unrolled (use unroll first), or its exit output was already spent`
       );
     }
     const txStatus = await wallet.onchainProvider.getTxStatus(vtxo.txid);
@@ -20832,6 +21606,22 @@ async function prepareUnrollTransaction(wallet, vtxoTxIds, outputAddress) {
   signedTx.finalize();
   return signedTx;
 }
+async function refreshSpentExitOutputs(wallet, signedTx) {
+  const outpoints = [];
+  for (let i = 0; i < signedTx.inputsLength; i++) {
+    const input = signedTx.getInput(i);
+    if (input.txid && input.index !== void 0) {
+      outpoints.push({ txid: hex.encode(input.txid), vout: input.index });
+    }
+  }
+  if (outpoints.length === 0) return;
+  try {
+    const manager = await wallet.getContractManager();
+    await manager.refreshOutpoints(outpoints);
+  } catch (e) {
+    console.error("completeUnroll: failed to refresh the spent exit outputs", e);
+  }
+}
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -20910,7 +21700,7 @@ async function buildSignedSweep(params) {
 }
 
 // src/wallet/exit/estimate.ts
-var CHILD_OUTPUT_DUST = 546;
+var CHILD_OUTPUT_DUST = CHILD_DUST_AMOUNT;
 function stepFundingAmount(stepFee) {
   return stepFee + CHILD_OUTPUT_DUST;
 }
@@ -21071,10 +21861,18 @@ async function computeExitLayout(opts, feeRate) {
     // 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,
+    // graph funding is what the executor sends to its own fee address: the
+    // CPFP fees, plus one dust floor. Change recycles through that single
+    // address, so each bump hands its remainder to the next and only the
+    // *final* change has to clear `CHILD_DUST_AMOUNT` — but it does have to,
+    // and `buildAnchorChild` throws rather than absorbing a short remainder
+    // into the fee. Quoting bare fees quotes an amount that strands the last
+    // bump and every sweep behind it.
+    //
+    // funded reserves the same floor per step instead of once overall (see
+    // `stepFundingAmount`), because it pre-funds each child separately
+    // through the splitter rather than recycling one output.
+    fundingRequiredSats: graph ? steps.length > 0 ? stepFees + CHILD_OUTPUT_DUST : 0 : 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);
@@ -21134,12 +21932,32 @@ var Executor = class {
     this.pollIntervalMs = opts?.pollIntervalMs ?? 5e3;
     this.feeWallet = opts?.feeWallet;
     this.signal = opts?.signal;
+    this.onExitObserved = opts?.onExitObserved;
   }
   pkg;
   provider;
   pollIntervalMs;
   feeWallet;
   signal;
+  onExitObserved;
+  /**
+   * Per-VTXO branch progress, which the executor otherwise does not track:
+   * `dead` / `done` are per-step, and a VTXO is only onchain once EVERY
+   * `package`/`bump` step naming it has confirmed. (`broadcast` — the funding
+   * splitter — carries no `forVtxos` and serves no single VTXO.)
+   */
+  branchSteps() {
+    const byVtxo = /* @__PURE__ */ new Map();
+    this.pkg.steps.forEach((step, i) => {
+      if (step.kind !== "package" && step.kind !== "bump") return;
+      for (const vtxo of step.forVtxos) {
+        let steps = byVtxo.get(vtxo);
+        if (!steps) byVtxo.set(vtxo, steps = /* @__PURE__ */ new Set());
+        steps.add(i);
+      }
+    });
+    return byVtxo;
+  }
   /**
    * Poll delay. Nearly all wall-clock time is spent here, so it must be the
    * thing that reacts to abort — checking only between polls would leave
@@ -21179,6 +21997,19 @@ var Executor = class {
   async *[Symbol.asyncIterator]() {
     throwIfAborted(this.signal);
     const dead = /* @__PURE__ */ new Set();
+    const branchSteps = this.branchSteps();
+    const onchainSteps = /* @__PURE__ */ new Set();
+    const branchObserved = /* @__PURE__ */ new Set();
+    const observeBranch = async (stepIndex, forVtxos) => {
+      onchainSteps.add(stepIndex);
+      for (const vtxo of forVtxos ?? []) {
+        if (branchObserved.has(vtxo)) continue;
+        const steps = branchSteps.get(vtxo);
+        if (!steps || ![...steps].every((i) => onchainSteps.has(i))) continue;
+        branchObserved.add(vtxo);
+        await this.observe(vtxo);
+      }
+    };
     if (this.pkg.validUntil && Date.now() / 1e3 > this.pkg.validUntil) {
       yield {
         stepIndex: -1,
@@ -21208,6 +22039,7 @@ var Executor = class {
       const anchorTxid = step.kind === "package" || step.kind === "bump" ? step.parentTxid : step.txid;
       const existing = await this.status(anchorTxid);
       if (existing?.confirmed) {
+        await observeBranch(i, forVtxos);
         yield {
           stepIndex: i,
           kind: step.kind,
@@ -21263,6 +22095,7 @@ var Executor = class {
         }
       }
       await this.waitConfirmed(anchorTxid);
+      await observeBranch(i, forVtxos);
       yield {
         stepIndex: i,
         kind: step.kind,
@@ -21293,6 +22126,7 @@ var Executor = class {
         const swept = await this.status(step.txid);
         if (swept?.confirmed) {
           done.add(index);
+          await this.observe(step.vtxo);
           yield {
             stepIndex: index,
             kind: "sweep",
@@ -21349,7 +22183,25 @@ var Executor = class {
       if (done.size < pending.length) await this.sleep();
     }
   }
+  /** `"txid:vout"` -> outpoint, then hand it to the hook. A malformed entry is skipped. */
+  async observe(outpoint) {
+    if (!this.onExitObserved) return;
+    const sep = outpoint.lastIndexOf(":");
+    const rest = outpoint.slice(sep + 1);
+    const vout = Number(rest);
+    if (sep <= 0 || rest === "" || !Number.isInteger(vout)) return;
+    await notifyExitObserved(this.onExitObserved, { txid: outpoint.slice(0, sep), vout });
+  }
 };
+
+// src/wallet/exit/execute.ts
+async function execute(wallet, pkg, opts) {
+  const manager = await wallet.getContractManager();
+  return new Executor(pkg, opts?.provider ?? wallet.onchainProvider, {
+    ...opts,
+    onExitObserved: opts?.onExitObserved ?? exitObserverFor(manager)
+  });
+}
 async function prepare(opts) {
   const { wallet, onchainWallet } = opts;
   const feeRate = await resolveFeeRate(opts);
@@ -21424,7 +22276,10 @@ async function prepare(opts) {
       totals: {
         txCount: bumpSteps.length * 2 + sweepSteps.length,
         totalFeeSats: stepFees2 + sweepFees2,
-        fundingRequiredSats: stepFees2,
+        // Fees plus the single dust floor the recycling change output
+        // must keep clear; see the note in `estimate.ts`. Must match
+        // the quote `estimate` gives for the same package.
+        fundingRequiredSats: bumpSteps.length > 0 ? stepFees2 + CHILD_OUTPUT_DUST : 0,
         recoveredSats: recovered2
       },
       vtxos: layout.infos,
@@ -21593,6 +22448,7 @@ function isValidStep(step) {
 var UnilateralExit = {
   estimate,
   prepare,
+  execute,
   Executor
 };
 
@@ -22010,6 +22866,10 @@ var ArkadeContract = class _ArkadeContract {
    * When a `contractManager` is configured and this contract is registered,
    * reads the repository-backed state (offline-first, kept fresh by the
    * contract watcher). Otherwise falls back to a direct indexer query.
+   *
+   * Both branches refuse a spent or unilaterally exited output. They are not
+   * otherwise interchangeable: the fallback asks `spendableOnly`, which also
+   * drops swept coins — the manager branch keeps those.
    */
   async getUtxos() {
     const manager = this.client.contractManager;
@@ -22018,7 +22878,9 @@ var ArkadeContract = class _ArkadeContract {
       const [registered] = await manager.getContracts({ script: scriptHex });
       if (registered) {
         const [withVtxos] = await manager.getContractsWithVtxos({ script: scriptHex });
-        return (withVtxos?.vtxos ?? []).filter((v) => !hasTerminalSpend(v));
+        return (withVtxos?.vtxos ?? []).filter(
+          (v) => !hasTerminalSpend(v) && !v.isUnrolled
+        );
       }
     }
     if (!this.client.indexer) {
@@ -22028,7 +22890,7 @@ var ArkadeContract = class _ArkadeContract {
       scripts: [scriptHex],
       spendableOnly: true
     });
-    return vtxos;
+    return vtxos.filter((v) => !hasTerminalSpend(v) && !v.isUnrolled);
   }
   /** Total spendable balance (requires an indexer). */
   async getBalance() {
@@ -22128,6 +22990,19 @@ var ArkadeTransactionBuilder = class {
     if (coin.sourceTx) {
       setArkPsbtField(arkTx, 0, PrevArkTxField, coin.sourceTx);
     }
+    if (this.fn.arkadeScript) {
+      const indexer = this.contract.client.indexer;
+      if (!indexer) {
+        throw new PrevTxUnavailableError(
+          "covenant spends require an `indexer` on the Arkade client to resolve the previous ark tx of each input"
+        );
+      }
+      await attachPrevArkTxs(
+        arkTx,
+        [coin.txid, ...this.fundingCoins.map((c) => c.txid)],
+        indexer
+      );
+    }
     const condition = (def.tapscript.witness ?? []).map((w) => this.witnessBytes(w));
     if (condition.length > 0) {
       setArkPsbtField(arkTx, 0, ConditionWitness, condition);
@@ -22633,6 +23508,6 @@ function createDefaultPaymentRouter(wallet) {
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, ChainedTxType, ConnectionDisposedError, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, ForeignDescriptorError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, gateExclusion, gatedContracts, getAllByIndexValues, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, isWatchedContract, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, onchainRail, openDatabase, outpointExclusion, outpointReasons, promisifyRequest, provisionClaimSecret, provisionRefundKey, requiresMigration, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-DSC3G6QZ.js.map
-//# sourceMappingURL=chunk-DSC3G6QZ.js.map
+export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, ForeignDescriptorError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, isWatchedContract, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, promisifyRequest, provisionClaimSecret, provisionRefundKey, requiresMigration, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript, withPrevTxs };
+//# sourceMappingURL=chunk-VBHXBI7F.js.map
+//# sourceMappingURL=chunk-VBHXBI7F.js.map