@arkade-os/sdk 0.4.47 → 0.4.48

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

@@ -1,10 +1,10 @@
-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-CDDWXBEM.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, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, DefaultVtxo, 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';
-import { hex, base58, base64 } from '@scure/base';
+import { hex, base58, base64, bech32m } from '@scure/base';
 import * as musig2 from '@scure/btc-signer/musig2.js';
 import { equalBytes as equalBytes$1, bytesToNumberBE } from '@noble/curves/utils.js';
 import { signAsync, schnorr as schnorr$1, Point } from '@noble/secp256k1';
@@ -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;
@@ -2437,6 +2423,15 @@ async function submitOffchainTx(provider, offchainTx, signer, hooks) {
   await hooks?.afterFinalize?.();
   return { arkTxid, signedCheckpointTxs };
 }
+async function signAndSubmitOffchainTx(params) {
+  const offchainTx = buildOffchainTx(params.inputs, params.outputs, params.serverUnrollScript);
+  const signer = {
+    signArkTx: async (arkTx) => ({ arkTx: await params.identity.sign(arkTx) }),
+    signCheckpoint: (checkpoint) => params.identity.sign(checkpoint)
+  };
+  const { arkTxid } = await submitOffchainTx(params.provider, offchainTx, signer);
+  return arkTxid;
+}
 var AmountVariableName = "amount";
 var ExpiryVariableName = "expiry";
 var BirthVariableName = "birth";
@@ -2716,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;
@@ -2744,19 +2739,32 @@ async function runWithCrossInstanceLock(name, fn) {
   });
 }
 var MAX_VTXOS_PER_SETTLEMENT = 50;
+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 = [];
@@ -2782,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)) {
+    if (canRecoverOnchain(vtxo, now)) {
       return true;
     }
-    if (isSpendable(vtxo) && isExpired(vtxo)) {
-      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) {
@@ -2821,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) {
@@ -2980,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");
     }
@@ -2989,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}`
@@ -3041,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 {
@@ -3075,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 [];
     }
@@ -3087,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
@@ -3140,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) {
@@ -3411,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,
@@ -3418,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) {
@@ -3458,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 {
@@ -3481,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 {
@@ -3494,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
       };
     }
   }
@@ -3528,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;
@@ -3542,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;
           }
@@ -3578,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") {
@@ -3956,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();
@@ -3966,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) {
@@ -4084,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);
       }
@@ -4119,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;
       }
@@ -4333,6 +4371,96 @@ function readUInt32BE(array, offset) {
 function noteTapscript(preimageHash) {
   return Script.encode(["SHA256", preimageHash, "EQUAL"]);
 }
+var ArkadeCash = class _ArkadeCash {
+  constructor(privateKey, serverPubKey, csvTimelock, hrp = _ArkadeCash.DefaultHRP) {
+    this.csvTimelock = csvTimelock;
+    this.hrp = hrp;
+    if (privateKey.length !== 32) {
+      throw new Error(
+        `Invalid private key length: expected 32 bytes, got ${privateKey.length}`
+      );
+    }
+    if (serverPubKey.length !== 32) {
+      throw new Error(
+        `Invalid server public key length: expected 32 bytes, got ${serverPubKey.length}`
+      );
+    }
+    this._privateKey = privateKey.slice();
+    this._serverPubKey = serverPubKey.slice();
+    this._publicKey = pubSchnorr(this._privateKey);
+  }
+  csvTimelock;
+  hrp;
+  static DefaultHRP = "arkadecash";
+  static Version = 0;
+  static PayloadLength = 1 + 32 + 32 + 4;
+  // 69 bytes
+  // Keys are held as private copies so a caller mutating the array it passed
+  // in — or one it reads back from a getter — cannot alter this note's
+  // identity or the outputs derived from it.
+  _privateKey;
+  _serverPubKey;
+  _publicKey;
+  /** The note's private key. Returns a fresh copy; mutating it is a no-op. */
+  get privateKey() {
+    return this._privateKey.slice();
+  }
+  /** The server's public key. Returns a fresh copy; mutating it is a no-op. */
+  get serverPubKey() {
+    return this._serverPubKey.slice();
+  }
+  /** The note's public key. Returns a fresh copy; mutating it is a no-op. */
+  get publicKey() {
+    return this._publicKey.slice();
+  }
+  static generate(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 arkadeCash string: failed to decode bech32m");
+    }
+    const data = new Uint8Array(bech32m.fromWords(decoded.words));
+    if (data.length !== _ArkadeCash.PayloadLength) {
+      throw new Error(
+        `Invalid arkadeCash data length: expected ${_ArkadeCash.PayloadLength} bytes, got ${data.length}`
+      );
+    }
+    const version = data[0];
+    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 _ArkadeCash(privateKey, serverPubKey, csvTimelock, decoded.prefix);
+  }
+  toString() {
+    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);
+    new DataView(data.buffer, data.byteOffset + 65, 4).setUint32(0, sequence, false);
+    const words = bech32m.toWords(data);
+    return bech32m.encode(this.hrp, words, 1023);
+  }
+  get identity() {
+    return SingleKey.fromPrivateKey(this._privateKey);
+  }
+  get vtxoScript() {
+    return new DefaultVtxo.Script({
+      pubKey: this._publicKey,
+      serverPubKey: this._serverPubKey,
+      csvTimelock: this.csvTimelock
+    });
+  }
+  address(addressHrp) {
+    return this.vtxoScript.address(addressHrp, this._serverPubKey);
+  }
+};
 
 // src/repositories/intentRepository.ts
 var ALL_INTENT_STATES = [
@@ -5397,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) {
@@ -5411,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
@@ -5474,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);
@@ -5863,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) {
@@ -5888,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]);
@@ -5959,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 {
@@ -5991,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;
@@ -6044,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,
@@ -6832,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) {
@@ -7036,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),
@@ -7635,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;
@@ -7690,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 [];
@@ -7710,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) {
@@ -7724,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 [];
@@ -7744,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) {
@@ -8396,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
+      );
     }
   }
   /**
@@ -8534,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);
@@ -8787,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
@@ -8803,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;
@@ -8826,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) => {
@@ -8853,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) {
@@ -8861,6 +8967,7 @@ var ContractManager = class _ContractManager {
               index,
               error: probe.error
             });
+            indeterminate = true;
             continue;
           }
           for (const c of probe.found) {
@@ -8868,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.
@@ -8929,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 {
@@ -9097,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;
@@ -9225,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
     });
@@ -9316,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,
@@ -10127,6 +10241,24 @@ async function spendableVtxosExcludingLocked(vtxos, intentRepository) {
   }
   return excludeLockedOutpoints(vtxos, locked);
 }
+var cashReport = (vtxo, reason) => ({
+  txid: vtxo.txid,
+  vout: vtxo.vout,
+  value: vtxo.value,
+  reason
+});
+var ArkadeCashCreateError = class extends Error {
+  constructor(cash, cause) {
+    super(
+      `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 = "ArkadeCashCreateError";
+  }
+  cash;
+  cause;
+};
 var ReadonlyWallet = class _ReadonlyWallet {
   constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, walletContractTimelocks) {
     this.identity = identity;
@@ -10585,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;
@@ -10634,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;
@@ -10672,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;
     });
@@ -10748,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,
@@ -10757,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
             });
@@ -10774,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) {
@@ -11003,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);
   }
   // ========================================================================
@@ -11106,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,
@@ -11583,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}`);
       }
     }
@@ -11678,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).`
       );
     }
@@ -11998,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;
         }
@@ -12220,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
@@ -12235,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 {
@@ -12246,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) {
@@ -12283,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) {
@@ -12586,18 +12725,17 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     if (!hasPending) {
       return { finalized: [], pending: [] };
     }
-    const MAX_INPUTS_PER_INTENT = 20;
     if (!vtxos || vtxos.length === 0) {
       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({
@@ -12696,6 +12834,271 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       settings: { ...state.settings, hasPendingTx: value }
     }));
   }
+  /**
+   * 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 arkadeCash string.
+   * The receiver can claim the funds using `claimCash()` without ever
+   * sharing their address.
+   *
+   * 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.
+   *
+   * @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 arkadeCash string (e.g., "arkadecash1...")
+   */
+  async createCash(amount) {
+    if (!Number.isSafeInteger(amount) || amount < Number(this.dustAmount)) {
+      throw new Error(
+        `Invalid ArkadeCash amount ${amount}: must be a whole number of sats >= dust (${this.dustAmount})`
+      );
+    }
+    const cashHrp = this.network.hrp.replace(/ark$/, "arkadecash");
+    const cash = ArkadeCash.generate(
+      this.arkServerPublicKey,
+      this.offchainTapscript.options.csvTimelock,
+      cashHrp
+    );
+    const address = cash.address(this.network.hrp).encode();
+    const cashStr = cash.toString();
+    try {
+      await this.send({ address, amount });
+    } catch (error) {
+      throw new ArkadeCashCreateError(cashStr, error);
+    }
+    return cashStr;
+  }
+  /**
+   * Claim an ArkadeCash bearer instrument: sweep what can be swept, report the
+   * rest.
+   *
+   * 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
+   * 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 arkadeCash string is the recovery token: a claim interrupted between
+   * submit and finalize is completed by simply re-running `claimCash`, which
+   * drains any pending arkadeCash transaction on the server before sweeping.
+   *
+   * @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 = 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 arkadeCash");
+    }
+    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));
+    if (drainable.length > 0) {
+      let drained = { count: 0, swept: 0, claimed: /* @__PURE__ */ new Set() };
+      try {
+        drained = await this.finalizePendingCashTxs(
+          cash,
+          drainable,
+          cashScript,
+          myPkScript
+        );
+      } catch (error) {
+        console.error("Failed to drain pending arkadeCash txs:", error);
+      }
+      if (drained.count > 0) {
+        vtxos = await this.fetchAllVtxos(scripts);
+        ({ spendable, unclaimed } = this.classifyCashVtxos(vtxos));
+        swept += drained.swept;
+        unclaimed = unclaimed.filter(
+          (vtxo) => !drained.claimed.has(`${vtxo.txid}:${vtxo.vout}`)
+        );
+      }
+    }
+    if (spendable.length > 0) {
+      const info = await this.arkProvider.getInfo();
+      const serverUnrollScript = CSVMultisigTapscript.decode(
+        hex.decode(info.checkpointTapscript)
+      );
+      for (const vtxo of spendable) {
+        try {
+          await signAndSubmitOffchainTx({
+            identity: cash.identity,
+            provider: this.arkProvider,
+            inputs: [
+              {
+                txid: vtxo.txid,
+                vout: vtxo.vout,
+                value: vtxo.value,
+                tapLeafScript: cashScript.forfeit(),
+                tapTree: cashScript.encode()
+              }
+            ],
+            outputs: [{ script: myPkScript, amount: BigInt(vtxo.value) }],
+            serverUnrollScript
+          });
+          swept += vtxo.value;
+        } catch (error) {
+          console.error(
+            `Failed to sweep arkadeCash VTXO ${vtxo.txid}:${vtxo.vout}:`,
+            error
+          );
+          unclaimed.push(cashReport(vtxo, "sweep-failed"));
+        }
+      }
+    }
+    return {
+      swept,
+      unclaimed: {
+        amount: unclaimed.reduce((total, vtxo) => total + vtxo.value, 0),
+        vtxos: unclaimed
+      }
+    };
+  }
+  /**
+   * 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 (hasTerminalSpend(vtxo)) {
+        unclaimed.push(cashReport(vtxo, "already-spent"));
+      } else if (isSubdust(vtxo, this.dustAmount)) {
+        unclaimed.push(cashReport(vtxo, "subdust"));
+      } else if (vtxo.isSwept) {
+        unclaimed.push(cashReport(vtxo, "swept"));
+      } else if (vtxo.assets && vtxo.assets.length > 0) {
+        unclaimed.push(cashReport(vtxo, "has-assets"));
+      } else {
+        spendable.push(vtxo);
+      }
+    }
+    return { spendable, unclaimed };
+  }
+  /** Read every page of an unfiltered VTXO query for the given scripts. */
+  async fetchAllVtxos(scripts) {
+    const pageSize = 100;
+    const all = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let pageIndex = 0; ; pageIndex++) {
+      const { vtxos, page } = await getNormalizedVtxos(this.indexerProvider, {
+        scripts,
+        pageIndex,
+        pageSize
+      });
+      for (const vtxo of vtxos) {
+        const outpoint = `${vtxo.txid}:${vtxo.vout}`;
+        if (seen.has(outpoint)) continue;
+        seen.add(outpoint);
+        all.push(vtxo);
+      }
+      if (!page || vtxos.length < pageSize) return all;
+    }
+  }
+  /**
+   * Complete any sweep a previous `claimCash` registered but never finalized.
+   * 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
+   * the destination, so a tx a different claimer left half-finished pays that
+   * claimer — finalizing it is still right (the input is spent either way, and
+   * 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 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.
+   * @returns The number of pending txs finalized, the sats among them paid to
+   * this wallet, and the outpoints those txs consumed to pay it.
+   */
+  async finalizePendingCashTxs(cash, vtxos, cashScript, myPkScript) {
+    const result = { count: 0, swept: 0, claimed: /* @__PURE__ */ new Set() };
+    const inputs = vtxos.map((vtxo) => ({
+      ...vtxo,
+      forfeitTapLeafScript: cashScript.forfeit(),
+      intentTapLeafScript: cashScript.forfeit(),
+      tapTree: cashScript.encode()
+    }));
+    if (inputs.length === 0) return result;
+    const identity = cash.identity;
+    const seenTxids = /* @__PURE__ */ new Set();
+    const pendingTxs = [];
+    for (let i = 0; i < inputs.length; i += MAX_INPUTS_PER_INTENT) {
+      const batch = inputs.slice(i, i + MAX_INPUTS_PER_INTENT);
+      const message = { type: "get-pending-tx", expire_at: 0 };
+      const proof = Intent.create(message, batch, []);
+      const signedProof = await identity.sign(
+        proof,
+        Array.from({ length: batch.length + 1 }, (_, j) => j)
+      );
+      const batchPending = await this.arkProvider.getPendingTxs({
+        proof: base64.encode(signedProof.toPSBT()),
+        message
+      });
+      for (const pendingTx of batchPending) {
+        if (seenTxids.has(pendingTx.arkTxid)) continue;
+        seenTxids.add(pendingTx.arkTxid);
+        pendingTxs.push(pendingTx);
+      }
+    }
+    const myPkScriptHex = hex.encode(myPkScript);
+    for (const pendingTx of pendingTxs) {
+      try {
+        const checkpointTxs = pendingTx.signedCheckpointTxs.map(
+          (checkpoint) => Transaction$2.fromPSBT(base64.decode(checkpoint))
+        );
+        const finalCheckpoints = await Promise.all(
+          checkpointTxs.map(
+            async (checkpoint) => base64.encode((await identity.sign(checkpoint)).toPSBT())
+          )
+        );
+        await this.arkProvider.finalizeTx(pendingTx.arkTxid, finalCheckpoints);
+        result.count++;
+        const paidToMe = this.arkTxAmountPaidTo(pendingTx.finalArkTx, myPkScriptHex);
+        if (paidToMe === 0) continue;
+        result.swept += paidToMe;
+        for (const checkpoint of checkpointTxs) {
+          for (let i = 0; i < checkpoint.inputsLength; i++) {
+            const input = checkpoint.getInput(i);
+            if (!input.txid) continue;
+            result.claimed.add(`${hex.encode(input.txid)}:${input.index}`);
+          }
+        }
+      } catch (error) {
+        console.error(
+          `Failed to finalize pending arkadeCash tx ${pendingTx.arkTxid}:`,
+          error
+        );
+      }
+    }
+    return result;
+  }
+  /** Sum the outputs of an ark tx PSBT that pay the given scriptPubKey. */
+  arkTxAmountPaidTo(arkTxPsbt, pkScriptHex) {
+    const arkTx = Transaction$2.fromPSBT(base64.decode(arkTxPsbt));
+    let total = 0;
+    for (let i = 0; i < arkTx.outputsLength; i++) {
+      const output = arkTx.getOutput(i);
+      if (!output.script || output.amount === void 0) continue;
+      if (hex.encode(output.script) === pkScriptHex) total += Number(output.amount);
+    }
+    return total;
+  }
   /**
    * Send BTC and/or assets to one or more recipients.
    *
@@ -12924,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");
     }
@@ -12933,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();
@@ -12969,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,
@@ -13070,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,
@@ -13114,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
           },
@@ -13189,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;
@@ -13270,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;
     }
@@ -13966,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;
       }
@@ -14707,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;
@@ -14766,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) {
@@ -14778,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(", ")}`
@@ -15039,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;
   }
   /**
@@ -15072,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) {
@@ -15774,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}`);
     }
@@ -15887,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");
         }
@@ -16332,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}`);
         }
@@ -18072,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) {
@@ -18741,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;
@@ -18818,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]
           });
@@ -19098,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
     });
@@ -19412,6 +19813,6 @@ function isArkContract(str) {
   return str.startsWith(ARKCONTRACT_PREFIX + "=");
 }
 
-export { ARKADE_MAGIC, ActivityRegistry, ArkNote, AssetManager, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, 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-OCS5S3L3.js.map
-//# sourceMappingURL=chunk-OCS5S3L3.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