@arkade-os/sdk 0.4.48-rc.0 → 0.4.48

package/dist/{chunk-SV4PCGKM.js → chunk-NYR5H6GR.js}

@@ -1,6 +1,6 @@
-import { Transaction, setArkPsbtField, PrevArkTxField, ConditionWitness, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, craftToSpendTx, getArkPsbtFields, CosignerPublicKey, BufferReader, BufferWriter, OP_RETURN_EMPTY_PKSCRIPT, VtxoTaprootTree, baseFetch, Intent, maybeArkError, isArkError, ArkErrorName, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError } from './chunk-GM6JRQP5.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, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, DefaultVtxo, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, BoardingContractHandler } from './chunk-XN3554FT.js';
-import { VtxoScript, CSVMultisigTapscript, DEFAULT_NETWORK, ArkAddress, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, timelockToSequence, DEFAULT_NETWORK_NAME, getSequence, getNetwork, MultisigTapscript, networks as networks$1, DEFAULT_ARKADE_SERVER_URL } from './chunk-C7TXXTMS.js';
+import { Transaction, setArkPsbtField, PrevArkTxField, ConditionWitness, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, craftToSpendTx, getArkPsbtFields, CosignerPublicKey, BufferReader, BufferWriter, OP_RETURN_EMPTY_PKSCRIPT, VtxoTaprootTree, baseFetch, Intent, rateGate, maybeArkError, isArkError, ArkErrorName, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError } from './chunk-BHHLRZCS.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, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, DefaultVtxo, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, BoardingContractHandler } from './chunk-4VVTRPH3.js';
+import { VtxoScript, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, hasTerminalSpend, getNormalizedVtxos, isVirtualCoin, ArkAddress, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, timelockToSequence, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, canSpendOffchain, toVirtualStatus, resolveTimeHeight, parseLegacyExpiry, networks as networks$1, isExpired, DEFAULT_ARKADE_SERVER_URL, isPastExpiry } from './chunk-ZDDBTFVO.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { sha256, 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';
@@ -991,7 +991,7 @@ var RestDelegateProvider = class {
    */
   async getDelegateInfo() {
     const url = `${this.url}/v1/delegator/info`;
-    const response = await baseFetch(url);
+    const response = await rateGate.runHttp(url, () => baseFetch(url));
     if (!response.ok) {
       const errorText2 = await response.text();
       throw new Error(`Failed to get delegate info: ${errorText2}`);
@@ -2042,20 +2042,6 @@ var TxType = /* @__PURE__ */ ((TxType2) => {
   TxType2["TxReceived"] = "RECEIVED";
   return TxType2;
 })(TxType || {});
-function isSpendable(vtxo) {
-  return !vtxo.isSpent;
-}
-function isRecoverable(vtxo) {
-  return vtxo.virtualStatus.state === "swept" && isSpendable(vtxo);
-}
-function isExpired(vtxo) {
-  if (vtxo.virtualStatus.state === "swept") return true;
-  const expiry = vtxo.virtualStatus.batchExpiry;
-  if (!expiry) return false;
-  const expireAt = new Date(expiry);
-  if (expireAt.getFullYear() < 2025) return false;
-  return expiry <= Date.now();
-}
 function isSubdust(vtxo, dust) {
   if (typeof vtxo === "bigint") return vtxo < dust;
   return vtxo.value < dust;
@@ -2725,7 +2711,7 @@ function selectPendingRecoveryOutpoints(contractsWithVtxos, signerSet, nowSecond
       continue;
     }
     for (const v of vtxos) {
-      if (isSpendable(v) && !isRecoverable(v)) out.add(`${v.txid}:${v.vout}`);
+      if (!hasTerminalSpend(v) && !v.isSwept) out.add(`${v.txid}:${v.vout}`);
     }
   }
   return out;
@@ -2757,16 +2743,28 @@ var MAX_INPUTS_PER_INTENT = 20;
 function byValueDescending(vtxos) {
   return [...vtxos].sort((a, b) => b.value - a.value);
 }
-function byExpiryAscending(vtxos) {
+async function fetchTimeHeight(wallet) {
+  return resolveTimeHeight(wallet.onchainProvider);
+}
+function canMigrateBySend(vtxo, now) {
+  if (!canSpendOffchain(vtxo, now)) return false;
+  return vtxo.expiresAt !== void 0 || vtxo.expiresAtHeight !== void 0;
+}
+function byExpiryAscending(vtxos, now) {
   const expiryKey = (vtxo) => {
-    if (isRecoverable(vtxo)) return -Infinity;
-    const batchExpiry = vtxo.virtualStatus.batchExpiry;
-    if (isExpired(vtxo)) return batchExpiry ?? -Infinity;
-    if (!batchExpiry) return Infinity;
-    if (new Date(batchExpiry).getFullYear() < 2025) return Infinity;
-    return batchExpiry;
+    if (vtxo.isSwept) return -Infinity;
+    if (vtxo.expiresAt !== void 0) return vtxo.expiresAt.getTime();
+    if (vtxo.expiresAtHeight !== void 0) {
+      return isPastExpiry(vtxo, now) ? -Infinity : Infinity;
+    }
+    return Infinity;
   };
-  return [...vtxos].sort((a, b) => expiryKey(a) - expiryKey(b));
+  return [...vtxos].sort((a, b) => {
+    const ka = expiryKey(a);
+    const kb = expiryKey(b);
+    if (ka === kb) return 0;
+    return ka < kb ? -1 : 1;
+  });
 }
 function capSettlementBatch(sorted, maxAmount) {
   const batch = [];
@@ -2792,22 +2790,19 @@ var DEFAULT_SETTLEMENT_CONFIG = {
   pollIntervalMs: 6e4,
   deprecatedSignerMigration: true
 };
-function getRecoverableVtxos(vtxos, dustAmount) {
+function getRecoverableVtxos(vtxos, dustAmount, now) {
   return vtxos.filter((vtxo) => {
-    if (isRecoverable(vtxo)) {
-      return true;
-    }
-    if (isSpendable(vtxo) && isExpired(vtxo)) {
+    if (canRecoverOnchain(vtxo, now)) {
       return true;
     }
-    if (vtxo.virtualStatus.state === "preconfirmed" && isSubdust(vtxo, dustAmount)) {
+    if (canSpendOffchain(vtxo, now) && vtxo.isPreconfirmed && isSubdust(vtxo, dustAmount)) {
       return true;
     }
     return false;
   });
 }
-function getRecoverableWithSubdust(vtxos, dustAmount) {
-  const recoverableVtxos = getRecoverableVtxos(vtxos, dustAmount);
+function getRecoverableWithSubdust(vtxos, dustAmount, now) {
+  const recoverableVtxos = getRecoverableVtxos(vtxos, dustAmount, now);
   const subdust = [];
   const regular = [];
   for (const vtxo of recoverableVtxos) {
@@ -2831,17 +2826,16 @@ function getRecoverableWithSubdust(vtxos, dustAmount) {
 }
 function isVtxoExpiringSoon(vtxo, thresholdMs) {
   const realThresholdMs = thresholdMs <= 100 ? DEFAULT_THRESHOLD_MS : thresholdMs;
-  const { batchExpiry } = vtxo.virtualStatus;
-  if (!batchExpiry) return false;
-  const expireAt = new Date(batchExpiry);
-  if (expireAt.getFullYear() < 2025) return false;
+  const expiresAt = normalizeVtxo(vtxo).expiresAt;
+  if (expiresAt === void 0) return false;
   const now = Date.now();
+  const batchExpiry = expiresAt.getTime();
   if (batchExpiry <= now) return false;
   return batchExpiry - now <= realThresholdMs;
 }
-function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount) {
+function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount, now) {
   return vtxos.filter(
-    (vtxo) => isVtxoExpiringSoon(vtxo, thresholdMs) || isRecoverable(vtxo) || isSpendable(vtxo) && isExpired(vtxo) || isSubdust(vtxo, dustAmount)
+    (vtxo) => isVtxoExpiringSoon(vtxo, thresholdMs) || canRecoverOnchain(vtxo, now) || isSubdust(vtxo, dustAmount)
   );
 }
 function isMigrationCapable(wallet) {
@@ -2990,7 +2984,8 @@ var VtxoManager = class _VtxoManager {
       withUnrolled: false
     });
     const dustAmount = getDustAmount(this.wallet);
-    let { vtxosToRecover, totalAmount } = getRecoverableWithSubdust(allVtxos, dustAmount);
+    const now = await fetchTimeHeight(this.wallet);
+    let { vtxosToRecover, totalAmount } = getRecoverableWithSubdust(allVtxos, dustAmount, now);
     if (vtxosToRecover.length === 0) {
       throw new Error("No recoverable VTXOs found");
     }
@@ -2999,7 +2994,7 @@ var VtxoManager = class _VtxoManager {
     const capped = capSettlementBatch(byValueDescending(vtxosToRecover), vtxoMaxAmount);
     if (capped.length < vtxosToRecover.length) {
       const recoverableCount = vtxosToRecover.length;
-      ({ vtxosToRecover, totalAmount } = getRecoverableWithSubdust(capped, dustAmount));
+      ({ vtxosToRecover, totalAmount } = getRecoverableWithSubdust(capped, dustAmount, now));
       if (vtxosToRecover.length === 0) {
         throw new Error(
           `Capped recovery batch (highest-value subset of ${recoverableCount} recoverable VTXOs within the ${MAX_VTXOS_PER_SETTLEMENT}-input and ${vtxoMaxAmount}-sat limits) is below the dust threshold ${dustAmount}`
@@ -3051,7 +3046,8 @@ var VtxoManager = class _VtxoManager {
     const dustAmount = getDustAmount(this.wallet);
     const { vtxosToRecover, includesSubdust, totalAmount } = getRecoverableWithSubdust(
       allVtxos,
-      dustAmount
+      dustAmount,
+      await fetchTimeHeight(this.wallet)
     );
     const subdustAmount = vtxosToRecover.filter((v) => BigInt(v.value) < dustAmount).reduce((sum, v) => sum + BigInt(v.value), 0n);
     return {
@@ -3085,6 +3081,16 @@ var VtxoManager = class _VtxoManager {
    * ```
    */
   async getExpiringVtxos(thresholdMs) {
+    return this.selectExpiringVtxos(thresholdMs);
+  }
+  /**
+   * {@link getExpiringVtxos}, against a caller-supplied chain tip.
+   *
+   * The settle paths select, re-select after pre-flight, and sort by expiry within one pass;
+   * each of those judges expiry, so they share one tip rather than fetching (and possibly
+   * disagreeing on) one apiece. Fetches its own when `now` is omitted.
+   */
+  async selectExpiringVtxos(thresholdMs, now) {
     if (this.settlementConfig === false && thresholdMs === void 0) {
       return [];
     }
@@ -3097,7 +3103,12 @@ var VtxoManager = class _VtxoManager {
     } else {
       threshold = this.renewalConfig?.thresholdMs ?? DEFAULT_RENEWAL_CONFIG.thresholdMs;
     }
-    return getExpiringAndRecoverableVtxos(vtxos, threshold, getDustAmount(this.wallet));
+    return getExpiringAndRecoverableVtxos(
+      vtxos,
+      threshold,
+      getDustAmount(this.wallet),
+      now ?? await fetchTimeHeight(this.wallet)
+    );
   }
   /**
    * Renew expiring virtual outputs by settling them back to the wallet's address
@@ -3150,17 +3161,18 @@ var VtxoManager = class _VtxoManager {
       } else {
         threshold = DEFAULT_RENEWAL_CONFIG.thresholdMs;
       }
-      let vtxos = await this.getExpiringVtxos(threshold);
+      const now = await fetchTimeHeight(this.wallet);
+      let vtxos = await this.selectExpiringVtxos(threshold, now);
       if (vtxos.length === 0) {
         throw new Error("No VTXOs available to renew");
       }
-      vtxos = await this.revalidateBeforeSettle(vtxos, threshold);
+      vtxos = await this.revalidateBeforeSettle(vtxos, threshold, now);
       if (vtxos.length === 0) {
         throw new Error("No VTXOs available to renew");
       }
       const info = await this.getInfoProvider()?.getInfo();
       const vtxoMaxAmount = info?.vtxoMaxAmount ?? -1n;
-      const capped = capSettlementBatch(byExpiryAscending(vtxos), vtxoMaxAmount);
+      const capped = capSettlementBatch(byExpiryAscending(vtxos, now), vtxoMaxAmount);
       if (vtxoMaxAmount >= 0n) {
         const oversized = vtxos.filter((vtxo) => BigInt(vtxo.value) > vtxoMaxAmount);
         if (oversized.length > 0) {
@@ -3421,6 +3433,7 @@ var VtxoManager = class _VtxoManager {
       signers: reports
     };
     if (vtxoMigratable.length > 0) {
+      const now = await fetchTimeHeight(this.wallet);
       report.vtxos = await this.runMigrationLeg(
         vtxoMigratable,
         (c) => c.vtxo.value,
@@ -3428,7 +3441,11 @@ var VtxoManager = class _VtxoManager {
         vtxoMaxAmount,
         dustAmount,
         "VTXO",
-        (capped) => wallet.sendSelectedVtxosToSelf(capped.map((c) => c.vtxo))
+        (capped) => wallet.sendSelectedVtxosToSelf(
+          capped.map((c) => c.vtxo),
+          now
+        ),
+        (c) => canMigrateBySend(c.vtxo, now)
       );
     }
     if (boardingMigratable.length > 0) {
@@ -3468,10 +3485,22 @@ var VtxoManager = class _VtxoManager {
    * the server ceiling by the cap). The dust floor guards the degenerate cases
    * where every input was oversized or the whole holding sums below dust.
    */
-  async runMigrationLeg(candidates, valueOf, toRef, vtxoMaxAmount, dustAmount, legName, submit) {
+  async runMigrationLeg(candidates, valueOf, toRef, vtxoMaxAmount, dustAmount, legName, submit, eligible) {
+    const notSpendableRefs = [];
+    const migratable = eligible ? candidates.filter((c) => {
+      if (eligible(c)) return true;
+      notSpendableRefs.push(toRef(c));
+      return false;
+    }) : candidates;
+    if (notSpendableRefs.length > 0) {
+      console.warn(
+        `Deprecated-signer migration (${legName}): ${notSpendableRefs.length} input(s) are no longer cooperatively spendable at the current chain tip and were excluded; they recover through the sweep/recovery path instead.`
+      );
+    }
+    const notSpendableField = notSpendableRefs.length > 0 ? { notSpendableOffchain: notSpendableRefs } : {};
     const oversizedRefs = [];
     const sized = [];
-    for (const c of candidates) {
+    for (const c of migratable) {
       if (vtxoMaxAmount >= 0n && BigInt(valueOf(c)) > vtxoMaxAmount) {
         oversizedRefs.push(toRef(c));
       } else {
@@ -3491,11 +3520,12 @@ var VtxoManager = class _VtxoManager {
     const deferred = sized.length - capped.length;
     const totalAmount = capped.reduce((sum, c) => sum + BigInt(valueOf(c)), 0n);
     if (totalAmount < dustAmount) {
-      const onlyOversized = sized.length === 0 && oversizedRefs.length > 0;
+      const skipped = sized.length > 0 ? "below-dust" : oversizedRefs.length > 0 ? "oversized-only" : notSpendableRefs.length > 0 ? "not-spendable-only" : "below-dust";
       return {
         migrated: [],
-        skipped: onlyOversized ? "oversized-only" : "below-dust",
-        ...oversizedField
+        skipped,
+        ...oversizedField,
+        ...notSpendableField
       };
     }
     try {
@@ -3504,13 +3534,15 @@ var VtxoManager = class _VtxoManager {
         txid,
         migrated: capped.map(toRef),
         ...deferred > 0 ? { deferred } : {},
-        ...oversizedField
+        ...oversizedField,
+        ...notSpendableField
       };
     } catch (e) {
       return {
         migrated: [],
         error: e instanceof Error ? e.message : String(e),
-        ...oversizedField
+        ...oversizedField,
+        ...notSpendableField
       };
     }
   }
@@ -3538,8 +3570,8 @@ var VtxoManager = class _VtxoManager {
       if (!serverPubKey) continue;
       const cls = classifyAgainstSignerSet(serverPubKey, signerSet, nowSeconds);
       if (cls.status === "CURRENT") continue;
-      const recoverable = vtxos.filter((v) => isRecoverable(v));
-      const spendable = vtxos.filter((v) => isSpendable(v) && !isRecoverable(v));
+      const recoverable = vtxos.filter((v) => v.isSwept && !hasTerminalSpend(v));
+      const spendable = vtxos.filter((v) => !hasTerminalSpend(v) && !v.isSwept);
       const value = spendable.reduce((sum, v) => sum + v.value, 0);
       let recoverableCount = 0;
       let recoverableValue = 0;
@@ -3552,7 +3584,7 @@ var VtxoManager = class _VtxoManager {
         awaitingSweepCount = spendable.length;
         awaitingSweepValue = value;
         for (const v of spendable) {
-          const exp = v.virtualStatus.batchExpiry;
+          const exp = toBatchExpiry(v);
           if (exp !== void 0 && (nextSweepEta === void 0 || exp < nextSweepEta)) {
             nextSweepEta = exp;
           }
@@ -3588,7 +3620,7 @@ var VtxoManager = class _VtxoManager {
       }
       if (isCooperativelyMigratable(cls.status)) {
         for (const v of spendable) {
-          if (!v.virtualStatus.batchExpiry) continue;
+          if (v.expiresAt === void 0 && v.expiresAtHeight === void 0) continue;
           migratable.push({ vtxo: v, classification: cls });
         }
       } else if (cls.status === "EXPIRED") {
@@ -3966,7 +3998,7 @@ var VtxoManager = class _VtxoManager {
    * candidates and lets the post-submit `VTXO_ALREADY_SPENT` recovery
    * handle whatever slipped through.
    */
-  async revalidateBeforeSettle(candidates, thresholdMs) {
+  async revalidateBeforeSettle(candidates, thresholdMs, now) {
     if (candidates.length === 0) return candidates;
     try {
       const cm = await this.wallet.getContractManager();
@@ -3976,7 +4008,7 @@ var VtxoManager = class _VtxoManager {
       return candidates;
     }
     try {
-      const refreshed = await this.getExpiringVtxos(thresholdMs);
+      const refreshed = await this.selectExpiringVtxos(thresholdMs, now);
       const candidateKeys = new Set(candidates.map((v) => `${v.txid}:${v.vout}`));
       return refreshed.filter((v) => candidateKeys.has(`${v.txid}:${v.vout}`));
     } catch (e) {
@@ -4094,10 +4126,12 @@ var VtxoManager = class _VtxoManager {
       (u) => u.status.confirmed && !this.knownBoardingUtxos.has(`${u.txid}:${u.vout}`) && !expiredSet.has(`${u.txid}:${u.vout}`)
     );
     let expiringVtxos = [];
+    let now;
     if (!this.renewalInProgress) {
       try {
-        expiringVtxos = await this.getExpiringVtxos();
-        expiringVtxos = await this.revalidateBeforeSettle(expiringVtxos);
+        now = await fetchTimeHeight(this.wallet);
+        expiringVtxos = await this.selectExpiringVtxos(void 0, now);
+        expiringVtxos = await this.revalidateBeforeSettle(expiringVtxos, void 0, now);
       } catch (e) {
         console.error("Error fetching expiring VTXOs:", e);
       }
@@ -4129,17 +4163,11 @@ var VtxoManager = class _VtxoManager {
       totalAmount += BigInt(u.value) - BigInt(inputFee.satoshis);
     }
     const filteredVtxos = [];
-    for (const v of byExpiryAscending(expiringVtxos)) {
+    for (const v of byExpiryAscending(expiringVtxos, now ?? { timestamp: /* @__PURE__ */ new Date() })) {
       if (filteredVtxos.length >= MAX_VTXOS_PER_SETTLEMENT) {
         break;
       }
-      const inputFee = estimator.evalOffchainInput({
-        amount: BigInt(v.value),
-        type: v.virtualStatus.state === "swept" ? "recoverable" : "vtxo",
-        weight: 0,
-        birth: v.createdAt,
-        expiry: v.virtualStatus.batchExpiry ? new Date(v.virtualStatus.batchExpiry) : void 0
-      });
+      const inputFee = estimator.evalOffchainInput(toOffchainInputFeeParams(v));
       if (inputFee.satoshis >= v.value) {
         continue;
       }
@@ -4343,8 +4371,8 @@ function readUInt32BE(array, offset) {
 function noteTapscript(preimageHash) {
   return Script.encode(["SHA256", preimageHash, "EQUAL"]);
 }
-var ArkCash = class _ArkCash {
-  constructor(privateKey, serverPubKey, csvTimelock, hrp = _ArkCash.DefaultHRP) {
+var ArkadeCash = class _ArkadeCash {
+  constructor(privateKey, serverPubKey, csvTimelock, hrp = _ArkadeCash.DefaultHRP) {
     this.csvTimelock = csvTimelock;
     this.hrp = hrp;
     if (privateKey.length !== 32) {
@@ -4363,7 +4391,7 @@ var ArkCash = class _ArkCash {
   }
   csvTimelock;
   hrp;
-  static DefaultHRP = "arkcash";
+  static DefaultHRP = "arkadecash";
   static Version = 0;
   static PayloadLength = 1 + 32 + 32 + 4;
   // 69 bytes
@@ -4386,32 +4414,32 @@ var ArkCash = class _ArkCash {
     return this._publicKey.slice();
   }
   static generate(serverPubKey, csvTimelock, hrp) {
-    return new _ArkCash(randomPrivateKeyBytes(), serverPubKey, csvTimelock, hrp);
+    return new _ArkadeCash(randomPrivateKeyBytes(), serverPubKey, csvTimelock, hrp);
   }
   static fromString(encoded) {
     const decoded = bech32m.decodeUnsafe(encoded.trim().toLowerCase(), 1023);
     if (!decoded) {
-      throw new Error("Invalid arkcash string: failed to decode bech32m");
+      throw new Error("Invalid arkadeCash string: failed to decode bech32m");
     }
     const data = new Uint8Array(bech32m.fromWords(decoded.words));
-    if (data.length !== _ArkCash.PayloadLength) {
+    if (data.length !== _ArkadeCash.PayloadLength) {
       throw new Error(
-        `Invalid arkcash data length: expected ${_ArkCash.PayloadLength} bytes, got ${data.length}`
+        `Invalid arkadeCash data length: expected ${_ArkadeCash.PayloadLength} bytes, got ${data.length}`
       );
     }
     const version = data[0];
-    if (version !== _ArkCash.Version) {
-      throw new Error(`Unsupported arkcash version: ${version}`);
+    if (version !== _ArkadeCash.Version) {
+      throw new Error(`Unsupported arkadeCash version: ${version}`);
     }
     const privateKey = data.slice(1, 33);
     const serverPubKey = data.slice(33, 65);
     const sequence = new DataView(data.buffer, data.byteOffset + 65, 4).getUint32(0, false);
     const csvTimelock = sequenceToTimelock(sequence);
-    return new _ArkCash(privateKey, serverPubKey, csvTimelock, decoded.prefix);
+    return new _ArkadeCash(privateKey, serverPubKey, csvTimelock, decoded.prefix);
   }
   toString() {
-    const data = new Uint8Array(_ArkCash.PayloadLength);
-    data[0] = _ArkCash.Version;
+    const data = new Uint8Array(_ArkadeCash.PayloadLength);
+    data[0] = _ArkadeCash.Version;
     data.set(this._privateKey, 1);
     data.set(this._serverPubKey, 33);
     const sequence = timelockToSequence(this.csvTimelock);
@@ -5497,13 +5525,13 @@ function subtractAssets(spent, change) {
   return Array.from(map, ([assetId, amount]) => ({ assetId, amount }));
 }
 async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnore, getTxCreatedAt) {
-  const fromOldestVtxo = [...vtxos].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  const fromOldestVtxo = vtxos.map(normalizeVtxo).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
   const unmatchedSettledBoardingTxs = allBoardingTxs.filter(isSettledBoardingReceive).sort((a, b) => a.createdAt - b.createdAt);
   const sent = [];
   let received = [];
   for (const vtxo of fromOldestVtxo) {
     if (vtxo.status.isLeaf) {
-      const commitmentTxid = vtxo.virtualStatus.commitmentTxIds[0];
+      const commitmentTxid = vtxo.commitmentTxIds[0];
       const vtxoCreatedAt = vtxo.createdAt.getTime();
       const ignoredCommitment = commitmentsToIgnore.has(commitmentTxid) || !!vtxo.settledBy && commitmentsToIgnore.has(vtxo.settledBy);
       if (ignoredCommitment) {
@@ -5511,7 +5539,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
           unmatchedSettledBoardingTxs,
           (tx) => tx.createdAt <= vtxoCreatedAt && (tx.key.commitmentTxid === commitmentTxid || tx.key.commitmentTxid === vtxo.settledBy)
         );
-      } else if (fromOldestVtxo.filter((v) => v.settledBy === vtxo.virtualStatus.commitmentTxIds[0]).length === 0) {
+      } else if (fromOldestVtxo.filter((v) => v.settledBy === vtxo.commitmentTxIds[0]).length === 0) {
         const duplicateBoardingReceive = consumeBoardingReceive(
           unmatchedSettledBoardingTxs,
           (tx) => tx.amount === vtxo.value && tx.createdAt <= vtxoCreatedAt
@@ -5574,7 +5602,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
       }
       if (vtxo.settledBy && !commitmentsToIgnore.has(vtxo.settledBy) && !sent.some((s) => s.key.commitmentTxid === vtxo.settledBy)) {
         const changes = fromOldestVtxo.filter(
-          (v) => v.status.isLeaf && v.virtualStatus.commitmentTxIds?.every((_) => vtxo.settledBy === _)
+          (v) => v.status.isLeaf && v.commitmentTxIds.length > 0 && v.commitmentTxIds.every((_) => vtxo.settledBy === _)
         );
         const forfeitVtxos = fromOldestVtxo.filter((v) => v.settledBy === vtxo.settledBy);
         const forfeitAmount = forfeitVtxos.reduce((acc, v) => acc + v.value, 0);
@@ -5963,7 +5991,7 @@ var DelegateManagerImpl = class {
     const destinationScript = ArkAddress.decode(destination).pkScript;
     const arkInfo = await this.arkInfoProvider.getInfo();
     const delegateInfo = await this.delegateProvider.getDelegateInfo();
-    const eligible = vtxos.filter(
+    const eligible = vtxos.map(normalizeVtxo).filter(
       (v) => isAnnotated(v) && findDelegateTapLeaf(v, delegateInfo.pubkey) !== void 0
     );
     if (eligible.length === 0) {
@@ -5988,14 +6016,15 @@ var DelegateManagerImpl = class {
       }
       return { delegated: eligible, failed: [] };
     }
+    const now = { timestamp: /* @__PURE__ */ new Date() };
     const groupByExpiry = /* @__PURE__ */ new Map();
     let recoverableVtxos = [];
     for (const vtxo of eligible) {
-      if (isRecoverable(vtxo)) {
+      if (canRecoverOnchain(vtxo, now)) {
         recoverableVtxos.push(vtxo);
         continue;
       }
-      const expiry = vtxo.virtualStatus.batchExpiry;
+      const expiry = toBatchExpiry(vtxo);
       if (!expiry) continue;
       const dayKey = getDayTimestamp(expiry);
       groupByExpiry.set(dayKey, [...groupByExpiry.get(dayKey) ?? [], vtxo]);
@@ -6059,10 +6088,8 @@ async function delegate(identity, delegateProvider, arkInfo, delegateInfo, vtxos
     throw new Error("unable to delegate: delegate provider not configured");
   }
   if (!delegateAt) {
-    const expiryTimestamp = vtxos.filter((coin) => !isRecoverable(coin) && coin.virtualStatus.batchExpiry).reduce(
-      (min, coin) => Math.min(min, coin.virtualStatus.batchExpiry),
-      Number.MAX_SAFE_INTEGER
-    );
+    const now = { timestamp: /* @__PURE__ */ new Date() };
+    const expiryTimestamp = vtxos.filter((coin) => !canRecoverOnchain(coin, now) && toBatchExpiry(coin)).reduce((min, coin) => Math.min(min, toBatchExpiry(coin)), Number.MAX_SAFE_INTEGER);
     if (!expiryTimestamp || expiryTimestamp === Number.MAX_SAFE_INTEGER) {
       delegateAt = new Date(Date.now() + 1 * 60 * 1e3);
     } else {
@@ -6091,11 +6118,8 @@ async function delegate(identity, delegateProvider, arkInfo, delegateInfo, vtxos
   let amount = 0n;
   for (const coin of vtxos) {
     const inputFee = estimator.evalOffchainInput({
-      amount: BigInt(coin.value),
-      type: "vtxo",
-      weight: 0,
-      birth: coin.createdAt,
-      expiry: coin.virtualStatus.batchExpiry ? new Date(coin.virtualStatus.batchExpiry) : void 0
+      ...toOffchainInputFeeParams(coin),
+      type: "vtxo"
     });
     if (inputFee.value >= coin.value) {
       continue;
@@ -6144,7 +6168,7 @@ async function delegate(identity, delegateProvider, arkInfo, delegateInfo, vtxos
     Address(getNetwork(network)).decode(forfeitAddress)
   );
   const forfeits = await Promise.all(
-    vtxos.filter((v) => !isRecoverable(v)).map(async (coin) => {
+    vtxos.filter((v) => !canRecoverOnchain(v, { timestamp: /* @__PURE__ */ new Date() })).map(async (coin) => {
       const forfeit = await makeDelegateForfeitTx(
         coin,
         dust,
@@ -6932,7 +6956,8 @@ function validateVtxosForScript(vtxos, script, context) {
   );
 }
 async function getVtxosForContract(repo, contract) {
-  return repo.getVtxosForScript ? repo.getVtxosForScript(contract.script) : filterVtxosForScript(await repo.getVtxos(contract.address), contract.script);
+  const vtxos = repo.getVtxosForScript ? await repo.getVtxosForScript(contract.script) : filterVtxosForScript(await repo.getVtxos(contract.address), contract.script);
+  return vtxos.map(normalizeVtxo);
 }
 async function saveVtxosForContract(repo, contract, vtxos) {
   if (repo.saveVtxosForScript) {
@@ -7136,7 +7161,7 @@ var deserializeTapLeaf = (t) => {
   const s = hex.decode(t.s);
   return [cb, s];
 };
-var deserializeVtxo = (o) => ({
+var deserializeVtxo = (o) => normalizeVtxo({
   ...o,
   createdAt: new Date(o.createdAt),
   tapTree: hex.decode(o.tapTree),
@@ -7735,50 +7760,12 @@ function getLifecycleWeight(v) {
   if (v.arkTxId) weight += 2;
   return weight;
 }
+
+// src/repositories/migrations/walletRepositoryImpl.ts
 var getVtxosStorageKey = (address) => `vtxos:${address}`;
 var getUtxosStorageKey = (address) => `utxos:${address}`;
 var getTransactionsStorageKey = (address) => `tx:${address}`;
 var walletStateStorageKey = "wallet:state";
-var serializeVtxo2 = (v) => ({
-  ...v,
-  tapTree: hex.encode(v.tapTree),
-  forfeitTapLeafScript: serializeTapLeaf2(v.forfeitTapLeafScript),
-  intentTapLeafScript: serializeTapLeaf2(v.intentTapLeafScript),
-  extraWitness: v.extraWitness?.map(hex.encode),
-  assets: serializeAssets(v.assets)
-});
-var serializeUtxo2 = (u) => ({
-  ...u,
-  tapTree: hex.encode(u.tapTree),
-  forfeitTapLeafScript: serializeTapLeaf2(u.forfeitTapLeafScript),
-  intentTapLeafScript: serializeTapLeaf2(u.intentTapLeafScript),
-  extraWitness: u.extraWitness?.map(hex.encode)
-});
-var deserializeVtxo2 = (o) => ({
-  ...o,
-  createdAt: new Date(o.createdAt),
-  tapTree: hex.decode(o.tapTree),
-  forfeitTapLeafScript: deserializeTapLeaf2(o.forfeitTapLeafScript),
-  intentTapLeafScript: deserializeTapLeaf2(o.intentTapLeafScript),
-  extraWitness: o.extraWitness?.map(hex.decode),
-  assets: deserializeAssets(o.assets)
-});
-var deserializeUtxo2 = (o) => ({
-  ...o,
-  tapTree: hex.decode(o.tapTree),
-  forfeitTapLeafScript: deserializeTapLeaf2(o.forfeitTapLeafScript),
-  intentTapLeafScript: deserializeTapLeaf2(o.intentTapLeafScript),
-  extraWitness: o.extraWitness?.map(hex.decode)
-});
-var serializeTapLeaf2 = ([cb, s]) => ({
-  cb: hex.encode(TaprootControlBlock.encode(cb)),
-  s: hex.encode(s)
-});
-var deserializeTapLeaf2 = (t) => {
-  const cb = TaprootControlBlock.decode(hex.decode(t.cb));
-  const s = hex.decode(t.s);
-  return [cb, s];
-};
 var WalletRepositoryImpl = class {
   version = 1;
   storage;
@@ -7790,7 +7777,7 @@ var WalletRepositoryImpl = class {
     if (!stored) return [];
     try {
       const parsed = JSON.parse(stored);
-      return parsed.map(deserializeVtxo2);
+      return parsed.map(deserializeVtxo);
     } catch (error) {
       console.error(`Failed to parse VTXOs for address ${address}:`, error);
       return [];
@@ -7810,7 +7797,7 @@ var WalletRepositoryImpl = class {
     }
     await this.storage.setItem(
       getVtxosStorageKey(address),
-      JSON.stringify(storedVtxos.map(serializeVtxo2))
+      JSON.stringify(storedVtxos.map(serializeVtxo))
     );
   }
   async clearVtxos(address) {
@@ -7824,7 +7811,7 @@ var WalletRepositoryImpl = class {
     if (!stored) return [];
     try {
       const parsed = JSON.parse(stored);
-      return parsed.map(deserializeUtxo2);
+      return parsed.map(deserializeUtxo);
     } catch (error) {
       console.error(`Failed to parse UTXOs for address ${address}:`, error);
       return [];
@@ -7844,7 +7831,7 @@ var WalletRepositoryImpl = class {
     });
     await this.storage.setItem(
       getUtxosStorageKey(address),
-      JSON.stringify(storedUtxos.map(serializeUtxo2))
+      JSON.stringify(storedUtxos.map(serializeUtxo))
     );
   }
   async clearUtxos(address) {
@@ -8496,15 +8483,27 @@ var ContractWatcher = class {
   }
   /**
    * Handle a subscription update.
+   *
+   * Normalization boundary: `getSubscription` is part of the public `IndexerProvider` interface,
+   * so a consumer implementation may yield legacy-shaped VTXOs. Normalizing on ingest also fixes
+   * the shape of the payloads emitted to external event consumers.
    */
   handleSubscriptionUpdate(update) {
     if (!this.eventCallback) return;
     const timestamp = Date.now();
     if (update.newVtxos?.length) {
-      this.processSubscriptionVtxos(update.newVtxos, "vtxo_received", timestamp);
+      this.processSubscriptionVtxos(
+        update.newVtxos.map(normalizeVtxo),
+        "vtxo_received",
+        timestamp
+      );
     }
     if (update.spentVtxos?.length) {
-      this.processSubscriptionVtxos(update.spentVtxos, "vtxo_spent", timestamp);
+      this.processSubscriptionVtxos(
+        update.spentVtxos.map(normalizeVtxo),
+        "vtxo_spent",
+        timestamp
+      );
     }
   }
   /**
@@ -8634,7 +8633,7 @@ async function reconcileIntents(deps) {
   let vtxosByOutpoint = /* @__PURE__ */ new Map();
   if (outpoints.length > 0) {
     try {
-      const { vtxos } = await deps.indexerProvider.getVtxos({ outpoints });
+      const { vtxos } = await getNormalizedVtxos(deps.indexerProvider, { outpoints });
       vtxosByOutpoint = new Map(vtxos.map((v) => [outpointKey(v), v]));
     } catch (e) {
       console.error("reconcileIntents: failed to fetch input VTXO state", e);
@@ -8887,9 +8886,10 @@ var ContractManager = class _ContractManager {
    * Safety-critical invariants (spec §2.C / §4):
    * - `opts.materialize(i)` throwing is structural/fatal: it is NOT
    *   wrapped — it propagates and aborts the scan.
-   * - A `discoverAt` rejection is collected into `handlerErrors` and the
-   *   loop continues (the gap counter still advances for that index if no
-   *   other handler hit it).
+   * - A `discoverAt` rejection is collected into `handlerErrors` and makes
+   *   its index *indeterminate*: it does NOT advance the gap counter, and
+   *   the scan stops verifying there, reporting `truncatedAt`. Only an index
+   *   every handler answered for can be a confirmed miss.
    * - `persistAndWatchContract` rejecting is operational/fatal and
    *   propagates (only `discoverAt` is guarded).
    * - Within an index the handler probes run concurrently (independent
@@ -8903,8 +8903,12 @@ var ContractManager = class _ContractManager {
    *   over-scanned, nothing is discarded, and `materialize`/`discoverAt` are
    *   invoked on exactly the same index set. The window's hits are still
    *   processed strictly in ascending index order, so the discovered set,
-   *   persisted rows, `lastIndexUsed`, and `handlerErrors` are byte-for-byte
-   *   identical to the serial path — only the wall-clock differs.
+   *   persisted rows, `highestConfirmedUsedIndex`, and `handlerErrors` are
+   *   byte-for-byte identical to the serial path — only the wall-clock
+   *   differs. Truncation is the one exception: a window's concurrent probes
+   *   can surface hits above the failed index that a serial scan would never
+   *   have reached, so a truncated batched scan discovers a superset — never
+   *   a subset — of the serial one.
    */
   async scanContracts(opts) {
     const gapLimit = opts.gapLimit ?? 20;
@@ -8926,7 +8930,8 @@ var ContractManager = class _ContractManager {
     ];
     const maxIdx = opts.hd ? SCAN_MAX_INDEX : 0;
     const handlerErrors = [];
-    let lastIndexUsed = -1;
+    let highestConfirmedUsedIndex = -1;
+    let truncatedAt;
     let unused = 0;
     let i = 0;
     const probeIndex = async (index) => {
@@ -8953,6 +8958,7 @@ var ContractManager = class _ContractManager {
         const index = windowIndices[w];
         const probes = windowProbes[w];
         let hitAtThisIndex = false;
+        let indeterminate = false;
         for (let h = 0; h < discoverables.length; h++) {
           const probe = probes[h];
           if (!probe.ok) {
@@ -8961,6 +8967,7 @@ var ContractManager = class _ContractManager {
               index,
               error: probe.error
             });
+            indeterminate = true;
             continue;
           }
           for (const c of probe.found) {
@@ -8968,21 +8975,26 @@ var ContractManager = class _ContractManager {
             hitAtThisIndex = true;
           }
         }
-        if (hitAtThisIndex) {
-          lastIndexUsed = index;
-          unused = 0;
-        } else {
-          unused += 1;
-        }
+        if (indeterminate && truncatedAt === void 0) truncatedAt = index;
+        if (hitAtThisIndex) highestConfirmedUsedIndex = index;
+        if (truncatedAt !== void 0) continue;
+        if (hitAtThisIndex) unused = 0;
+        else unused += 1;
       }
+      if (truncatedAt !== void 0) break;
       i = windowEnd + 1;
     }
-    if (opts.hd && i > maxIdx && unused < gapLimit) {
+    if (opts.hd && truncatedAt === void 0 && i > maxIdx && unused < gapLimit) {
       throw new Error(
         `scanContracts: reached SCAN_MAX_INDEX (${SCAN_MAX_INDEX}) without closing the ${gapLimit}-index gap window; a Discoverable handler may be returning unconditional hits`
       );
     }
-    return { lastIndexUsed, handlerErrors };
+    return {
+      lastIndexUsed: highestConfirmedUsedIndex,
+      highestConfirmedUsedIndex,
+      ...truncatedAt !== void 0 && { truncatedAt },
+      handlerErrors
+    };
   }
   /**
    * Get contracts with optional filters.
@@ -9029,7 +9041,9 @@ var ContractManager = class _ContractManager {
       byScript.set(contract.script, contract);
     }
     const tapscriptCache = /* @__PURE__ */ new Map();
-    return vtxos.map((vtxo) => extendVirtualCoinForContract(vtxo, byScript, tapscriptCache));
+    return vtxos.map(
+      (vtxo) => extendVirtualCoinForContract(normalizeVtxo(vtxo), byScript, tapscriptCache)
+    );
   }
   buildContractsDbFilter(filter) {
     return {
@@ -9197,7 +9211,7 @@ var ContractManager = class _ContractManager {
   }
   async refreshOutpoints(outpoints) {
     if (outpoints.length === 0) return;
-    const { vtxos } = await this.config.indexerProvider.getVtxos({
+    const { vtxos } = await getNormalizedVtxos(this.config.indexerProvider, {
       outpoints
     });
     if (vtxos.length === 0) return;
@@ -9325,7 +9339,7 @@ var ContractManager = class _ContractManager {
   async reconcilePendingFrontier(contracts) {
     const scripts = contracts.map((c) => c.script);
     const scriptToContract = new Map(contracts.map((c) => [c.script, c]));
-    const { vtxos } = await this.config.indexerProvider.getVtxos({
+    const { vtxos } = await getNormalizedVtxos(this.config.indexerProvider, {
       scripts,
       pendingOnly: true
     });
@@ -9416,7 +9430,7 @@ var ContractManager = class _ContractManager {
     let pageIndex = 0;
     let hasMore = true;
     while (hasMore) {
-      const { vtxos, page } = await this.config.indexerProvider.getVtxos({
+      const { vtxos, page } = await getNormalizedVtxos(this.config.indexerProvider, {
         scripts,
         ...windowOpts,
         pageIndex,
@@ -10233,14 +10247,14 @@ var cashReport = (vtxo, reason) => ({
   value: vtxo.value,
   reason
 });
-var ArkCashCreateError = class extends Error {
+var ArkadeCashCreateError = class extends Error {
   constructor(cash, cause) {
     super(
-      `Failed to create ArkCash: send failed after the note may have been submitted. Recover with claimCash using the token on this error's \`cash\` field.`
+      `Failed to create ArkadeCash: send failed after the note may have been submitted. Recover with claimCash using the token on this error's \`cash\` field.`
     );
     this.cash = cash;
     this.cause = cause;
-    this.name = "ArkCashCreateError";
+    this.name = "ArkadeCashCreateError";
   }
   cash;
   cause;
@@ -10703,20 +10717,21 @@ var ReadonlyWallet = class _ReadonlyWallet {
     }
     let recoverable = 0;
     let pendingRecovery = 0;
-    const settled = vtxos.filter((coin) => coin.virtualStatus.state === "settled" && !isPendingRecovery(coin)).reduce((sum, coin) => sum + coin.value, 0);
-    const preconfirmed = vtxos.filter(
-      (coin) => coin.virtualStatus.state === "preconfirmed" && !isPendingRecovery(coin)
+    const now = { timestamp: /* @__PURE__ */ new Date() };
+    const settled = vtxos.filter(
+      (coin) => canSpendOffchain(coin, now) && !coin.isPreconfirmed && !isPendingRecovery(coin)
     ).reduce((sum, coin) => sum + coin.value, 0);
-    const available = unlockedVtxos.filter(
-      (coin) => (coin.virtualStatus.state === "settled" || coin.virtualStatus.state === "preconfirmed") && !isPendingRecovery(coin)
+    const preconfirmed = vtxos.filter(
+      (coin) => canSpendOffchain(coin, now) && coin.isPreconfirmed && !isPendingRecovery(coin)
     ).reduce((sum, coin) => sum + coin.value, 0);
-    recoverable = vtxos.filter((coin) => isSpendable(coin) && coin.virtualStatus.state === "swept").reduce((sum, coin) => sum + coin.value, 0);
+    const available = unlockedVtxos.filter((coin) => canSpendOffchain(coin, now) && !isPendingRecovery(coin)).reduce((sum, coin) => sum + coin.value, 0);
+    recoverable = vtxos.filter((coin) => canRecoverOnchain(coin, now) && !isPendingRecovery(coin)).reduce((sum, coin) => sum + coin.value, 0);
     pendingRecovery = vtxos.filter(isPendingRecovery).reduce((sum, coin) => sum + coin.value, 0);
     const totalBoarding = confirmed + unconfirmed;
     const totalOffchain = settled + preconfirmed + recoverable + pendingRecovery;
     const assetBalances = /* @__PURE__ */ new Map();
     for (const vtxo of vtxos) {
-      if (!isSpendable(vtxo)) continue;
+      if (hasTerminalSpend(vtxo)) continue;
       if (vtxo.assets) {
         for (const a of vtxo.assets) {
           const current = assetBalances.get(a.assetId) ?? 0n;
@@ -10752,12 +10767,13 @@ var ReadonlyWallet = class _ReadonlyWallet {
     const f = filter ?? { withRecoverable: true, withUnrolled: false };
     const contractManager = await this.getContractManager();
     const vtxos = await contractManager.getContractsWithVtxos();
+    const now = { timestamp: /* @__PURE__ */ new Date() };
     return vtxos.flatMap((_) => _.vtxos).filter((vtxo) => {
       if (this._pendingSpendOutpoints.has(`${vtxo.txid}:${vtxo.vout}`)) {
         return false;
       }
-      if (isSpendable(vtxo)) {
-        if (!f.withRecoverable && (isRecoverable(vtxo) || isExpired(vtxo))) {
+      if (!hasTerminalSpend(vtxo)) {
+        if (!f.withRecoverable && canRecoverOnchain(vtxo, now)) {
           return false;
         }
         return true;
@@ -10790,7 +10806,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
     const response = await contractManager.getContractsWithVtxos();
     const allVtxos = response.flatMap((_) => _.vtxos);
     const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
-    const getTxCreatedAt = (txid) => this.indexerProvider.getVtxos({ outpoints: [{ txid, vout: 0 }] }).then((res) => res.vtxos[0]?.createdAt.getTime()).catch((err) => {
+    const getTxCreatedAt = (txid) => getNormalizedVtxos(this.indexerProvider, { outpoints: [{ txid, vout: 0 }] }).then((res) => res.vtxos[0]?.createdAt.getTime()).catch((err) => {
       if (isRetryableProviderError(err)) return void 0;
       throw err;
     });
@@ -10866,6 +10882,12 @@ var ReadonlyWallet = class _ReadonlyWallet {
             if (spent && commitmentTxid) {
               commitmentsToIgnore.add(commitmentTxid);
             }
+            const boardingFacts = {
+              isSpent: spent,
+              isSwept: false,
+              isPreconfirmed: false,
+              commitmentTxIds: spent && commitmentTxid ? [commitmentTxid] : []
+            };
             utxos.push({
               txid: tx.txid,
               vout: i,
@@ -10875,10 +10897,9 @@ var ReadonlyWallet = class _ReadonlyWallet {
                 block_time: tx.status.block_time
               },
               isUnrolled: true,
-              virtualStatus: {
-                state: spent ? "spent" : "settled",
-                commitmentTxIds: spent && commitmentTxid ? [commitmentTxid] : void 0
-              },
+              ...boardingFacts,
+              virtualStatus: toVirtualStatus(boardingFacts),
+              spentBy: "",
               createdAt: tx.status.confirmed ? new Date(tx.status.block_time * 1e3) : /* @__PURE__ */ new Date(0),
               script: scriptHex
             });
@@ -10892,12 +10913,12 @@ var ReadonlyWallet = class _ReadonlyWallet {
       const tx = {
         key: {
           boardingTxid: utxo.txid,
-          commitmentTxid: utxo.virtualStatus.commitmentTxIds?.[0] ?? "",
+          commitmentTxid: utxo.commitmentTxIds[0] ?? "",
           arkTxid: ""
         },
         amount: utxo.value,
         type: "RECEIVED" /* TxReceived */,
-        settled: utxo.virtualStatus.state === "spent",
+        settled: utxo.isSpent,
         createdAt: utxo.status.block_time ? new Date(utxo.status.block_time * 1e3).getTime() : 0
       };
       if (!utxo.status.block_time) {
@@ -11121,11 +11142,11 @@ var ReadonlyWallet = class _ReadonlyWallet {
   /** Fetch Arkade transaction ids that are still pending final settlement. */
   async fetchPendingTxs() {
     const scripts = await this.getWalletScripts();
-    let { vtxos } = await this.indexerProvider.getVtxos({
+    let { vtxos } = await getNormalizedVtxos(this.indexerProvider, {
       scripts
     });
     return vtxos.filter(
-      (vtxo) => vtxo.virtualStatus.state !== "swept" && vtxo.virtualStatus.state !== "settled" && vtxo.arkTxId !== void 0
+      (vtxo) => (vtxo.isSpent || vtxo.isPreconfirmed && !vtxo.isSwept) && vtxo.arkTxId !== void 0
     ).map((_) => _.arkTxId);
   }
   // ========================================================================
@@ -11224,7 +11245,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       });
       onVtxosPersisted = async (_contract, vtxos) => {
         for (const v of vtxos) {
-          if (v.virtualStatus.state === "spent") continue;
+          if (v.isSpent) continue;
           await captureExitBranch({
             resolver,
             repository: virtualTxRepository,
@@ -11701,14 +11722,14 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   _restoreInFlight;
   _addPendingSpends(inputs) {
     for (const input of inputs) {
-      if ("virtualStatus" in input) {
+      if (isVirtualCoin(input)) {
         this._pendingSpendOutpoints.add(`${input.txid}:${input.vout}`);
       }
     }
   }
   _removePendingSpends(inputs) {
     for (const input of inputs) {
-      if ("virtualStatus" in input) {
+      if (isVirtualCoin(input)) {
         this._pendingSpendOutpoints.delete(`${input.txid}:${input.vout}`);
       }
     }
@@ -11796,15 +11817,22 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       materialize,
       deps
     });
-    if (hd && result.lastIndexUsed >= 0) {
-      await provider.advanceLastIndexUsed(result.lastIndexUsed);
+    if (hd && result.highestConfirmedUsedIndex >= 0) {
+      await provider.advanceLastIndexUsed(result.highestConfirmedUsedIndex);
     }
     await manager.refreshVtxos({ includeInactive: true });
+    const causes = result.handlerErrors.map(
+      (e) => e.error instanceof Error ? e.error : new Error(String(e.error))
+    );
+    if (result.truncatedAt !== void 0) {
+      throw new AggregateError(
+        causes,
+        `restore: scan truncated at index ${result.truncatedAt}; indices >= ${result.truncatedAt} are unverified (${result.handlerErrors.length} discovery handler failure(s)). Retry is safe (idempotent).`
+      );
+    }
     if (result.handlerErrors.length > 0) {
       throw new AggregateError(
-        result.handlerErrors.map(
-          (e) => e.error instanceof Error ? e.error : new Error(String(e.error))
-        ),
+        causes,
         `restore: ${result.handlerErrors.length} discovery handler(s) failed; the gap window may have closed early \u2014 retry is safe (idempotent).`
       );
     }
@@ -12116,13 +12144,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         if (filteredVtxos.length >= MAX_VTXOS_PER_SETTLEMENT) {
           break;
         }
-        const inputFee = estimator.evalOffchainInput({
-          amount: BigInt(vtxo.value),
-          type: vtxo.virtualStatus.state === "swept" ? "recoverable" : "vtxo",
-          weight: 0,
-          birth: vtxo.createdAt,
-          expiry: vtxo.virtualStatus.batchExpiry ? new Date(vtxo.virtualStatus.batchExpiry) : void 0
-        });
+        const inputFee = estimator.evalOffchainInput(toOffchainInputFeeParams(vtxo));
         if (inputFee.satoshis >= vtxo.value) {
           continue;
         }
@@ -12338,9 +12360,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    * renewal / offboard) is not a board and leaves the boarding address
    * untouched.
    *
-   * Boarding inputs are the non-VTXO coins (no `virtualStatus`), the same
+   * Boarding inputs are the non-VTXO coins (no `script`), the same
    * discriminator {@link handleSettlementFinalizationEvent} uses; the
-   * `typeof` guard skips arknote string inputs before the `in` test.
+   * `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
@@ -12353,7 +12375,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   async maybeRotateBoardingAfterBoard(inputs) {
     if (!this._descriptorProvider) return;
     const consumedBoarding = inputs.some(
-      (input) => typeof input !== "string" && !("virtualStatus" in input)
+      (input) => typeof input !== "string" && !isVirtualCoin(input)
     );
     if (!consumedBoarding) return;
     try {
@@ -12364,13 +12386,12 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   }
   async handleSettlementFinalizationEvent(event, inputs, forfeitOutputScript, connectorsGraph) {
     const signedForfeits = [];
-    const isVtxo = (input) => "virtualStatus" in input;
     let settlementPsbt = Transaction$2.fromPSBT(base64.decode(event.commitmentTx));
     let hasBoardingUtxos = false;
     let connectorIndex = 0;
     const connectorsLeaves = connectorsGraph?.leaves() || [];
     for (const input of inputs) {
-      if (!isVtxo(input)) {
+      if (!isVirtualCoin(input)) {
         for (let i = 0; i < settlementPsbt.inputsLength; i++) {
           const settlementInput = settlementPsbt.getInput(i);
           if (!settlementInput.txid || settlementInput.index === void 0) {
@@ -12401,7 +12422,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         }
         continue;
       }
-      if (isRecoverable(input) || isSubdust({ value: input.value }, this.dustAmount)) {
+      if (canRecoverOnchain(input, { timestamp: /* @__PURE__ */ new Date() }) || isSubdust({ value: input.value }, this.dustAmount)) {
         continue;
       }
       if (connectorsLeaves.length === 0) {
@@ -12708,13 +12729,13 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       const scriptMap = await this.getScriptMap();
       const allExtended = [];
       const allScripts = [...scriptMap.keys()];
-      const { vtxos: fetchedVtxos } = await this.indexerProvider.getVtxos({
+      const { vtxos: fetchedVtxos } = await getNormalizedVtxos(this.indexerProvider, {
         scripts: allScripts
       });
       for (const vtxo of fetchedVtxos) {
         const vtxoScript = scriptMap.get(vtxo.script);
         if (!vtxoScript) continue;
-        if (vtxo.virtualStatus.state === "swept" || vtxo.virtualStatus.state === "settled") {
+        if (!vtxo.isSpent && !(vtxo.isPreconfirmed && !vtxo.isSwept)) {
           continue;
         }
         allExtended.push({
@@ -12814,14 +12835,14 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     }));
   }
   /**
-   * Create an ArkCash bearer instrument.
+   * Create an ArkadeCash bearer instrument.
    *
    * Generates a fresh keypair, sends the specified amount to a DefaultVtxo
-   * controlled by the new key, and returns the encoded arkcash string.
+   * controlled by the new key, and returns the encoded arkadeCash string.
    * The receiver can claim the funds using `claimCash()` without ever
    * sharing their address.
    *
-   * ArkCash is a short-lived instrument: it carries a private key, so it is
+   * ArkadeCash is a short-lived instrument: it carries a private key, so it is
    * meant to be handed over and claimed promptly, not held. A note left
    * unclaimed past its batch expiry is swept by the server and `claimCash`
    * can only report it, not move it.
@@ -12829,16 +12850,16 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    * @param amount - Amount in satoshis to send. Must be a whole number of
    * sats at or above the dust threshold — a below-dust amount would mint an
    * OP_RETURN output that is unspendable as cash.
-   * @returns The encoded arkcash string (e.g., "arkcash1...")
+   * @returns The encoded arkadeCash string (e.g., "arkadecash1...")
    */
   async createCash(amount) {
     if (!Number.isSafeInteger(amount) || amount < Number(this.dustAmount)) {
       throw new Error(
-        `Invalid ArkCash amount ${amount}: must be a whole number of sats >= dust (${this.dustAmount})`
+        `Invalid ArkadeCash amount ${amount}: must be a whole number of sats >= dust (${this.dustAmount})`
       );
     }
-    const cashHrp = this.network.hrp.replace(/ark$/, "arkcash");
-    const cash = ArkCash.generate(
+    const cashHrp = this.network.hrp.replace(/ark$/, "arkadecash");
+    const cash = ArkadeCash.generate(
       this.arkServerPublicKey,
       this.offchainTapscript.options.csvTimelock,
       cashHrp
@@ -12848,37 +12869,37 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     try {
       await this.send({ address, amount });
     } catch (error) {
-      throw new ArkCashCreateError(cashStr, error);
+      throw new ArkadeCashCreateError(cashStr, error);
     }
     return cashStr;
   }
   /**
-   * Claim an ArkCash bearer instrument: sweep what can be swept, report the
+   * Claim an ArkadeCash bearer instrument: sweep what can be swept, report the
    * rest.
    *
-   * Every spendable VTXO at the arkcash address is swept to this wallet in
-   * its own offchain transaction, signed with the key carried by the arkcash
+   * Every spendable VTXO at the arkadeCash address is swept to this wallet in
+   * its own offchain transaction, signed with the key carried by the arkadeCash
    * string. Nothing is ever persisted: no contract is imported, and the
-   * arkcash key is not stored. Anything that cannot be swept — server-swept,
+   * arkadeCash key is not stored. Anything that cannot be swept — server-swept,
    * subdust, already claimed, or asset-bearing — is returned in `unclaimed`
    * with a per-VTXO reason and otherwise ignored.
    *
-   * The arkcash string is the recovery token: a claim interrupted between
+   * The arkadeCash string is the recovery token: a claim interrupted between
    * submit and finalize is completed by simply re-running `claimCash`, which
-   * drains any pending arkcash transaction on the server before sweeping.
+   * drains any pending arkadeCash transaction on the server before sweeping.
    *
-   * @param cashStr - The encoded arkcash string (e.g., "arkcash1...")
+   * @param cashStr - The encoded arkadeCash string (e.g., "arkadecash1...")
    * @returns The swept total and the report of what was left behind. The
    * shape is open: further buckets may be added alongside `unclaimed`.
    */
   async claimCash(cashStr) {
-    const cash = ArkCash.fromString(cashStr);
+    const cash = ArkadeCash.fromString(cashStr);
     const cashScript = cash.vtxoScript;
     const cashPkScript = hex.encode(cashScript.pkScript);
     const scripts = [cashPkScript];
     let vtxos = await this.fetchAllVtxos(scripts);
     if (vtxos.length === 0) {
-      throw new Error("No VTXOs found for this arkcash");
+      throw new Error("No VTXOs found for this arkadeCash");
     }
     const myPkScript = ArkAddress.decode(await this.getAddress()).pkScript;
     let { spendable, unclaimed } = this.classifyCashVtxos(vtxos);
@@ -12894,7 +12915,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           myPkScript
         );
       } catch (error) {
-        console.error("Failed to drain pending arkcash txs:", error);
+        console.error("Failed to drain pending arkadeCash txs:", error);
       }
       if (drained.count > 0) {
         vtxos = await this.fetchAllVtxos(scripts);
@@ -12929,7 +12950,10 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           });
           swept += vtxo.value;
         } catch (error) {
-          console.error(`Failed to sweep arkcash VTXO ${vtxo.txid}:${vtxo.vout}:`, error);
+          console.error(
+            `Failed to sweep arkadeCash VTXO ${vtxo.txid}:${vtxo.vout}:`,
+            error
+          );
           unclaimed.push(cashReport(vtxo, "sweep-failed"));
         }
       }
@@ -12943,18 +12967,18 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     };
   }
   /**
-   * Split the VTXOs at an arkcash address into the ones the thin sweep can
+   * Split the VTXOs at an arkadeCash address into the ones the thin sweep can
    * move and the ones it can only report.
    */
   classifyCashVtxos(vtxos) {
     const spendable = [];
     const unclaimed = [];
     for (const vtxo of vtxos) {
-      if (!isSpendable(vtxo)) {
+      if (hasTerminalSpend(vtxo)) {
         unclaimed.push(cashReport(vtxo, "already-spent"));
       } else if (isSubdust(vtxo, this.dustAmount)) {
         unclaimed.push(cashReport(vtxo, "subdust"));
-      } else if (isRecoverable(vtxo)) {
+      } else if (vtxo.isSwept) {
         unclaimed.push(cashReport(vtxo, "swept"));
       } else if (vtxo.assets && vtxo.assets.length > 0) {
         unclaimed.push(cashReport(vtxo, "has-assets"));
@@ -12970,7 +12994,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     const all = [];
     const seen = /* @__PURE__ */ new Set();
     for (let pageIndex = 0; ; pageIndex++) {
-      const { vtxos, page } = await this.indexerProvider.getVtxos({
+      const { vtxos, page } = await getNormalizedVtxos(this.indexerProvider, {
         scripts,
         pageIndex,
         pageSize
@@ -12986,7 +13010,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   }
   /**
    * Complete any sweep a previous `claimCash` registered but never finalized.
-   * A thin variant of {@link finalizePendingTxs}, scoped to the arkcash key:
+   * A thin variant of {@link finalizePendingTxs}, scoped to the arkadeCash key:
    * the intent is signed with it, and so are the returned checkpoints.
    *
    * A drained sweep is not automatically *ours*. Whoever registered it chose
@@ -12995,7 +13019,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    * completing it unsticks the funds), but only the value it actually pays to
    * `myPkScript` may be counted as claimed here.
    *
-   * @param vtxos - VTXOs at the arkcash contract's own pkScript, spent ones
+   * @param vtxos - VTXOs at the arkadeCash contract's own pkScript, spent ones
    * included (a registered sweep marks its input spent). Any other outpoint —
    * subdust above all — would make the proof invalid, since it describes every
    * input by that pkScript.
@@ -13056,7 +13080,10 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           }
         }
       } catch (error) {
-        console.error(`Failed to finalize pending arkcash tx ${pendingTx.arkTxid}:`, error);
+        console.error(
+          `Failed to finalize pending arkadeCash tx ${pendingTx.arkTxid}:`,
+          error
+        );
       }
     }
     return result;
@@ -13300,7 +13327,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    * there is no separate change output. It records no `TxSent` history — the
    * funds never leave the wallet.
    */
-  async sendSelectedVtxosToSelf(inputs) {
+  async sendSelectedVtxosToSelf(inputs, now) {
     if (inputs.length === 0) {
       throw new Error("sendSelectedVtxosToSelf: no inputs");
     }
@@ -13309,26 +13336,28 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       const serverPubKey = this.arkServerPublicKey;
       const serverUnrollScript = this.serverUnrollScript;
       const arkAddress = offchainTapscript.address(this.network.hrp, serverPubKey);
-      for (const input of inputs) {
-        if (!isSpendable(input) || isRecoverable(input)) {
+      const normalizedInputs = inputs.map(normalizeVtxo);
+      const at = now ?? await resolveTimeHeight(this.onchainProvider);
+      for (const input of normalizedInputs) {
+        if (!canSpendOffchain(input, at)) {
           throw new Error(
             `sendSelectedVtxosToSelf: input ${input.txid}:${input.vout} is not cooperatively spendable`
           );
         }
-        if (!input.virtualStatus.batchExpiry) {
+        if (input.expiresAt === void 0 && input.expiresAtHeight === void 0) {
           throw new Error(
-            `sendSelectedVtxosToSelf: input ${input.txid}:${input.vout} has no batchExpiry`
+            `sendSelectedVtxosToSelf: input ${input.txid}:${input.vout} has no batch expiry`
           );
         }
       }
-      const total = inputs.reduce((sum, c) => sum + BigInt(c.value), 0n);
+      const total = normalizedInputs.reduce((sum, c) => sum + BigInt(c.value), 0n);
       const outputs = [
         {
           script: total < this.dustAmount ? arkAddress.subdustPkScript : arkAddress.pkScript,
           amount: total
         }
       ];
-      const assetInputs = selectedCoinsToAssetInputs(inputs);
+      const assetInputs = selectedCoinsToAssetInputs(normalizedInputs);
       let selfAssets;
       if (assetInputs.size > 0) {
         const totals = /* @__PURE__ */ new Map();
@@ -13345,7 +13374,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         const packet = createAssetPacket(assetInputs, [], selfReceiver);
         outputs.push(Extension.create([packet]).txOut());
       }
-      return this._submitOffchainSpend(inputs, outputs, {
+      return this._submitOffchainSpend(normalizedInputs, outputs, {
         sentAmount: 0,
         changeAmount: total,
         changeVout: 0,
@@ -13446,43 +13475,42 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       const cm = await this.getContractManager();
       const annotatedInputs = await cm.annotateVtxos(inputs);
       for (const [inputIndex, vtxo] of annotatedInputs.entries()) {
+        const spentFacts = { ...vtxo, isSpent: true };
         if (inputIndex < safeLength && signedCheckpointTxs[inputIndex]) {
           const checkpoint = Transaction$2.fromPSBT(
             base64.decode(signedCheckpointTxs[inputIndex])
           );
           spentVtxos.push({
-            ...vtxo,
-            virtualStatus: {
-              ...vtxo.virtualStatus,
-              state: "spent"
-            },
+            ...spentFacts,
+            virtualStatus: toVirtualStatus(spentFacts),
             spentBy: checkpoint.id,
-            arkTxId: arkTxid,
-            isSpent: true
+            arkTxId: arkTxid
           });
         } else {
           spentVtxos.push({
-            ...vtxo,
-            virtualStatus: {
-              ...vtxo.virtualStatus,
-              state: "spent"
-            },
-            arkTxId: arkTxid,
-            isSpent: true
+            ...spentFacts,
+            virtualStatus: toVirtualStatus(spentFacts),
+            arkTxId: arkTxid
           });
         }
-        if (vtxo.virtualStatus.commitmentTxIds) {
-          for (const id of vtxo.virtualStatus.commitmentTxIds) {
-            commitmentTxIds.add(id);
-          }
+        for (const id of vtxo.commitmentTxIds) {
+          commitmentTxIds.add(id);
         }
-        if (vtxo.virtualStatus.batchExpiry) {
-          batchExpiry = Math.min(batchExpiry, vtxo.virtualStatus.batchExpiry);
+        const vtxoExpiry = toBatchExpiry(vtxo);
+        if (vtxoExpiry) {
+          batchExpiry = Math.min(batchExpiry, vtxoExpiry);
         }
       }
       const createdAt = Date.now();
       let changeVtxo;
       if (changeAmount > 0n && batchExpiry !== Number.MAX_SAFE_INTEGER) {
+        const changeFacts = {
+          isSpent: false,
+          isSwept: false,
+          isPreconfirmed: true,
+          commitmentTxIds: Array.from(commitmentTxIds),
+          ...parseLegacyExpiry(batchExpiry)
+        };
         changeVtxo = {
           txid: arkTxid,
           vout: changeVout,
@@ -13490,14 +13518,11 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           forfeitTapLeafScript: offchainTapscript.forfeit(),
           intentTapLeafScript: offchainTapscript.forfeit(),
           isUnrolled: false,
-          isSpent: false,
           tapTree: offchainTapscript.encode(),
           value: Number(changeAmount),
-          virtualStatus: {
-            state: "preconfirmed",
-            commitmentTxIds: Array.from(commitmentTxIds),
-            batchExpiry
-          },
+          ...changeFacts,
+          virtualStatus: toVirtualStatus(changeFacts),
+          spentBy: "",
           status: {
             confirmed: false
           },
@@ -13565,25 +13590,25 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       const spentVtxos = [];
       const inputArkTxIds = /* @__PURE__ */ new Set();
       const boardingRemovalsByAddress = /* @__PURE__ */ new Map();
-      const isVtxo = (input) => "virtualStatus" in input;
-      const vtxoInputs = inputs.filter(isVtxo);
+      const vtxoInputs = inputs.filter(isVirtualCoin);
       const cm = await this.getContractManager();
       const annotatedVtxos = await cm.annotateVtxos(vtxoInputs);
       const annotatedByKey = new Map(annotatedVtxos.map((v) => [`${v.txid}:${v.vout}`, v]));
       for (const input of inputs) {
-        if (isVtxo(input)) {
-          const vtxo = annotatedByKey.get(`${input.txid}:${input.vout}`);
+        if (isVirtualCoin(input)) {
+          const outpoint = `${input.txid}:${input.vout}`;
+          const vtxo = annotatedByKey.get(outpoint);
+          if (!vtxo) {
+            throw new Error(`missing annotation for virtual coin ${outpoint}`);
+          }
           if (vtxo.arkTxId) {
             inputArkTxIds.add(vtxo.arkTxId);
           }
+          const settledFacts = { ...vtxo, isSpent: true };
           spentVtxos.push({
-            ...vtxo,
-            virtualStatus: {
-              ...vtxo.virtualStatus,
-              state: "settled"
-            },
-            settledBy: commitmentTxid,
-            isSpent: true
+            ...settledFacts,
+            virtualStatus: toVirtualStatus(settledFacts),
+            settledBy: commitmentTxid
           });
         } else {
           let sourceAddress;
@@ -13646,9 +13671,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   }
 };
 function selectVirtualCoins(coins, targetAmount) {
-  const sortedCoins = [...coins].sort((a, b) => {
-    const expiryA = a.virtualStatus.batchExpiry || Number.MAX_SAFE_INTEGER;
-    const expiryB = b.virtualStatus.batchExpiry || Number.MAX_SAFE_INTEGER;
+  const sortedCoins = coins.map(normalizeVtxo).sort((a, b) => {
+    const expiryA = toBatchExpiry(a) || Number.MAX_SAFE_INTEGER;
+    const expiryB = toBatchExpiry(b) || Number.MAX_SAFE_INTEGER;
     if (expiryA !== expiryB) {
       return expiryA - expiryB;
     }
@@ -14342,13 +14367,7 @@ var Ramps = class {
     const filteredVtxos = [];
     let totalAmount = 0n;
     for (const vtxo of vtxos) {
-      const inputFee = estimator.evalOffchainInput({
-        amount: BigInt(vtxo.value),
-        type: vtxo.virtualStatus.state === "swept" ? "recoverable" : "vtxo",
-        weight: 0,
-        birth: vtxo.createdAt,
-        expiry: vtxo.virtualStatus.batchExpiry ? new Date(vtxo.virtualStatus.batchExpiry) : void 0
-      });
+      const inputFee = estimator.evalOffchainInput(toOffchainInputFeeParams(vtxo));
       if (inputFee.satoshis >= vtxo.value) {
         continue;
       }
@@ -15083,30 +15102,30 @@ var WalletMessageHandler = class {
         unconfirmed += utxo.value;
       }
     }
-    const spendableVtxos = allVtxos.filter(isSpendable);
-    const sweptVtxos = allVtxos.filter((vtxo) => vtxo.virtualStatus.state === "swept");
+    const now = { timestamp: /* @__PURE__ */ new Date() };
     let settled = 0;
     let preconfirmed = 0;
     let recoverable = 0;
     let pendingRecovery = 0;
-    for (const vtxo of spendableVtxos) {
+    for (const vtxo of allVtxos) {
+      if (hasTerminalSpend(vtxo)) continue;
       if (pendingOutpoints.has(`${vtxo.txid}:${vtxo.vout}`)) {
         pendingRecovery += vtxo.value;
-      } else if (vtxo.virtualStatus.state === "settled") {
-        settled += vtxo.value;
-      } else if (vtxo.virtualStatus.state === "preconfirmed") {
-        preconfirmed += vtxo.value;
-      }
-    }
-    for (const vtxo of sweptVtxos) {
-      if (isSpendable(vtxo)) {
+      } else if (canRecoverOnchain(vtxo, now)) {
         recoverable += vtxo.value;
+      } else if (canSpendOffchain(vtxo, now)) {
+        if (vtxo.isPreconfirmed) {
+          preconfirmed += vtxo.value;
+        } else {
+          settled += vtxo.value;
+        }
       }
     }
     const totalBoarding = confirmed + unconfirmed;
     const totalOffchain = settled + preconfirmed + recoverable + pendingRecovery;
     const assetBalances = /* @__PURE__ */ new Map();
-    for (const vtxo of spendableVtxos) {
+    for (const vtxo of allVtxos) {
+      if (hasTerminalSpend(vtxo)) continue;
       if (vtxo.assets) {
         for (const a of vtxo.assets) {
           const current = assetBalances.get(a.assetId) ?? 0n;
@@ -15142,7 +15161,7 @@ var WalletMessageHandler = class {
    */
   async getSpendableVtxos() {
     const vtxos = await this.getVtxosFromRepo();
-    return vtxos.filter(isSpendable);
+    return vtxos.filter((v) => !hasTerminalSpend(v));
   }
   async onWalletInitialized() {
     if (!this.readonlyWallet || !this.arkProvider || !this.indexerProvider || !this.walletRepository) {
@@ -15154,9 +15173,7 @@ var WalletMessageHandler = class {
       try {
         const vtxos = await this.getVtxosFromRepo();
         const { pending, finalized } = await this.wallet.finalizePendingTxs(
-          vtxos.filter(
-            (vtxo) => vtxo.virtualStatus.state !== "swept" && vtxo.virtualStatus.state !== "settled"
-          )
+          vtxos.filter((vtxo) => vtxo.isSpent || vtxo.isPreconfirmed && !vtxo.isSwept)
         );
         console.info(
           `Recovered ${finalized.length}/${pending.length} pending transactions: ${finalized.join(", ")}`
@@ -15415,8 +15432,12 @@ var WalletMessageHandler = class {
         `WalletMessageHandler.getVtxosFromRepo: failed to derive script from wallet address ${walletAddress}: ${e instanceof Error ? e.message : String(e)}`
       );
     }
-    const walletVtxos = await this.walletRepository.getVtxos(walletAddress);
-    addVtxos(filterVtxosForScript(walletVtxos, walletScript));
+    addVtxos(
+      await getVtxosForContract(this.walletRepository, {
+        script: walletScript,
+        address: walletAddress
+      })
+    );
     return allVtxos;
   }
   /**
@@ -15448,7 +15469,7 @@ var WalletMessageHandler = class {
         }));
         const BATCH_SIZE = 100;
         for (let i = 0; i < outpoints.length; i += BATCH_SIZE) {
-          const res = await this.indexerProvider.getVtxos({
+          const res = await getNormalizedVtxos(this.indexerProvider, {
             outpoints: outpoints.slice(i, i + BATCH_SIZE)
           });
           for (const v of res.vtxos) {
@@ -16150,7 +16171,7 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
     };
     try {
       const response = await this.sendMessage(message);
-      return response.payload.vtxos;
+      return response.payload.vtxos.map(normalizeVtxo);
     } catch (error) {
       throw new Error(`Failed to get vtxos: ${error}`);
     }
@@ -16263,7 +16284,7 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
         };
         try {
           const response = await sendContractMessage(message);
-          return response.payload.vtxos;
+          return response.payload.vtxos.map(normalizeVtxo);
         } catch (e) {
           throw new Error("Failed to annotate vtxos");
         }
@@ -16708,7 +16729,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
         };
         try {
           const response = await wallet.sendMessage(message);
-          return response.payload.vtxos;
+          return response.payload.vtxos.map(normalizeVtxo);
         } catch (e) {
           throw new Error(`Failed to get expiring vtxos: ${e}`);
         }
@@ -18448,7 +18469,7 @@ async function resolveFeeRate(opts) {
 }
 async function selectExitVtxos(opts) {
   if (!opts.vtxos) return opts.wallet.getVtxos();
-  const res = await opts.wallet.indexerProvider.getVtxos({ outpoints: opts.vtxos });
+  const res = await getNormalizedVtxos(opts.wallet.indexerProvider, { outpoints: opts.vtxos });
   const tapTrees = /* @__PURE__ */ new Map();
   const out = [];
   for (const vtxo of res.vtxos) {
@@ -19117,7 +19138,7 @@ __export(arkade_exports, {
   validateProgram: () => validateProgram,
   witnessRefToBytes: () => witnessRefToBytes
 });
-var isVtxoCoin = (input) => "virtualStatus" in input;
+var isVtxoCoin = (input) => isVirtualCoin(input);
 function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message, session, arkProvider, emulator, network, recipients) {
   let batchId;
   let sweepTapTreeRoot;
@@ -19194,7 +19215,11 @@ function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message
               break;
             }
           }
-          if (boardingIdx === null) continue;
+          if (boardingIdx === null) {
+            throw new Error(
+              `input ${input.txid}:${input.vout} is neither a virtual output nor an input of the commitment tx; a virtual output must carry its \`script\``
+            );
+          }
           commitmentPsbt.updateInput(boardingIdx, {
             tapLeafScript: [input.forfeitTapLeafScript]
           });
@@ -19474,13 +19499,13 @@ var ArkadeContract = class _ArkadeContract {
       const [registered] = await manager.getContracts({ script: scriptHex });
       if (registered) {
         const [withVtxos] = await manager.getContractsWithVtxos({ script: scriptHex });
-        return (withVtxos?.vtxos ?? []).filter(isSpendable);
+        return (withVtxos?.vtxos ?? []).filter((v) => !hasTerminalSpend(v));
       }
     }
     if (!this.client.indexer) {
       throw new Error("ArkadeContract.getUtxos: an indexer is required");
     }
-    const { vtxos } = await this.client.indexer.getVtxos({
+    const { vtxos } = await getNormalizedVtxos(this.client.indexer, {
       scripts: [scriptHex],
       spendableOnly: true
     });
@@ -19788,6 +19813,6 @@ function isArkContract(str) {
   return str.startsWith(ARKCONTRACT_PREFIX + "=");
 }
 
-export { ARKADE_MAGIC, ActivityRegistry, ArkCash, ArkCashCreateError, ArkNote, AssetManager, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkade_exports, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isExpired, isRecoverable, isRetryableProviderError, isSpendable, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-SV4PCGKM.js.map
-//# sourceMappingURL=chunk-SV4PCGKM.js.map
+export { ARKADE_MAGIC, ActivityRegistry, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkade_exports, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isRetryableProviderError, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
+//# sourceMappingURL=chunk-NYR5H6GR.js.map
+//# sourceMappingURL=chunk-NYR5H6GR.js.map