@black-market/sdk 0.12.0 → 0.14.0

package/examples/launch-example-support.ts

@@ -607,9 +607,7 @@ export function createLocalLaunchWallet({ privateKey, creator, chainId, orchestr
           if (request[field] < 0n) throw exampleError("INVALID_ENVELOPE", `${field} must be unsigned`);
         }
       }
-      request.nonce = envelope.nonce === undefined
-        ? exactNumber(await client.request({ method: "eth_getTransactionCount", params: [creator, "pending"] }), "nonce")
-        : exactNumber(envelope.nonce, "nonce");
+      if (envelope.nonce !== undefined) request.nonce = exactNumber(envelope.nonce, "nonce");
       if (request.type !== undefined) {
         request.type = transactionTypes[request.type];
         if (!request.type) throw exampleError("INVALID_ENVELOPE", "Only legacy/EIP-2930/EIP-1559 envelopes are supported");
@@ -622,6 +620,16 @@ export function createLocalLaunchWallet({ privateKey, creator, chainId, orchestr
         request.maxFeePerGas ??= fees.maxFeePerGas;
         request.maxPriorityFeePerGas ??= fees.maxPriorityFeePerGas;
       }
+      const [nonceValue, balanceValue] = await Promise.all([
+        client.request({ method: "eth_getTransactionCount", params: [creator, "pending"] }),
+        client.request({ method: "eth_getBalance", params: [creator, "pending"] }),
+      ]);
+      const pendingNonce = exactNumber(nonceValue, "pending nonce");
+      if (request.nonce !== undefined && request.nonce !== pendingNonce) throw exampleError("PENDING_NONCE_CHANGED", "Pending account nonce differs from the exact reviewed envelope");
+      request.nonce = pendingNonce;
+      const maximumFee = request.gas * (request.gasPrice ?? request.maxFeePerGas);
+      if (BigInt(balanceValue) < request.value + maximumFee) throw exampleError("INSUFFICIENT_PENDING_BALANCE", "Pending balance cannot fund the exact transaction value and maximum gas envelope");
+      await assertChain();
       const rawTransaction = await account.signTransaction(request);
       redactor.addSecret(rawTransaction);
       const wire = { ...envelope, chainId: toHex(id), nonce: toHex(request.nonce) };

package/examples/launch-example.ts

@@ -494,7 +494,7 @@ async function executePlan({ client, fixture, planned, sdk, artifacts, signal, l
     const next = await sdk.buildNextTransaction({ client, planned, receipts: references, limits, submissionClient: client, reviewedTransaction, signal });
     if (!next) return { references, activation };
     assert.ok(reviewedTransaction, "No transaction outside the saved review may be submitted");
-    for (const field of ["id", "kind", "chainId", "from", "to", "data", "value", "gas", "gasPrice"]) assert.equal(next[field], reviewedTransaction[field], `Fresh ${field} must match the saved review`);
+    for (const field of ["id", "kind", "chainId", "from", "to", "data", "value", "nonce", "gas", "gasPrice"]) assert.equal(next[field], reviewedTransaction[field], `Fresh ${field} must match the saved review`);
     if (retainedReferences.length) {
       const progress = await sdk.readLaunchProgress({ client, planned, receipts: references, confirmations: planned.confirmations, signal });
       assertRetainedExampleReceipts({ progress, references, artifacts });

package/examples/launch-lifecycle-smoke.ts

@@ -46,7 +46,7 @@ async function send(transaction) {
   const gasPrice = transaction.gasPrice ?? BigInt(await client.request({ method: "eth_gasPrice" }));
   const head = await client.request({ method: "eth_getBlockByNumber", params: ["latest", false] });
   const ceiling = [BigInt(head.gasLimit), BigInt(policy.chainTransactionGasLimit), BigInt(policy.rpcTransactionGasLimit), BigInt(policy.accountTransactionGasLimit)].reduce((a, b) => a < b ? a : b);
-  const wire = { from: transaction.from, to: transaction.to, data: transaction.data, value: toHex(transaction.value), gasPrice: toHex(gasPrice) };
+  const wire = { from: transaction.from, to: transaction.to, data: transaction.data, value: toHex(transaction.value), gasPrice: toHex(gasPrice), ...(transaction.nonce === undefined ? {} : { nonce: toHex(transaction.nonce) }) };
   const estimated = transaction.gas ?? ((BigInt(await client.request({ method: "eth_estimateGas", params: [{ ...wire, gas: toHex(ceiling) }] })) * BigInt(10000 + Number(policy.headroomBps)) + 9999n) / 10000n);
   assert.ok(estimated <= ceiling, "Unsigned helper must still fit explicit local execution admission");
   const transactionHash = await client.request({ method: "eth_sendTransaction", params: [{ ...wire, gas: toHex(estimated) }] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@black-market/sdk",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "TypeScript SDK for Abyss token launches, swaps, and lending.",
   "license": "MIT",
   "repository": {

package/src/lifecycle/index.ts

@@ -5,11 +5,15 @@ export * from "./abi.js";
 export * from "./markets.js";
 export * from "./hmm.js";
 export * from "./ufg.js";
-export * from "./progress.js";
+export { ABYSS_LIFECYCLE_CONFIG_SCHEMA, readLifecycleTokenAtBlock, readLifecycleHeadProgress, predictLifecycleToken,
+  validateV4LifecycleOracle, readLifecycleProfiles, readPoolBoundHookDeployment,
+  buildPoolBoundHookDeploymentTransaction, validateLifecycleMarketIdentity, readLaunchProgress } from "./progress.js";
 export * from "./fork.js";
 export * from "./authors.js";
 export * from "./presets.js";
 export * from "./transactions.js";
 export { createLifecycleSessionCache } from "./rpc.js";
+export { launchLensAbi } from "./lens.js";
+export { hookSaltMinerAbi } from "./mining.js";
 export { planLaunch, simulateLaunchPlan, buildNextTransaction, prepareAndPlanLifecycleLaunch } from "./planner.js";
 export { assertLaunchTopologyCoverage, getTickAtSqrtRatio, type LaunchTopologyCoverageInput, type LaunchTopologyPosition } from "../launch.js";

package/src/lifecycle/lens.ts

@@ -0,0 +1,42 @@
+import { type Address, type Hex } from "viem";
+import { launchPlanV1Components, launchProgressV1Components, preparedMarketV1Components, marketLiveStateV1Components, type LaunchProgressV1, type PreparedMarketV1, type MarketLiveStateV1 } from "./schema.js";
+import type { LifecycleBlock, LifecycleRpcClient } from "./types.js";
+
+/** ILaunchLens.sol, versioned planning snapshot. No preset lens is deployed by this release. */
+export const launchLensAbi = [{ type: "function", name: "snapshot", stateMutability: "view",
+  inputs: [{ name: "plan", type: "tuple", components: launchPlanV1Components }, { name: "owner", type: "address" },
+    { name: "fundingEscrow", type: "address" }, { name: "tokens", type: "address[]" }, { name: "maxAttempts", type: "uint256" }],
+  outputs: [{ name: "result", type: "tuple", components: [
+    { name: "chainId", type: "uint256" }, { name: "blockNumber", type: "uint256" },
+    { name: "parentBlockHash", type: "bytes32" }, { name: "timestamp", type: "uint256" }, { name: "nativeBalance", type: "uint256" },
+    { name: "tokenBalances", type: "tuple[]", components: [{ name: "token", type: "address" }, { name: "balance", type: "uint256" }, { name: "allowance", type: "uint256" }] },
+    { name: "predictedToken", type: "address" }, { name: "launchId", type: "bytes32" },
+    { name: "progress", type: "tuple", components: launchProgressV1Components },
+    { name: "preparedMarkets", type: "tuple[]", components: [
+      { name: "index", type: "uint32" }, { name: "adapter", type: "address" }, { name: "prepared", type: "tuple", components: preparedMarketV1Components },
+      { name: "liveStateSuccess", type: "bool" }, { name: "live", type: "tuple", components: marketLiveStateV1Components }, { name: "liveStateError", type: "bytes" },
+    ] },
+    { name: "hookDeployments", type: "tuple[]", components: [
+      { name: "marketIndex", type: "uint32" }, { name: "adapter", type: "address" }, { name: "deployer", type: "address" },
+      { name: "constructorParameters", type: "bytes" }, { name: "initCodeHash", type: "bytes32" }, { name: "salt", type: "bytes32" }, { name: "hook", type: "address" }, { name: "found", type: "bool" },
+    ] },
+  ] }],
+}] as const;
+
+export type LifecycleLensSnapshot = {
+  chainId: bigint; blockNumber: bigint; parentBlockHash: Hex; timestamp: bigint; nativeBalance: bigint;
+  tokenBalances: readonly { token: Address; balance: bigint; allowance: bigint }[];
+  predictedToken: Address; launchId: Hex; progress: LaunchProgressV1;
+  preparedMarkets: readonly { index: number; adapter: Address; prepared: PreparedMarketV1; liveStateSuccess: boolean; live: MarketLiveStateV1; liveStateError: Hex }[];
+  hookDeployments: readonly { marketIndex: number; adapter: Address; deployer: Address; constructorParameters: Hex; initCodeHash: Hex; salt: Hex; hook: Address; found: boolean }[];
+};
+const snapshots = new WeakMap<LifecycleRpcClient, { blockHash: Hex; snapshot: LifecycleLensSnapshot }>();
+
+export function observeLifecycleLens(client: LifecycleRpcClient, block: LifecycleBlock, snapshot: LifecycleLensSnapshot): void {
+  snapshots.set(client, { blockHash: block.hash.toLowerCase() as Hex, snapshot });
+}
+
+export function lifecycleLensSnapshot(client: LifecycleRpcClient, block: LifecycleBlock): LifecycleLensSnapshot | undefined {
+  const observation = snapshots.get(client);
+  return observation?.snapshot.blockNumber === block.number && observation.blockHash === block.hash.toLowerCase() ? observation.snapshot : undefined;
+}

package/src/lifecycle/mining.ts

@@ -0,0 +1,80 @@
+import { parseAbi, type Address, type Hex } from "viem";
+import { hasLifecycleV4HookPermissions, minePoolBoundHookSalt, predictPoolBoundHookAddress } from "./markets.js";
+import { readLifecycleContract } from "./rpc.js";
+import { LifecyclePlanningError, type LifecycleBlock, type LifecyclePoolBoundHookDeployment, type LifecycleRpcClient, type PoolBoundLifecyclePreparationProgress } from "./types.js";
+import { lifecycleLensSnapshot } from "./lens.js";
+
+export const hookSaltMinerAbi = parseAbi(["function findMany((address deployer, bytes32 initCodeHash, uint256 startSalt, uint160 flags)[] searches, uint256 maxAttempts) pure returns (bytes32[] salts, address[] hooks, bool[] found)"]);
+
+/** Read-only bounded EVM mining; every returned winner is checked with local CREATE2. */
+export async function mineLifecycleHooks(options: {
+  client: LifecycleRpcClient; block: LifecycleBlock; miner?: Address;
+  deployments: readonly LifecyclePoolBoundHookDeployment[]; signal?: AbortSignal;
+  onProgress?: (progress: PoolBoundLifecyclePreparationProgress) => void;
+}): Promise<LifecyclePoolBoundHookDeployment[]> {
+  const { deployments, signal, onProgress, miner, client, block } = options;
+  const checkActive = () => { if (signal?.aborted) throw Object.assign(new Error("Lifecycle hook mining cancelled"), { name: "AbortError" }); };
+  checkActive();
+  if (miner === undefined) return Promise.all(deployments.map(async (deployment) => ({ ...deployment,
+    ...await minePoolBoundHookSalt({ ...deployment, startSalt: BigInt(deployment.salt), signal,
+      onProgress: onProgress === undefined ? undefined : (progress) => onProgress({ marketIndex: deployment.marketIndex, ...progress }) }),
+  })));
+  const results = deployments.map((deployment) => ({ ...deployment }));
+  const lens = lifecycleLensSnapshot(client, block);
+  let pending: number[] = [];
+  for (const [index, deployment] of deployments.entries()) {
+    const observed = lens?.hookDeployments.find((hook) => hook.marketIndex === deployment.marketIndex);
+    if (observed === undefined) { pending.push(index); continue; }
+    const predictedHook = predictPoolBoundHookAddress({ ...deployment, salt: observed.salt });
+    if (observed.deployer.toLowerCase() !== deployment.deployer.toLowerCase() || observed.initCodeHash.toLowerCase() !== deployment.initCodeHash.toLowerCase() ||
+      BigInt(observed.salt) < BigInt(deployment.salt) || observed.found && (observed.hook.toLowerCase() !== predictedHook.toLowerCase() || !hasLifecycleV4HookPermissions(predictedHook))) {
+      throw new LifecyclePlanningError("INVALID_MINER_RESULT", "LaunchLens hook result differs from the locally derived constructor or CREATE2 address");
+    }
+    results[index] = { ...deployment, salt: observed.salt, predictedHook };
+    if (!observed.found) pending.push(index);
+    else onProgress?.({ marketIndex: deployment.marketIndex, salt: observed.salt, predictedHook, attempts: BigInt(observed.salt) - BigInt(deployment.salt) + 1n });
+  }
+  while (pending.length > 0) {
+    checkActive();
+    let maxAttempts = BigInt(Math.floor(150_000 / pending.length));
+    for (const index of pending) {
+      const available = (1n << 256n) - 1n - BigInt(results[index]!.salt);
+      if (available < maxAttempts) maxAttempts = available;
+    }
+    if (maxAttempts === 0n) {
+      pending = pending.filter((index) => {
+        const deployment = results[index]!;
+        if (BigInt(deployment.salt) !== (1n << 256n) - 1n) return true;
+        const predictedHook = predictPoolBoundHookAddress(deployment);
+        if (!hasLifecycleV4HookPermissions(predictedHook)) throw new LifecyclePlanningError("HOOK_SALT_EXHAUSTED", "No valid hook address remains in the uint256 salt range");
+        results[index] = { ...deployment, predictedHook };
+        onProgress?.({ marketIndex: deployment.marketIndex, salt: deployment.salt, predictedHook, attempts: BigInt(deployment.salt) - BigInt(deployments[index]!.salt) + 1n });
+        return false;
+      });
+      continue;
+    }
+    const searches = pending.map((index) => ({ deployer: results[index]!.deployer, initCodeHash: results[index]!.initCodeHash, startSalt: BigInt(results[index]!.salt), flags: 0x1afcn }));
+    const [salts, hooks, found] = await readLifecycleContract<readonly [readonly Hex[], readonly Address[], readonly boolean[]]>(client, miner, hookSaltMinerAbi, "findMany", [searches, maxAttempts], block);
+    checkActive();
+    if (salts.length !== pending.length || hooks.length !== pending.length || found.length !== pending.length) throw new LifecyclePlanningError("INVALID_MINER_RESULT", "Hook miner omitted a search result");
+    const unfinished: number[] = [];
+    for (const [ordinal, index] of pending.entries()) {
+      const deployment = results[index]!;
+      const salt = salts[ordinal]!;
+      const end = searches[ordinal]!.startSalt + maxAttempts;
+      const predictedHook = predictPoolBoundHookAddress({ ...deployment, salt });
+      if (found[ordinal]) {
+        if (BigInt(salt) < searches[ordinal]!.startSalt || BigInt(salt) >= end || hooks[ordinal]!.toLowerCase() !== predictedHook.toLowerCase() || !hasLifecycleV4HookPermissions(predictedHook)) throw new LifecyclePlanningError("INVALID_MINER_RESULT", "Hook miner returned an invalid CREATE2 salt or permission mask");
+      } else {
+        if (BigInt(salt) !== end) throw new LifecyclePlanningError("INVALID_MINER_RESULT", "Hook miner did not advance to the next unsearched salt");
+        unfinished.push(index);
+      }
+      results[index] = { ...deployment, salt, predictedHook };
+      onProgress?.({ marketIndex: deployment.marketIndex, salt, predictedHook, attempts: BigInt(salt) - BigInt(deployments[index]!.salt) + (found[ordinal] ? 1n : 0n) });
+      checkActive();
+    }
+    pending = unfinished;
+  }
+  checkActive();
+  return results;
+}

package/src/lifecycle/planner.ts

@@ -3,10 +3,10 @@ import { ABYSS_FEE_TIERS } from "../abyss.js";
 import { assertLaunchTopologyCoverage, getTickAtSqrtRatio } from "../launch.js";
 import { launchLifecycleAbi, lifecycleAdapterAbi, lifecycleErc20Abi } from "./abi.js";
 import { hashLaunchIdentity, hashLaunchPlan, LifecycleFundingKind, LifecyclePhase, LifecycleRewardMode, LifecycleTokenKind, LIFECYCLE_MAX_REWARD_ERC20_SUPPLY, LIFECYCLE_MAX_ERC404_SUPPLY, parseLaunchPlan, serializeLaunchPlan, type LaunchPlanV1 } from "./schema.js";
-import { readLaunchProgress, readLifecycleProfiles, readLifecycleTokenAtBlock, readPoolBoundHookDeployment } from "./progress.js";
-import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, encodePoolBoundV4LifecycleMarketConfig, isPoolBoundV4ConfigVersion, minePoolBoundHookSalt, type AbyssLifecycleMarketConfig, type V4LifecycleMarketConfig, type V4PoolBoundLifecycleMarketConfig } from "./markets.js";
-import { assertLifecycleBlock, assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleStaticRpc, lifecycleRpc, lifecycleStage, readLifecycleBlock, readLifecycleChainId, readLifecycleContract, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
-import { prepareLaunchSimulation, simulateLaunchTransactions, type NextTransactionEnvelope } from "./simulation.js";
+import { readLaunchProgress, readLifecycleExecutionProgress, readLifecycleHeadProgress, readLifecycleProfiles, readLifecycleTokenAtBlock, readPoolBoundHookDeployment } from "./progress.js";
+import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, encodePoolBoundV4LifecycleMarketConfig, isPoolBoundV4ConfigVersion, type AbyssLifecycleMarketConfig, type V4LifecycleMarketConfig, type V4PoolBoundLifecycleMarketConfig } from "./markets.js";
+import { assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleStaticRpc, lifecycleRpc, lifecycleStage, readLifecycleChainId, readLifecycleContract, readLifecycleGasPrice, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
+import { prepareLaunchSimulation, simulateLaunchTransactions, type GasSizingHints, type NextTransactionEnvelope } from "./simulation.js";
 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";
@@ -14,6 +14,8 @@ import { buildLaunchTransactions, packPreparationBatches } from "./transactions.
 import { assertLifecycleMarketAllocation, assertLifecycleSupplyAllocation } from "./allocations.js";
 import { assertUfgLaunchAccount, hashUfgLaunchConfig, UFG_LAUNCH_PROXY_ADDRESS } from "./ufg-config.js";
 import { buildUfgLaunchTransactions, buildUfgCancelTransaction, validateUfgLaunchPlan } from "./ufg.js";
+import { readLifecyclePlanningBlock } from "./snapshot.js";
+import { mineLifecycleHooks } from "./mining.js";
 
 type ValidatedPlanShape = {
   commitment: Hex;
@@ -144,7 +146,7 @@ function orderedTransactions(plan: LaunchPlanV1, mode: "atomic" | "staged", prog
     (transaction.kind !== "begin" && transaction.kind !== "atomic" || progress.canonical.phase === LifecyclePhase.None) &&
     (transaction.kind !== "prepare" || (transaction.marketStart ?? 0) >= prepared));
   const transactions = progress.canonical.phase === LifecyclePhase.None ? [...approvals, ...commands] : commands;
-  return transactions.map((transaction, index) => ({ ...transaction, calldataBytes: (transaction.data.length - 2) / 2, dependencies: index === 0 ? [] : [transactions[index - 1]!.id] }));
+  return transactions.map((transaction, index) => ({ ...transaction, nonce: progress.pendingAccountNonce + BigInt(index), calldataBytes: (transaction.data.length - 2) / 2, dependencies: index === 0 ? [] : [transactions[index - 1]!.id] }));
 }
 
 function attachEstimates(transactions: readonly LifecycleTransaction[], simulation: LifecycleSimulation): LifecycleTransaction[] {
@@ -154,7 +156,7 @@ function attachEstimates(transactions: readonly LifecycleTransaction[], simulati
       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;
+type ReviewedNextTransaction = Pick<LifecycleTransaction, "id" | "kind" | "chainId" | "from" | "to" | "data" | "value" | "nonce"> & NextTransactionEnvelope;
 const reviewedTransactionKinds = ["approve-reset", "approve", "atomic", "begin", "prepare", "activate", "cancel"] as const;
 
 function readReviewedNextTransaction(transaction: LifecycleTransaction | undefined): ReviewedNextTransaction | undefined {
@@ -167,7 +169,8 @@ function readReviewedNextTransaction(transaction: LifecycleTransaction | undefin
     typeof transaction.data !== "string" || !/^0x(?:[\da-fA-F]{2})*$/.test(transaction.data) ||
     typeof transaction.value !== "bigint" || transaction.value < 0n || transaction.value >= 1n << 256n ||
     typeof transaction.gas !== "bigint" || transaction.gas <= 0n || transaction.gas >= 1n << 64n ||
-    typeof transaction.gasPrice !== "bigint" || transaction.gasPrice < 0n || transaction.gasPrice >= 1n << 256n) {
+    typeof transaction.gasPrice !== "bigint" || transaction.gasPrice < 0n || transaction.gasPrice >= 1n << 256n ||
+    transaction.nonce !== undefined && (typeof transaction.nonce !== "bigint" || transaction.nonce < 0n || transaction.nonce >= 1n << 64n)) {
     throw new LifecyclePlanningError("INVALID_REVIEWED_TRANSACTION", "Reviewed transaction must contain a well-formed exact chain/account/target/calldata/value and uint64 gas/uint256 price envelope");
   }
   return transaction as ReviewedNextTransaction;
@@ -176,7 +179,8 @@ function readReviewedNextTransaction(transaction: LifecycleTransaction | undefin
 function matchesReviewedNextTransaction(next: LifecycleTransaction | ReviewedNextTransaction | undefined, reviewed: ReviewedNextTransaction): boolean {
   return next !== undefined && next.id === reviewed.id && next.kind === reviewed.kind && next.chainId === reviewed.chainId &&
     next.from.toLowerCase() === reviewed.from.toLowerCase() && next.to.toLowerCase() === reviewed.to.toLowerCase() &&
-    next.data.toLowerCase() === reviewed.data.toLowerCase() && next.value === reviewed.value;
+    next.data.toLowerCase() === reviewed.data.toLowerCase() && next.value === reviewed.value &&
+    (reviewed.nonce === undefined || next.nonce === reviewed.nonce);
 }
 
 function assertReviewedTransactionUnchanged(options: BuildNextTransactionOptions, reviewed: ReviewedNextTransaction | undefined, next: LifecycleTransaction): void {
@@ -273,55 +277,68 @@ function assertFinalPlan(planned: PlannedLaunch, signal?: AbortSignal): void {
 export async function prepareAndPlanLifecycleLaunch(options: PrepareAndPlanLifecycleLaunchOptions): Promise<PlannedLaunch> {
   const { commitment, ufgConfigHash } = validatePlanningIntent(options);
   if (options.buySlippageBps !== undefined) validateBuySlippageBps(options.buySlippageBps);
+  const fixed = options.fixedFinalEnvelope;
+  if (fixed !== undefined && (fixed === null || typeof fixed !== "object" || options.mode !== "atomic" || typeof fixed.gas !== "bigint" || fixed.gas <= 0n || fixed.gas >= 1n << 64n ||
+    fixed.gasPrice !== undefined && (typeof fixed.gasPrice !== "bigint" || fixed.gasPrice < 0n || fixed.gasPrice >= 1n << 256n))) {
+    throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Fixed final envelope requires atomic mode, exact positive uint64 gas and optional uint256 price");
+  }
+  const heldEnvelope = fixed === undefined ? undefined : Object.freeze({ ...fixed });
   const needsMining = options.plan.markets.some((market) => isPoolBoundV4ConfigVersion(market.configVersion));
   const needsProtection = options.buySlippageBps !== undefined && options.plan.buys.length !== 0;
-  if (!needsMining && !needsProtection) return planLaunch(options);
+  if (!needsMining && !needsProtection && fixed === undefined) return planLaunch(options);
   const draft = parseLaunchPlan(serializeLaunchPlan(options.plan));
   const assertDraft = () => {
     assertPlanningActive(options.signal);
     if (hashLaunchPlan(options.plan).toLowerCase() !== commitment.toLowerCase()) throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed during asynchronous preparation; previous construction is invalid");
     if ((options.ufg === undefined ? undefined : hashUfgLaunchConfig(options.ufg.config)) !== ufgConfigHash) throw new LifecyclePlanningError("PLAN_MUTATED", "UFG config changed during asynchronous preparation");
+    if (fixed === undefined ? options.fixedFinalEnvelope !== undefined : options.fixedFinalEnvelope !== fixed ||
+      fixed.gas !== heldEnvelope!.gas || fixed.gasPrice !== heldEnvelope!.gasPrice) throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Fixed final envelope changed during preparation");
   };
-  return withLifecycleReadClient(options.client, async (client) => {
-    const [block, chainId] = await Promise.all([readLifecycleBlock(client), readLifecycleChainId(client)]);
+  const result = await withLifecycleReadClient(options.client, async (client) => {
+    const block = await readLifecyclePlanningBlock(client, draft, options.account, options.ufg !== undefined, true);
+    const chainId = await readLifecycleChainId(client);
     if (chainId !== draft.chainId) throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the economic plan being finalized");
     const metadata = needsMining ? await Promise.all(draft.markets.map((market, marketIndex) => isPoolBoundV4ConfigVersion(market.configVersion)
       ? readPoolBoundHookDeployment({ client, plan: draft, marketIndex }, block) : undefined)) : [];
     assertDraft();
     const markets = [...draft.markets];
-    const minedDeployments: LifecyclePoolBoundHookDeployment[] = [];
-    for (const [marketIndex, deployment] of metadata.entries()) {
-      if (deployment === undefined) continue;
+    const minedDeployments = await mineLifecycleHooks({ client, block,
+      miner: getKnownLifecycleDeployment({ chainId, orchestrator: draft.orchestrator })?.hookSaltMiner,
+      deployments: metadata.flatMap((deployment, marketIndex) => deployment === undefined ? [] : [{ marketIndex, ...deployment }]),
+      signal: options.signal, onProgress: options.onProgress });
+    for (const mined of minedDeployments) {
       assertDraft();
-      const mined = await minePoolBoundHookSalt({
-        deployer: deployment.deployer, initCodeHash: deployment.initCodeHash, startSalt: BigInt(deployment.salt), signal: options.signal,
-        onProgress: options.onProgress === undefined ? undefined : (progress) => options.onProgress?.({ marketIndex, ...progress }),
-      });
+      const marketIndex = mined.marketIndex;
       const market = markets[marketIndex]!;
       if (!isPoolBoundV4ConfigVersion(market.configVersion)) throw new LifecyclePlanningError("INVALID_BOUND_MARKET", "Mined market lost its explicit pool-bound version");
       markets[marketIndex] = { ...market, config: encodePoolBoundV4LifecycleMarketConfig({ ...decodePoolBoundV4LifecycleMarketConfig(market.config, market.configVersion), hookSalt: mined.salt }) };
-      minedDeployments.push({ marketIndex, deployer: deployment.deployer, initCodeHash: deployment.initCodeHash, ...mined });
     }
     assertDraft();
-    // Mining is local construction, not a state admission. Economic observations
-    // start at a fresh post-mining snapshot and share it through final protection.
-    const executionBlock = needsMining ? await readLifecycleBlock(client) : block;
+    const executionBlock = block;
     assertDraft();
+    const price = heldEnvelope === undefined ? undefined : heldEnvelope.gasPrice ?? rpcQuantity(await readLifecycleGasPrice(client), "gas price");
+    const baseFeeEnvelope = (executionBlock.baseFeePerGas ?? 0n) * 2n;
+    const finalEnvelope = heldEnvelope === undefined ? undefined : Object.freeze({
+      gas: heldEnvelope.gas,
+      gasPrice: heldEnvelope.gasPrice ?? (price! > baseFeeEnvelope ? price! : baseFeeEnvelope),
+    });
     let plan: LaunchPlanV1 = { ...draft, markets };
     let ownedProgress: CanonicalLaunchProgress | undefined;
+    let sizing: GasSizingHints | undefined;
     if (needsProtection) {
       // A diagnostic minimum is never returned as an admitted or executable plan.
       // Price guards, funding minima, recipients and all ordered budgets stay exact.
       const diagnosticPlan = { ...plan, buys: plan.buys.map((buy) => ({ ...buy, minTokenOut: 1n })) };
-      const diagnostic = await lifecycleStage(client, "plan", () => planLaunchWithReads({ ...options, plan: diagnosticPlan }, client, executionBlock, undefined, true));
+      const diagnostic = await lifecycleStage(client, "plan", () => planLaunchWithReads({ ...options, plan: diagnosticPlan }, client, executionBlock, undefined, true, finalEnvelope));
       assertDraft();
       if (diagnostic.progress.canonical.phase !== LifecyclePhase.None || diagnostic.progress.head.phase !== LifecyclePhase.None) throw new LifecyclePlanningError("LAUNCH_ALREADY_STARTED", "Buy protection cannot replace an already committed launch plan");
       plan = protectOrderedBuyMinimums(diagnostic, options.buySlippageBps!);
       // This is the real SDK-owned None observation, not an assumed new-launch
       // state. No onchain commitment existed at this exact snapshot to replace.
       ownedProgress = { ...diagnostic.progress, planHash: hashLaunchPlan(plan) };
+      sizing = new Map(diagnostic.simulation.steps.map((step) => [step.transactionId, step.gasRequired ?? step.gasUsed!]));
     }
-    const planned = await lifecycleStage(client, "plan", () => planLaunchWithReads({ ...options, plan }, client, executionBlock, ownedProgress));
+    const planned = await lifecycleStage(client, "plan", () => planLaunchWithReads({ ...options, plan }, client, executionBlock, ownedProgress, false, finalEnvelope, sizing));
     assertDraft();
     assertFinalPlan(planned, options.signal);
     if (planned.progress.canonical.phase !== LifecyclePhase.Active && planned.progress.canonical.phase !== LifecyclePhase.Cancelled) {
@@ -333,23 +350,28 @@ export async function prepareAndPlanLifecycleLaunch(options: PrepareAndPlanLifec
     if (needsProtection && !planned.simulation.admitted) throw new LifecyclePlanningError("PROTECTED_PLAN_NOT_ADMITTED", planned.simulation.reason ?? "The final protected launch did not establish exact execution proof", planned.simulation);
     return planned;
   });
+  assertDraft();
+  assertFinalPlan(result, options.signal);
+  return result;
 }
 
 /** Independently fresh current-state admission of an already finalized commitment. No broadcasts. */
 export async function planLaunch(options: PlanLaunchOptions): Promise<PlannedLaunch> {
-  return withLifecycleReadClient(options.client, async (client) => {
+  const result = await withLifecycleReadClient(options.client, async (client) => {
     const planned = await lifecycleStage(client, "plan", () => planLaunchWithReads(options, client));
     assertFinalPlan(planned, options.signal);
     return planned;
   });
+  assertFinalPlan(result, options.signal);
+  return result;
 }
 
-async function planLaunchWithReads(options: PlanLaunchOptions, client: LifecycleRpcClient, pinnedBlock?: LifecycleBlock, ownedProgress?: CanonicalLaunchProgress, diagnostic = false, reviewed?: ReviewedNextTransaction): Promise<PlannedLaunch> {
+async function planLaunchWithReads(options: PlanLaunchOptions, client: LifecycleRpcClient, pinnedBlock?: LifecycleBlock, ownedProgress?: CanonicalLaunchProgress, diagnostic = false, fixedFinalEnvelope?: NextTransactionEnvelope, sizing?: GasSizingHints): Promise<PlannedLaunch> {
   const { plan, account, mode, ufg } = options;
   const { commitment: planHash, marketConfigs, ufgConfigHash } = validatePlanningIntent(options);
   const launchId = hashLaunchIdentity(plan);
   const [block, chainId] = await lifecycleStage(client, "plan.context", () => Promise.all([
-    pinnedBlock ?? readLifecycleBlock(client), readLifecycleChainId(client),
+    pinnedBlock ?? readLifecyclePlanningBlock(client, plan, account, ufg !== undefined), readLifecycleChainId(client),
   ]));
   if (chainId !== plan.chainId) throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed plan");
   // Only preparation/build-next can supply freshly observed progress from this
@@ -366,7 +388,10 @@ async function planLaunchWithReads(options: PlanLaunchOptions, client: Lifecycle
     preset ?? readTokenFactoryBinding(client, plan.orchestrator, block),
     resolveLifecycleLimits({ client, account, orchestrator: plan.orchestrator, block, chainId: plan.chainId }, options.limits),
     lifecycleStage(client, "plan.progress", async () => {
-      const predictedToken = await readLifecycleTokenAtBlock(client, plan, block);
+      const [predictedToken] = await Promise.all([
+        readLifecycleTokenAtBlock(client, plan, block),
+        ownedProgress === undefined ? readLifecycleHeadProgress(client, plan, account, block) : undefined,
+      ]);
       const identity = { plan, planHash, launchId, predictedToken, account, mode, confirmations: options.confirmations ?? 1,
         ...(ufg === undefined ? {} : { ufg: { config: ufg.config, configHash: ufgConfigHash! } }) };
       if (ufg !== undefined) validateUfgLaunchPlan(plan, ufg.config, predictedToken);
@@ -389,11 +414,11 @@ async function planLaunchWithReads(options: PlanLaunchOptions, client: Lifecycle
       hookDeployments.push({ marketIndex, ...(known?.deployment ?? await readPoolBoundHookDeployment({ client, plan, marketIndex }, block)) });
     }
     const waiting = { ...placeholder, confidence: "stateful" as const, reason: !progress.confirmationSafe ? "Canonical confirmed progress/account nonce has not caught up with head or pending transactions; wait for the selected confirmation depth" : "Wait for canonical receipt confirmations or resolve replacement before requesting another transaction" };
-    await assertLifecycleBlock(client, block, plan.chainId);
+    
     return { ...planned, hookDeployments, simulation: waiting };
   }
   if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled) {
-    await assertLifecycleBlock(client, block, plan.chainId);
+    
     return { ...planned, simulation: { ...placeholder, confidence: "stateful", executionProof: "proved", protocolFit: "proved", admitted: true, reason: "Canonical launch is terminal; no transaction remains" } };
   }
   // Topology is a creation policy, not a retroactive obstacle to recovery of
@@ -408,39 +433,30 @@ async function planLaunchWithReads(options: PlanLaunchOptions, client: Lifecycle
   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] : [])];
-  }
+  if (mode === "staged") batches = packPreparationBatches(plan, prepared, computeCap);
   let transactions = orderedTransactions(plan, mode, progress, funding.approvals, batches, ufg);
-  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 (fixedFinalEnvelope !== undefined && (transactions.length !== 1 || transactions[0]!.kind !== "atomic")) {
+    throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Fixed final envelope requires one immediate atomic launch with no preceding approvals");
   }
   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, true, reviewed);
+  const envelope = diagnostic ? undefined : fixedFinalEnvelope;
+  const preparedSimulation = prepareLaunchSimulation({ client, planned, limits: options.limits, fork: options.fork, signal: options.signal }, block, true, envelope, fixedFinalEnvelope?.gasPrice, sizing);
   try {
-    const execute = diagnostic ? preparedSimulation.measure : (candidate: readonly LifecycleTransaction[]) => preparedSimulation(candidate, reviewed);
+    const execute = diagnostic ? preparedSimulation.measure : (candidate: readonly LifecycleTransaction[]) => preparedSimulation(candidate, envelope);
     let simulation = await execute(transactions);
     assertFinalPlan(planned, options.signal);
     if (mode === "staged") {
-      // 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:")) {
+      // Only pressure at the native ceiling can invalidate packing. A smaller
+      // affordability/RPC/account envelope is not evidence for another wallet write.
+      while (!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;
+        if (count <= 1 || step?.gasUsed === undefined || step.gasLimit === undefined || step.gasLimit < limits.executionGasCeiling || step.gasUsed * 100n < limits.executionGasCeiling * 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);
@@ -453,9 +469,6 @@ async function planLaunchWithReads(options: PlanLaunchOptions, client: Lifecycle
     } 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, transactions: attachEstimates(transactions, simulation), totalCalldataBytes: transactions.reduce((total, transaction) => total + (transaction.data.length - 2) / 2, 0) };
   } finally { preparedSimulation.close(); }
 }
@@ -475,21 +488,15 @@ async function preflightNextTransaction(options: BuildNextTransactionOptions, ne
     if (rpcQuantity(await lifecycleRpc(submissionClient, "eth_chainId"), "submission chain ID") !== simulation.chainId) throw new Error("Active submission RPC chain differs from the reviewed transaction");
     const estimated = rpcQuantity(await lifecycleRpc(submissionClient, "eth_estimateGas", [{
       from: next.from, to: next.to, data: next.data, value: toHex(next.value), gas: toHex(next.gas), gasPrice: toHex(next.gasPrice),
+      ...(next.nonce === undefined ? {} : { nonce: toHex(next.nonce) }),
     }, "latest"]), "submission gas estimate");
     if (estimated <= 0n || estimated > next.gas) throw new Error("Submission RPC gas estimate exceeds the exact reviewed envelope or is zero");
-    if (rpcQuantity(await lifecycleRpc(submissionClient, "eth_chainId"), "submission chain ID") !== simulation.chainId) throw new Error("Active submission RPC chain changed during preflight");
     assertPlanningActive(options.signal);
   } catch (failure) {
     if (failure instanceof Error && failure.name === "AbortError") throw failure;
     const reason = `Exact next-transaction submission preflight failed: ${lifecycleFailureReason(failure)}`;
     throw new LifecyclePlanningError("SUBMISSION_PREFLIGHT_FAILED", reason, { ...simulation, transportPreflight: "failed", reason });
   }
-  const [canonical, chainId] = await Promise.all([
-    readLifecycleBlock(options.client, toHex(simulation.blockNumber)),
-    lifecycleRpc(options.client, "eth_chainId"),
-  ]);
-  if (canonical.hash.toLowerCase() !== simulation.blockHash.toLowerCase()) throw new LifecyclePlanningError("STATE_REORGED", "Pinned launch proof changed during submission preflight; rebuild from canonical progress");
-  if (rpcQuantity(chainId, "chain ID") !== simulation.chainId) throw new LifecyclePlanningError("CHAIN_MISMATCH", "Source RPC chain changed during submission preflight");
   if (next.admission === undefined) throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Next transaction omitted its exact simulation admission", simulation);
   assertPlanningActive(options.signal);
   assertReviewedTransactionUnchanged(options, reviewed, next);
@@ -503,15 +510,23 @@ export async function buildNextTransaction(options: BuildNextTransactionOptions)
   // Snapshot only the reviewed wire fields; caller proofs and commands are never
   // reused, and final checks compare the mutable input with this one local copy.
   const reviewed = supplied === undefined ? undefined : Object.freeze({ id: supplied.id, kind: supplied.kind, chainId: supplied.chainId,
-    from: supplied.from, to: supplied.to, data: supplied.data, value: supplied.value, gas: supplied.gas, gasPrice: supplied.gasPrice });
-  return withLifecycleReadClient(options.client, async (client) => {
-    const block = await readLifecycleBlock(client);
-    const progress = await readLaunchProgress({ ...options, client }, block);
+    from: supplied.from, to: supplied.to, data: supplied.data, value: supplied.value, gas: supplied.gas, gasPrice: supplied.gasPrice, nonce: supplied.nonce });
+  const result = await withLifecycleReadClient(options.client, async (client) => {
+    const block = await readLifecyclePlanningBlock(client, options.planned.plan, options.planned.account, options.planned.ufg !== undefined);
+    const limitSource = options.limits === undefined ? options.planned.limits : options.limits;
+    if (getKnownLifecycleDeployment({ chainId: options.planned.chainId, orchestrator: options.planned.plan.orchestrator }) !== undefined && typeof limitSource !== "function") {
+      await Promise.all([
+        readLifecycleTokenAtBlock(client, options.planned.plan, block),
+        readLifecycleHeadProgress(client, options.planned.plan, options.planned.account, block),
+        resolveLifecycleLimits({ client, account: options.planned.account, orchestrator: options.planned.plan.orchestrator, block, chainId: options.planned.chainId }, limitSource),
+      ]);
+    }
+    const progress = await readLifecycleExecutionProgress({ ...options, client }, block);
     if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled) {
       // Only the confirmed canonical terminal phase is terminal; a head-only
       // Active observation is not, and the confirmation/nonce/receipt gates below
       // remain in force for every nonterminal case.
-      await assertLifecycleBlock(client, block, options.planned.chainId);
+      
       return undefined;
     }
     if (!progress.confirmationSafe) throw new LifecyclePlanningError("UNCONFIRMED_STATE", "Wait for confirmed canonical progress and account nonce, including untracked approvals/replacements, before constructing the next transaction");
@@ -523,6 +538,7 @@ export async function buildNextTransaction(options: BuildNextTransactionOptions)
       assertFinalPlan(planned, options.signal);
       const transaction: LifecycleTransaction = planned.ufg !== undefined ? buildUfgCancelTransaction({ plan: planned.plan, preparedMarkets: progress.canonical.preparedMarkets })
         : { id: "cancel", kind: "cancel", chainId: Number(planned.chainId), from: planned.account, to: planned.plan.orchestrator, data: encodeFunctionData({ abi: launchLifecycleAbi, functionName: "cancelLaunch", args: [planned.plan] }), value: 0n, dependencies: [], postconditions: [{ kind: "launch", phase: "Cancelled", preparedMarkets: progress.canonical.preparedMarkets }] };
+      transaction.nonce = progress.pendingAccountNonce;
       if (reviewed !== undefined && !matchesReviewedNextTransaction(transaction, reviewed)) throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current canonical cancellation");
       const simulation = await simulateLaunchTransactions({ client, planned, limits: options.limits === undefined ? planned.limits : options.limits, fork: options.fork, signal: options.signal }, [transaction], block, reviewed);
       if (!simulation.admitted) throw new LifecyclePlanningError("CANCEL_NOT_ADMITTED", simulation.reason ?? "Cancellation could not be proved against current canonical state", simulation);
@@ -530,15 +546,48 @@ export async function buildNextTransaction(options: BuildNextTransactionOptions)
       if (next === undefined) throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Cancellation omitted its exact simulation admission", simulation);
       return preflightNextTransaction(options, next, simulation, reviewed);
     }
-    const refreshed = await lifecycleStage(client, "plan", () => planLaunchWithReads({ client, plan: options.planned.plan, account: options.planned.account, mode: options.planned.mode, limits: options.limits === undefined ? options.planned.limits : options.limits, fork: options.fork, receipts: options.receipts, confirmations: options.confirmations ?? options.planned.confirmations, signal: options.signal,
-      ufg: options.planned.ufg, allowTopologyGaps: options.planned.allowTopologyGaps, allowMissingPermanentTail: options.planned.allowMissingPermanentTail }, client, block, progress, false, reviewed));
-    assertFinalPlan(refreshed, options.signal);
-    if (!refreshed.simulation.admitted) throw new LifecyclePlanningError("PLAN_NOT_ADMITTED", refreshed.simulation.reason ?? "Remaining exact launch sequence is not admitted", refreshed.simulation);
-    assertPlannedDeploymentBindings(options.planned, refreshed);
-    const next = refreshed.transactions[0];
-    if (next === undefined) return undefined;
-    return preflightNextTransaction(options, next, refreshed.simulation, reviewed);
+    const { planned } = options;
+    assertFinalPlan(planned, options.signal);
+    const funding = progress.canonical.phase === LifecyclePhase.None
+      ? await readFunding(client, planned.plan, block, planned.account, planned.ufg !== undefined)
+      : { prerequisites: [], approvals: [] };
+    const prepared = progress.canonical.preparedMarkets;
+    let batches: number[] = [];
+    if (planned.mode === "staged") {
+      let suffixStart = prepared;
+      const prefix = prepared > 0 ? [prepared] : [];
+      if (reviewed?.kind === "prepare") {
+        const span = /^prepare:(\d+):(\d+)$/.exec(reviewed.id);
+        const first = Number(span?.[1]), count = Number(span?.[2]);
+        if (first !== prepared || !Number.isSafeInteger(count) || count <= 0 || first + count > planned.plan.markets.length) throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed preparation does not start at the canonical unfinished market");
+        prefix.push(count);
+        suffixStart += count;
+      }
+      const suffix = planned.transactions
+        .filter((transaction) => transaction.kind === "prepare" && transaction.marketStart! + transaction.marketCount! > suffixStart)
+        .map((transaction) => transaction.marketStart! + transaction.marketCount! - Math.max(transaction.marketStart!, suffixStart));
+      if (suffix.length === 0 && suffixStart < planned.plan.markets.length) {
+        const { limits } = await resolveLifecycleLimits({ client, account: planned.account, orchestrator: planned.plan.orchestrator, block, chainId: planned.chainId }, limitSource);
+        const cap = limits.transactionGasCeiling !== undefined && limits.transactionGasCeiling < limits.executionGasCeiling ? limits.transactionGasCeiling : limits.executionGasCeiling;
+        suffix.push(...packPreparationBatches(planned.plan, suffixStart, cap).slice(suffixStart > 0 ? 1 : 0));
+      }
+      batches = [...prefix, ...suffix];
+    }
+    const candidate = orderedTransactions(planned.plan, planned.mode, progress, funding.approvals, batches, planned.ufg)[0];
+    if (candidate === undefined) return undefined;
+    if (reviewed !== undefined && !matchesReviewedNextTransaction(candidate, reviewed)) throw new LifecyclePlanningError("REVIEWED_TRANSACTION_MISMATCH", "Reviewed transaction differs from the current canonical unfinished next step");
+    const observed = planned.simulation.executionProof === "proved" ? planned.simulation.steps.find((step) => step.transactionId === candidate.id && step.success) : undefined;
+    const compute = observed?.computeGasRequired;
+    const sizing: GasSizingHints | undefined = reviewed !== undefined || compute === undefined ? undefined : new Map([[candidate.id, compute]]);
+    const simulation = await simulateLaunchTransactions({ client, planned, limits: limitSource, fork: options.fork, signal: options.signal }, [candidate], block, reviewed, sizing);
+    assertFinalPlan(planned, options.signal);
+    if (!simulation.admitted) throw new LifecyclePlanningError("PLAN_NOT_ADMITTED", simulation.reason ?? "Next exact launch transaction is not admitted", simulation);
+    const next = attachEstimates([candidate], simulation)[0]!;
+    return preflightNextTransaction(options, next, simulation, reviewed);
   });
+  assertFinalPlan(options.planned, options.signal);
+  if (result !== undefined) assertReviewedTransactionUnchanged(options, reviewed, result);
+  return result;
 }
 
 /** Re-simulates only canonical unfinished work with the same submitted receipt