@arkade-os/sdk 0.5.1 → 0.5.3

package/dist/{chunk-NKKJEA3Z.js → chunk-HAQAWBYG.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, RestIndexerProvider, BufferReader, BufferWriter, AssetRef } from './chunk-6MIGYYWB.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-3M22PJVB.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-QFB55EOZ.js';
+import { Packet, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, RestIndexerProvider, BufferReader, BufferWriter, AssetRef } from './chunk-6FL4N4S2.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-P7B4LQ3H.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, assertAllowedSighashTypes, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, DEFAULT_ARKADE_SERVER_URL, baseFetch, DEFAULT_NETWORK_NAME, sequenceToCanonicalTimelock, assertTimerMs, isEventSourceError, isEventSourceUnavailableError, normalizeVtxo, isPastExpiry, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, formatSighash, isArkError, ArkErrorName, Intent, rateGate, 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-OPX2HRWM.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,
@@ -3826,32 +3833,36 @@ function assertCheckpointsMatchInputs(checkpoints, inputs, unrollCandidates, con
   }
 }
 async function submitOffchainTx(provider, offchainTx, signer, hooks, options) {
-  const { arkTx: signedArkTx, userSignedCheckpoints } = await signer.signArkTx(
+  const oneShot = options?.oneShot !== false;
+  const { arkTx: signedArkTx, userSignedCheckpoints: batchSigned } = await signer.signArkTx(
     offchainTx.arkTx,
     offchainTx.checkpoints
   );
-  if (userSignedCheckpoints && userSignedCheckpoints.length !== offchainTx.checkpoints.length) {
+  if (batchSigned && batchSigned.length !== offchainTx.checkpoints.length) {
     throw new Error(
-      `signer returned ${userSignedCheckpoints.length} signed checkpoints, expected ${offchainTx.checkpoints.length}`
+      `signer returned ${batchSigned.length} signed checkpoints, expected ${offchainTx.checkpoints.length}`
     );
   }
+  const userSignedCheckpoints = (batchSigned ?? (oneShot ? await Promise.all(offchainTx.checkpoints.map((c) => signer.signCheckpoint(c.clone()))) : void 0))?.map((c) => withArkInputWitness(c, signedArkTx));
   await hooks?.beforeSubmit?.();
   const response = await provider.submitTx(
     base64.encode(signedArkTx.toPSBT()),
-    offchainTx.checkpoints.map((c) => base64.encode(c.toPSBT()))
+    (oneShot ? userSignedCheckpoints : offchainTx.checkpoints.map((c) => withArkInputWitness(c, signedArkTx))).map((c) => base64.encode(c.toPSBT()))
   );
   assertSubmittedArkTxid(response, signedArkTx, "submitTx");
   const { arkTxid, signedCheckpointTxs } = response;
   const matched = matchServerCheckpoints(signedCheckpointTxs, offchainTx.checkpoints, "submitTx");
-  matched.forEach(({ server }, index) => {
-    try {
-      assertAllowedSighashTypes(server);
-    } catch (error) {
-      throw new ServerResponseMismatchError(
-        `submitTx checkpoint ${index}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  });
+  if (!oneShot) {
+    matched.forEach(({ server }, index) => {
+      try {
+        assertAllowedSighashTypes(server);
+      } catch (error) {
+        throw new ServerResponseMismatchError(
+          `submitTx checkpoint ${index}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    });
+  }
   const verify = options?.verifyServerSignatures;
   if (verify) {
     if (response.finalArkTx === void 0) {
@@ -3878,26 +3889,62 @@ async function submitOffchainTx(provider, offchainTx, signer, hooks, options) {
       ({ server, local }, index) => assertServerSignedLeaf(server, local, 0, serverPubkeys, `submitTx checkpoint ${index}`)
     );
   }
+  const result = { arkTxid, finalArkTx: response.finalArkTx, signedCheckpointTxs };
   let finalCheckpoints;
   if (userSignedCheckpoints) {
     const userByTxid = new Map(
       userSignedCheckpoints.map((c, i) => [offchainTx.checkpoints[i].id, c])
     );
+    if (oneShot && matched.every(
+      ({ server, local }) => carriesTapscriptSigs(server, userByTxid.get(local.id))
+    )) {
+      await hooks?.afterFinalize?.();
+      return result;
+    }
     finalCheckpoints = matched.map(({ server, local }) => {
-      combineTapscriptSigs(userByTxid.get(local.id), server);
+      const userSigned = userByTxid.get(local.id);
+      combineTapscriptSigs(userSigned, server);
+      carryConditionWitness(userSigned, server);
       return base64.encode(server.toPSBT());
     });
   } else {
     finalCheckpoints = await Promise.all(
-      matched.map(async ({ server }) => {
+      matched.map(async ({ server, local }) => {
         const signed = await signer.signCheckpoint(server);
+        carryConditionWitness(local, signed);
         return base64.encode(signed.toPSBT());
       })
     );
   }
   await provider.finalizeTx(arkTxid, finalCheckpoints);
   await hooks?.afterFinalize?.();
-  return { arkTxid, signedCheckpointTxs };
+  return result;
+}
+function carryConditionWitness(ours, server) {
+  if (getArkPsbtFields(server, 0, ConditionWitness).length > 0) return;
+  const [witness] = getArkPsbtFields(ours, 0, ConditionWitness);
+  if (witness) setArkPsbtField(server, 0, ConditionWitness, witness);
+}
+function withArkInputWitness(checkpoint, signedArkTx) {
+  if (getArkPsbtFields(checkpoint, 0, ConditionWitness).length > 0) return checkpoint;
+  for (let i = 0; i < signedArkTx.inputsLength; i++) {
+    const { txid } = signedArkTx.getInput(i);
+    if (!txid || hex.encode(txid) !== checkpoint.id) continue;
+    const [witness] = getArkPsbtFields(signedArkTx, i, ConditionWitness);
+    if (!witness) return checkpoint;
+    const carried = checkpoint.clone();
+    setArkPsbtField(carried, 0, ConditionWitness, witness);
+    return carried;
+  }
+  return checkpoint;
+}
+function carriesTapscriptSigs(server, userSigned) {
+  const entries = (tx) => (tx.getInput(0).tapScriptSig ?? []).map(
+    ([{ pubKey, leafHash }, sig]) => hex.encode(pubKey) + hex.encode(leafHash) + hex.encode(sig)
+  );
+  const have = new Set(entries(server));
+  const want = entries(userSigned);
+  return want.length > 0 && want.every((entry) => have.has(entry));
 }
 async function signAndSubmitOffchainTx(params) {
   const offchainTx = buildOffchainTx(params.inputs, params.outputs, params.serverUnrollScript);
@@ -3906,7 +3953,8 @@ async function signAndSubmitOffchainTx(params) {
     signCheckpoint: (checkpoint) => params.identity.sign(checkpoint)
   };
   const { arkTxid } = await submitOffchainTx(params.provider, offchainTx, signer, void 0, {
-    verifyServerSignatures: params.verifyServerSignatures
+    verifyServerSignatures: params.verifyServerSignatures,
+    oneShot: params.oneShot
   });
   return arkTxid;
 }
@@ -4676,12 +4724,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 +4832,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 +4860,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 +4916,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 +5015,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 +5315,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 +5340,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 +5354,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 +6359,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 +6560,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 +6602,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 +6790,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 +7913,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
     );
@@ -10646,8 +10707,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);
@@ -12548,7 +12611,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,
@@ -12556,7 +12622,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;
@@ -12666,11 +12732,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();
@@ -12687,7 +12753,7 @@ function computeOffchainBalance(vtxos, caps) {
       continue;
     }
     if (isPendingRecovery(vtxo)) {
-      pendingRecovery += vtxo.value;
+      deprecatedSignerLocked += vtxo.value;
       continue;
     }
     if (canRecoverOnchain(vtxo, now)) {
@@ -12701,7 +12767,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)) {
@@ -12719,13 +12785,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)
   };
@@ -12750,15 +12816,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
   };
 }
 
@@ -13806,22 +13876,42 @@ var ReadonlyWallet = class _ReadonlyWallet {
     const utxos = [];
     const commitmentsToIgnore = /* @__PURE__ */ new Set();
     const tapscripts = await this.getBoardingTapscripts(this.watchedBoardingSigners());
-    const outspendCache = /* @__PURE__ */ new Map();
-    const outspendOf = async (txid, index) => {
-      if (this.onchainProvider.getTxOutspend) {
-        return this.onchainProvider.getTxOutspend(txid, index);
-      }
-      let statuses = outspendCache.get(txid);
-      if (!statuses) {
-        statuses = await this.onchainProvider.getTxOutspends(txid);
-        outspendCache.set(txid, statuses);
-      }
-      return statuses[index];
+    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]);
     };
-    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 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 ?? []) {
@@ -13831,37 +13921,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) {
-            const spentStatus = await outspendOf(tx.txid, 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) {
@@ -13953,9 +14057,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]);
@@ -13978,14 +14085,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([
@@ -14010,6 +14123,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;
@@ -14062,8 +14176,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)) {
@@ -14209,21 +14322,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,
@@ -14243,7 +14360,7 @@ 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,
@@ -14337,7 +14454,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
   }
 };
 var Wallet2 = class extends ReadonlyWallet {
-  constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, settlementConfig, walletContractTimelocks, receiveRotator, descriptorProvider, keyring, lookAheadWindow, batchExpiryPolicy) {
+  constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, serverUnrollScript, forfeitOutputScript, forfeitPubkey, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, settlementConfig, walletContractTimelocks, receiveRotator, descriptorProvider, keyring, lookAheadWindow, batchExpiryPolicy, oneShotSubmit = true) {
     super(
       identity,
       network,
@@ -14357,6 +14474,7 @@ var Wallet2 = class extends ReadonlyWallet {
     this.forfeitOutputScript = forfeitOutputScript;
     this.forfeitPubkey = forfeitPubkey;
     this.batchExpiryPolicy = batchExpiryPolicy;
+    this.oneShotSubmit = oneShotSubmit;
     this.identity = identity;
     this.settlementConfig = settlementConfig !== void 0 ? settlementConfig : { ...DEFAULT_SETTLEMENT_CONFIG };
     this._delegateManager = delegateProvider ? new DelegateManagerImpl(delegateProvider, arkProvider, identity) : void 0;
@@ -14378,6 +14496,7 @@ var Wallet2 = class extends ReadonlyWallet {
   forfeitOutputScript;
   forfeitPubkey;
   batchExpiryPolicy;
+  oneShotSubmit;
   static MIN_FEE_RATE = 1;
   // sats/vbyte
   identity;
@@ -14846,13 +14965,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
@@ -15035,13 +15154,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")
@@ -15221,7 +15342,8 @@ var Wallet2 = class extends ReadonlyWallet {
       {
         advertisedVtxoTreeExpiry: setup.info.vtxoTreeExpiry,
         ...config.minBatchExpirySeconds !== void 0 ? { minSeconds: config.minBatchExpirySeconds } : {}
-      }
+      },
+      config.oneShotSubmit
     );
     wallet.lazyInitialization = config.lazyInitialization ?? false;
     wallet._serverInfoSource = setup.serverInfoSource;
@@ -15589,25 +15711,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);
@@ -16254,7 +16384,8 @@ var Wallet2 = class extends ReadonlyWallet {
               }
             ],
             outputs: [{ script: myPkScript, amount: BigInt(vtxo.value) }],
-            serverUnrollScript
+            serverUnrollScript,
+            oneShot: this.oneShotSubmit
           });
           swept += vtxo.value;
         } catch (error) {
@@ -17096,7 +17227,8 @@ var Wallet2 = class extends ReadonlyWallet {
             deprecatedServerPubkeys: [...this._deprecatedSigners.keys()].map(
               (h) => hex.decode(h)
             )
-          }
+          },
+          oneShot: this.oneShotSubmit
         }
       );
     } finally {
@@ -17744,6 +17876,7 @@ var MessageBus = class {
         lazyInitialization: config.lazyInitialization,
         watcherConfig: config.watcherConfig,
         lookAheadWindow: config.lookAheadWindow,
+        oneShotSubmit: config.oneShotSubmit,
         minBatchExpirySeconds: config.minBatchExpirySeconds
       });
       return { wallet, arkProvider, readonlyWallet: wallet };
@@ -18536,6 +18669,7 @@ var WalletMessageHandler = class {
   indexerProvider;
   walletRepository;
   incomingFundsSubscription;
+  incomingFundsRegistrations = /* @__PURE__ */ new WeakMap();
   contractEventsSubscription;
   onNextTick = [];
   channel;
@@ -18547,6 +18681,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. */
@@ -18571,6 +18710,7 @@ var WalletMessageHandler = class {
   }
   async stop() {
     this.requestEpoch++;
+    this.initEpoch++;
     this.incomingFundsEpoch++;
     this.contractEventsEpoch++;
     this.boardingEpoch++;
@@ -18611,6 +18751,8 @@ var WalletMessageHandler = class {
   }
   epochOf(scope) {
     switch (scope) {
+      case "init":
+        return this.initEpoch;
       case "incomingFunds":
         return this.incomingFundsEpoch;
       case "contractEvents":
@@ -19367,18 +19509,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(
@@ -19389,11 +19535,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") {
@@ -19462,13 +19631,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
@@ -19497,24 +19659,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.
@@ -19529,11 +19697,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;
@@ -19631,6 +19805,7 @@ var WalletMessageHandler = class {
     const wallet = this.wallet ?? this.readonlyWallet;
     if (!wallet) return;
     this.requestEpoch++;
+    this.initEpoch++;
     this.incomingFundsEpoch++;
     this.contractEventsEpoch++;
     this.boardingEpoch++;
@@ -19682,7 +19857,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) => {
@@ -19697,19 +19874,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);
@@ -19718,13 +19894,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 };
   }
   /**
@@ -20427,7 +20616,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}`);
     }
@@ -20924,9 +21118,10 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
   }
 };
 var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadonlyWallet {
-  constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag, hasDelegate) {
+  constructor(serviceWorker, identity, walletRepository, contractRepository, messageTag, hasDelegate, oneShotSubmit) {
     super(serviceWorker, identity, walletRepository, contractRepository, messageTag);
     this.serviceWorker = serviceWorker;
+    this.oneShotSubmit = oneShotSubmit;
     this.identity = identity;
     this.walletRepository = walletRepository;
     this.contractRepository = contractRepository;
@@ -20937,6 +21132,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
     this.hasDelegate = hasDelegate;
   }
   serviceWorker;
+  oneShotSubmit;
   walletRepository;
   contractRepository;
   identity;
@@ -20973,7 +21169,8 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
       walletRepository,
       contractRepository,
       messageTag,
-      !!options.delegateUrl
+      !!options.delegateUrl,
+      options.oneShotSubmit
     );
     wallet._concurrentSpending = options.concurrentSpending === true;
     return _ServiceWorkerWallet.bootstrap(wallet, options, serializedWallet, {
@@ -20984,6 +21181,7 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
       lazyInitialization: options.lazyInitialization,
       watcherConfig: options.watcherConfig,
       lookAheadWindow: options.lookAheadWindow,
+      oneShotSubmit: options.oneShotSubmit,
       minBatchExpirySeconds: options.minBatchExpirySeconds
     });
   }
@@ -22621,8 +22819,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));
@@ -23076,40 +23278,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,
@@ -23267,15 +23482,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`
@@ -23294,6 +23512,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({
@@ -23331,46 +23553,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) => {
@@ -24578,6 +24811,7 @@ var Arkade = class _Arkade {
   userKey;
   /** The contract manager, when contract persistence is wired up (passed in or owned). */
   contractManager;
+  oneShotSubmit;
   /** Whether {@link connect} built {@link contractManager}, so {@link dispose} must stop it. */
   ownsContractManager;
   /** {@link ArkadeContract.on} handles by contract script (hex). */
@@ -24597,6 +24831,7 @@ var Arkade = class _Arkade {
     this.identity = fields.identity;
     this.userKey = fields.userKey;
     this.contractManager = fields.contractManager;
+    this.oneShotSubmit = fields.oneShotSubmit;
     this.ownsContractManager = fields.ownsContractManager ?? false;
   }
   /**
@@ -24673,7 +24908,8 @@ var Arkade = class _Arkade {
       identity: opts.identity,
       userKey,
       contractManager,
-      ownsContractManager
+      ownsContractManager,
+      oneShotSubmit: opts.oneShotSubmit
     });
   }
   /**
@@ -24770,6 +25006,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) {
@@ -24831,7 +25074,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;
   }
@@ -24949,27 +25208,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);
@@ -25006,23 +25300,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) {
@@ -25035,23 +25345,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"
@@ -25059,56 +25369,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");
       }
@@ -25116,7 +25446,8 @@ var ArkadeTransactionBuilder = class {
         inputIndexes: userInputs
       });
     }
-    if (!client.identity) {
+    const identity = client.identity;
+    if (!identity) {
       throw new Error("a signing identity is required for non-covenant spends");
     }
     const ark = client.arkProvider;
@@ -25125,21 +25456,19 @@ var ArkadeTransactionBuilder = class {
         "broadcasting requires an `arkade` provider with `submitTx`/`finalizeTx` on the Arkade client"
       );
     }
-    const signedArk = await this.signArk(arkTx, userInputs);
-    const res = await ark.submitTx(
-      base64.encode(signedArk.toPSBT()),
-      checkpoints.map((c) => base64.encode(c.toPSBT()))
-    );
-    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())
-      )
+    const res = await submitOffchainTx(
+      ark,
+      { arkTx, checkpoints },
+      {
+        signArkTx: async (tx) => ({ arkTx: await this.signArk(tx, userInputs) }),
+        signCheckpoint: (checkpoint) => identity.sign(checkpoint, [0])
+      },
+      void 0,
+      { oneShot: client.oneShotSubmit }
     );
-    await ark.finalizeTx(res.arkTxid, finalCps);
     return {
       txid: res.arkTxid,
+      // Required by ArkadeBroadcaster; RestArkProvider.submitTx rejects a response without it.
       signedArkTx: res.finalArkTx,
       signedCheckpointTxs: res.signedCheckpointTxs
     };
@@ -25147,31 +25476,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);
@@ -25185,10 +25527,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) {
@@ -25688,5 +26035,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-NKKJEA3Z.js.map
-//# sourceMappingURL=chunk-NKKJEA3Z.js.map
+//# sourceMappingURL=chunk-HAQAWBYG.js.map
+//# sourceMappingURL=chunk-HAQAWBYG.js.map