@black-market/sdk 0.9.1 → 0.11.0

package/src/lifecycle/planner.ts

@@ -10,7 +10,7 @@ import { prepareLaunchSimulation, simulateLaunchTransactions, type NextTransacti
 import { LifecyclePlanningError, type BuildNextTransactionOptions, type CanonicalLaunchProgress, type LifecycleBlock, type LifecycleConstructionProfile, type LifecycleFundingPrerequisite, type LifecyclePoolBoundHookDeployment, type LifecycleProfile, type LifecycleRpcClient, type LifecycleSimulation, type LifecycleTransaction, type PlannedLaunch, type PlanLaunchOptions, type PrepareAndPlanLifecycleLaunchOptions, type SimulateLaunchPlanOptions } from "./types.js";
 import { deriveKnownPoolBoundHookDeployment, protectOrderedBuyMinimums, validateBuySlippageBps } from "./calibration.js";
 import { getKnownLifecycleDeployment, getKnownLifecycleProfile } from "./presets.js";
-import { buildLaunchTransactions } from "./transactions.js";
+import { buildLaunchTransactions, packPreparationBatches } from "./transactions.js";
 import { assertLifecycleMarketAllocation, assertLifecycleSupplyAllocation } from "./allocations.js";
 
 type ValidatedPlanShape = {
@@ -132,11 +132,9 @@ async function readPlanMetadata(client: LifecycleRpcClient, plan: LaunchPlanV1,
   return { profiles, hookDeployments, reasons: live.filter((profile) => !profile.admitted).map((profile) => profile.reason ?? "Unlisted lifecycle profile is unavailable") };
 }
 
-function orderedTransactions(plan: LaunchPlanV1, mode: "atomic" | "staged", progress: CanonicalLaunchProgress, approvals: readonly LifecycleTransaction[], batchSize: number): LifecycleTransaction[] {
+function orderedTransactions(plan: LaunchPlanV1, mode: "atomic" | "staged", progress: CanonicalLaunchProgress, approvals: readonly LifecycleTransaction[], batches: readonly number[]): LifecycleTransaction[] {
   if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled) return [];
   const prepared = progress.canonical.preparedMarkets;
-  const batches: number[] = prepared > 0 ? [prepared] : [];
-  for (let first = prepared; first < plan.markets.length; first += batchSize) batches.push(Math.min(batchSize, plan.markets.length - first));
   const commands = buildLaunchTransactions({ plan, mode, preparationBatches: mode === "staged" ? batches : undefined }).filter((transaction) =>
     (transaction.kind !== "begin" && transaction.kind !== "atomic" || progress.canonical.phase === LifecyclePhase.None) &&
     (transaction.kind !== "prepare" || (transaction.marketStart ?? 0) >= prepared));
@@ -147,7 +145,8 @@ function orderedTransactions(plan: LaunchPlanV1, mode: "atomic" | "staged", prog
 function attachEstimates(transactions: readonly LifecycleTransaction[], simulation: LifecycleSimulation): LifecycleTransaction[] {
   return transactions.map((transaction) => {
     const estimate = simulation.steps.find((step) => step.transactionId === transaction.id)?.estimate;
-    return { ...transaction, calldataBytes: (transaction.data.length - 2) / 2, gas: estimate?.gasLimit, gasPrice: estimate?.gasPrice, estimate, admission: { admitted: simulation.admitted, confidence: simulation.confidence, executionProof: simulation.executionProof, protocolFit: simulation.protocolFit, transportPreflight: simulation.transportPreflight, blockNumber: simulation.blockNumber, blockHash: simulation.blockHash, account: simulation.account, chainId: simulation.chainId, reason: simulation.reason, limits: simulation.limits } };
+    return { ...transaction, calldataBytes: (transaction.data.length - 2) / 2, gas: estimate?.gasLimit, gasPrice: estimate?.gasPrice, estimate,
+      admission: estimate === undefined ? undefined : { admitted: simulation.admitted, confidence: simulation.confidence, executionProof: simulation.executionProof, protocolFit: simulation.protocolFit, transportPreflight: simulation.transportPreflight, blockNumber: simulation.blockNumber, blockHash: simulation.blockHash, account: simulation.account, chainId: simulation.chainId, reason: simulation.reason, limits: simulation.limits } };
   });
 }
 type ReviewedNextTransaction = Pick<LifecycleTransaction, "id" | "kind" | "chainId" | "from" | "to" | "data" | "value"> & NextTransactionEnvelope;
@@ -364,8 +363,8 @@ async function planLaunchWithReads(options: PlanLaunchOptions, client: Lifecycle
     }),
   ]));
   assertPlanningActive(options.signal);
-  const placeholder: LifecycleSimulation = { backend: "unavailable", confidence: "provisional", admitted: false, executionProof: "unavailable", protocolFit: "unknown", transportPreflight: "not-requested", blockNumber: block.number, blockHash: block.hash, account, chainId: plan.chainId, limits, steps: [] };
-  let planned: PlannedLaunch = { ...identity, tokenFactory, tokenFactoryCodeHash, chainId: plan.chainId, transactions: [], totalCalldataBytes: 0, prerequisites: [], profiles: [], hookDeployments: [], progress, simulation: placeholder, preparationBatchSize: plan.markets.length, limits: options.limits,
+  const placeholder: LifecycleSimulation = { backend: "unavailable", confidence: "provisional", admitted: false, executionProof: "unavailable", protocolFit: "unknown", transportPreflight: "not-requested", blockNumber: block.number, blockHash: block.hash, account, chainId: plan.chainId, limits, steps: [], deferredTransactionIds: [] };
+  let planned: PlannedLaunch = { ...identity, tokenFactory, tokenFactoryCodeHash, chainId: plan.chainId, transactions: [], totalCalldataBytes: 0, prerequisites: [], profiles: [], hookDeployments: [], progress, simulation: placeholder, limits: options.limits,
     allowTopologyGaps: options.allowTopologyGaps === true, allowMissingPermanentTail: options.allowMissingPermanentTail === true };
   const receiptsPending = progress.receipts.some((receipt) => receipt.status === "pending" || receipt.status === "unconfirmed");
   if (!progress.confirmationSafe || receiptsPending) {
@@ -393,48 +392,58 @@ async function planLaunchWithReads(options: PlanLaunchOptions, client: Lifecycle
   ]));
   assertFinalPlan(planned, options.signal);
   planned = { ...planned, prerequisites: funding.prerequisites, profiles: metadata.profiles, hookDeployments: metadata.hookDeployments };
-  let preparationBatchSize = plan.markets.length;
-  let transactions = orderedTransactions(plan, mode, progress, funding.approvals, preparationBatchSize);
+  const prepared = progress.canonical.preparedMarkets;
+  const computeCap = limits.transactionGasCeiling !== undefined && limits.transactionGasCeiling < limits.executionGasCeiling ? limits.transactionGasCeiling : limits.executionGasCeiling;
+  let batches: number[] = [];
+  if (mode === "staged") batches = reviewed === undefined ? packPreparationBatches(plan, prepared, computeCap)
+    : [...(prepared > 0 ? [prepared] : []), ...(prepared < plan.markets.length ? [plan.markets.length - prepared] : [])];
+  if (reviewed !== undefined && reviewed.kind === "prepare") {
+    // Canonical progress fixes the start; the exact held calldata fixes its span.
+    // Never rediscover a batch or enlarge a reviewed transaction.
+    const match = /^prepare:(\d+):(\d+)$/.exec(reviewed.id);
+    const start = Number(match?.[1]), count = Number(match?.[2]);
+    if (start !== prepared || !Number.isSafeInteger(count) || count <= 0 || start + count > plan.markets.length) throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed preparation differs from canonical unfinished progress");
+    batches = [...(prepared > 0 ? [prepared] : []), count, ...(start + count < plan.markets.length ? [plan.markets.length - start - count] : [])];
+  }
+  let transactions = orderedTransactions(plan, mode, progress, funding.approvals, batches);
+  if (reviewed !== undefined) {
+    if (!matchesReviewedNextTransaction(transactions[0], reviewed)) throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current canonical unfinished next step");
+    transactions = transactions.slice(0, 1);
+  }
   if (metadata.reasons.length > 0) {
     await assertLifecycleBlock(client, block, plan.chainId);
     return { ...planned, simulation: { ...placeholder, confidence: "stateful", reason: metadata.reasons.join("; "), failureCategory: "semantic" }, transactions, totalCalldataBytes: transactions.reduce((total, transaction) => total + (transaction.data.length - 2) / 2, 0) };
   }
-  const preparedSimulation = prepareLaunchSimulation({ client, planned, limits: options.limits, fork: options.fork, signal: options.signal }, block);
+  const preparedSimulation = prepareLaunchSimulation({ client, planned, limits: options.limits, fork: options.fork, signal: options.signal }, block, true, reviewed);
   try {
-    const execute = diagnostic ? preparedSimulation.measure : (candidate: readonly LifecycleTransaction[]) => {
-      if (reviewed === undefined) return preparedSimulation(candidate);
-      if (!matchesReviewedNextTransaction(candidate[0], reviewed)) {
-        // A fresh prepare batch may still require SDK-owned capacity discovery.
-        // Never use held fees for a different step or caller-selected calldata.
-        if (candidate[0]?.kind === "prepare" && reviewed.kind === "prepare") return preparedSimulation(candidate);
-        throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current canonical unfinished next step");
-      }
-      return preparedSimulation(candidate, reviewed);
-    };
+    const execute = diagnostic ? preparedSimulation.measure : (candidate: readonly LifecycleTransaction[]) => preparedSimulation(candidate, reviewed);
     let simulation = await execute(transactions);
     assertFinalPlan(planned, options.signal);
     if (mode === "staged") {
-      // Only explicit gas/compute evidence can partition empty preparations.
-      // Byte caps cannot shrink: each prepare still carries the entire plan.
-      while (!simulation.admitted && simulation.failureCategory === "capacity" &&
-        (simulation.capacityConstraint === "compute" || simulation.capacityConstraint === "gas-envelope") &&
-        !(reviewed !== undefined && simulation.capacityConstraint === "gas-envelope" && simulation.failedTransactionId === transactions[0]?.id && matchesReviewedNextTransaction(transactions[0], reviewed)) &&
-        simulation.failedTransactionId?.startsWith("prepare:") && preparationBatchSize > 1) {
-        const failedMarketCount = transactions.find((transaction) => transaction.id === simulation.failedTransactionId)?.marketCount ?? 0;
-        if (failedMarketCount <= 1) break;
-        preparationBatchSize = Math.ceil(failedMarketCount / 2);
-        transactions = orderedTransactions(plan, mode, progress, funding.approvals, preparationBatchSize);
+      // Only a measurement that consumed almost its entire legal envelope
+      // invalidates packing estimates, including gas hidden by CREATE wrappers.
+      while (reviewed === undefined && !simulation.admitted && simulation.failedTransactionId?.startsWith("prepare:")) {
+        const failedIndex = transactions.findIndex((transaction) => transaction.id === simulation.failedTransactionId);
+        const failedTransaction = transactions[failedIndex];
+        const step = simulation.steps.find((candidate) => candidate.transactionId === simulation.failedTransactionId);
+        const count = failedTransaction?.marketCount ?? 0;
+        if (count <= 1 || step?.estimate !== undefined || step?.gasUsed === undefined || step.gasLimit === undefined || step.gasUsed * 100n < step.gasLimit * 95n) break;
+        let first = 0;
+        const batchIndex = batches.findIndex((batch) => { const matches = first === failedTransaction?.marketStart; first += batch; return matches; });
+        const left = Math.ceil(count / 2);
+        batches.splice(batchIndex, 1, left, count - left);
+        transactions = orderedTransactions(plan, mode, progress, funding.approvals, batches);
         simulation = await execute(transactions);
         assertFinalPlan(planned, options.signal);
       }
       if (!simulation.admitted && simulation.failedTransactionId === "activate") simulation = { ...simulation, reason: `${simulation.reason ?? "Final activation failed"}; final mint/lock/all-buys/public-opening is indivisible and will not be partitioned` };
-    } else if (!diagnostic && !simulation.admitted) {
+    } else if (!diagnostic && !simulation.admitted && !(simulation.capacityConstraint === "compute" && simulation.confidence === "provisional")) {
       simulation = { ...simulation, reason: `${simulation.reason ?? "Exact atomic plan is not admitted"}; choose staged explicitly only if empty preparation can be partitioned and complete activation fits` };
     }
     if (reviewed !== undefined && !matchesReviewedNextTransaction(transactions[0], reviewed)) {
       throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current canonical unfinished next step");
     }
-    return { ...planned, simulation, preparationBatchSize, transactions: attachEstimates(transactions, simulation), totalCalldataBytes: transactions.reduce((total, transaction) => total + (transaction.data.length - 2) / 2, 0) };
+    return { ...planned, simulation, transactions: attachEstimates(transactions, simulation), totalCalldataBytes: transactions.reduce((total, transaction) => total + (transaction.data.length - 2) / 2, 0) };
   } finally { preparedSimulation.close(); }
 }
 

package/src/lifecycle/presets.ts

@@ -1,13 +1,13 @@
 import type { Address, Hex } from "viem";
 import type {
-  AdapterRegistrationV1, LaunchEnvelopeV2, ProfileRegistrationV1, ProfileTopologyV1,
+  AdapterRegistrationV1, LaunchEnvelopeV2, LaunchPlanV1, ProfileRegistrationV1, ProfileTopologyV1,
 } from "./schema.js";
 import type { LifecycleProfile } from "./types.js";
 import { fixedFeePoolHookV1CreationCode } from "./deployments/fixed-fee-pool-hook-v1-20261008.js";
 import { dynamicFeePoolHookV1CreationCode } from "./deployments/dynamic-fee-pool-hook-v1-20261011.js";
-import { hmmFixedEnvelope, hmmFixedAdapter, hmmFixedRegistration, hmmFixedCreationCode } from "./deployments/hmm-fixed-pool-hook-v1-20261011.js";
-import { hmmDynamicEnvelope, hmmDynamicAdapter, hmmDynamicRegistration, hmmDynamicCreationCode } from "./deployments/hmm-dynamic-pool-hook-v1-20261011.js";
-import { HMM_FIXED_PROFILE_ID, HMM_DYNAMIC_PROFILE_ID } from "./hmm.js";
+import { hmmFixedEnvelope, hmmFixedAdapter, hmmFixedRegistration, hmmFixedCreationCode } from "./deployments/hmm-fixed-pool-hook-v2-20261017.js";
+import { hmmDynamicEnvelope, hmmDynamicAdapter, hmmDynamicRegistration, hmmDynamicCreationCode } from "./deployments/hmm-dynamic-pool-hook-v2-20261017.js";
+import { HMM_FIXED_PROFILE_ID, HMM_DYNAMIC_PROFILE_ID, isHmmProfile } from "./hmm.js";
 
 export enum KnownLifecycleProfile {
   Abyss0 = "abyss-0",
@@ -23,8 +23,8 @@ export enum KnownLifecycleProfile {
 export enum KnownLifecycleHook {
   FixedFeePoolV1 = "fixed-fee-pool-v1",
   DynamicFeePoolV1 = "dynamic-fee-pool-v1",
-  HmmFixedPoolV1 = "hmm-fixed-pool-v1",
-  HmmDynamicPoolV1 = "hmm-dynamic-pool-v1",
+  HmmFixedPoolV2 = "hmm-fixed-pool-v2",
+  HmmDynamicPoolV2 = "hmm-dynamic-pool-v2",
 }
 
 Object.freeze(KnownLifecycleProfile);
@@ -280,6 +280,20 @@ const dynamicFeePoolPreset: LifecycleProfilePreset = Object.freeze({
   }),
 });
 
+// HMMLiquidityHookV2.sol:98-119 requires ~3.06M available before manager calls,
+// including opening and swaps. Robinhood fork measurements: activation minima
+// 9.60M/15.40M/21.11M for 1/2/3 markets despite used gas 5.85M/11.13M/16.54M.
+// Apply this forwarding target once per activate/atomic envelope, not per callback.
+export const HMM_V2_FORWARDING_BASE_GAS = 4_250_000n;
+export const HMM_V2_FORWARDING_EXTRA_MARKET_GAS = 500_000n;
+export const HMM_V2_PREPARE_GAS = 14_500_000n;
+
+export function hmmV2ForwardingReserve(plan: LaunchPlanV1): bigint {
+  let count = 0;
+  for (const market of plan.markets) if (isHmmProfile(market.profileId)) count += 1;
+  return count === 0 ? 0n : HMM_V2_FORWARDING_BASE_GAS + HMM_V2_FORWARDING_EXTRA_MARKET_GAS * BigInt(count - 1);
+}
+
 function hmmPreset(key: KnownLifecycleProfile, id: Hex, envelope: LaunchEnvelopeV2,
   adapter: AdapterRegistrationV1, registration: ProfileRegistrationV1, creationCode: Hex): LifecycleProfilePreset {
   return Object.freeze({

package/src/lifecycle/rpc.ts

@@ -433,6 +433,7 @@ async function resolveLifecycleLimitsFresh(context: LifecycleLimitContext, sourc
     throw new LifecyclePlanningError("LIMIT_CONTEXT_MISMATCH", "Supplied execution policy provenance differs from the canonical chain/account/core/block context");
   }
   const protocol = context.chainId === 4663n ? "nitro" : "evm";
+  const maxSimulationGas = configuration.maxSimulationGas ?? (context.chainId === 4663n ? 50_000_000n : undefined);
   let arbOSVersion: bigint | undefined; let maxTxComputeGas: bigint | undefined; let maxBlockComputeGas: bigint | undefined;
   if (protocol === "nitro") {
     try {
@@ -464,14 +465,14 @@ async function resolveLifecycleLimitsFresh(context: LifecycleLimitContext, sourc
     ...(configuration.rpcGasLimit === undefined ? ["RPC transaction gas-envelope cap is unknown"] : []),
     ...(configuration.accountGasLimit === undefined ? ["Current account/wallet transaction gas-envelope cap is unknown"] : []),
     ...(configuration.maxCalldataBytes === undefined ? ["Applicable chain/account/RPC calldata byte cap is unknown"] : []),
-    ...(configuration.maxSimulationGas === undefined ? ["RPC aggregate simulation gas cap is unknown"] : []),
+    ...(maxSimulationGas === undefined ? ["RPC aggregate simulation gas cap is unknown"] : []),
   ];
   assertCurrent();
   return {
     configuration, assertCurrent,
     limits: Object.freeze({
       protocol, executionGasCeiling, transactionGasCeiling, arbOSVersion, maxTxComputeGas, maxBlockComputeGas, headroomBps,
-      maxCalldataBytes: configuration.maxCalldataBytes, maxSimulationGas: configuration.maxSimulationGas,
+      maxCalldataBytes: configuration.maxCalldataBytes, maxSimulationGas,
       blockGasLimit: context.block.gasLimit, chainGasLimit: configuration.chainGasLimit,
       rpcGasLimit: configuration.rpcGasLimit, accountGasLimit: configuration.accountGasLimit,
       unknownExecutionConstraints: Object.freeze(unknownExecutionConstraints),

package/src/lifecycle/simulation.ts

@@ -4,6 +4,8 @@ import { hashLaunchIdentity, hashLaunchPlan, LifecyclePhase, type LaunchPlanV1,
 import { assertLifecycleBlock, assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleRpc, lifecycleSourceClient, lifecycleStage, nitroArbSys, nitroArbSysAbi, nitroGasInfo, nitroGasInfoAbi, readLifecycleBlock, readLifecycleChainId, readNitroPosterGas, resolveLifecycleLimits, rpcHex, rpcObject, rpcQuantity, type LifecycleLimitObservation } from "./rpc.js";
 import { LifecyclePlanningError, type ControlledLifecycleFork, type LifecycleBlock, type LifecycleLimitContext, type LifecyclePostcondition, type LifecycleRpcClient, type LifecycleSimulation, type LifecycleSimulationStep, type LifecycleTransaction, type PlannedLaunch, type ResolvedLifecycleLimits, type SimulateLaunchPlanOptions } from "./types.js";
 import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, isPoolBoundV4ConfigVersion } from "./markets.js";
+import { hmmV2ForwardingReserve } from "./presets.js";
+import { transactionGasEstimate } from "./transactions.js";
 
 function committedPositionCount(plan: LaunchPlanV1): number {
   let count = 0;
@@ -111,8 +113,6 @@ async function proveNitroBackend(client: LifecycleRpcClient, planned: PlannedLau
 }
 
 async function simulateRpcPass(client: LifecycleRpcClient, planned: PlannedLaunch, block: LifecycleBlock, transactions: readonly LifecycleTransaction[], gasLimits: readonly bigint[], limits: ResolvedLifecycleLimits, gasPrice: bigint, validation: boolean): Promise<LifecycleSimulationStep[]> {
-  const totalRequestedGas = gasLimits.reduce((total, gas) => total + gas, 0n);
-  if (limits.maxSimulationGas !== undefined && totalRequestedGas > limits.maxSimulationGas) throw new LifecyclePlanningError("SIMULATION_RPC_CAP", "Sequential request exceeds the current RPC aggregate simulation gas cap; use an isolated controlled fork");
   // Natural child-block fees must govern fee-bearing admission; overriding
   // baseFeePerGas with the parent's would fabricate a lower envelope and admit
   // calls that the actual chain would reject. eth_simulateV1 derives the child
@@ -315,7 +315,7 @@ function observedFields<T extends object>(value: T): () => boolean {
 
 /** Internal continuation owned by one SDK read invocation. Only its positive
  * capability proof is reused; every candidate executes its entire economic sequence. */
-export function prepareLaunchSimulation(options: SimulateLaunchPlanOptions, block: LifecycleBlock, hasTransactions = true): PreparedLaunchSimulation {
+export function prepareLaunchSimulation(options: SimulateLaunchPlanOptions, block: LifecycleBlock, hasTransactions = true, reviewedEnvelope?: NextTransactionEnvelope): PreparedLaunchSimulation {
   const { client, planned, fork } = options;
   const signal = options.signal;
   if (signal?.aborted) throw Object.assign(new Error("Lifecycle simulation cancelled"), { name: "AbortError" });
@@ -353,7 +353,7 @@ export function prepareLaunchSimulation(options: SimulateLaunchPlanOptions, bloc
       resolveLifecycleLimits(context, policy),
       readLifecycleChainId(client),
       lifecyclePinnedRpc(client, "eth_getCode", [context.account, toHex(context.block.number)], context.block),
-      hasTransactions ? lifecycleRpc(client, "eth_gasPrice") : undefined,
+      hasTransactions && reviewedEnvelope === undefined ? lifecycleRpc(client, "eth_gasPrice") : undefined,
     ]));
   })().then((observations) => ({ observations }), (failure: unknown) => ({ failure }));
   // Refused inputs may discard this read-only preparation before it settles.
@@ -439,7 +439,7 @@ export async function simulateLaunchTransactions(options: SimulateLaunchPlanOpti
   // Standalone calls always produce fresh context, including live chain and fees.
   if (options.fork !== undefined && lifecycleSourceClient(options.fork.client) === lifecycleSourceClient(options.client)) throw new LifecyclePlanningError("UNSAFE_FORK", "Source RPC must never receive controlled simulation transactions/snapshots/resets");
   const block = pinnedBlock ?? await readLifecycleBlock(options.client);
-  const prepared = prepareLaunchSimulation(options, block, transactions.length !== 0);
+  const prepared = prepareLaunchSimulation(options, block, transactions.length !== 0, nextEnvelope);
   try { return await prepared(transactions, nextEnvelope); }
   finally { prepared.close(); }
 }
@@ -458,7 +458,7 @@ async function simulateLaunchTransactionsWithContext(
   const sourceClient = lifecycleSourceClient(client);
   const { block } = context;
   const [{ limits, configuration }, chainId, accountCodeValue, gasPriceValue] = observations;
-  const base = { confidence: "stateful" as const, executionProof: "failed" as const, protocolFit: "unknown" as const, transportPreflight: "not-requested" as const, blockNumber: block.number, blockHash: block.hash, account: planned.account, chainId: planned.chainId, limits };
+  const base = { confidence: "stateful" as const, executionProof: "failed" as const, protocolFit: "unknown" as const, transportPreflight: "not-requested" as const, blockNumber: block.number, blockHash: block.hash, account: planned.account, chainId: planned.chainId, limits, deferredTransactionIds: [] as string[] };
   if (chainId !== planned.chainId) throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain changed before sequential simulation");
   const accountCode = rpcHex(accountCodeValue, "account code");
   if (accountCode !== "0x") {
@@ -473,36 +473,48 @@ async function simulateLaunchTransactionsWithContext(
     }
   }
   if (transactions.length === 0) { await assertLifecycleBlock(client, block, planned.chainId); return { ...base, executionProof: "proved", protocolFit: "proved", backend: "unavailable", admitted: true, steps: [] }; }
-  const recommendedGasPrice = rpcQuantity(gasPriceValue, "gas price");
-  if (recommendedGasPrice >= 1n << 256n) throw new LifecyclePlanningError("INVALID_RPC_RESPONSE", "Recommended gas price must be a uint256 quantity");
-  // Initial construction reserves twice the pinned base fee if the quote lags.
-  // Reviewed fees are not new recommendations: native replay must accept them
-  // under natural child fees, with no base-fee override or silent fee increase.
+  if (nextEnvelope !== undefined && (transactions.length !== 1 || typeof nextEnvelope.gas !== "bigint" || nextEnvelope.gas <= 0n || nextEnvelope.gas >= 1n << 64n ||
+    typeof nextEnvelope.gasPrice !== "bigint" || nextEnvelope.gasPrice < 0n || nextEnvelope.gasPrice >= 1n << 256n)) {
+    throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Reviewed replay requires one immediate transaction with exact uint64 gas and uint256 price");
+  }
+  const allTransactions = transactions;
+  if (limits.maxSimulationGas !== undefined && nextEnvelope === undefined) {
+    let estimatedGas = 0n, count = 0;
+    for (const transaction of transactions) {
+      estimatedGas += transactionGasEstimate(planned.plan, transaction);
+      if (estimatedGas > limits.maxSimulationGas) break;
+      count += 1;
+    }
+    transactions = transactions.slice(0, count);
+    base.deferredTransactionIds = allTransactions.slice(count).map((transaction) => transaction.id);
+    if (count === 0) {
+      const computeCap = limits.transactionGasCeiling !== undefined && limits.transactionGasCeiling < limits.executionGasCeiling ? limits.transactionGasCeiling : limits.executionGasCeiling;
+      const exceedsCompute = estimatedGas > computeCap;
+      const gasInMillions = (gas: bigint) => {
+        const tenths = (gas + 50_000n) / 100_000n;
+        return `${tenths / 10n}.${tenths % 10n}`;
+      };
+      const atomic = allTransactions[0]!.kind === "atomic";
+      const reason = exceedsCompute
+        ? `${atomic ? "Atomic launch" : "Immediate transaction"} needs about ${gasInMillions(estimatedGas)}M gas, above the ${gasInMillions(computeCap)}M per-transaction limit${atomic ? "; use staged" : ""}`
+        : "The immediate transaction estimate exceeds the RPC aggregate simulation gas cap; no prefix can be proved";
+      await assertLifecycleBlock(client, block, planned.chainId);
+      return { ...base, confidence: "provisional", executionProof: "unavailable", backend: "unavailable", admitted: false, steps: [], failureCategory: "capacity", capacityConstraint: exceedsCompute ? "compute" : "simulation-gas", reason };
+    }
+  }
+  const recommendedGasPrice = nextEnvelope === undefined ? rpcQuantity(gasPriceValue, "gas price") : nextEnvelope.gasPrice;
+  // New recommendations cover lagging quotes; reviewed fees are replayed unchanged
+  // under natural child fees, never refreshed or silently increased.
   const baseFeeEnvelope = (block.baseFeePerGas ?? 0n) * 2n;
   const gasPrice = nextEnvelope?.gasPrice ?? (recommendedGasPrice > baseFeeEnvelope ? recommendedGasPrice : baseFeeEnvelope);
   if (gasPrice >= 1n << 256n) throw new LifecyclePlanningError("INVALID_RPC_RESPONSE", "Gas price must be a uint256 quantity");
-  if (nextEnvelope !== undefined && (typeof nextEnvelope.gas !== "bigint" || nextEnvelope.gas <= 0n || nextEnvelope.gas >= 1n << 64n ||
-    typeof nextEnvelope.gasPrice !== "bigint" || nextEnvelope.gasPrice < 0n || nextEnvelope.gasPrice >= 1n << 256n)) {
-    throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Reviewed gas and gas price must be exact positive uint64 gas and nonnegative uint256 price");
-  }
   const buffer = (gas: bigint) => (gas * BigInt(10000 + limits.headroomBps) + 9999n) / 10000n;
-  const computeCeiling = limits.transactionGasCeiling !== undefined && limits.transactionGasCeiling < limits.executionGasCeiling ? limits.transactionGasCeiling : limits.executionGasCeiling;
-  // Nonnegative poster gas cannot make this complete discovery request smaller.
-  // A generic controlled fork retains the existing RPC-to-fork fallback.
-  if (limits.maxSimulationGas !== undefined && BigInt(transactions.length) * computeCeiling > limits.maxSimulationGas &&
-    (limits.protocol === "nitro" || options.fork === undefined)) {
-    assertCurrent();
-    await assertLifecycleBlock(client, block, planned.chainId);
-    return { ...base, confidence: "provisional", executionProof: "unavailable", backend: "unavailable", admitted: false, steps: [], failureCategory: "capacity", capacityConstraint: "simulation-gas", reason: `Stateful sequential RPC simulation unavailable: Sequential request exceeds the current RPC aggregate simulation gas cap; use an isolated controlled fork. ${limits.protocol === "nitro" ? "Generic Anvil/Hardhat forks cannot prove ArbOS compute/poster metering." : "Dependent eth_call estimates are not proof."}` };
-  }
   const posterGas: bigint[] = [];
   if (limits.protocol === "nitro") {
-    // Lightweight poster reads may overlap the isolated capability request.
-    // Economic work is not even queued until both prerequisites have succeeded.
     try {
       const [, estimates] = await Promise.all([
         proveBackend(limits, gasPrice),
-        lifecycleStage(client, "simulation.poster", () => Promise.all(transactions.map(async (transaction) => buffer((await readNitroPosterGas(transaction, context)).posterGas)))),
+        nextEnvelope === undefined ? lifecycleStage(client, "simulation.poster", () => Promise.all(transactions.map(async (transaction) => buffer((await readNitroPosterGas(transaction, context)).posterGas)))) : [],
       ]);
       posterGas.push(...estimates);
     } catch (failure) {
@@ -513,176 +525,110 @@ async function simulateLaunchTransactionsWithContext(
     }
   }
   assertCurrent();
-  // The poster quote allocates gas only. The native exact replay enforces actual
-  // compute hold; subtracting this approximate budget from gasUsed would not.
   const discoveryGas = transactions.map((_, index) => {
     const total = limits.executionGasCeiling + (posterGas[index] ?? 0n);
     const capped = limits.transactionGasCeiling !== undefined && limits.transactionGasCeiling < total ? limits.transactionGasCeiling : total;
     if (capped <= 0n || capped >= 1n << 64n) throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Compute/poster envelope exceeds uint64 gas");
     return capped;
   });
-  let backend: "eth_simulateV1" | "controlled-fork" = "eth_simulateV1";
-  let measured: LifecycleSimulationStep[];
-  // A permissive measurement needs the legal complete compute + poster envelope.
-  // It is not proof: fixed compute/headroom checks and exact validated replay still follow.
-  try {
-    measured = await lifecycleStage(client, "simulation.measure", () => simulateRpcPass(client, planned, block, transactions, discoveryGas, limits, gasPrice, false));
-  }
-  catch (failure) {
-    if (simulationFailureKind(failure) === "abort") throw failure;
+  let backend: "eth_simulateV1" | "controlled-fork" = nextEnvelope !== undefined && limits.protocol === "evm" && options.fork !== undefined ? "controlled-fork" : "eth_simulateV1";
+  let measured: LifecycleSimulationStep[] = [];
+  if (nextEnvelope === undefined) {
+    try {
+      measured = await lifecycleStage(client, "simulation.measure", () => simulateRpcPass(client, planned, block, transactions, discoveryGas, limits, gasPrice, false));
+    } catch (failure) {
+      if (simulationFailureKind(failure) === "abort") throw failure;
+      assertCurrent();
+      if (options.fork === undefined || limits.protocol === "nitro") {
+        await assertLifecycleBlock(client, block, planned.chainId);
+        return { ...base, confidence: "provisional", executionProof: "unavailable", backend: "unavailable", admitted: false, steps: [], reason: `Stateful sequential RPC simulation unavailable: ${lifecycleFailureReason(failure)}. ${limits.protocol === "nitro" ? "Generic Anvil/Hardhat forks cannot prove ArbOS compute/poster metering." : "Dependent eth_call estimates are not proof."}` };
+      }
+      backend = "controlled-fork";
+      measured = await simulateForkPass(options.fork, planned, block, transactions, discoveryGas, gasPrice, true, limits.headroomBps);
+    }
     assertCurrent();
-    if (options.fork === undefined || limits.protocol === "nitro") {
+    const failedIndex = measured.findIndex((step) => !step.success);
+    if (failedIndex >= 0 && limits.maxSimulationGas !== undefined &&
+      measured.reduce((gas, step) => gas + (step.gasUsed ?? 0n), 0n) * 100n >= limits.maxSimulationGas * 95n) {
+      // The provider exhausted its aggregate used-gas budget, not the contract.
+      // Preserve only actual successful results; the failed call is deferred too.
+      measured = measured.slice(0, failedIndex);
+      transactions = transactions.slice(0, failedIndex);
+      base.deferredTransactionIds = allTransactions.slice(failedIndex).map((transaction) => transaction.id);
+      if (transactions.length === 0) {
+        await assertLifecycleBlock(client, block, planned.chainId);
+        return { ...base, confidence: "provisional", executionProof: "unavailable", backend, admitted: false, steps: [], failureCategory: "source", reason: "RPC aggregate simulation gas cap left no successful prefix to prove" };
+      }
+    }
+    const failed = measured.find((step) => !step.success);
+    if (failed !== undefined) { await assertLifecycleBlock(client, block, planned.chainId); return { ...base, backend, admitted: false, steps: measured, reason: failed.error, failedTransactionId: failed.transactionId, failureCategory: failed.failureCategory ?? "opaque", capacityConstraint: failed.failureCategory === "capacity" ? "compute" : undefined }; }
+    if (diagnostic) {
       await assertLifecycleBlock(client, block, planned.chainId);
-      return { ...base, confidence: "provisional", executionProof: "unavailable", backend: "unavailable", admitted: false, steps: [], reason: `Stateful sequential RPC simulation unavailable: ${lifecycleFailureReason(failure)}. ${limits.protocol === "nitro" ? "Generic Anvil/Hardhat forks cannot prove ArbOS compute/poster metering." : "Dependent eth_call estimates are not proof."}` };
+      return { ...base, backend, admitted: false, executionProof: "unavailable", steps: measured };
     }
-    backend = "controlled-fork";
-    measured = await simulateForkPass(options.fork, planned, block, transactions, discoveryGas, gasPrice, true, limits.headroomBps);
-  }
-  assertCurrent();
-  const failed = measured.find((step) => !step.success);
-  if (failed !== undefined) { await assertLifecycleBlock(client, block, planned.chainId); return { ...base, backend, admitted: false, steps: measured, reason: failed.error, failedTransactionId: failed.transactionId, failureCategory: failed.failureCategory ?? "opaque", capacityConstraint: failed.failureCategory === "capacity" ? "compute" : undefined }; }
-  if (diagnostic) {
-    await assertLifecycleBlock(client, block, planned.chainId);
-    return { ...base, backend, admitted: false, executionProof: "unavailable", steps: measured };
   }
-  // Padding belongs to new envelopes. A reviewed envelope may consume its
-  // original margin; only exact replay at its held gas/price proves it still fits.
-  const computeGas = measured.map((step, index) => {
-    const required = step.gasRequired ?? step.gasUsed ?? computeCeiling;
-    return nextEnvelope !== undefined && index === 0 ? required : buffer(required);
-  });
-  const gasLimits = computeGas.map((gas, index) =>
-    nextEnvelope !== undefined && index === 0 ? nextEnvelope.gas : gas + (posterGas[index] ?? 0n));
-  const exceeds = gasLimits.findIndex((gas, index) => gas <= 0n || gas >= 1n << 64n || (computeGas[index] ?? 0n) > limits.executionGasCeiling || limits.transactionGasCeiling !== undefined && gas > limits.transactionGasCeiling);
+  const gasLimits = nextEnvelope === undefined ? measured.map((step, index) => {
+    const gross = step.gasRequired ?? step.gasUsed!;
+    const reserve = transactions[index]?.kind === "activate" || transactions[index]?.kind === "atomic" ? hmmV2ForwardingReserve(planned.plan) : 0n;
+    const desired = gross + reserve > buffer(gross) ? gross + reserve : buffer(gross);
+    const available = discoveryGas[index]! - (posterGas[index] ?? 0n);
+    return (desired < available ? desired : available) + (posterGas[index] ?? 0n);
+  }) : [nextEnvelope.gas];
+  const exceeds = gasLimits.findIndex((gas, index) =>
+    gas <= 0n || gas >= 1n << 64n || limits.transactionGasCeiling !== undefined && gas > limits.transactionGasCeiling ||
+    nextEnvelope === undefined && (measured[index]!.gasRequired ?? measured[index]!.gasUsed!) > gas - (posterGas[index] ?? 0n) ||
+    limits.protocol === "evm" && gas > limits.executionGasCeiling);
   if (exceeds >= 0) {
     await assertLifecycleBlock(client, block, planned.chainId);
-    return { ...base, executionProof: "unavailable", protocolFit: "failed", backend, admitted: false, steps: measured, failureCategory: "capacity", capacityConstraint: (computeGas[exceeds] ?? 0n) > limits.executionGasCeiling ? "compute" : "gas-envelope", reason: "Execution compute/headroom or complete poster gas envelope is outside positive uint64 gas and current protocol/known transaction limits", failedTransactionId: transactions[exceeds]?.id };
+    return { ...base, executionProof: "unavailable", protocolFit: "failed", backend, admitted: false, steps: measured, failureCategory: "capacity", capacityConstraint: "gas-envelope", reason: "Measured execution or reviewed gas exceeds the current compute/complete transaction envelope", failedTransactionId: transactions[exceeds]?.id };
   }
-  // Envelope discovery may enlarge future unfinished steps, never the reviewed
-  // immediate one. Every retry still executes the entire sequence at held price.
-  const envelopeDiscoveryGas = nextEnvelope === undefined ? discoveryGas : discoveryGas.map((gas, index) => index === 0 ? nextEnvelope.gas : gas);
-  // Replay the complete sequence from its original state at the exact buffered
-  // limits. Only explicit native OOG can discover one larger legal envelope;
-  // semantic, opaque and transport failures cannot authorize a capacity retry.
-  let verified: LifecycleSimulationStep[];
-  let validatedReplayError: string | undefined;
-  assertCurrent();
+  let verifiedSteps: LifecycleSimulationStep[] = [];
+  let admittedGasLimits = gasLimits;
+  let replayError: string | undefined;
+  const replay = (gas: readonly bigint[]) => backend === "eth_simulateV1"
+    ? simulateRpcPass(client, planned, block, transactions, gas, limits, gasPrice, true)
+    : simulateForkPass(options.fork!, planned, block, transactions, gas, gasPrice, false, limits.headroomBps);
   try {
-    if (backend === "eth_simulateV1") verified = await lifecycleStage(client, "simulation.replay", () => simulateRpcPass(client, planned, block, transactions, gasLimits, limits, gasPrice, true));
-    else {
-      if (options.fork === undefined) throw new LifecyclePlanningError("INVALID_SIMULATION", "Controlled fork is missing for the exact-gas replay");
-      verified = await simulateForkPass(options.fork, planned, block, transactions, gasLimits, gasPrice, false, limits.headroomBps);
-    }
+    verifiedSteps = await lifecycleStage(client, "simulation.replay", () => replay(gasLimits));
   } catch (failure) {
     const kind = simulationFailureKind(failure);
     if (kind === "abort") throw failure;
     assertCurrent();
-    const message = lifecycleFailureReason(failure);
-    if (backend !== "eth_simulateV1") {
+    if (kind !== "out-of-gas" || backend !== "eth_simulateV1" || nextEnvelope !== undefined) {
       await assertLifecycleBlock(client, block, planned.chainId);
-      return { ...base, backend, admitted: false, steps: [], reason: `Exact-gas validated replay failed: ${message}` };
+      return { ...base, backend: "unavailable", confidence: "provisional", executionProof: "unavailable", admitted: false, steps: measured, failureCategory: kind === "source" ? "source" : "opaque", reason: `Exact-gas validated replay unavailable: ${lifecycleFailureReason(failure)}` };
     }
-    if (kind !== "out-of-gas") {
-      await assertLifecycleBlock(client, block, planned.chainId);
-      return { ...base, backend: "unavailable", confidence: "provisional", executionProof: "unavailable", admitted: false, steps: measured, failureCategory: kind === "source" ? "source" : "opaque", reason: `Exact-gas validated replay unavailable: ${message}` };
-    }
-    validatedReplayError = message;
-    verified = [];
+    replayError = lifecycleFailureReason(failure);
   }
   assertCurrent();
-  let verifiedSteps = verified;
-  let admittedGasLimits = gasLimits;
   let finalFailure = verifiedSteps.find((step) => !step.success);
-  let finalFailureReason: string | undefined;
-  if (finalFailure === undefined && validatedReplayError !== undefined) {
-    if (!envelopeDiscoveryGas.some((gas, index) => gas > (gasLimits[index] ?? gas))) {
-      await assertLifecycleBlock(client, block, planned.chainId);
-      return { ...base, backend, admitted: false, steps: measured, reason: `Validated execution at the exact current gas ceiling failed: ${validatedReplayError}` };
-    }
-    // The buffered validated replay threw before yielding steps. Attempt one
-    // explicit envelope-discovery replay at the exact execution ceiling on the
-    // same pinned block; headroom is never silently raised — the carried gas is
-    // the validated envelope itself.
+  const failedIndex = verifiedSteps.findIndex((step) => !step.success);
+  const rescue = nextEnvelope === undefined && backend === "eth_simulateV1" &&
+    (replayError !== undefined && discoveryGas.some((gas, index) => index < transactions.length && gas > gasLimits[index]!) ||
+      finalFailure !== undefined && looksGasExhausted(finalFailure, gasLimits[failedIndex]!) && discoveryGas[failedIndex]! > gasLimits[failedIndex]!);
+  // One legal-envelope rescue covers thrown/returned genuine OOG. Never retry
+  // semantic errors, switch replay backends, or enlarge a held immediate envelope.
+  if (rescue) {
     assertCurrent();
     try {
-      const ceilingLimits = envelopeDiscoveryGas;
-      const retried = backend === "eth_simulateV1"
-        ? await lifecycleStage(client, "simulation.envelope", () => simulateRpcPass(client, planned, block, transactions, ceilingLimits, limits, gasPrice, true))
-        : options.fork === undefined ? undefined : await simulateForkPass(options.fork, planned, block, transactions, ceilingLimits, gasPrice, false, limits.headroomBps);
-      const retryFailureIndex = retried?.findIndex((step) => !step.success) ?? -1;
-      const retryFailure = retried?.[retryFailureIndex];
-      if (retried === undefined) {
-        await assertLifecycleBlock(client, block, planned.chainId);
-        return { ...base, backend, admitted: false, steps: measured, reason: `Validated execution at the exact current gas ceiling still failed: ${validatedReplayError}` };
-      }
-      admittedGasLimits = ceilingLimits;
-      verifiedSteps = retried;
-      finalFailure = retryFailure;
-      validatedReplayError = undefined;
-      if (retryFailure !== undefined) {
-        const kind = transactions[retryFailureIndex]?.kind;
-        const indivisible = kind === "activate" || kind === "atomic";
-        finalFailureReason = `Validated execution at the exact current gas ceiling still failed: ${retryFailure.error ?? "Execution reverted"}${indivisible ? "; final mint/lock/all-buys/public-opening is indivisible and will not be partitioned" : ""}`;
-      }
+      admittedGasLimits = discoveryGas.slice(0, transactions.length);
+      verifiedSteps = await lifecycleStage(client, "simulation.envelope", () => replay(admittedGasLimits));
+      finalFailure = verifiedSteps.find((step) => !step.success);
+      replayError = undefined;
     } catch (failure) {
       const kind = simulationFailureKind(failure);
       if (kind === "abort") throw failure;
       assertCurrent();
       await assertLifecycleBlock(client, block, planned.chainId);
-      if (kind !== "out-of-gas") return { ...base, backend: "unavailable", confidence: "provisional", executionProof: "unavailable", admitted: false, steps: measured, failureCategory: kind === "source" ? "source" : "opaque", reason: `Legal-envelope validated replay unavailable after buffered execution refusal: ${lifecycleFailureReason(failure)}` };
-      return { ...base, backend, admitted: false, steps: measured, reason: `Validated buffered replay failed (${validatedReplayError}) and execution at the exact gas ceiling still reverted; final mint/lock/all-buys/public-opening is indivisible` };
-    }
-  } else if (finalFailure !== undefined) {
-    const failedIndex = verifiedSteps.findIndex((step) => !step.success);
-    const bufferedLimit = gasLimits[failedIndex];
-    const failedTransaction = transactions[failedIndex];
-    if (bufferedLimit !== undefined && failedTransaction !== undefined && (nextEnvelope === undefined || failedIndex !== 0) &&
-      looksGasExhausted(finalFailure, bufferedLimit) && (envelopeDiscoveryGas[failedIndex] ?? 0n) > bufferedLimit) {
-      // Buffered replay returned an exhaustion-shaped failed step; learn the true
-      // validated envelope with one explicit replay at the exact execution ceiling.
-      assertCurrent();
-      try {
-        const ceilingLimits = envelopeDiscoveryGas;
-        const retried = backend === "eth_simulateV1"
-          ? await lifecycleStage(client, "simulation.envelope", () => simulateRpcPass(client, planned, block, transactions, ceilingLimits, limits, gasPrice, true))
-          : options.fork === undefined ? undefined : await simulateForkPass(options.fork, planned, block, transactions, ceilingLimits, gasPrice, false, limits.headroomBps);
-        if (retried === undefined) {
-          await assertLifecycleBlock(client, block, planned.chainId);
-          return { ...base, backend, admitted: false, steps: measured, reason: "Validated execution at the exact current gas ceiling omitted transaction results" };
-        }
-        const retryFailureIndex = retried.findIndex((step) => !step.success);
-        const retryFailure = retried[retryFailureIndex];
-        admittedGasLimits = ceilingLimits;
-        verifiedSteps = retried;
-        finalFailure = retryFailure;
-        if (retryFailure !== undefined) {
-          const kind = transactions[retryFailureIndex]?.kind;
-          const indivisible = kind === "activate" || kind === "atomic";
-          finalFailureReason = `Validated execution at the exact current gas ceiling still failed: ${retryFailure.error ?? "Execution reverted"}${indivisible ? "; final mint/lock/all-buys/public-opening is indivisible and will not be partitioned" : ""}`;
-        }
-      } catch (failure) {
-        const kind = simulationFailureKind(failure);
-        if (kind === "abort") throw failure;
-        assertCurrent();
-        if (kind !== "out-of-gas") {
-          await assertLifecycleBlock(client, block, planned.chainId);
-          return { ...base, backend: "unavailable", confidence: "provisional", executionProof: "unavailable", admitted: false, steps: measured, reason: `Legal-envelope validated replay unavailable: ${lifecycleFailureReason(failure)}` };
-        }
-        await assertLifecycleBlock(client, block, planned.chainId);
-        return { ...base, backend, admitted: false, steps: measured, reason: `Validated buffered replay failed (${finalFailure?.error ?? "Execution reverted"}) and execution at the exact gas ceiling still reverted: ${lifecycleFailureReason(failure)}` };
-      }
+      if (kind !== "out-of-gas") return { ...base, backend: "unavailable", confidence: "provisional", executionProof: "unavailable", admitted: false, steps: measured, failureCategory: kind === "source" ? "source" : "opaque", reason: `Legal-envelope validated replay unavailable: ${lifecycleFailureReason(failure)}` };
+      return { ...base, backend, admitted: false, steps: measured, reason: `Validated execution at the exact current gas ceiling still failed: ${lifecycleFailureReason(failure)}` };
     }
   }
-  assertCurrent();
-  if (nextEnvelope !== undefined && finalFailure === undefined) {
-    const currentMinimum = verifiedSteps[0]?.gasRequired ?? verifiedSteps[0]?.gasUsed ?? nextEnvelope.gas;
-    if (nextEnvelope.gas < currentMinimum) {
-      await assertLifecycleBlock(client, block, planned.chainId);
-      return { ...base, backend, admitted: false, executionProof: "proved", protocolFit: "failed", steps: verifiedSteps,
-        failureCategory: "capacity", capacityConstraint: "gas-envelope", failedTransactionId: transactions[0]?.id,
-        reason: "Exact reviewed replay exceeds the held gas envelope" };
-    }
+  if (replayError !== undefined) {
+    await assertLifecycleBlock(client, block, planned.chainId);
+    return { ...base, backend, admitted: false, steps: measured, reason: `Validated execution at the exact current gas ceiling failed: ${replayError}` };
   }
+  assertCurrent();
   const estimates: LifecycleSimulationStep[] = [];
   // A definitive returned replay failure already refuses execution. Retain its
   // fee observations without inventing a balance or doing redundant payer work.
@@ -708,6 +654,6 @@ async function simulateLaunchTransactionsWithContext(
     estimates.push({ ...step, estimate: { gasUsed: step.gasUsed ?? 0n, gasLimit, gasPrice, executionFee, dataFee, posterGas: poster, posterFee: poster === undefined ? undefined : poster * gasPrice, dataFeeIncludedInGas: limits.protocol === "nitro", totalFee: dataFee === undefined ? undefined : executionFee + dataFee, feeConfidence: dataFee === undefined ? "execution-only" : "execution-and-data" } });
   }
   await assertLifecycleBlock(client, block, planned.chainId);
-  return { ...base, backend, executionProof: finalFailure === undefined ? "proved" : "failed", protocolFit: finalFailure === undefined ? "proved" : "unknown", admitted: finalFailure === undefined && affordabilityFailure === undefined, steps: estimates, reason: finalFailureReason ?? finalFailure?.error ?? affordabilityFailure, failedTransactionId: finalFailure?.transactionId, failureCategory: finalFailure?.failureCategory ?? (affordabilityFailure === undefined ? undefined : "affordability"), capacityConstraint: finalFailure?.failureCategory === "capacity" ? "compute" : undefined };
+  return { ...base, backend, executionProof: finalFailure === undefined ? "proved" : "failed", protocolFit: finalFailure === undefined ? "proved" : "unknown", admitted: finalFailure === undefined && affordabilityFailure === undefined, steps: estimates, reason: finalFailure?.error ?? affordabilityFailure, failedTransactionId: finalFailure?.transactionId, failureCategory: finalFailure?.failureCategory ?? (affordabilityFailure === undefined ? undefined : "affordability"), capacityConstraint: finalFailure?.failureCategory === "capacity" ? "compute" : undefined };
 }