@arkade-os/sdk 0.5.0 → 0.5.2

package/dist/{chunk-GWJWXVUB.js → chunk-AJWXVQYG.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, RestIndexerProvider, BufferReader, BufferWriter, AssetRef } from './chunk-HABGVRLF.js';
-import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, UnsupportedProgramVersionError, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, toXOnly, ARKADE_TYPE_ENCODINGS, validateParamValue, contractHandlers, speculativeReceiveMetadata, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, normalizeToDescriptor, extractPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-K352GMVL.js';
-import { VtxoScript, __export, Transaction, requiresForfeit, CSVMultisigTapscript, networks, getNetwork, DEFAULT_NETWORK, resolveEmulatorPubkey, timelockToSequence, isVtxoSpent, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, RestArkProvider, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, assertNonNegativeMs, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, DEFAULT_ARKADE_SERVER_URL, baseFetch, DEFAULT_NETWORK_NAME, sequenceToCanonicalTimelock, assertTimerMs, isEventSourceError, isEventSourceUnavailableError, normalizeVtxo, isPastExpiry, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, isArkError, ArkErrorName, assertAllowedSighashTypes, Intent, rateGate, formatSighash, getSequence, maybeArkError, toOffchainInputFeeParams, canRecoverOnchain, MultisigTapscript, DEFAULT_ARKADE_EMULATOR_URL, networkFromArkadeInfo, ArkError, toBIP371TapTree, resolveTimeHeight, canSpendOffchain, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, fetchVtxoCreatedAtByTxid, EXPIRY_MIN_PLAUSIBLE_MS, ProviderUnavailableError } from './chunk-ZOEB53NQ.js';
+import { Packet, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, RestIndexerProvider, BufferReader, BufferWriter, AssetRef } from './chunk-U5XG7SWA.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, UnsupportedProgramVersionError, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, toXOnly, ARKADE_TYPE_ENCODINGS, validateParamValue, contractHandlers, speculativeReceiveMetadata, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, normalizeToDescriptor, extractPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-LWRMSC4M.js';
+import { VtxoScript, __export, Transaction, requiresForfeit, CSVMultisigTapscript, networks, getNetwork, DEFAULT_NETWORK, resolveEmulatorPubkey, timelockToSequence, isVtxoSpent, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, getArkPsbtFields, craftToSpendTx, RestArkProvider, ArkAddress, isVirtualCoin, CosignerPublicKey, ServerResponseMismatchError, assertNonNegativeMs, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, DEFAULT_ARKADE_SERVER_URL, baseFetch, DEFAULT_NETWORK_NAME, sequenceToCanonicalTimelock, assertTimerMs, isEventSourceError, isEventSourceUnavailableError, normalizeVtxo, isPastExpiry, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, isArkError, ArkErrorName, assertAllowedSighashTypes, Intent, rateGate, formatSighash, getSequence, maybeArkError, toOffchainInputFeeParams, canRecoverOnchain, MultisigTapscript, DEFAULT_ARKADE_EMULATOR_URL, networkFromArkadeInfo, ArkError, toBIP371TapTree, resolveTimeHeight, canSpendOffchain, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, fetchVtxoCreatedAtByTxid, EXPIRY_MIN_PLAUSIBLE_MS, ProviderUnavailableError } from './chunk-HKG26NUT.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$1 } from '@scure/btc-signer';
 import { hex, base58, base64, bech32m } from '@scure/base';
@@ -1328,10 +1328,15 @@ async function provisionDescriptor(wallet) {
   return allocated ?? await identityDescriptor(wallet.identity);
 }
 async function provisionRefundKey(wallet) {
-  const descriptor = await identityDescriptor(wallet.identity);
+  const descriptorPromise = identityDescriptor(wallet.identity);
+  const identityPubkeyPromise = wallet.identity.xOnlyPublicKey();
+  void identityPubkeyPromise.catch(() => void 0);
+  const descriptor = await descriptorPromise;
   const signer = await contractSigner(wallet, descriptor);
-  const pubkey = await signer.xOnlyPublicKey();
-  const identityPubkey = await wallet.identity.xOnlyPublicKey();
+  const [pubkey, identityPubkey] = await Promise.all([
+    signer.xOnlyPublicKey(),
+    identityPubkeyPromise
+  ]);
   if (!equalBytes(pubkey, identityPubkey)) {
     throw new Error(
       "provisionRefundKey: descriptor pubkey does not match wallet identity \u2014 the refund key and the refund address would be on different keys"
@@ -1347,7 +1352,6 @@ async function provisionClaimSecret(wallet, opts = {}) {
   }
   const descriptor = await provisionDescriptor(wallet);
   const signer = await contractSigner(wallet, descriptor);
-  const pubkey = await signer.xOnlyPublicKey();
   const claim2 = async () => {
     if (opts.preimage) return { preimage: opts.preimage, mustPersistPreimage: true };
     if (isPerArtifactDescriptor(descriptor)) {
@@ -1370,7 +1374,10 @@ async function provisionClaimSecret(wallet, opts = {}) {
       return { preimage: randomBytes(32), mustPersistPreimage: true };
     }
   };
-  const { preimage, preimageSalt, mustPersistPreimage } = await claim2();
+  const [pubkey, { preimage, preimageSalt, mustPersistPreimage }] = await Promise.all([
+    signer.xOnlyPublicKey(),
+    claim2()
+  ]);
   return {
     descriptor,
     pubkey,
@@ -4676,12 +4683,14 @@ var VtxoManager = class _VtxoManager {
    * ```
    */
   async recoverVtxos(eventCallback) {
-    const allVtxos = await this.wallet.getVtxos({
-      withRecoverable: true,
-      withUnrolled: false
-    });
+    const [allVtxos, now] = await Promise.all([
+      this.wallet.getVtxos({
+        withRecoverable: true,
+        withUnrolled: false
+      }),
+      fetchTimeHeight(this.wallet)
+    ]);
     const dustAmount = getDustAmount(this.wallet);
-    const now = await fetchTimeHeight(this.wallet);
     let { vtxosToRecover } = getRecoverableWithSubdust(allVtxos, dustAmount, now);
     if (vtxosToRecover.length === 0) {
       throw new Error("No recoverable VTXOs found");
@@ -4782,12 +4791,17 @@ var VtxoManager = class _VtxoManager {
    * ```
    */
   async getRecoverableBalance() {
-    const allVtxos = await this.wallet.getVtxos({
-      withRecoverable: true,
-      withUnrolled: false
-    });
+    const infoProvider = this.getInfoProvider();
+    const [allVtxos, now, info, arkAddress] = await Promise.all([
+      this.wallet.getVtxos({
+        withRecoverable: true,
+        withUnrolled: false
+      }),
+      fetchTimeHeight(this.wallet),
+      infoProvider?.getInfo(),
+      this.wallet.getAddress()
+    ]);
     const dustAmount = getDustAmount(this.wallet);
-    const now = await fetchTimeHeight(this.wallet);
     let { vtxosToRecover, includesSubdust } = getRecoverableWithSubdust(
       allVtxos,
       dustAmount,
@@ -4805,14 +4819,9 @@ var VtxoManager = class _VtxoManager {
         now
       ));
     }
-    const info = await this.getInfoProvider()?.getInfo();
     const estimator = new Estimator(info?.fees.intentFee ?? {});
     const { payable, net } = priceSettlementInputs(vtxosToRecover, estimator);
-    const priced = deductOffchainOutputFee(
-      subtotalOf(payable, net),
-      estimator,
-      await this.wallet.getAddress()
-    );
+    const priced = deductOffchainOutputFee(subtotalOf(payable, net), estimator, arkAddress);
     const recoverable = priced > 0n ? priced : 0n;
     const subdustAmount = subtotalOf(
       payable.filter((v) => BigInt(v.value) < dustAmount),
@@ -4866,8 +4875,11 @@ var VtxoManager = class _VtxoManager {
       const cm = await wallet.getContractManager();
       const recoveryScripts = (await cm.getContracts()).filter(isRecoveryOnlyContract).map((contract) => contract.script);
       if (recoveryScripts.length === 0) return;
-      const recoveryContracts = await cm.getContractsWithVtxos({ script: recoveryScripts });
-      const info = await this.getInfoProvider()?.getInfo();
+      const infoProvider = this.getInfoProvider();
+      const [recoveryContracts, info] = await Promise.all([
+        cm.getContractsWithVtxos({ script: recoveryScripts }),
+        infoProvider?.getInfo()
+      ]);
       const dustAmount = getDustAmount(wallet);
       for (const { contract, vtxos } of recoveryContracts) {
         try {
@@ -4962,12 +4974,13 @@ var VtxoManager = class _VtxoManager {
     if (this.settlementConfig === false && thresholdMs === void 0) {
       return [];
     }
-    const vtxos = await this.wallet.getSpendableVtxos({
+    const threshold = thresholdMs !== void 0 ? thresholdMs : this.configuredThresholdMs();
+    const vtxosPromise = this.wallet.getSpendableVtxos({
       withRecoverable: true,
       genericallySpendableOnly: true
     });
-    const threshold = thresholdMs !== void 0 ? thresholdMs : this.configuredThresholdMs();
     const tip = now ?? await fetchTimeHeight(this.wallet);
+    const vtxos = await vtxosPromise;
     await this.warnHeldExpiring(threshold, tip);
     return getExpiringAndRecoverableVtxos(vtxos, threshold, getDustAmount(this.wallet), tip);
   }
@@ -5261,8 +5274,10 @@ var VtxoManager = class _VtxoManager {
     const wallet = this.requireMigrationCapableWallet();
     const info = await wallet.arkProvider.getInfo();
     await wallet.settleServerInfoChanges?.();
-    const { reports: vtxoReports } = await this.classifyDeprecatedSignerContracts(info);
-    const { reports: boardingReports } = await this.classifyDeprecatedSignerBoarding(info);
+    const [{ reports: vtxoReports }, { reports: boardingReports }] = await Promise.all([
+      this.classifyDeprecatedSignerContracts(info),
+      this.classifyDeprecatedSignerBoarding(info)
+    ]);
     return mergeSignerReports(vtxoReports, boardingReports);
   }
   /**
@@ -5284,8 +5299,10 @@ var VtxoManager = class _VtxoManager {
       return { rotated: rotatedOnRefresh, expired: [], signers: [] };
     }
     if (walletClass.status === "UNKNOWN_SIGNER") {
-      const { reports: vtxoReports2 } = await this.classifyDeprecatedSignerContracts(info);
-      const { reports: boardingReports2 } = await this.classifyDeprecatedSignerBoarding(info);
+      const [{ reports: vtxoReports2 }, { reports: boardingReports2 }] = await Promise.all([
+        this.classifyDeprecatedSignerContracts(info),
+        this.classifyDeprecatedSignerBoarding(info)
+      ]);
       return {
         // True only if a second rotation landed inside the drain, leaving us on a signer
         // newer than `info` (a drained rotation otherwise classifies CURRENT).
@@ -5296,16 +5313,13 @@ var VtxoManager = class _VtxoManager {
       };
     }
     const rotated = await this.ensureReceiveOnActiveSigner(info) || rotatedOnRefresh;
-    const {
-      reports: vtxoReports,
-      migratable: vtxoMigratable,
-      expired: vtxoExpired
-    } = await this.classifyDeprecatedSignerContracts(info);
-    const {
-      reports: boardingReports,
-      migratable: boardingMigratable,
-      expired: boardingExpired
-    } = await this.classifyDeprecatedSignerBoarding(info);
+    const [
+      { reports: vtxoReports, migratable: vtxoMigratable, expired: vtxoExpired },
+      { reports: boardingReports, migratable: boardingMigratable, expired: boardingExpired }
+    ] = await Promise.all([
+      this.classifyDeprecatedSignerContracts(info),
+      this.classifyDeprecatedSignerBoarding(info)
+    ]);
     const reports = mergeSignerReports(vtxoReports, boardingReports);
     const expiredRefs = [
       ...vtxoExpired.map(classifiedToRef),
@@ -6304,11 +6318,6 @@ async function classifyIntent(intent, vtxosByOutpoint, now) {
       cancellationReason: "reconciliation: an input was unilaterally exited"
     });
   }
-  if (intent.state === "waiting_to_submit") {
-    return terminal(intent, "cancelled", now, {
-      cancellationReason: "reconciliation: intent was never submitted before restart"
-    });
-  }
   if (intent.validUntil !== void 0 && intent.validUntil < now) {
     return terminal(intent, "cancelled", now, {
       cancellationReason: "reconciliation: intent expired"
@@ -6510,9 +6519,16 @@ function chainTxTypeToChainedExit(t) {
 var isCommitment = (t) => t === "INDEXER_CHAINED_TX_TYPE_COMMITMENT" /* COMMITMENT */ || t === "INDEXER_CHAINED_TX_TYPE_UNSPECIFIED" /* UNSPECIFIED */;
 async function buildExitDag(params) {
   const byTxid = /* @__PURE__ */ new Map();
-  for (const vtxo of params.vtxos) {
-    const outpoint = `${vtxo.txid}:${vtxo.vout}`;
-    const chain = await params.chain.getVtxoChain({ txid: vtxo.txid, vout: vtxo.vout });
+  const chains = await Promise.allSettled(
+    params.vtxos.map(async (vtxo) => ({
+      outpoint: `${vtxo.txid}:${vtxo.vout}`,
+      // The resolver returns the full chain (all pages merged, local-first).
+      chain: await params.chain.getVtxoChain({ txid: vtxo.txid, vout: vtxo.vout })
+    }))
+  );
+  for (const result of chains) {
+    if (result.status === "rejected") throw result.reason;
+    const { outpoint, chain } = result.value;
     for (const chainTx of chain) {
       const existing = byTxid.get(chainTx.txid);
       if (existing) {
@@ -6545,25 +6561,26 @@ async function buildExitDag(params) {
   if (order.length !== pending.size) {
     throw new Error("inconsistent vtxo chain from indexer (cycle detected)");
   }
-  const nodes = [];
-  for (const tx of order) {
-    let confirmed = false;
-    try {
-      const status = await params.onchain.getTxStatus(tx.txid);
-      confirmed = status.confirmed;
-    } catch {
-      confirmed = false;
-    }
+  const confirmed = await Promise.all(
+    order.map(async (tx) => {
+      try {
+        const status = await params.onchain.getTxStatus(tx.txid);
+        return status.confirmed;
+      } catch {
+        return false;
+      }
+    })
+  );
+  return order.map((tx, i) => {
     const expires = Number(tx.expiresAt);
-    nodes.push({
+    return {
       txid: tx.txid,
       type: tx.type,
       expiresAt: Number.isFinite(expires) && expires > 0 ? expires : void 0,
       forVtxos: [...tx.forVtxos].sort(),
-      confirmed
-    });
-  }
-  return nodes;
+      confirmed: confirmed[i]
+    };
+  });
 }
 function topoSortByDeps(items, idOf, depsOf) {
   const produced = new Set(items.map(idOf));
@@ -6732,11 +6749,12 @@ var RepositoryExitDataSource = class {
     return chain;
   }
   async getVirtualTxs(txids) {
+    const stored = await Promise.all(txids.map((txid) => this.repo.getVirtualTx(txid)));
     const out = /* @__PURE__ */ new Map();
-    for (const txid of txids) {
-      const stored = await this.repo.getVirtualTx(txid);
-      if (stored?.psbt) out.set(txid, stored.psbt);
-    }
+    txids.forEach((txid, i) => {
+      const row = stored[i];
+      if (row?.psbt) out.set(txid, row.psbt);
+    });
     return out;
   }
 };
@@ -7854,8 +7872,10 @@ var DelegateManagerImpl = class {
       return { delegated: [], failed: [] };
     }
     const destinationScript = ArkAddress.decode(destination).pkScript;
-    const arkInfo = await this.arkInfoProvider.getInfo();
-    const delegateInfo = await this.delegateProvider.getDelegateInfo();
+    const [arkInfo, delegateInfo] = await Promise.all([
+      this.arkInfoProvider.getInfo(),
+      this.delegateProvider.getDelegateInfo()
+    ]);
     const eligible = vtxos.map(normalizeVtxo).filter(
       (v) => isAnnotated(v) && findDelegateTapLeaf(v, delegateInfo.pubkey) !== void 0
     );
@@ -7947,23 +7967,16 @@ async function delegate(identity, delegateProvider, arkInfo, delegateInfo, vtxos
     if (!expiryTimestamp || expiryTimestamp === Number.MAX_SAFE_INTEGER) {
       delegateAt = new Date(Date.now() + 1 * 60 * 1e3);
     } else {
-      delegateAt = defaultDelegateAt(expiryTimestamp, arkInfo.sessionDuration);
+      const nowMs = now.timestamp.getTime();
+      const target = expiryTimestamp - Number(arkInfo.sessionDuration * 3000n);
+      delegateAt = new Date(
+        target > nowMs ? target : expiryTimestamp > nowMs ? nowMs + 2e3 : nowMs + 6e4
+      );
     }
   }
   const { fees, dust, forfeitAddress, network } = arkInfo;
   const delegateAtSeconds = delegateAt.getTime() / 1e3;
-  const estimator = new Estimator({
-    ...fees.intentFee,
-    // replace now() function with the delegateAt timestamp
-    offchainInput: fees.intentFee.offchainInput?.replace(
-      "now()",
-      `double(${delegateAtSeconds})`
-    ),
-    offchainOutput: fees.intentFee.offchainOutput?.replace(
-      "now()",
-      `double(${delegateAtSeconds})`
-    )
-  });
+  const estimator = estimatorAt(fees.intentFee, delegateAt);
   let amount = 0n;
   for (const coin of vtxos) {
     const inputFee = estimator.evalOffchainInput({
@@ -8107,14 +8120,6 @@ async function makeSignedDelegateIntent(identity, coins, outputs, onchainOutputs
     message
   };
 }
-function defaultDelegateAt(expiryTimestamp, sessionDurationSeconds, now = Date.now()) {
-  const remainingTimeMs = expiryTimestamp - now;
-  if (remainingTimeMs <= 0) return new Date(now + 6e4);
-  const sessionLeadMs = Number(sessionDurationSeconds * 1000n);
-  const leadTimeMs = Math.max(remainingTimeMs * 0.1, sessionLeadMs);
-  const delegateAt = expiryTimestamp - leadTimeMs;
-  return new Date(delegateAt > now ? delegateAt : now + 2e3);
-}
 function findDestinationOutputIndex(outputs, destinationScript) {
   return outputs.findIndex((o) => o.script && equalBytes(o.script, destinationScript));
 }
@@ -8136,6 +8141,14 @@ function findDelegateTapLeaf(vtxo, delegatePubkey) {
 function isAnnotated(v) {
   return v.tapTree !== void 0 && v.forfeitTapLeafScript !== void 0 && v.intentTapLeafScript !== void 0;
 }
+function estimatorAt(intentFee, at) {
+  const now = `double(${at.getTime() / 1e3})`;
+  return new Estimator({
+    ...intentFee,
+    offchainInput: intentFee.offchainInput?.replace("now()", now),
+    offchainOutput: intentFee.offchainOutput?.replace("now()", now)
+  });
+}
 
 // src/repositories/inMemory/intentRepository.ts
 var InMemoryIntentRepository = class {
@@ -10653,8 +10666,10 @@ var ContractManager = class _ContractManager {
       return contract !== void 0 && contractHandlers.get(contract.type)?.assertSpendableNow !== void 0;
     });
     if (asking.length === 0) return refused;
-    const tip = await this.currentChainTip();
-    const walletDescriptorValue = await walletDescriptor?.();
+    const [tip, walletDescriptorValue] = await Promise.all([
+      this.currentChainTip(),
+      walletDescriptor?.()
+    ]);
     for (const vtxo of asking) {
       const contract = byScript.get(vtxo.script);
       const handler = contractHandlers.get(contract.type);
@@ -11527,7 +11542,9 @@ async function setupServiceWorker(pathOrOptions) {
   }
   const { path, activationTimeoutMs } = normalizeOptions2(pathOrOptions);
   const registration = await navigator.serviceWorker.register(path);
-  await registration.update();
+  registration.update().catch(
+    (error) => console.warn("Service worker update failed; continuing with the active worker", error)
+  );
   const serviceWorker = registration.active || registration.waiting || registration.installing;
   if (!serviceWorker) {
     throw new Error("Failed to get service worker instance");
@@ -12553,7 +12570,10 @@ var WalletReceiveRotator = class _WalletReceiveRotator {
    * watched; it just stops being advertised). The untagged index-0 baseline is never retired.
    */
   async rotate(wallet) {
-    const descriptor = await this.provider.getNextSigningDescriptor();
+    const descriptorPromise = this.provider.getNextSigningDescriptor();
+    const managerPromise = wallet.getContractManager();
+    void managerPromise.catch(() => void 0);
+    const descriptor = await descriptorPromise;
     const { tapscript: newTapscript, params } = buildReceiveContract(
       wallet.offchainTapscript,
       descriptor,
@@ -12561,7 +12581,7 @@ var WalletReceiveRotator = class _WalletReceiveRotator {
       true
     );
     const newScript = params.script;
-    const manager = await wallet.getContractManager();
+    const manager = await managerPromise;
     await manager.createContract(params);
     wallet.setOffchainTapscriptForRotation(newTapscript);
     const previousTagged = this.currentTaggedScript;
@@ -12671,11 +12691,11 @@ function computeOffchainBalance(vtxos, caps) {
   let settled = 0;
   let preconfirmed = 0;
   let available = 0;
-  let gated = 0;
+  let contractLocked = 0;
   let pendingSettlement = 0;
   let reserved = 0;
   let recoverable = 0;
-  let pendingRecovery = 0;
+  let deprecatedSignerLocked = 0;
   let unrolled = 0;
   const owned = /* @__PURE__ */ new Map();
   const spendable = /* @__PURE__ */ new Map();
@@ -12692,7 +12712,7 @@ function computeOffchainBalance(vtxos, caps) {
       continue;
     }
     if (isPendingRecovery(vtxo)) {
-      pendingRecovery += vtxo.value;
+      deprecatedSignerLocked += vtxo.value;
       continue;
     }
     if (canRecoverOnchain(vtxo, now)) {
@@ -12706,7 +12726,7 @@ function computeOffchainBalance(vtxos, caps) {
       settled += vtxo.value;
     }
     if (!isGenericallySpendable(vtxo)) {
-      gated += vtxo.value;
+      contractLocked += vtxo.value;
     } else if (!isUnlocked(vtxo)) {
       pendingSettlement += vtxo.value;
     } else if (isReserved?.(vtxo)) {
@@ -12724,13 +12744,13 @@ function computeOffchainBalance(vtxos, caps) {
     settled,
     preconfirmed,
     available,
-    gated,
+    contractLocked,
     pendingSettlement,
     reserved,
     recoverable,
-    pendingRecovery,
+    deprecatedSignerLocked,
     unrolled,
-    total: settled + preconfirmed + recoverable + pendingRecovery + unrolled,
+    total: settled + preconfirmed + recoverable + deprecatedSignerLocked + unrolled,
     assets: toAssets(owned),
     availableAssets: toAssets(spendable)
   };
@@ -12755,15 +12775,19 @@ function toWalletBalance(boardingUtxos, offchain) {
     settled: offchain.settled,
     preconfirmed: offchain.preconfirmed,
     available: offchain.available,
-    gated: offchain.gated,
+    contractLocked: offchain.contractLocked,
     pendingSettlement: offchain.pendingSettlement,
     reserved: offchain.reserved,
     recoverable: offchain.recoverable,
-    pendingRecovery: offchain.pendingRecovery,
+    deprecatedSignerLocked: offchain.deprecatedSignerLocked,
     unrolled: offchain.unrolled,
     total: totalBoarding + offchain.total,
     assets: offchain.assets,
-    availableAssets: offchain.availableAssets
+    availableAssets: offchain.availableAssets,
+    // Deprecated aliases, so code written against older releases still reads a value.
+    gated: offchain.contractLocked,
+    intentLocked: offchain.pendingSettlement,
+    pendingRecovery: offchain.deprecatedSignerLocked
   };
 }
 
@@ -13811,11 +13835,42 @@ var ReadonlyWallet = class _ReadonlyWallet {
     const utxos = [];
     const commitmentsToIgnore = /* @__PURE__ */ new Set();
     const tapscripts = await this.getBoardingTapscripts(this.watchedBoardingSigners());
-    const outspendCache = /* @__PURE__ */ new Map();
-    for (const tapscript of tapscripts) {
-      const boardingAddress = tapscript.onchainAddress(this.network);
-      const scriptHex = hex.encode(tapscript.pkScript);
-      const txs = await this.onchainProvider.getTransactions(boardingAddress);
+    const getOne = this.onchainProvider.getTxOutspend?.bind(this.onchainProvider);
+    const listInflight = /* @__PURE__ */ new Map();
+    const oneInflight = /* @__PURE__ */ new Map();
+    const outspendOf = (txid, index) => {
+      if (getOne) {
+        const key = `${txid}:${index}`;
+        let pending2 = oneInflight.get(key);
+        if (!pending2) {
+          pending2 = getOne(txid, index);
+          oneInflight.set(key, pending2);
+        }
+        return pending2;
+      }
+      let pending = listInflight.get(txid);
+      if (!pending) {
+        pending = this.onchainProvider.getTxOutspends(txid);
+        listInflight.set(txid, pending);
+      }
+      return pending.then((statuses) => statuses[index]);
+    };
+    const historyResults = await Promise.allSettled(
+      tapscripts.map(async (tapscript) => {
+        const boardingAddress = tapscript.onchainAddress(this.network);
+        return {
+          boardingAddress,
+          scriptHex: hex.encode(tapscript.pkScript),
+          txs: await this.onchainProvider.getTransactions(boardingAddress)
+        };
+      })
+    );
+    const histories = historyResults.map((result) => {
+      if (result.status === "rejected") throw result.reason;
+      return result.value;
+    });
+    const outputs = [];
+    for (const { boardingAddress, scriptHex, txs } of histories) {
       const commitmentByOutpoint = /* @__PURE__ */ new Map();
       for (const tx of txs) {
         for (const input of tx.vin ?? []) {
@@ -13825,42 +13880,51 @@ var ReadonlyWallet = class _ReadonlyWallet {
       for (const tx of txs) {
         for (let i = 0; i < tx.vout.length; i++) {
           const vout = tx.vout[i];
-          if (vout.scriptpubkey_address === boardingAddress) {
-            let spentStatuses = outspendCache.get(tx.txid);
-            if (!spentStatuses) {
-              spentStatuses = await this.onchainProvider.getTxOutspends(tx.txid);
-              outspendCache.set(tx.txid, spentStatuses);
-            }
-            const spentStatus = spentStatuses[i];
-            const commitmentTxid = spentStatus?.txid || commitmentByOutpoint.get(`${tx.txid}:${i}`);
-            const spent = Boolean(spentStatus?.spent) || commitmentTxid !== void 0;
-            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,
-              value: Number(vout.value),
-              status: {
-                confirmed: tx.status.confirmed,
-                block_time: tx.status.block_time
-              },
-              isUnrolled: true,
-              ...boardingFacts,
-              spentBy: "",
-              createdAt: tx.status.confirmed ? new Date(tx.status.block_time * 1e3) : /* @__PURE__ */ new Date(0),
-              script: scriptHex
-            });
-          }
+          if (vout.scriptpubkey_address !== boardingAddress) continue;
+          outputs.push({
+            txid: tx.txid,
+            vout: i,
+            value: Number(vout.value),
+            confirmed: tx.status.confirmed,
+            blockTime: tx.status.block_time,
+            scriptHex,
+            commitmentFromVin: commitmentByOutpoint.get(`${tx.txid}:${i}`),
+            spentStatus: outspendOf(tx.txid, i)
+          });
         }
       }
     }
+    const spentResults = await Promise.allSettled(outputs.map((output) => output.spentStatus));
+    for (const [i, output] of outputs.entries()) {
+      const spentResult = spentResults[i];
+      if (spentResult.status === "rejected") throw spentResult.reason;
+      const spentStatus = spentResult.value;
+      const commitmentTxid = spentStatus?.txid || output.commitmentFromVin;
+      const spent = Boolean(spentStatus?.spent) || commitmentTxid !== void 0;
+      if (spent && commitmentTxid) {
+        commitmentsToIgnore.add(commitmentTxid);
+      }
+      const boardingFacts = {
+        isSpent: spent,
+        isSwept: false,
+        isPreconfirmed: false,
+        commitmentTxIds: spent && commitmentTxid ? [commitmentTxid] : []
+      };
+      utxos.push({
+        txid: output.txid,
+        vout: output.vout,
+        value: output.value,
+        status: {
+          confirmed: output.confirmed,
+          block_time: output.blockTime
+        },
+        isUnrolled: true,
+        ...boardingFacts,
+        spentBy: "",
+        createdAt: output.confirmed ? new Date(output.blockTime * 1e3) : /* @__PURE__ */ new Date(0),
+        script: output.scriptHex
+      });
+    }
     const unconfirmedTxs = [];
     const confirmedTxs = [];
     for (const utxo of utxos) {
@@ -13952,9 +14016,12 @@ var ReadonlyWallet = class _ReadonlyWallet {
     await this.walletRepository.saveUtxos(
       new Map(groups.map((group, i) => [addresses[i], group.coins]))
     );
+    const cachedByAddress = await Promise.all(
+      addresses.map((address) => collectUtxos(this.walletRepository, address))
+    );
     for (const [i, group] of groups.entries()) {
       const fresh = new Set(group.coins.map((coin) => `${coin.txid}:${coin.vout}`));
-      const cached = await collectUtxos(this.walletRepository, addresses[i]);
+      const cached = cachedByAddress[i];
       const kept = cached.filter((coin) => fresh.has(`${coin.txid}:${coin.vout}`));
       if (kept.length === cached.length) continue;
       await this.walletRepository.deleteUtxos(addresses[i]);
@@ -13977,14 +14044,20 @@ var ReadonlyWallet = class _ReadonlyWallet {
     return groups.flatMap((g) => g.coins);
   }
   /**
-   * @internal {@link getBoardingUtxos} minus those an in-flight settle is spending, for SDK
-   * picks. The getter itself lists them: callers that mirror it (the worker's cache and
-   * broadcasts, balances) must not see a settle's inputs vanish, and then stay gone if it fails.
+   * @internal {@link getBoardingUtxos} minus those an in-flight settle is spending or an
+   * unresolved intent locks, for SDK picks. The getter itself lists them: callers that mirror it
+   * (the worker's cache and broadcasts, balances) must not see a settle's inputs vanish, and then
+   * stay gone if it fails.
    */
   async getSelectableBoardingUtxos() {
-    return (await this.getBoardingUtxos()).filter(
-      (coin) => !this._pendingSpendOutpoints.has(`${coin.txid}:${coin.vout}`)
-    );
+    const [utxos, locked] = await Promise.all([
+      this.getBoardingUtxos(),
+      this.lockedOutpoints()
+    ]);
+    return utxos.filter((coin) => {
+      const key = `${coin.txid}:${coin.vout}`;
+      return !this._pendingSpendOutpoints.has(key) && !locked.has(key);
+    });
   }
   async getStoredBoardingUtxos() {
     const currentOnly = /* @__PURE__ */ new Set([
@@ -14009,6 +14082,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
    * @returns A function that stops the subscriptions
    */
   async notifyIncomingFunds(eventCallback) {
+    const cm = this.indexerProvider ? await this.getContractManager() : void 0;
     const arkAddress = await this.getAddress();
     let onchainStopFunc;
     let indexerStopFunc;
@@ -14061,8 +14135,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       void subscribeOnchain();
     });
     await subscribeOnchain();
-    if (this.indexerProvider && arkAddress) {
-      const cm = await this.getContractManager();
+    if (cm && arkAddress) {
       let annotationQueue = Promise.resolve();
       indexerStopFunc = cm.onContractEvent((event) => {
         if (!isContractVtxoEvent(event)) {
@@ -14208,21 +14281,25 @@ var ReadonlyWallet = class _ReadonlyWallet {
         extraSources: capture?.sources
       });
       onVtxosPersisted = async (_contract, vtxos) => {
-        for (const v of vtxos) {
-          if (v.isSpent) continue;
-          await captureExitBranch({
-            resolver,
-            repository: virtualTxRepository,
-            vtxo: { txid: v.txid, vout: v.vout },
-            value: v.value,
-            mode: capture?.mode ?? DEFAULT_EXIT_CAPTURE_MODE,
-            minExitWorthSats: capture?.minExitWorthSats ?? DEFAULT_MIN_EXIT_WORTH_SATS
-          }).catch(() => {
-          });
-        }
+        await Promise.all(
+          vtxos.map((v) => {
+            if (v.isSpent) return void 0;
+            return captureExitBranch({
+              resolver,
+              repository: virtualTxRepository,
+              vtxo: { txid: v.txid, vout: v.vout },
+              value: v.value,
+              mode: capture?.mode ?? DEFAULT_EXIT_CAPTURE_MODE,
+              minExitWorthSats: capture?.minExitWorthSats ?? DEFAULT_MIN_EXIT_WORTH_SATS
+            }).catch(() => {
+            });
+          })
+        );
       };
       onVtxosSpent = (vtxos) => pruneExitBranches(virtualTxRepository, vtxos);
     }
+    const baselinePubkeyPromise = this.identity.xOnlyPublicKey();
+    void baselinePubkeyPromise.catch(() => void 0);
     const manager = await ContractManager.create({
       lazyInitialization: this.lazyInitialization,
       indexerProvider: this.indexerProvider,
@@ -14242,13 +14319,14 @@ var ReadonlyWallet = class _ReadonlyWallet {
         return { height, time };
       }
     });
-    const baselinePubkey = await this.identity.xOnlyPublicKey();
+    const baselinePubkey = await baselinePubkeyPromise;
     const delegatePubKey = this.offchainTapscript instanceof DelegateVtxo.Script ? this.offchainTapscript.options.delegatePubKey : void 0;
     const baselineSigners = [
       this.offchainTapscript.options.serverPubKey,
       ...[...this._deprecatedSigners.keys()].map((h) => hex.decode(h))
     ];
     const seenBaselineScripts = /* @__PURE__ */ new Set();
+    const baseline = [];
     for (const serverPubKey of baselineSigners) {
       for (const csvTimelock2 of this.walletContractTimelocks) {
         const csvTimelockStr = timelockToSequence(csvTimelock2).toString();
@@ -14260,7 +14338,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
         const defaultScriptHex = hex.encode(defaultScript.pkScript);
         if (!seenBaselineScripts.has(defaultScriptHex)) {
           seenBaselineScripts.add(defaultScriptHex);
-          await manager.createContract({
+          baseline.push({
             type: "default",
             params: {
               pubKey: hex.encode(defaultScript.options.pubKey),
@@ -14282,7 +14360,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
           const delegateScriptHex = hex.encode(delegateScript.pkScript);
           if (seenBaselineScripts.has(delegateScriptHex)) continue;
           seenBaselineScripts.add(delegateScriptHex);
-          await manager.createContract({
+          baseline.push({
             type: "delegate",
             params: {
               pubKey: hex.encode(delegateScript.options.pubKey),
@@ -14307,7 +14385,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       const boardingScriptHex = hex.encode(baselineBoarding.pkScript);
       if (seenBaselineScripts.has(boardingScriptHex)) continue;
       seenBaselineScripts.add(boardingScriptHex);
-      await manager.createContract({
+      baseline.push({
         type: "boarding",
         params: {
           pubKey: hex.encode(baselineBoarding.options.pubKey),
@@ -14319,6 +14397,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
         state: "active"
       });
     }
+    await manager.createContracts(baseline);
     return manager;
   }
   /** Dispose wallet-owned managers and release background resources. */
@@ -14843,13 +14922,13 @@ var Wallet2 = class extends ReadonlyWallet {
   async _doRotateServerSigner(xonly, newServerUnrollScript) {
     if (equalBytes(xonly, this.arkServerPublicKey)) return;
     const manager = await this.getContractManager();
-    const [currentOffchainRow] = await manager.getContracts({
-      script: this.defaultContractScript
-    });
     const currentBoardingScript = hex.encode(this._boardingTapscript.pkScript);
-    const [currentBoardingRow] = await manager.getContracts({
-      script: currentBoardingScript
-    });
+    const [offchainRows, boardingRows] = await Promise.all([
+      manager.getContracts({ script: this.defaultContractScript }),
+      manager.getContracts({ script: currentBoardingScript })
+    ]);
+    const [currentOffchainRow] = offchainRows;
+    const [currentBoardingRow] = boardingRows;
     const newOffchain = this.offchainTapscript instanceof DelegateVtxo.Script ? new DelegateVtxo.Script({
       ...this.offchainTapscript.options,
       serverPubKey: xonly
@@ -15032,13 +15111,15 @@ var Wallet2 = class extends ReadonlyWallet {
     return this._restoreInFlight;
   }
   async _runRestore(gapLimit) {
-    const manager = await this.getContractManager();
     const provider = this._hdProvider;
     const hd = provider !== void 0;
-    const staticDescriptor = hd ? void 0 : await identityDescriptor(this.identity);
+    const [manager, staticDescriptor, arkInfo] = await Promise.all([
+      this.getContractManager(),
+      hd ? void 0 : identityDescriptor(this.identity),
+      this.arkProvider.getInfo()
+    ]);
     const materialize = (index) => hd ? provider.materializeDescriptorAt(index) : staticDescriptor;
     const delegatePubKey = this.offchainTapscript instanceof DelegateVtxo.Script ? this.offchainTapscript.options.delegatePubKey : void 0;
-    const arkInfo = await this.arkProvider.getInfo();
     const currentSignerPubKey = toXOnly(hex.decode(arkInfo.signerPubkey), "ark signer key");
     const deprecatedSignerPubKeys = arkInfo.deprecatedSigners.map(
       (s) => toXOnly(hex.decode(s.pubkey), "deprecated signer key")
@@ -15586,25 +15667,33 @@ var Wallet2 = class extends ReadonlyWallet {
         throw error;
       }
       const inputIds = params.inputs.map((i) => `${i.txid}:${i.vout}`).join(",");
+      let released = !registering;
       if (registering) {
-        await this.arkProvider.deleteIntent(deleteIntent).catch((e) => {
-          if (isNoMatchingIntentsError(e)) return;
-          console.warn(
-            `Failed to delete intent after settle failure for inputs [${inputIds}]; intent may linger on server and cause 'duplicated input' on next settle`,
-            e
-          );
-        });
-      }
-      await this.persistIntentSnapshot(
-        intentTxId,
-        "cancelled",
-        intent,
-        deleteIntent,
-        params.inputs,
-        {
-          cancellationReason: error instanceof Error ? error.message : String(error)
+        try {
+          await this.arkProvider.deleteIntent(deleteIntent);
+          released = true;
+        } catch (e) {
+          if (isNoMatchingIntentsError(e)) released = true;
+          else {
+            console.warn(
+              `Failed to delete intent after settle failure for inputs [${inputIds}]; intent may linger on server and cause 'duplicated input' on next settle`,
+              e
+            );
+          }
         }
-      );
+      }
+      if (released) {
+        await this.persistIntentSnapshot(
+          intentTxId,
+          "cancelled",
+          intent,
+          deleteIntent,
+          params.inputs,
+          {
+            cancellationReason: error instanceof Error ? error.message : String(error)
+          }
+        );
+      }
       throw error;
     } finally {
       this._removePendingSpends(params.inputs);
@@ -18533,6 +18622,7 @@ var WalletMessageHandler = class {
   indexerProvider;
   walletRepository;
   incomingFundsSubscription;
+  incomingFundsRegistrations = /* @__PURE__ */ new WeakMap();
   contractEventsSubscription;
   onNextTick = [];
   channel;
@@ -18544,6 +18634,11 @@ var WalletMessageHandler = class {
   // stale, folding requests in would truncate an in-flight settle, and
   // sharing with boarding would kill every lazy refresh (see `boardingEpoch`).
   incomingFundsEpoch = 0;
+  /**
+   * Supersedes older initializers without touching `incomingFundsEpoch`, so a
+   * re-init that fails before registering leaves the live subscription delivering.
+   */
+  initEpoch = 0;
   contractEventsEpoch = 0;
   boardingEpoch = 0;
   /** Per-request progress callbacks: ends with the handler, not with a re-init. */
@@ -18568,6 +18663,7 @@ var WalletMessageHandler = class {
   }
   async stop() {
     this.requestEpoch++;
+    this.initEpoch++;
     this.incomingFundsEpoch++;
     this.contractEventsEpoch++;
     this.boardingEpoch++;
@@ -18608,6 +18704,8 @@ var WalletMessageHandler = class {
   }
   epochOf(scope) {
     switch (scope) {
+      case "init":
+        return this.initEpoch;
       case "incomingFunds":
         return this.incomingFundsEpoch;
       case "contractEvents":
@@ -19364,18 +19462,22 @@ var WalletMessageHandler = class {
   }
   async onWalletInitialized() {
     const wallet = this.readonlyWallet;
+    const signingWallet = this.wallet;
+    const lazyBoarding = this.lazyBoardingInit;
     if (!wallet || !this.arkProvider || !this.indexerProvider || !this.walletRepository) {
       return;
     }
-    const init = this.newGeneration("incomingFunds");
+    this.initEpoch++;
+    const init = this.newGeneration("init");
     await this.ensureContractEventBroadcasting();
     if (init.stale) return;
-    await this.refreshCachedData({ lazyBoarding: this.lazyBoardingInit });
+    await this.refreshCachedData({ lazyBoarding });
     if (init.stale) return;
-    if (this.wallet) {
+    if (signingWallet) {
       try {
         const vtxos = await this.getVtxosFromRepo();
-        const { pending, finalized } = await this.wallet.finalizePendingTxs(
+        if (init.stale) return;
+        const { pending, finalized } = await signingWallet.finalizePendingTxs(
           vtxos.filter((vtxo) => vtxo.isSpent || vtxo.isPreconfirmed && !vtxo.isSwept)
         );
         console.info(
@@ -19386,11 +19488,34 @@ var WalletMessageHandler = class {
       }
       if (init.stale) return;
     }
-    if (this.incomingFundsSubscription) this.incomingFundsSubscription();
-    this.incomingFundsSubscription = void 0;
     this.incomingFundsEpoch++;
     const emitter = this.newEmitter("incomingFunds");
+    const provider = wallet.onchainProvider ?? this;
+    const previousRegistration = this.incomingFundsRegistrations.get(provider) ?? Promise.resolve();
+    const registration = previousRegistration.then(
+      () => this.registerIncomingFunds(wallet, emitter)
+    );
+    this.incomingFundsRegistrations.set(
+      provider,
+      registration.catch((error) => {
+        console.error("Error subscribing to incoming funds:", error);
+      })
+    );
+    if (!lazyBoarding) await registration;
+    if (signingWallet && !emitter.stale) {
+      try {
+        await signingWallet.getVtxoManager();
+      } catch (error) {
+        console.error("Error starting VtxoManager:", error);
+      }
+    }
+  }
+  async registerIncomingFunds(wallet, emitter) {
+    if (emitter.stale) return;
+    if (this.incomingFundsSubscription) this.incomingFundsSubscription();
+    this.incomingFundsSubscription = void 0;
     const address = await wallet.getAddress();
+    if (emitter.stale) return;
     const unsubscribe = await wallet.notifyIncomingFunds(async (funds) => {
       if (emitter.stale) return;
       if (funds.type === "vtxo") {
@@ -19459,13 +19584,6 @@ var WalletMessageHandler = class {
     });
     if (emitter.stale) return unsubscribe();
     this.incomingFundsSubscription = unsubscribe;
-    if (this.wallet) {
-      try {
-        await this.wallet.getVtxoManager();
-      } catch (error) {
-        console.error("Error starting VtxoManager:", error);
-      }
-    }
   }
   /**
    * Refresh boarding inputs and transaction history. The virtual outputs come
@@ -19494,24 +19612,30 @@ var WalletMessageHandler = class {
             payload: { coins }
           })
         );
-        await this.refreshHistoryCache(emitter);
+        await this.storeHistoryCache(await this.loadHistoryCache(), emitter);
       })().catch((error) => {
         console.warn("[wallet] background refresh failed", error);
       });
       return;
     }
+    const history = this.loadHistoryCache();
+    void history.catch(() => void 0);
     await this.refreshBoardingCache();
     this.boardingLoaded = true;
-    await this.refreshHistoryCache();
+    await this.storeHistoryCache(await history);
   }
-  /** @param gen - set by a background caller; each write is skipped once it goes stale. */
-  async refreshHistoryCache(gen) {
+  /** History rows plus the address they are stored under. Does not write. */
+  async loadHistoryCache() {
     const wallet = this.readonlyWallet;
-    const repository = this.walletRepository;
-    if (!wallet || !repository) return;
+    if (!wallet || !this.walletRepository) return void 0;
     const address = await wallet.getAddress();
     const txs = await this.buildTransactionHistoryFromCache();
-    if (txs && !gen?.stale) await repository.saveTransactions(address, txs);
+    if (!txs) return void 0;
+    return { address, txs };
+  }
+  async storeHistoryCache(history, gen) {
+    if (!history || gen?.stale || !this.walletRepository) return;
+    await this.walletRepository.saveTransactions(history.address, history.txs);
   }
   /**
    * @param gen - set by a background caller; each write here is skipped once it goes stale.
@@ -19526,11 +19650,17 @@ var WalletMessageHandler = class {
       hex.encode(wallet.boardingTapscript.options.serverPubKey)
     );
     const groups = await wallet.getBoardingUtxosForSigners(/* @__PURE__ */ new Set([currentSigner]));
-    for (const { tapscript, coins } of groups) {
+    if (gen?.stale) return;
+    const cachedByAddress = await Promise.all(
+      groups.map(
+        ({ tapscript }) => collectUtxos(repository, tapscript.onchainAddress(wallet.network))
+      )
+    );
+    for (const [i, { tapscript, coins }] of groups.entries()) {
       if (gen?.stale) return;
       const address = tapscript.onchainAddress(wallet.network);
       const freshKeys = new Set(coins.map((coin) => `${coin.txid}:${coin.vout}`));
-      const cached = await collectUtxos(repository, address);
+      const cached = cachedByAddress[i];
       const kept = cached.filter((coin) => freshKeys.has(`${coin.txid}:${coin.vout}`));
       if (kept.length === cached.length) continue;
       if (gen?.stale) return;
@@ -19628,6 +19758,7 @@ var WalletMessageHandler = class {
     const wallet = this.wallet ?? this.readonlyWallet;
     if (!wallet) return;
     this.requestEpoch++;
+    this.initEpoch++;
     this.incomingFundsEpoch++;
     this.contractEventsEpoch++;
     this.boardingEpoch++;
@@ -19679,7 +19810,9 @@ var WalletMessageHandler = class {
    * {@link getVtxosFromRepo}).
    */
   async repoSnapshot(options = {}) {
-    if (!this.walletRepository || !this.readonlyWallet) return { snapshot: [], vtxos: [] };
+    const repository = this.walletRepository;
+    const wallet = this.readonlyWallet;
+    if (!repository || !wallet) return { snapshot: [], vtxos: [] };
     const seen = /* @__PURE__ */ new Set();
     const allVtxos = [];
     const addVtxos = (vtxos) => {
@@ -19694,19 +19827,18 @@ var WalletMessageHandler = class {
       }
       return fresh;
     };
-    const manager = await this.readonlyWallet.getContractManager();
+    const addressPromise = wallet.getAddress();
+    void addressPromise.catch(() => void 0);
+    const manager = await wallet.getContractManager();
     const contracts = await manager.getContracts();
-    const snapshot = [];
-    for (const contract of contracts) {
-      if (!options.includeRecoveryOnly && isRecoveryOnlyContract(contract)) continue;
-      snapshot.push({
-        contract,
-        vtxos: addVtxos(
-          await getVtxosForContract(this.walletRepository, contract, options)
-        )
-      });
-    }
-    const walletAddress = await this.readonlyWallet.getAddress();
+    const eligible = contracts.filter(
+      (contract) => options.includeRecoveryOnly || !isRecoveryOnlyContract(contract)
+    );
+    const listsPromise = Promise.all(
+      eligible.map((contract) => getVtxosForContract(repository, contract, options))
+    );
+    void listsPromise.catch(() => void 0);
+    const walletAddress = await addressPromise;
     let walletScript;
     try {
       walletScript = scriptFromArkAddress(walletAddress);
@@ -19715,13 +19847,26 @@ var WalletMessageHandler = class {
         `WalletMessageHandler.getVtxosFromRepo: failed to derive script from wallet address ${walletAddress}: ${e instanceof Error ? e.message : String(e)}`
       );
     }
-    addVtxos(
-      await getVtxosForContract(
-        this.walletRepository,
+    const [lists, primaryVtxos] = await Promise.all([
+      listsPromise,
+      // Routed through the same helper as the contract buckets rather than reading the
+      // repository directly, so this bucket normalizes too. Anything left here
+      // is outside every contract row, so it carries no contract to judge it
+      // by — the wallet's own receive address, which is never gated.
+      getVtxosForContract(
+        repository,
         { script: walletScript, address: walletAddress },
         options
       )
-    );
+    ]);
+    const snapshot = [];
+    for (const [i, contract] of eligible.entries()) {
+      snapshot.push({
+        contract,
+        vtxos: addVtxos(lists[i])
+      });
+    }
+    addVtxos(primaryVtxos);
     return { snapshot, vtxos: allVtxos };
   }
   /**
@@ -20424,7 +20569,12 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
     };
     try {
       const response = await this.sendMessage(message);
-      return response.payload;
+      const balance = response.payload;
+      return {
+        ...balance,
+        contractLocked: balance.contractLocked ?? balance.gated,
+        deprecatedSignerLocked: balance.deprecatedSignerLocked ?? balance.pendingRecovery
+      };
     } catch (error) {
       throw new Error(`Failed to get balance: ${error}`);
     }
@@ -22106,6 +22256,14 @@ var ElectrumOnchainProvider = class {
     return hex.decode(tx.hex);
   }
   async getTxOutspends(txid) {
+    return this.resolveOutspends(txid);
+  }
+  /** Reads `vout`'s script alone: another output of a tx someone else built (their change, a
+   *  service's fee address) can have a history Fulcrum answers empty and electrs refuses. */
+  async getTxOutspend(txid, vout) {
+    return (await this.resolveOutspends(txid, vout))[vout] ?? { spent: false, txid: "" };
+  }
+  async resolveOutspends(txid, only) {
     const [txResult] = await this.chain.fetchTransactions([txid]);
     const tx = Transaction$1.fromRaw(hex.decode(txResult.hex), {
       allowUnknownOutputs: true
@@ -22114,7 +22272,10 @@ var ElectrumOnchainProvider = class {
     const outputScriptHashes = [];
     for (let i = 0; i < outputCount; i++) {
       const output = tx.getOutput(i);
-      outputScriptHashes.push(output.script ? toScriptHash(output.script) : void 0);
+      const wanted = only === void 0 || i === only;
+      outputScriptHashes.push(
+        wanted && output.script ? toScriptHash(output.script) : void 0
+      );
     }
     const validScriptHashes = outputScriptHashes.filter((h) => h !== void 0);
     const results = Array.from(
@@ -22607,8 +22768,12 @@ async function attachPrevoutTxs(tx, source) {
   }
   if (pending.length === 0) return;
   const resolved = /* @__PURE__ */ new Map();
-  for (const txid of new Set(pending.map((p) => p.txid))) {
-    resolved.set(txid, await source.getRawTransaction(txid));
+  const txids = [...new Set(pending.map((p) => p.txid))];
+  const fetched = await Promise.allSettled(txids.map((txid) => source.getRawTransaction(txid)));
+  for (let i = 0; i < fetched.length; i++) {
+    const result = fetched[i];
+    if (result.status === "rejected") throw result.reason;
+    resolved.set(txids[i], result.value);
   }
   for (const { index, txid } of pending) {
     setArkPsbtField(tx, index, PrevoutTxField, resolved.get(txid));
@@ -23062,40 +23227,53 @@ var Unroll;
   Unroll2.completeUnroll = completeUnroll;
 })(Unroll || (Unroll = {}));
 async function prepareUnrollTransaction(wallet, vtxoTxIds, outputAddress) {
-  const chainTip = await wallet.onchainProvider.getChainTip();
-  let vtxos = await wallet.getVtxos({ withUnrolled: true });
-  vtxos = vtxos.filter((vtxo) => vtxoTxIds.includes(vtxo.txid));
+  const [chainTip, storedVtxos, walletDescriptor] = await Promise.all([
+    wallet.onchainProvider.getChainTip(),
+    wallet.getVtxos({ withUnrolled: true }),
+    wallet.identity.xOnlyPublicKey().then((key) => hex.encode(key))
+  ]);
+  const vtxos = storedVtxos.filter((vtxo) => vtxoTxIds.includes(vtxo.txid));
   if (vtxos.length === 0) {
     throw new Error("No vtxos to complete unroll");
   }
   const inputs = [];
   let totalAmount = 0n;
   const txWeightEstimator = TxWeightEstimator.create();
-  const walletDescriptor = hex.encode(await wallet.identity.xOnlyPublicKey());
   for (const vtxo of vtxos) {
     if (!canSweepOnchain(vtxo)) {
       throw new Error(
         `Vtxo ${vtxo.txid}:${vtxo.vout} cannot be swept onchain: it is not fully unrolled (use unroll first), or its exit output was already spent`
       );
     }
-    const txStatus = await wallet.onchainProvider.getTxStatus(vtxo.txid);
-    if (!txStatus.confirmed) {
-      throw new Error(`tx ${vtxo.txid} is not confirmed`);
-    }
-    const resolved = await resolveUnilateralPath({
-      vtxo,
-      scriptHex: hex.encode(VtxoScript.decode(vtxo.tapTree).pkScript),
-      contractRepository: wallet.contractRepository,
-      walletDescriptor,
-      currentTime: Date.now()
-    });
-    const spendingLeaf = resolved.selection.leaf;
-    const sequence = resolved.selection.sequence;
-    const timelock = sequenceToTimelock(sequence);
-    const elapsed = timelock.type === "blocks" ? chainTip.height >= txStatus.blockHeight + Number(timelock.value) : chainTip.time >= txStatus.blockTime + Number(timelock.value);
-    if (!elapsed) {
-      throw new Error(`no available exit path found for vtxo ${vtxo.txid}:${vtxo.vout}`);
-    }
+  }
+  const prepared = await Promise.allSettled(
+    vtxos.map(async (vtxo) => {
+      const [txStatus, resolved] = await Promise.all([
+        wallet.onchainProvider.getTxStatus(vtxo.txid),
+        resolveUnilateralPath({
+          vtxo,
+          scriptHex: hex.encode(VtxoScript.decode(vtxo.tapTree).pkScript),
+          contractRepository: wallet.contractRepository,
+          walletDescriptor,
+          currentTime: Date.now()
+        })
+      ]);
+      if (!txStatus.confirmed) {
+        throw new Error(`tx ${vtxo.txid} is not confirmed`);
+      }
+      const spendingLeaf = resolved.selection.leaf;
+      const sequence = resolved.selection.sequence;
+      const timelock = sequenceToTimelock(sequence);
+      const elapsed = timelock.type === "blocks" ? chainTip.height >= txStatus.blockHeight + Number(timelock.value) : chainTip.time >= txStatus.blockTime + Number(timelock.value);
+      if (!elapsed) {
+        throw new Error(`no available exit path found for vtxo ${vtxo.txid}:${vtxo.vout}`);
+      }
+      return { vtxo, spendingLeaf, sequence };
+    })
+  );
+  for (const result of prepared) {
+    if (result.status === "rejected") throw result.reason;
+    const { vtxo, spendingLeaf, sequence } = result.value;
     totalAmount += BigInt(vtxo.value);
     inputs.push({
       txid: vtxo.txid,
@@ -23253,15 +23431,18 @@ async function resolveFeeRate(opts) {
 async function selectExitVtxos(opts) {
   if (!opts.vtxos) return opts.wallet.getVtxos();
   const res = await getNormalizedVtxos(opts.wallet.indexerProvider, { outpoints: opts.vtxos });
+  const scripts = [
+    ...new Set(res.vtxos.filter((vtxo) => !vtxo.isSpent).map((vtxo) => vtxo.script))
+  ];
+  const contracts = scripts.length === 0 ? [] : await collectContracts(opts.wallet.contractRepository, { script: scripts });
+  const byScript = new Map(contracts.map((contract) => [contract.script, contract]));
   const tapTrees = /* @__PURE__ */ new Map();
   const out = [];
   for (const vtxo of res.vtxos) {
     if (vtxo.isSpent) continue;
     let tapTree = tapTrees.get(vtxo.script);
     if (!tapTree) {
-      const [contract] = await collectContracts(opts.wallet.contractRepository, {
-        script: vtxo.script
-      });
+      const contract = byScript.get(vtxo.script);
       if (!contract) {
         throw new Error(
           `no contract registered for vtxo script ${vtxo.script} \u2014 register the contract before exiting`
@@ -23280,6 +23461,10 @@ async function selectExitVtxos(opts) {
 }
 async function computeExitLayout(opts, feeRate) {
   const { wallet, onchainWallet } = opts;
+  const coinsPromise = onchainWallet.getCoins();
+  const pubkeyPromise = wallet.identity.xOnlyPublicKey();
+  void coinsPromise.catch(() => void 0);
+  void pubkeyPromise.catch(() => void 0);
   const vtxos = await selectExitVtxos(opts);
   if (vtxos.length === 0) throw new Error("no vtxos to exit");
   const resolver = createExitChainResolver({
@@ -23317,46 +23502,57 @@ async function computeExitLayout(opts, feeRate) {
     (s) => s.parent.id,
     (s) => txInputTxids(s.parent)
   );
-  const walletDescriptor = hex.encode(await wallet.identity.xOnlyPublicKey());
+  const walletDescriptor = hex.encode(await pubkeyPromise);
+  const resolvedPaths = await Promise.allSettled(
+    vtxos.map(async (vtxo) => {
+      try {
+        return {
+          vtxo,
+          resolved: await resolveUnilateralPath({
+            vtxo,
+            scriptHex: hex.encode(VtxoScript.decode(vtxo.tapTree).pkScript),
+            contractRepository: wallet.contractRepository,
+            walletDescriptor,
+            currentTime: Date.now()
+          })
+        };
+      } catch (e) {
+        if (e instanceof ExitPathError) return { vtxo, skipped: e.message };
+        throw e;
+      }
+    })
+  );
   const infos = [];
   const sweeps = [];
-  for (const vtxo of vtxos) {
+  for (const result of resolvedPaths) {
+    if (result.status === "rejected") throw result.reason;
+    const { vtxo } = result.value;
     const outpoint = `${vtxo.txid}:${vtxo.vout}`;
-    try {
-      const resolved = await resolveUnilateralPath({
-        vtxo,
-        scriptHex: hex.encode(VtxoScript.decode(vtxo.tapTree).pkScript),
-        contractRepository: wallet.contractRepository,
-        walletDescriptor,
-        currentTime: Date.now()
+    if ("skipped" in result.value) {
+      infos.push({ outpoint, value: vtxo.value, skipped: result.value.skipped });
+      continue;
+    }
+    const { resolved } = result.value;
+    const sweepFee = sweepFeeFor(
+      resolved.selection,
+      opts.sweepAddress,
+      wallet.network,
+      feeRate
+    );
+    if (vtxo.value - sweepFee < CHILD_OUTPUT_DUST) {
+      infos.push({
+        outpoint,
+        value: vtxo.value,
+        skipped: `uneconomic: value ${vtxo.value} <= sweep fee + dust`
       });
-      const sweepFee = sweepFeeFor(
-        resolved.selection,
-        opts.sweepAddress,
-        wallet.network,
-        feeRate
-      );
-      if (vtxo.value - sweepFee < CHILD_OUTPUT_DUST) {
-        infos.push({
-          outpoint,
-          value: vtxo.value,
-          skipped: `uneconomic: value ${vtxo.value} <= sweep fee + dust`
-        });
-        continue;
-      }
-      const t = sequenceToTimelock(resolved.selection.sequence);
-      const delay = { type: t.type, value: Number(t.value) };
-      infos.push({ outpoint, value: vtxo.value, sweepFee, path: resolved.label, delay });
-      sweeps.push({ vtxo, resolved, sweepFee, delay });
-    } catch (e) {
-      if (e instanceof ExitPathError) {
-        infos.push({ outpoint, value: vtxo.value, skipped: e.message });
-        continue;
-      }
-      throw e;
+      continue;
     }
+    const t = sequenceToTimelock(resolved.selection.sequence);
+    const delay = { type: t.type, value: Number(t.value) };
+    infos.push({ outpoint, value: vtxo.value, sweepFee, path: resolved.label, delay });
+    sweeps.push({ vtxo, resolved, sweepFee, delay });
   }
-  const coins = (await onchainWallet.getCoins()).filter((c) => c.status.confirmed);
+  const coins = (await coinsPromise).filter((c) => c.status.confirmed);
   const balance = coins.reduce((sum, c) => sum + c.value, 0);
   const fundingTotal = steps.reduce((sum, s) => sum + s.funding, 0);
   const splitterFeeFor = (inputCount) => {
@@ -24756,6 +24952,13 @@ var Arkade = class _Arkade {
     }
     return new ArkadeContract(this, program, args);
   }
+  /**
+   * Start a spend with no function of its own: each `.from(coins, contract.unlock.<name>(...))`
+   * names the function its coins are spent through.
+   */
+  transaction() {
+    return new ArkadeTransactionBuilder(this);
+  }
 };
 var ArkadeContract = class _ArkadeContract {
   constructor(client, program, args = {}, keys) {
@@ -24817,7 +25020,23 @@ var ArkadeContract = class _ArkadeContract {
   get functions() {
     const out = /* @__PURE__ */ Object.create(null);
     for (const fn of this.compiled) {
-      out[fn.name] = (...callArgs) => new ArkadeTransactionBuilder(this, fn, bindInputs(fn, callArgs));
+      out[fn.name] = (...callArgs) => new ArkadeTransactionBuilder(this.client, {
+        contract: this,
+        fn,
+        args: bindInputs(fn, callArgs)
+      });
+    }
+    return out;
+  }
+  /** Spending paths bound to their arguments, for `.from(coins, contract.unlock.<name>(...))`. */
+  get unlock() {
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const fn of this.compiled) {
+      out[fn.name] = (...callArgs) => ({
+        contract: this,
+        fn,
+        args: bindInputs(fn, callArgs)
+      });
     }
     return out;
   }
@@ -24935,27 +25154,62 @@ var ArkadeContract = class _ArkadeContract {
 };
 var ArkadeTransactionBuilder = class {
   /** @internal */
-  constructor(contract, fn, args) {
-    this.contract = contract;
-    this.fn = fn;
-    this.args = args;
+  constructor(client, unlocker) {
+    this.client = client;
+    this.unlocker = unlocker;
   }
-  contract;
-  fn;
-  args;
+  client;
+  unlocker;
   outputs = [];
   fundingCoins = [];
   assetSpecs = [];
   extraPackets = [];
-  coin;
+  inputs = [];
   changeScript;
-  from(coin) {
-    this.coin = coin;
+  /**
+   * Spend coins through this builder's function, or through `unlocker`
+   * (`other.unlock.<name>(...args)`, same client), which `ark.transaction()` requires. Calls add
+   * up; contract coins come first, in call order, then `.fund()` inputs.
+   *
+   * Every coin's script sees the same outputs: "output 0 pays X" passes once for all of them.
+   * For one payment per coin, the contract must check `INSPECTNUMINPUTS` or `PUSHCURRENTINPUTINDEX`.
+   */
+  from(coins, unlocker = this.unlocker) {
+    const list = Array.isArray(coins) ? coins : [coins];
+    if (list.length === 0) throw new Error("from(): no coins given");
+    if (!unlocker) {
+      throw new Error("from(): name the function to spend through: contract.unlock.<name>()");
+    }
+    const { contract, fn } = unlocker;
+    if (contract.client !== this.client) {
+      throw new Error(`from(): ${fn.name} belongs to a contract on another Arkade client`);
+    }
+    const script = hex.encode(contract.pkScript);
+    const taken = new Set(this.inputs.map(({ coin: c }) => `${c.txid}:${c.vout}`));
+    const now = Date.now();
+    for (const coin of list) {
+      const outpoint = `${coin.txid}:${coin.vout}`;
+      if (coin.script && coin.script !== script) {
+        throw new Error(
+          `from(): coin ${outpoint} is not locked by the contract of ${fn.name}`
+        );
+      }
+      if (taken.has(outpoint))
+        throw new Error(`from(): coin ${outpoint} is already an input`);
+      const reason = unspendable(coin, now);
+      if (reason) {
+        throw new Error(
+          `from(): coin ${outpoint} ${reason}; recover it into a batch instead`
+        );
+      }
+      taken.add(outpoint);
+    }
+    this.inputs.push(...list.map((coin) => ({ coin, unlocker })));
     return this;
   }
   /**
    * Add extra inputs the caller funds (e.g. a taker's own coins in a swap).
-   * These become inputs 1..n and are signed with the client identity.
+   * These come after the contract coins and are signed with the client identity.
    */
   fund(coins) {
     this.fundingCoins.push(...coins);
@@ -24992,23 +25246,39 @@ var ArkadeTransactionBuilder = class {
   }
   /** Assemble the unsigned ark transaction and its checkpoints. */
   async build() {
-    if (this.fn.def.tapscript.csv) {
-      throw new Error(
-        `${this.fn.name}: CSV leaves require an aged onchain output; the offchain builder creates fresh checkpoints \u2014 use the wallet's unilateral exit flow`
-      );
+    const { arkTx, checkpoints } = await this.assemble();
+    return { arkTx, checkpoints };
+  }
+  async assemble() {
+    for (const { fn } of this.unlockers()) {
+      if (fn.def.tapscript.csv) {
+        throw new Error(
+          `${fn.name}: CSV leaves require an aged onchain output; the offchain builder creates fresh checkpoints \u2014 use the wallet's unilateral exit flow`
+        );
+      }
     }
     if (this.outputs.length === 0) {
       throw new Error("ArkadeTransactionBuilder: at least one output is required");
     }
     const outputsSum = this.outputs.reduce((s, o) => s + (o.amount ?? 0n), 0n);
-    const coin = this.coin ?? await this.selectCoin(outputsSum);
-    const def = this.fn.def;
+    let inputs = [...this.inputs];
+    if (inputs.length === 0) {
+      if (!this.unlocker) {
+        throw new Error(
+          "ArkadeTransactionBuilder: add coins with .from(coins, contract.unlock.<name>())"
+        );
+      }
+      inputs = [
+        { coin: await this.selectCoin(this.unlocker, outputsSum), unlocker: this.unlocker }
+      ];
+    }
+    const coinsSum = inputs.reduce((s, { coin }) => s + BigInt(coin.value), 0n);
     const outputs = [...this.outputs];
     const fundingSum = this.fundingCoins.reduce((s, f) => s + BigInt(f.value), 0n);
-    const surplus = BigInt(coin.value) + fundingSum - outputsSum;
+    const surplus = coinsSum + fundingSum - outputsSum;
     if (surplus < 0n) {
       throw new Error(
-        `ArkadeTransactionBuilder: insufficient inputs \u2014 outputs ${outputsSum} exceed inputs ${BigInt(coin.value) + fundingSum}`
+        `ArkadeTransactionBuilder: insufficient inputs \u2014 outputs ${outputsSum} exceed inputs ${coinsSum + fundingSum}`
       );
     }
     if (surplus > 0n) {
@@ -25021,23 +25291,23 @@ var ArkadeTransactionBuilder = class {
     }
     const { arkTx, checkpoints } = buildOffchainTx(
       [
-        {
+        ...inputs.map(({ coin, unlocker }) => ({
           txid: coin.txid,
           vout: coin.vout,
           value: coin.value,
-          tapLeafScript: this.fn.tapLeafScript,
-          tapTree: this.contract.tapTree
-        },
+          tapLeafScript: unlocker.fn.tapLeafScript,
+          tapTree: unlocker.contract.tapTree
+        })),
         ...this.fundingCoins
       ],
       outputs,
-      this.contract.client.checkpoint
+      this.client.checkpoint
     );
-    if (coin.sourceTx) {
-      setArkPsbtField(arkTx, 0, PrevArkTxField, coin.sourceTx);
-    }
-    if (this.fn.arkadeScript) {
-      const indexer = this.contract.client.indexer;
+    inputs.forEach(({ coin }, i) => {
+      if (coin.sourceTx) setArkPsbtField(arkTx, i, PrevArkTxField, coin.sourceTx);
+    });
+    if (inputs.some(({ unlocker }) => unlocker.fn.arkadeScript)) {
+      const indexer = this.client.indexer;
       if (!indexer) {
         throw new PrevTxUnavailableError(
           "covenant spends require an `indexer` on the Arkade client to resolve the previous ark tx of each input"
@@ -25045,56 +25315,76 @@ var ArkadeTransactionBuilder = class {
       }
       await attachPrevArkTxs(
         arkTx,
-        [coin.txid, ...this.fundingCoins.map((c) => c.txid)],
+        [...inputs.map(({ coin }) => coin), ...this.fundingCoins].map((c) => c.txid),
         indexer
       );
     }
-    const condition = (def.tapscript.witness ?? []).map((w) => this.witnessBytes(w));
-    if (condition.length > 0) {
-      setArkPsbtField(arkTx, 0, ConditionWitness, condition);
-      setArkPsbtField(checkpoints[0], 0, ConditionWitness, condition);
-    }
+    inputs.forEach(({ unlocker }, i) => {
+      const condition = (unlocker.fn.def.tapscript.witness ?? []).map(
+        (w) => witnessBytes(unlocker, w)
+      );
+      if (condition.length === 0) return;
+      setArkPsbtField(arkTx, i, ConditionWitness, condition);
+      setArkPsbtField(checkpoints[i], 0, ConditionWitness, condition);
+    });
     const packets = [];
     if (this.assetSpecs.length > 0) {
       packets.push(this.buildAssetPacket());
     }
-    const arkadeScript = this.fn.arkadeScript;
-    if (arkadeScript) {
-      const stack = (def.arkadeScript?.witness ?? []).map((w) => this.witnessBytes(w));
-      packets.push(
-        EmulatorPacket.create([
-          { vin: 0, script: arkadeScript, witness: RawWitness.encode(stack) }
-        ])
-      );
+    const entries = inputs.flatMap(({ unlocker }, vin) => {
+      const { arkadeScript, def } = unlocker.fn;
+      if (!arkadeScript) return [];
+      const stack = (def.arkadeScript?.witness ?? []).map((w) => witnessBytes(unlocker, w));
+      return [{ vin, script: arkadeScript, witness: RawWitness.encode(stack) }];
+    });
+    if (entries.length > 0) {
+      packets.push(EmulatorPacket.create(entries));
     }
     packets.push(...this.extraPackets);
     if (packets.length > 0) {
       attachExtension(arkTx, packets);
     }
-    return { arkTx, checkpoints };
+    return { arkTx, checkpoints, inputs };
   }
   /** Build, submit and return the finalized transaction. */
   async send() {
-    if (this.fn.def.tapscript.signers.some(
-      (signer) => typeof signer === "object" && "tweak" in signer
-    )) {
-      throw new Error(
-        `${this.fn.name}: covenant-tweaked leaf signing is not supported by Identity; use a signer that supports the covenant tweak with build()`
-      );
+    const client = this.client;
+    const userKey = client.userKey;
+    for (const { contract, fn } of this.unlockers()) {
+      if (fn.def.tapscript.signers.some(
+        (signer) => typeof signer === "object" && "tweak" in signer
+      )) {
+        throw new Error(
+          `${fn.name}: covenant-tweaked leaf signing is not supported by Identity; use a signer that supports the covenant tweak with build()`
+        );
+      }
+      const { serverKey } = contract.keys;
+      if (fn.signerKeys.some(
+        (key) => !equalBytes(key, serverKey) && (!userKey || !equalBytes(key, userKey))
+      )) {
+        throw new Error(
+          `${fn.name}: external leaf signatures are required; use build() and sign the PSBT with all required signers`
+        );
+      }
     }
-    const { serverKey } = this.contract.keys;
-    const userKey = this.contract.client.userKey;
-    if (this.fn.signerKeys.some(
-      (key) => !equalBytes(key, serverKey) && (!userKey || !equalBytes(key, userKey))
-    )) {
+    const { arkTx, checkpoints, inputs } = await this.assemble();
+    const userInputs = this.userInputIndexes(inputs);
+    const serverOnly = inputs.find(
+      ({ unlocker }, i) => !unlocker.fn.arkadeScript && !userInputs.includes(i)
+    );
+    if (serverOnly) {
       throw new Error(
-        `${this.fn.name}: external leaf signatures are required; use build() and sign the PSBT with all required signers`
+        `${serverOnly.unlocker.fn.name}: a leaf without a covenant needs the user's signature, and this one has only the server's`
       );
     }
-    const { arkTx, checkpoints } = await this.build();
-    const client = this.contract.client;
-    const userInputs = this.userInputIndexes();
-    if (this.fn.arkadeScript) {
+    inputs.forEach(({ coin }, vin) => {
+      if (coin.assets?.length && !this.routesAssetsFrom(vin)) {
+        throw new Error(
+          `coin ${coin.txid}:${coin.vout} carries assets; route them with .withAsset() from input ${vin}`
+        );
+      }
+    });
+    if (inputs.some(({ unlocker }) => unlocker.fn.arkadeScript)) {
       if (!client.emulator) {
         throw new Error("covenant spends require an `emulator` on the Arkade client");
       }
@@ -25119,9 +25409,14 @@ var ArkadeTransactionBuilder = class {
     assertSubmittedArkTxid(res, signedArk, "submitTx");
     const matched = matchServerCheckpoints(res.signedCheckpointTxs, checkpoints, "submitTx");
     const finalCps = await Promise.all(
-      matched.map(
-        async ({ server }) => base64.encode((await client.identity.sign(server, [0])).toPSBT())
-      )
+      matched.map(async ({ server, local }) => {
+        const signed = await client.identity.sign(server, [0]);
+        const [condition] = getArkPsbtFields(local, 0, ConditionWitness);
+        if (condition && getArkPsbtFields(signed, 0, ConditionWitness).length === 0) {
+          setArkPsbtField(signed, 0, ConditionWitness, condition);
+        }
+        return base64.encode(signed.toPSBT());
+      })
     );
     await ark.finalizeTx(res.arkTxid, finalCps);
     return {
@@ -25133,31 +25428,44 @@ var ArkadeTransactionBuilder = class {
   /** Sign the client-owned inputs of the ark tx (no-op when there are none). */
   async signArk(arkTx, userInputs) {
     if (userInputs.length === 0) return arkTx;
-    const { identity } = this.contract.client;
+    const { identity } = this.client;
     if (!identity) {
       throw new Error("this spend requires an `identity` to sign its user/funding inputs");
     }
     return identity.sign(arkTx, userInputs);
   }
-  /** Indexes of inputs the client owns and must sign (contract input + funded inputs). */
-  userInputIndexes() {
-    const idxs = [];
-    const userKey = this.contract.client.userKey;
-    if (userKey && this.fn.signerKeys.some((k) => equalBytes(k, userKey))) {
-      idxs.push(0);
-    }
-    for (let i = 0; i < this.fundingCoins.length; i++) {
-      idxs.push(i + 1);
-    }
+  /** The functions this spend goes through: the `.from()` ones, else this builder's own. */
+  unlockers() {
+    if (this.inputs.length > 0) return this.inputs.map((i) => i.unlocker);
+    return this.unlocker ? [this.unlocker] : [];
+  }
+  /** Indexes of inputs the client owns and must sign (contract inputs + funded inputs). */
+  userInputIndexes(inputs) {
+    const userKey = this.client.userKey;
+    const idxs = inputs.flatMap(
+      ({ unlocker }, i) => userKey && unlocker.fn.signerKeys.some((k) => equalBytes(k, userKey)) ? [i] : []
+    );
+    for (let i = 0; i < this.fundingCoins.length; i++) idxs.push(inputs.length + i);
     return idxs;
   }
-  async selectCoin(amount) {
-    const utxos = await this.contract.getUtxos();
+  async selectCoin(unlocker, amount) {
+    const now = Date.now();
+    const routed = this.routesAssetsFrom(0);
+    const utxos = (await unlocker.contract.getUtxos()).filter(
+      (u) => !unspendable(u, now) && (routed || !u.assets?.length)
+    );
     if (utxos.length === 0) throw new Error("no spendable coins for this contract");
     const covering = utxos.filter((u) => BigInt(u.value) >= amount).sort((a, b) => a.value - b.value);
     if (covering.length > 0) return covering[0];
     return [...utxos].sort((a, b) => b.value - a.value)[0];
   }
+  /**
+   * Whether input `vin`'s assets are routed: by a `.withAsset()` input, or a caller's asset packet.
+   * A caller's packet counts for every input, unread; arkd checks what it actually routes.
+   */
+  routesAssetsFrom(vin) {
+    return this.extraPackets.some((p) => p.type() === Packet.PACKET_TYPE) || this.assetSpecs.some((spec) => spec.inputs.some((i) => i.vin === vin));
+  }
   buildAssetPacket() {
     const groups = this.assetSpecs.map((s) => {
       const id = typeof s.assetId === "string" ? AssetId.fromString(s.assetId) : AssetId.fromBytes(s.assetId);
@@ -25171,10 +25479,15 @@ var ArkadeTransactionBuilder = class {
     });
     return Packet.create(groups);
   }
-  witnessBytes(ref) {
-    return witnessRefToBytes(ref, this.args, this.contract.args);
-  }
 };
+function unspendable(coin, now) {
+  if (coin.isSwept) return "was swept";
+  if (coin.expiresAt && now >= new Date(coin.expiresAt).getTime()) return "has expired";
+  return void 0;
+}
+function witnessBytes({ contract, args }, ref) {
+  return witnessRefToBytes(ref, args, contract.args);
+}
 function bindInputs(fn, callArgs) {
   const inputs = fn.def.inputs ?? [];
   if (callArgs.length !== inputs.length) {
@@ -25674,5 +25987,5 @@ function createDefaultPaymentRouter(wallet) {
 }
 
 export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, AbortError, ActivityRegistry, AmbiguousRouteError, ArkNote, Arkade, ArkadeCash, ArkadeCashCreateError, ArkadeCashOperatorMismatchError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractWatcher, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, ForeignDescriptorError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, KeyringDescriptorProvider, MAX_PAGE_SIZE, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, OversizedChangeError, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestEmulatorProvider, SeedIdentity, SendDeadlineExceededError, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, StaticDescriptorProvider, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, VtxoReservedError, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertHistoryPageFilter, assertIntentIdUnique, assertNoAssets, assertNoSelection, assertPageRequest, assertRecipientArkadeAddress, assertSendDeadline, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, captureSendDeadline, checkSaveVtxosForScript, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, collectContracts, collectIntents, collectPages, collectScriptVtxos, collectTransactionHistory, collectUtxos, collectVtxos, combineTapscriptSigs, compareHistoryCursors, contractFilterMatchesNothing, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, createdAtToIso, decodeArkContract, defaultBatchExpiryPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, iteratePages, legacyVtxoFacts, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, pageResult, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveBatchExpiryPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, selectionOf, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, submitViaEmulator, toXOnlySignerHex, tryResolveSendAmount, utxoEntries, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
-//# sourceMappingURL=chunk-GWJWXVUB.js.map
-//# sourceMappingURL=chunk-GWJWXVUB.js.map
+//# sourceMappingURL=chunk-AJWXVQYG.js.map
+//# sourceMappingURL=chunk-AJWXVQYG.js.map