@black-market/sdk 0.14.1 → 0.15.1

package/src/lifecycle/presets.ts

@@ -11,6 +11,9 @@ import { HMM_FIXED_PROFILE_ID, HMM_DYNAMIC_PROFILE_ID, isHmmProfile } from "./hm
 import { ufgFixedEnvelope, ufgFixedAdapter, ufgFixedRegistration } from "./deployments/ufg-fixed-pool-20261021.js";
 import { ufgDynamicEnvelope, ufgDynamicAdapter, ufgDynamicRegistration } from "./deployments/ufg-dynamic-pool-20261021.js";
 import { UFG_FIXED_PROFILE_ID, UFG_DYNAMIC_PROFILE_ID } from "./ufg-config.js";
+import { autoCompoundStaticEnvelope, autoCompoundStaticAdapter, autoCompoundStaticRegistration, autoCompoundStaticCreationCode } from "./deployments/auto-compound-static-pool-v1-20261028.js";
+import { autoCompoundDynamicEnvelope, autoCompoundDynamicAdapter, autoCompoundDynamicRegistration, autoCompoundDynamicCreationCode } from "./deployments/auto-compound-dynamic-pool-v1-20261028.js";
+import { AUTO_COMPOUND_STATIC_V1_PROFILE_ID, AUTO_COMPOUND_DYNAMIC_V1_PROFILE_ID } from "./auto-compound.js";
 
 export enum KnownLifecycleProfile {
   Abyss0 = "abyss-0",
@@ -23,6 +26,8 @@ export enum KnownLifecycleProfile {
   V4HmmDynamicPool = "v4-hmm-dynamic-pool",
   V4UfgFixedPool = "v4-ufg-fixed-pool",
   V4UfgDynamicPool = "v4-ufg-dynamic-pool",
+  V4AutoCompoundStaticPool = "v4-auto-compound-static-pool",
+  V4AutoCompoundDynamicPool = "v4-auto-compound-dynamic-pool",
 }
 
 export enum KnownLifecycleHook {
@@ -30,11 +35,16 @@ export enum KnownLifecycleHook {
   DynamicFeePoolV1 = "dynamic-fee-pool-v1",
   HmmFixedPoolV2 = "hmm-fixed-pool-v2",
   HmmDynamicPoolV2 = "hmm-dynamic-pool-v2",
+  AutoCompoundStaticV1 = "auto-compound-static-v1",
+  AutoCompoundDynamicV1 = "auto-compound-dynamic-v1",
 }
 
 Object.freeze(KnownLifecycleProfile);
 Object.freeze(KnownLifecycleHook);
 
+/** Total launch-transaction gas limit, including Nitro poster gas; unused gas is refunded. */
+export const ROBINHOOD_NATIVE_TRANSACTION_GAS_LIMIT = 32_000_000n;
+
 /** Frozen construction metadata, not a current eligibility or execution observation. */
 export type LifecycleProfilePreset = {
   readonly key: KnownLifecycleProfile;
@@ -61,6 +71,7 @@ export type LifecycleDeploymentPreset = {
   readonly tokenFactory: Address;
   readonly tokenFactoryCodeHash: Hex;
   readonly fundingEscrow: Address;
+  readonly nativeTransactionGasLimit?: bigint;
   /** Optional SDK-owned read-only acceleration contracts. */
   readonly hookSaltMiner?: Address;
   readonly launchLens?: Address;
@@ -330,6 +341,7 @@ const knownDeployment: LifecycleDeploymentPreset = Object.freeze({
   tokenFactory: "0xd3cE64E49224a9a96075633f63761FE6BE22FE30",
   tokenFactoryCodeHash: "0x6bbbdfe93ec615b7f1e70bac5e69aa890eba5e5f248f25e7022e866b4064d541",
   fundingEscrow: "0x7bc77946CeF52A178583FCe1EEB7751983cEC703",
+  nativeTransactionGasLimit: ROBINHOOD_NATIVE_TRANSACTION_GAS_LIMIT,
   hookSaltMiner: "0x2f06176ba739b609b6a7334e2e6647558ba78ad5",
   // LaunchLens/871f9385, L2 deployment block 100095353.
   // tx 0xafdf35fa50d2c3fe08f1ab231a4e5d5e4dd5629c57f14dfe0a3aff5b0b8404ff
@@ -346,6 +358,8 @@ const knownDeployment: LifecycleDeploymentPreset = Object.freeze({
     poolBoundPreset(KnownLifecycleProfile.V4HmmDynamicPool, HMM_DYNAMIC_PROFILE_ID, hmmDynamicEnvelope, hmmDynamicAdapter, hmmDynamicRegistration, hmmDynamicCreationCode),
     poolBoundPreset(KnownLifecycleProfile.V4UfgFixedPool, UFG_FIXED_PROFILE_ID, ufgFixedEnvelope, ufgFixedAdapter, ufgFixedRegistration, fixedFeePoolHookV1CreationCode),
     poolBoundPreset(KnownLifecycleProfile.V4UfgDynamicPool, UFG_DYNAMIC_PROFILE_ID, ufgDynamicEnvelope, ufgDynamicAdapter, ufgDynamicRegistration, dynamicFeePoolHookV1CreationCode),
+    poolBoundPreset(KnownLifecycleProfile.V4AutoCompoundStaticPool, AUTO_COMPOUND_STATIC_V1_PROFILE_ID, autoCompoundStaticEnvelope, autoCompoundStaticAdapter, autoCompoundStaticRegistration, autoCompoundStaticCreationCode),
+    poolBoundPreset(KnownLifecycleProfile.V4AutoCompoundDynamicPool, AUTO_COMPOUND_DYNAMIC_V1_PROFILE_ID, autoCompoundDynamicEnvelope, autoCompoundDynamicAdapter, autoCompoundDynamicRegistration, autoCompoundDynamicCreationCode),
   ]),
   provenance: Object.freeze({ sourceCommit: "e174ce695c7010f50ca9211b07b9f178c990beac", deploymentBlock: 82880546n }),
 });
@@ -375,7 +389,7 @@ export function getKnownLifecycleProfile(options: KnownLifecycleDeploymentIdenti
   return undefined;
 }
 
-/** Stable, frozen order: Abyss variants, fixed/dynamic V4, HMM, then UFG fixed/dynamic. */
+/** Stable, frozen order: Abyss, fixed/dynamic V4, HMM, UFG, then auto-compounding. */
 export function listKnownLifecycleProfiles(options: KnownLifecycleDeploymentIdentity): readonly LifecycleProfilePreset[] {
   return getKnownLifecycleDeployment(options)?.profiles ?? noProfiles;
 }

package/src/lifecycle/progress.ts

@@ -1,4 +1,4 @@
-import { concatHex, decodeFunctionData, encodeAbiParameters, encodeFunctionData, keccak256, stringToHex, toHex, zeroAddress, zeroHash, type Address, type Hash, type Hex } from "viem";
+import { concatHex, decodeFunctionData, encodeAbiParameters, encodeFunctionData, keccak256, stringToHex, toHex, zeroAddress, zeroHash, type Address, type Hex } from "viem";
 import { launchLifecycleAbi, lifecycleAdapterAbi, lifecycleDirectoryAbi, lifecycleErc20Abi, lifecycleOracleFactoryAbi, lifecycleRegistryAbi, poolFeeCollectorFactoryV1Abi, poolFeeCollectorFactoryConfigV6Abi, lifecycleV4HookAbi, lifecycleV4LockerAbi, poolHookDeployerV1Abi, poolHookDeployerConfigV6Abi, sharedHookDeployerV1Abi, fixedFeePoolHookV1Abi, fixedFeePoolHookConfigV6Abi, poolMarketAdapterV1Abi, sharedMarketAdapterV1Abi } from "./abi.js";
 import { buildPoolBoundHookParameters, decodePoolBoundV4LifecycleMarketConfig, encodePoolBoundHookParameters, hasLifecycleV4HookPermissions, isPoolBoundV4ConfigVersion, poolBoundHookInitCodeHash, predictPoolBoundHookAddress, validateV4LifecycleMarket, V4_LIFECYCLE_CONFIG_SCHEMA, V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA_V5, V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA_V6, type PoolBoundHookParameters, type PoolBoundLifecycleConfigVersion } from "./markets.js";
 import { hashLaunchIdentity, hashLaunchPlan, hashLaunchBounds, hashLaunchDependencies, hashLifecycleProfile, lifecycleTokenComponents, launchProgressV1Components, LifecycleMode, LifecyclePhase, LifecycleVenue, LIFECYCLE_REQUIRED_CAPABILITIES, LIFECYCLE_ERC404_CAPABILITY, LIFECYCLE_MULTI_POSITION_CAPABILITY, type AdapterRegistrationV1, type LaunchPlanV1, type LaunchProgressV1, type MarketIdentityV1, type MarketLiveStateV1, type PreparedMarketV1, type ProfileRegistrationV1, type ProfileTopologyV1, type LaunchEnvelopeV2, type LifecycleDeveloperTerms } from "./schema.js";
@@ -507,7 +507,12 @@ type ReceiptObservation = {
 
 async function readReceipt(reference: LifecycleReceiptReference, options: ReadLaunchProgressOptions, block: LifecycleBlock, readIdentityBlock: (number: bigint) => Promise<LifecycleBlock>): Promise<ReceiptObservation> {
   const effectiveHash = reference.replacementHash ?? reference.transactionHash;
-  const base = { transactionHash: reference.transactionHash, effectiveHash, replaced: reference.replacementHash !== undefined && reference.replacementHash.toLowerCase() !== reference.transactionHash.toLowerCase() };
+  const base: Pick<LifecycleReceiptStatus, "transactionHash" | "effectiveHash" | "replaced" | "nonce"> = {
+    transactionHash: reference.transactionHash, effectiveHash,
+    replaced: reference.replacementHash !== undefined && reference.replacementHash.toLowerCase() !== reference.transactionHash.toLowerCase(),
+    ...(reference.nonce === undefined ? {} : { nonce: reference.nonce }),
+  };
+  if (reference.nonce !== undefined && (typeof reference.nonce !== "bigint" || reference.nonce < 0n || reference.nonce >= 1n << 64n)) throw new LifecyclePlanningError("INVALID_RECEIPT_NONCE", "Observed submitted nonce must be a uint64 bigint");
   const pins: { number: bigint; hash: Hex }[] = [];
   const observedNumber = reference.observedBlockNumber, observedHash = reference.observedBlockHash;
   if (observedNumber !== undefined && observedHash !== undefined) pins.push({ number: observedNumber, hash: observedHash });
@@ -527,13 +532,20 @@ async function readReceipt(reference: LifecycleReceiptReference, options: ReadLa
       lifecycleRpc(options.client, "eth_getTransactionReceipt", [effectiveHash]),
       lifecycleRpc(options.client, "eth_getTransactionByHash", [effectiveHash]),
     ]);
+    const transaction = transactionValue === null ? undefined : rpcObject(transactionValue, "receipt transaction");
+    if (transaction !== undefined) {
+      if (rpcHex(transaction.from, "receipt transaction account").toLowerCase() !== options.planned.account.toLowerCase()) throw new LifecyclePlanningError("RECEIPT_ACCOUNT", "Submitted transaction belongs to a different account");
+      const nonce = rpcQuantity(transaction.nonce, "submitted transaction nonce");
+      if (reference.nonce !== undefined && nonce !== reference.nonce) throw new LifecyclePlanningError("RECEIPT_NONCE", "Submitted or replacement transaction differs from the retained nonce");
+      base.nonce = nonce;
+    }
     if (receiptValue === null) return finish({ ...base, status: "pending", blockNumber: observedNumber, blockHash: observedHash });
     if (transactionValue === null) throw new LifecyclePlanningError("INVALID_RPC_RESPONSE", "Receipt exists without its canonical transaction");
     const receipt = rpcObject(receiptValue, "receipt");
     const blockNumber = rpcQuantity(receipt.blockNumber, "receipt block number");
     const blockHash = rpcHex(receipt.blockHash, "receipt block hash");
     pins.push({ number: blockNumber, hash: blockHash });
-    const matches = await transactionMatchesLaunch(rpcObject(transactionValue, "receipt transaction"), options,
+    const matches = await transactionMatchesLaunch(transaction!, options,
       () => readIdentityBlock(blockNumber));
     const confirmations = block.number >= blockNumber ? block.number - blockNumber + 1n : 0n;
     const required = reference.confirmations ?? 1;
@@ -595,7 +607,7 @@ export async function readLaunchProgress(options: ReadLaunchProgressOptions, pin
   return result;
 }
 
-/** Build-next needs the state machine, receipts and nonce, not display-only live markets. */
+/** Build-next needs the state machine and receipts, not account nonce or display-only markets. */
 export async function readLifecycleExecutionProgress(options: ReadLaunchProgressOptions, block: LifecycleBlock): Promise<CanonicalLaunchProgress> {
   if (!assertLifecycleReadClientOpen(options.client)) throw new LifecyclePlanningError("INVALID_READ_CONTEXT", "Execution progress requires an invocation owner");
   return readLaunchProgressAtBlock(options, options.client, block, false);
@@ -622,13 +634,10 @@ async function readLaunchProgressAtBlock(options: ReadLaunchProgressOptions, cli
     if (hashUfgLaunchConfig(planned.ufg.config) !== planned.ufg.configHash) throw new LifecyclePlanningError("PLAN_MUTATED", "UFG config differs from its finalized commitment");
   } else if (planned.account.toLowerCase() !== planned.plan.creator.toLowerCase()) throw new LifecyclePlanningError("ACCOUNT_MISMATCH", "Execution account must be the committed creator/payer/refund account");
   if (hashLaunchPlan(planned.plan).toLowerCase() !== planned.planHash.toLowerCase() || hashLaunchIdentity(planned.plan).toLowerCase() !== planned.launchId.toLowerCase()) throw new LifecyclePlanningError("PLAN_MUTATED", "Stored economic plan no longer matches its commitment");
-  const [head, confirmedProgress, token, confirmedNonce, headNonce, pendingNonce] = await Promise.all([
+  const [head, confirmedProgress, token] = await Promise.all([
     readLifecycleHeadProgress(client, planned.plan, planned.account, block),
     confirmedNumber === block.number ? undefined : readLifecycleContract<LaunchProgressV1>(client, planned.plan.orchestrator, launchLifecycleAbi, "readLaunchProgress", [planned.launchId], confirmedBlock, planned.account),
     readLifecycleTokenAtBlock(client, planned.plan, block),
-    lifecycleRpc(client, "eth_getTransactionCount", [planned.account, toHex(confirmedBlock.number)]),
-    confirmedNumber === block.number ? undefined : lifecycleRpc(client, "eth_getTransactionCount", [planned.account, toHex(block.number)]),
-    lifecycleRpc(client, "eth_getTransactionCount", [planned.account, "pending"]),
   ]);
   assertActive();
   const canonical = confirmedProgress ?? head;
@@ -638,18 +647,8 @@ async function readLaunchProgressAtBlock(options: ReadLaunchProgressOptions, cli
     if (progress.mode !== (planned.mode === "atomic" ? LifecycleMode.Atomic : LifecycleMode.Staged)) throw new LifecyclePlanningError("MODE_MISMATCH", "Execution mode differs from the already recorded launch");
     if (progress.preparedMarkets > progress.marketCount || progress.phase === LifecyclePhase.Activating || (progress.phase === LifecyclePhase.Ready && progress.preparedMarkets !== progress.marketCount)) throw new LifecyclePlanningError("INVALID_PROGRESS", "Canonical progress violates the committed ordered state machine");
   }
-  if (planned.ufg !== undefined && head.phase !== LifecyclePhase.None) {
-    const [principal, configHash] = await Promise.all([
-      readLifecycleContract<Address>(client, UFG_LAUNCH_PROXY_ADDRESS, ufgLaunchProxyV1Abi, "principalOf", [planned.launchId], block),
-      readLifecycleContract<Hash>(client, UFG_LAUNCH_PROXY_ADDRESS, ufgLaunchProxyV1Abi, "launchConfigHash", [planned.launchId], block),
-    ]);
-    if (principal.toLowerCase() !== planned.account.toLowerCase() || configHash.toLowerCase() !== planned.ufg.configHash.toLowerCase()) throw new LifecyclePlanningError("PLAN_REPLAY", "UFG proxy principal or launch config differs from the stored launch");
-  }
-  const confirmedAccountNonce = rpcQuantity(confirmedNonce, "confirmed account nonce");
-  const headAccountNonce = headNonce === undefined ? confirmedAccountNonce : rpcQuantity(headNonce, "head account nonce");
-  const pendingAccountNonce = rpcQuantity(pendingNonce, "pending account nonce");
   const progressParameters = [{ type: "tuple", components: launchProgressV1Components }] as const;
-  const confirmationSafe = confirmedAccountNonce === headAccountNonce && pendingAccountNonce === headAccountNonce && keccak256(encodeAbiParameters(progressParameters, [canonical])) === keccak256(encodeAbiParameters(progressParameters, [head]));
+  const confirmationSafe = keccak256(encodeAbiParameters(progressParameters, [canonical])) === keccak256(encodeAbiParameters(progressParameters, [head]));
   const receipts = await readReceipts({ ...options, client }, block, confirmationDepth);
   assertActive();
   let markets: LifecycleMarketProgress[] = [];
@@ -676,5 +675,5 @@ async function readLaunchProgressAtBlock(options: ReadLaunchProgressOptions, cli
   }
   if (hashLaunchPlan(planned.plan).toLowerCase() !== planned.planHash.toLowerCase() || hashLaunchIdentity(planned.plan).toLowerCase() !== planned.launchId.toLowerCase()) throw new LifecyclePlanningError("PLAN_MUTATED", "Stored economic plan changed during asynchronous progress reads");
   assertActive();
-  return { canonical, head, confirmationDepth, confirmedBlockNumber: confirmedBlock.number, confirmedBlockHash: confirmedBlock.hash, confirmedAccountNonce, headAccountNonce, pendingAccountNonce, confirmationSafe, token, planHash: planned.planHash, launchId: planned.launchId, chainId, blockNumber: block.number, blockHash: block.hash, markets, receipts };
+  return { canonical, head, confirmationDepth, confirmedBlockNumber: confirmedBlock.number, confirmedBlockHash: confirmedBlock.hash, confirmationSafe, token, planHash: planned.planHash, launchId: planned.launchId, chainId, blockNumber: block.number, blockHash: block.hash, markets, receipts };
 }

package/src/lifecycle/rpc.ts

@@ -3,18 +3,27 @@ import { LifecyclePlanningError, type LifecycleBlock, type LifecycleDiagnosticEv
 import { lifecycleRegistryAbi } from "./abi.js";
 import type { ProfileTopologyV1 } from "./schema.js";
 import { robinhoodMainnet } from "../addresses.js";
+import { ROBINHOOD_NATIVE_TRANSACTION_GAS_LIMIT } from "./presets.js";
 
 // Reviewed chain4663 deployment, independently observed at block 98,136,655.
 const multicall3CodeHash = "0xd5c15df687b16f2ff992fc8d767b4216323184a2bbc6ee2f9c398c318e770891";
 const sessionObservations = new WeakMap<object, Map<string, Promise<unknown>>>();
+const clientChainIds = new WeakMap<LifecycleRpcClient, Promise<bigint>>();
+
+function rememberClientChainId(source: LifecycleRpcClient, request: Promise<unknown>): Promise<bigint> {
+  const pending = request.then((value) => rpcQuantity(value, "chain ID"));
+  clientChainIds.set(source, pending);
+  void pending.catch(() => { if (clientChainIds.get(source) === pending) clientChainIds.delete(source); });
+  return pending;
+}
 const canonicalWireValue = (_key: string, value: unknown): unknown => typeof value === "string" && value.startsWith("0x") ? value.toLowerCase() : value;
 type IndependentRead = { params: readonly unknown[]; resolve: (value: unknown) => void; reject: (failure: unknown) => void };
 
 const lifecycleReadConcurrency = 8;
 const diagnosticRpcMethods: Record<string, true> = {
   eth_chainId: true, eth_getBlockByNumber: true, eth_getBlockByHash: true, eth_getCode: true,
-  eth_getBalance: true, eth_call: true, eth_estimateGas: true, eth_gasPrice: true,
-  eth_simulateV1: true, eth_getTransactionCount: true, eth_getTransactionReceipt: true, eth_getTransactionByHash: true,
+  eth_getBalance: true, eth_call: true, eth_gasPrice: true,
+  eth_getTransactionReceipt: true, eth_getTransactionByHash: true,
 };
 
 type SessionReadGroup = {
@@ -61,7 +70,7 @@ class SessionLifecycleCache implements LifecycleSessionCache {
   }
 }
 
-/** Opt in per caller/session; there is no global or transport-owned lifecycle cache. */
+/** Opt-in pinned read reuse; client-bound identity/deployment facts are separate. */
 export function createLifecycleSessionCache(): LifecycleSessionCache {
   return new SessionLifecycleCache();
 }
@@ -153,7 +162,17 @@ class InvocationLifecycleClient implements LifecycleRpcClient {
 
   observeChainId(): Promise<bigint> {
     this.assertOpen();
-    return this.chainId ??= this.run("eth_chainId", []).then((value) => rpcQuantity(value, "chain ID"));
+    if (this.chainId === undefined) {
+      const observed = clientChainIds.get(this.source) ?? rememberClientChainId(this.source, this.run("eth_chainId", []));
+      this.chainId = this.session === undefined ? observed : observed.then((chainId) => {
+        if (!this.closed) {
+          this.observedChainId = chainId;
+          if (this.sessionGroup !== undefined) this.session!.observeChain(this.sessionGroup, chainId);
+        }
+        return chainId;
+      });
+    }
+    return this.chainId;
   }
 
   observeGasPrice(): Promise<unknown> {
@@ -373,16 +392,17 @@ export function lifecycleStaticRpc(client: LifecycleRpcClient, method: "eth_call
 export async function lifecycleRpc(client: LifecycleRpcClient, method: string, params: readonly unknown[] = []): Promise<unknown> {
   return client instanceof InvocationLifecycleClient ? client.run(method, params) : client.request({ method, params });
 }
-/** One invocation's observed identity; wallet submission owns its final chain check. */
+/** Client-bound identity, observed once per underlying client, never a freshness guard. */
 export function readLifecycleChainId(client: LifecycleRpcClient): Promise<bigint> {
-  return client instanceof InvocationLifecycleClient
-    ? client.observeChainId()
-    : lifecycleRpc(client, "eth_chainId").then((value) => rpcQuantity(value, "chain ID"));
+  if (client instanceof InvocationLifecycleClient) return client.observeChainId();
+  return clientChainIds.get(client) ?? rememberClientChainId(client, lifecycleRpc(client, "eth_chainId"));
 }
 
 /** A single operation-local recommendation, never a session or cross-head quote. */
-export function readLifecycleGasPrice(client: LifecycleRpcClient): Promise<unknown> {
-  return client instanceof InvocationLifecycleClient ? client.observeGasPrice() : lifecycleRpc(client, "eth_gasPrice");
+export function readLifecycleGasPrice(client: LifecycleRpcClient, block: LifecycleBlock, chainId: bigint): Promise<bigint> {
+  if (chainId === 4663n) return readNitroPrices(client, block).then((prices) => prices[5]);
+  return (client instanceof InvocationLifecycleClient ? client.observeGasPrice() : lifecycleRpc(client, "eth_gasPrice"))
+    .then((price) => rpcQuantity(price, "gas price"));
 }
 
 /** Only the reviewed immutable factory identity may use an invocation-wide key. */
@@ -390,7 +410,7 @@ export function readLifecycleImmutable<T>(client: LifecycleRpcClient, key: strin
   return (client instanceof InvocationLifecycleClient ? client.immutableRead(key, work) : work()) as Promise<T>;
 }
 
-/** Successful deployment/backend observations live for the caller's session, not one block. */
+/** Successful deployment observations live for the caller's session, not one block. */
 export function lifecycleSessionRead<T>(client: LifecycleRpcClient, key: string, work: () => Promise<T>): Promise<T> {
   const source = lifecycleSourceClient(client);
   const owner = source.sessionCache ?? source;
@@ -472,18 +492,10 @@ export async function readLifecycleBlock(client: LifecycleRpcClient, tag: Hex |
   if (client instanceof InvocationLifecycleClient) client.observeBlock(block, tag === "latest");
   return block;
 }
-export async function assertLifecycleBlock(client: LifecycleRpcClient, block: Pick<LifecycleBlock, "number" | "hash">, expectedChainId?: bigint): Promise<void> {
+export async function assertLifecycleBlock(client: LifecycleRpcClient, block: Pick<LifecycleBlock, "number" | "hash">): Promise<void> {
   if (client instanceof InvocationLifecycleClient) return;
-  const [chainId, current] = await Promise.all([
-    expectedChainId === undefined ? undefined : lifecycleRpc(client, "eth_chainId"),
-    readLifecycleBlock(client, toHex(block.number)),
-  ]);
-  if (expectedChainId !== undefined && rpcQuantity(chainId, "chain ID") !== expectedChainId) {
-    if (client instanceof InvocationLifecycleClient) client.invalidateSession();
-    throw new LifecyclePlanningError("CHAIN_MISMATCH", "Source RPC chain changed during the pinned operation");
-  }
+  const current = await readLifecycleBlock(client, toHex(block.number));
   if (current.hash.toLowerCase() !== block.hash.toLowerCase()) {
-    if (client instanceof InvocationLifecycleClient) client.invalidateSession();
     throw new LifecyclePlanningError("STATE_REORGED", "Pinned launch state changed during the operation; read canonical progress again");
   }
 }
@@ -512,31 +524,32 @@ export async function readLifecycleProfileTopology(client: LifecycleRpcClient, r
   if (topology.hookTopology !== 0 && topology.hookTopology !== 1 && topology.hookTopology !== 2) throw new LifecyclePlanningError("INVALID_RPC_RESPONSE", "Registry returned an unsupported hook topology");
   return { ...topology, hookTopology: topology.hookTopology };
 }
-export const nitroArbSys = "0x0000000000000000000000000000000000000064";
 export const nitroGasInfo = "0x000000000000000000000000000000000000006c";
-export const nitroNodeInterface = "0x00000000000000000000000000000000000000c8";
-export const nitroArbSysAbi = parseAbi(["function arbOSVersion() view returns (uint256)"]);
-export const nitroGasInfoAbi = parseAbi(["function getMaxTxGasLimit() view returns (uint256)", "function getMaxBlockGasLimit() view returns (uint64)"]);
-const nitroNodeInterfaceAbi = parseAbi(["function gasEstimateL1Component(address to, bool contractCreation, bytes data) payable returns (uint64 gasEstimateForL1, uint256 baseFee, uint256 l1BaseFeeEstimate)"]);
+export const nitroGasInfoAbi = parseAbi([
+  // Transaction ceilings are release preset metadata, not guard-only getter reads.
+  "function getPricesInWei() view returns (uint256,uint256,uint256,uint256,uint256,uint256)",
+]);
+export type LifecycleNitroPrices = readonly [bigint, bigint, bigint, bigint, bigint, bigint];
 const maxUint64 = (1n << 64n) - 1n;
 
-/** A poster quote is an envelope budget, never an execution/compute proof. */
-export async function readNitroPosterGas(transaction: LifecycleTransaction, context: LifecycleLimitContext): Promise<{ posterGas: bigint; baseFee: bigint; l1BaseFeeEstimate: bigint }> {
-  const data = encodeFunctionData({ abi: nitroNodeInterfaceAbi, functionName: "gasEstimateL1Component", args: [transaction.to, false, transaction.data] });
-  const result = rpcHex(await lifecycleStaticRpc(context.client, "eth_call", [{ from: transaction.from, to: nitroNodeInterface, data, value: toHex(transaction.value) }, toHex(context.block.number)], context.block), "Nitro poster estimate");
-  if (result.length !== 194) throw new LifecyclePlanningError("INVALID_RPC_RESPONSE", "Nitro poster estimate must contain exactly three ABI words");
-  const [posterGas, baseFee, l1BaseFeeEstimate] = decodeFunctionResult({ abi: nitroNodeInterfaceAbi, functionName: "gasEstimateL1Component", data: result });
-  if (posterGas < 0n || posterGas > maxUint64 || baseFee <= 0n || l1BaseFeeEstimate < 0n) throw new LifecyclePlanningError("INVALID_RPC_RESPONSE", "Nitro poster estimate has invalid gas or fee values");
-  return { posterGas, baseFee, l1BaseFeeEstimate };
+/** Seeded by the explicitly pinned planning aggregate. */
+export function readNitroPrices(client: LifecycleRpcClient, block: LifecycleBlock): Promise<LifecycleNitroPrices> {
+  return readLifecycleContract(client, nitroGasInfo, nitroGasInfoAbi, "getPricesInWei", [], block, undefined, true, true);
 }
 
-async function readNitroScalar(context: LifecycleLimitContext, to: Address, abi: Abi, functionName: string): Promise<bigint> {
-  const data = encodeFunctionData({ abi, functionName });
-  const result = rpcHex(await lifecycleIndependentRpc(context.client, [{ to, data }, toHex(context.block.number)], context.block, true), functionName);
-  if (result.length !== 66) throw new LifecyclePlanningError("INVALID_RPC_RESPONSE", `${functionName} must return exactly one ABI word`);
-  return decodeFunctionResult({ abi, functionName, data: result }) as bigint;
+/** EOA legacy/1559 serialization and Nitro's Brotli allocation bound, not a
+ * per-transaction oracle quote. Wallet-added access/auth lists and AA wrappers
+ * need their own wallet envelope; they are outside the direct-EOA profile. */
+export function nitroPosterGasBound(transaction: Pick<LifecycleTransaction, "data">, prices: LifecycleNitroPrices): { posterGas: bigint; feeBound: bigint } {
+  const serializedBytes = BigInt((transaction.data.length - 2) / 2) + 384n;
+  const compressedBytes = serializedBytes + 8n * (serializedBytes / 1024n) + 64n;
+  const feeBound = compressedBytes * prices[1];
+  if (feeBound === 0n) return { posterGas: 0n, feeBound };
+  if (prices[5] === 0n) throw new LifecyclePlanningError("NITRO_PRICES_UNAVAILABLE", "Positive poster fees cannot be converted at a zero L2 gas price");
+  return { posterGas: 2n * ((feeBound + prices[5] - 1n) / prices[5]), feeBound };
 }
 
+
 export type LifecycleLimitObservation = {
   limits: ResolvedLifecycleLimits;
   configuration: LifecycleLimits;
@@ -570,7 +583,7 @@ async function resolveLifecycleLimitsFresh(context: LifecycleLimitContext, sourc
   };
   const headroomBps = configuration.headroomBps === undefined ? 1500 : configuration.headroomBps;
   if (!Number.isSafeInteger(headroomBps) || headroomBps < 0 || headroomBps > 10000) throw new LifecyclePlanningError("INVALID_LIMITS", "Headroom must be between zero and 10000 basis points");
-  for (const limit of [context.block.gasLimit, configuration.chainGasLimit, configuration.rpcGasLimit, configuration.accountGasLimit, configuration.maxSimulationGas]) {
+  for (const limit of [context.block.gasLimit, configuration.chainGasLimit, configuration.rpcGasLimit, configuration.accountGasLimit]) {
     if (limit !== undefined && (typeof limit !== "bigint" || limit <= 0n || limit > maxUint64)) throw new LifecyclePlanningError("INVALID_LIMITS", "Gas caps must be positive exact uint64 bigint values");
   }
   if (configuration.maxCalldataBytes !== undefined && (!Number.isSafeInteger(configuration.maxCalldataBytes) || configuration.maxCalldataBytes <= 0)) throw new LifecyclePlanningError("INVALID_LIMITS", "Calldata cap must be a positive byte count");
@@ -583,46 +596,23 @@ 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 {
-      const [rawVersion, txComputeGas, blockComputeGas] = await Promise.all([
-        readNitroScalar(context, nitroArbSys, nitroArbSysAbi, "arbOSVersion"),
-        readNitroScalar(context, nitroGasInfo, nitroGasInfoAbi, "getMaxTxGasLimit"),
-        readNitroScalar(context, nitroGasInfo, nitroGasInfoAbi, "getMaxBlockGasLimit"),
-      ]);
-      // ArbSys alone adds 55 to the logical Nitro ArbOS version.
-      if (typeof rawVersion !== "bigint" || rawVersion < 105n) throw new Error("ArbOS version 50 or newer is required (ArbSys raw version >= 105)");
-      arbOSVersion = rawVersion - 55n;
-      maxTxComputeGas = txComputeGas;
-      maxBlockComputeGas = blockComputeGas;
-      if ([maxTxComputeGas, maxBlockComputeGas].some((limit) => typeof limit !== "bigint" || limit <= 0n || limit > maxUint64)) throw new Error("Nitro compute getters must be positive uint64 values");
-    } catch (failure) {
-      if (failure instanceof Error && failure.name === "AbortError") throw failure;
-      throw new LifecyclePlanningError("NITRO_LIMITS_UNAVAILABLE", `Pinned Nitro compute limits could not be established: ${lifecycleFailureReason(failure)}; header gasLimit is not a fallback`);
-    }
-    if (configuration.estimateDataFee !== undefined) throw new LifecyclePlanningError("INVALID_LIMITS", "Nitro poster fees are already included in gas; an external data-fee estimator would double-charge them");
-  }
+  if (protocol === "nitro" && configuration.estimateDataFee !== undefined) throw new LifecyclePlanningError("INVALID_LIMITS", "Nitro poster fees are already included in gas; an external data-fee estimator would double-charge them");
   const envelopeCaps = [configuration.chainGasLimit, configuration.rpcGasLimit, configuration.accountGasLimit].filter((limit): limit is bigint => limit !== undefined);
   if (protocol === "evm") envelopeCaps.push(context.block.gasLimit);
   const transactionGasCeiling = envelopeCaps.length === 0 ? undefined : envelopeCaps.reduce((minimum, limit) => limit < minimum ? limit : minimum);
-  const executionGasCeiling = maxTxComputeGas !== undefined && maxBlockComputeGas !== undefined
-    ? (maxTxComputeGas < maxBlockComputeGas ? maxTxComputeGas : maxBlockComputeGas)
-    : transactionGasCeiling ?? context.block.gasLimit;
+  const executionGasCeiling = protocol === "nitro" ? ROBINHOOD_NATIVE_TRANSACTION_GAS_LIMIT : transactionGasCeiling ?? context.block.gasLimit;
   const unknownExecutionConstraints = [
-    ...(protocol === "evm" && configuration.chainGasLimit === undefined ? ["Independent chain per-transaction execution cap is unknown; proof is bounded by the pinned header and validated backend"] : []),
+    ...(protocol === "evm" && configuration.chainGasLimit === undefined ? ["Independent chain per-transaction cap is unknown; the budget is bounded by the pinned header"] : []),
     ...(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"] : []),
-    ...(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,
+      protocol, executionGasCeiling, transactionGasCeiling, headroomBps,
+      maxCalldataBytes: configuration.maxCalldataBytes,
       blockGasLimit: context.block.gasLimit, chainGasLimit: configuration.chainGasLimit,
       rpcGasLimit: configuration.rpcGasLimit, accountGasLimit: configuration.accountGasLimit,
       unknownExecutionConstraints: Object.freeze(unknownExecutionConstraints),

package/src/lifecycle/snapshot.ts

@@ -5,7 +5,7 @@ import { getKnownLifecycleDeployment, type LifecycleDeploymentPreset } from "./p
 import { lifecycleTokenPredictionAbi } from "./progress.js";
 import { launchLensAbi, observeLifecycleLens, type LifecycleLensSnapshot } from "./lens.js";
 import { hashLaunchIdentity, LifecycleFundingKind, type LaunchPlanV1 } from "./schema.js";
-import { attestLifecycleMulticall, lifecycleRpc, nitroArbSys, nitroArbSysAbi, nitroGasInfo, nitroGasInfoAbi, readLifecycleBlock, readLifecycleChainId, rpcHex, seedLifecycleRead } from "./rpc.js";
+import { attestLifecycleMulticall, lifecycleRpc, nitroGasInfo, nitroGasInfoAbi, readLifecycleBlock, readLifecycleChainId, rpcHex, seedLifecycleRead } from "./rpc.js";
 import { LifecyclePlanningError, type LifecycleBlock, type LifecycleRpcClient } from "./types.js";
 import { UFG_LAUNCH_PROXY_ADDRESS } from "./ufg-config.js";
 
@@ -36,9 +36,7 @@ export async function readLifecyclePlanningBlock(client: LifecycleRpcClient, pla
       if (escrow !== undefined) add(asset, lifecycleErc20Abi, "allowance", [account, escrow]);
     }
   }
-  add(nitroArbSys, nitroArbSysAbi, "arbOSVersion", []);
-  add(nitroGasInfo, nitroGasInfoAbi, "getMaxTxGasLimit", []);
-  add(nitroGasInfo, nitroGasInfoAbi, "getMaxBlockGasLimit", []);
+  add(nitroGasInfo, nitroGasInfoAbi, "getPricesInWei", []);
   await attestLifecycleMulticall(client, block);
   const calls = reads.map((read) => ({ target: read.to, allowFailure: true, callData: encodeFunctionData({ abi: read.abi, functionName: read.functionName, args: read.args }) }));
   const data = encodeFunctionData({ abi: multicall3Abi, functionName: "aggregate3", args: [calls] });

package/src/lifecycle/transactions.ts

@@ -1,28 +1,59 @@
-import { encodeFunctionData } from "viem";
+import { encodeFunctionData, type Address } from "viem";
 import { launchLifecycleAbi } from "./abi.js";
 import { LifecycleFundingKind, LifecycleMode, type LaunchPlanV1 } from "./schema.js";
 import { LifecyclePlanningError, type BuildLaunchTransactionsOptions, type LifecycleTransaction } from "./types.js";
 import { assertLifecycleTokenAllocation } from "./allocations.js";
-import { HMM_V2_PREPARE_GAS, hmmV2ForwardingReserve } from "./presets.js";
+import { ufgLaunchProxyV1Abi } from "./ufg-abi.js";
+import { UFG_LAUNCH_PROXY_ADDRESS, isUfgProfile } from "./ufg-config.js";
+import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, isPoolBoundV4ConfigVersion } from "./markets.js";
 import { isHmmProfile } from "./hmm.js";
+import type { UfgLaunchConfig } from "./ufg-config.js";
 
-const OTHER_MARKET_PREPARE_GAS = 16_000_000n;
-const BEGIN_GAS = 9_500_000n;
-const ACTIVATE_MARKET_GAS = 6_000_000n;
+// Native9,723,187 Abyss3 (0x679d…e77), fork32-position10,900,786;
+// fork V4 fixed/dynamic8-position8,804,466; UFG9,896,176; native HMM8-position14,676,638 (0x459c…5b7).
+const preparationCosts = {
+  abyss: { market: 9_800_000n, position: 70_000n },
+  v4: { market: 9_000_000n, position: 40_000n },
+  ufg: { market: 10_000_000n, position: 70_000n },
+  hmm: { market: 15_000_000n, position: 50_000n },
+} as const;
+export const LIFECYCLE_CAPACITY_PADDING_BPS = 2500;
+/** Full single-market observations include call overhead. Add conservative full
+ * calldata/hash processing (16 intrinsic gas per nonzero byte plus8 for copying). */
+export function preparationCalldataGas(data: `0x${string}`): bigint { return 24n * BigInt((data.length - 2) / 2); }
 
 export function preparationGasEstimate(plan: LaunchPlanV1, first: number, count: number): bigint {
   let gas = 0n;
-  for (let index = first; index < first + count; index += 1) gas += isHmmProfile(plan.markets[index]!.profileId) ? HMM_V2_PREPARE_GAS : OTHER_MARKET_PREPARE_GAS;
+  for (let index = first; index < first + count; index += 1) {
+    const market = plan.markets[index]!;
+    const positions = market.configVersion === 1 ? decodeAbyssLifecycleMarketConfig(market.config).positions.length
+      : isPoolBoundV4ConfigVersion(market.configVersion) ? decodePoolBoundV4LifecycleMarketConfig(market.config, market.configVersion).positions.length
+      : decodeV4LifecycleMarketConfig(market.config).positions.length;
+    const cost = market.configVersion === 1 ? preparationCosts.abyss : isHmmProfile(market.profileId) ? preparationCosts.hmm
+      : isUfgProfile(market.profileId) ? preparationCosts.ufg : preparationCosts.v4;
+    gas += cost.market + cost.position * BigInt(positions - 1);
+  }
   return gas;
 }
 
-/** Contiguous cost packing preserves committed market order and recovery progress. */
-export function packPreparationBatches(plan: LaunchPlanV1, prepared: number, computeCap: bigint): number[] {
+/** Contiguous deterministic packing with compute headroom. The caller reserves
+ * poster allocation separately from computeCap; neither resizes transaction gas. */
+export function packPreparationBatches(plan: LaunchPlanV1, prepared: number, computeCap: bigint, headroomBps = 1500): number[] {
+  const data = buildLifecycleCommand(plan, { kind: "prepare", first: prepared, count: 1 }).data;
+  return packLifecyclePreparationBatches(plan, prepared, computeCap, headroomBps, preparationCalldataGas(data));
+}
+
+/** Internal path reuses the command already encoded for poster allocation. */
+export function packLifecyclePreparationBatches(plan: LaunchPlanV1, prepared: number, computeCap: bigint, headroomBps: number, calldataGas: bigint): number[] {
+  if (!Number.isSafeInteger(headroomBps) || headroomBps < 0 || headroomBps > 10000) throw new LifecyclePlanningError("INVALID_LIMITS", "Headroom must be between zero and10000 basis points");
+  const padding = BigInt(10000 + Math.max(LIFECYCLE_CAPACITY_PADDING_BPS, headroomBps));
+  const fits = (gas: bigint) => ((gas + calldataGas) * padding + 9999n) / 10000n <= computeCap;
   const batches = prepared > 0 ? [prepared] : [];
   let count = 0, gas = 0n;
   for (let index = prepared; index < plan.markets.length; index += 1) {
     const estimate = preparationGasEstimate(plan, index, 1);
-    if (count > 0 && gas + estimate > computeCap) { batches.push(count); count = 0; gas = 0n; }
+    if (!fits(estimate)) throw new LifecyclePlanningError("PREPARATION_GAS_LIMIT", "A market exceeds the preparation gas budget. Reduce its positions before launching.");
+    if (count > 0 && !fits(gas + estimate)) { batches.push(count); count = 0; gas = 0n; }
     count += 1;
     gas += estimate;
   }
@@ -30,42 +61,53 @@ export function packPreparationBatches(plan: LaunchPlanV1, prepared: number, com
   return batches;
 }
 
-/** Estimates select RPC proof coverage only; measurement and exact replay size gas. */
-export function transactionGasEstimate(plan: LaunchPlanV1, transaction: LifecycleTransaction): bigint {
-  switch (transaction.kind) {
-    case "begin": return BEGIN_GAS;
-    case "prepare": return preparationGasEstimate(plan, transaction.marketStart!, transaction.marketCount!);
-    case "activate": return ACTIVATE_MARKET_GAS * BigInt(plan.markets.length) + hmmV2ForwardingReserve(plan);
-    case "atomic": return BEGIN_GAS + preparationGasEstimate(plan, 0, plan.markets.length) + ACTIVATE_MARKET_GAS * BigInt(plan.markets.length) + hmmV2ForwardingReserve(plan);
-    default: return 100_000n;
+export type LifecycleCommand =
+  | { kind: "atomic" | "begin" | "activate" }
+  | { kind: "prepare"; first: number; count: number };
+type LifecycleUfgRoute = { account: Address; config: UfgLaunchConfig };
+
+/** Internal encoder shared by complete plans and the one-command continuation. */
+export function buildLifecycleCommand(plan: LaunchPlanV1, command: LifecycleCommand, ufg?: LifecycleUfgRoute): LifecycleTransaction {
+  const abi = ufg === undefined ? launchLifecycleAbi : ufgLaunchProxyV1Abi;
+  const base = { chainId: Number(plan.chainId), from: ufg?.account ?? plan.creator, to: ufg === undefined ? plan.orchestrator : UFG_LAUNCH_PROXY_ADDRESS };
+  const value = command.kind === "atomic" || command.kind === "begin"
+    ? plan.funding.reduce((total, funding) => total + (funding.kind === LifecycleFundingKind.NativeWrap || funding.kind === LifecycleFundingKind.Swap && BigInt(funding.inputAsset) === 0n ? funding.inputAmount : 0n), 0n) : 0n;
+  switch (command.kind) {
+    case "atomic": return { ...base, id: "atomic", kind: "atomic", data: encodeFunctionData({ abi, functionName: "launchAtomic", args: ufg === undefined ? [plan] : [plan, ufg.config] }), value, dependencies: [], postconditions: [{ kind: "launch", phase: "Active", preparedMarkets: plan.markets.length }] };
+    case "begin": return { ...base, id: "begin", kind: "begin", data: encodeFunctionData({ abi, functionName: "beginLaunch", args: ufg === undefined ? [plan, LifecycleMode.Staged] : [plan, LifecycleMode.Staged, ufg.config] }), value, dependencies: [], postconditions: [{ kind: "launch", phase: "Preparing", preparedMarkets: 0 }] };
+    case "activate": return { ...base, id: "activate", kind: "activate", data: encodeFunctionData({ abi, functionName: "activateLaunch", args: [plan] }), value, dependencies: [], postconditions: [{ kind: "launch", phase: "Active", preparedMarkets: plan.markets.length }] };
+    case "prepare": return { ...base, id: `prepare:${command.first}:${command.count}`, kind: "prepare", data: encodeFunctionData({ abi, functionName: "prepareMarkets", args: [plan, command.first, command.count] }), value, dependencies: [], marketStart: command.first, marketCount: command.count,
+      postconditions: [{ kind: "launch", phase: command.first + command.count === plan.markets.length ? "Ready" : "Preparing", preparedMarkets: command.first + command.count }] };
   }
 }
 
 /** Pure unsigned launch commands. Every command carries the complete commitment;
  * preparation splits only empty markets, never positions, buys or public opening.
- * Allowance discovery, recovery and execution proof belong to the planner. */
-export function buildLaunchTransactions({ plan, mode, preparationBatches }: BuildLaunchTransactionsOptions): LifecycleTransaction[] {
+ * Allowance discovery, recovery and gas-budget checks belong to the planner. */
+export function buildLifecycleCommands({ plan, mode, preparationBatches }: BuildLaunchTransactionsOptions, ufg?: LifecycleUfgRoute): LifecycleTransaction[] {
   if (mode !== "atomic" && mode !== "staged") throw new LifecyclePlanningError("EXPLICIT_MODE_REQUIRED", "Choose atomic or staged explicitly; staged is never silently substituted");
   if (plan.chainId <= 0n || plan.chainId > BigInt(Number.MAX_SAFE_INTEGER)) throw new LifecyclePlanningError("CHAIN_MISMATCH", "Chain ID must be a positive exact JavaScript integer");
   if (plan.markets.length === 0 || plan.markets.length > 16) throw new LifecyclePlanningError("INVALID_MARKET_COUNT", "A launch requires between one and sixteen markets");
   if (mode === "atomic" && preparationBatches !== undefined) throw new LifecyclePlanningError("INVALID_PREPARATION_BATCHES", "Atomic execution has no separate preparation batches");
   assertLifecycleTokenAllocation(plan);
-  const nativeValue = plan.funding.reduce((total, funding) => total + (funding.kind === LifecycleFundingKind.NativeWrap || funding.kind === LifecycleFundingKind.Swap && BigInt(funding.inputAsset) === 0n ? funding.inputAmount : 0n), 0n);
-  const base = { chainId: Number(plan.chainId), from: plan.creator, to: plan.orchestrator };
   const transactions: LifecycleTransaction[] = [];
   if (mode === "atomic") {
-    transactions.push({ ...base, id: "atomic", kind: "atomic", data: encodeFunctionData({ abi: launchLifecycleAbi, functionName: "launchAtomic", args: [plan] }), value: nativeValue, dependencies: [], postconditions: [{ kind: "launch", phase: "Active", preparedMarkets: plan.markets.length }] });
+    transactions.push(buildLifecycleCommand(plan, { kind: "atomic" }, ufg));
   } else {
     const batches = preparationBatches ?? [plan.markets.length];
     if (batches.length === 0 || batches.some((count) => !Number.isSafeInteger(count) || count <= 0) || batches.reduce((total, count) => total + count, 0) !== plan.markets.length) throw new LifecyclePlanningError("INVALID_PREPARATION_BATCHES", "Positive ordered preparation counts must cover every market exactly");
-    transactions.push({ ...base, id: "begin", kind: "begin", data: encodeFunctionData({ abi: launchLifecycleAbi, functionName: "beginLaunch", args: [plan, LifecycleMode.Staged] }), value: nativeValue, dependencies: [], postconditions: [{ kind: "launch", phase: "Preparing", preparedMarkets: 0 }] });
+    transactions.push(buildLifecycleCommand(plan, { kind: "begin" }, ufg));
     let first = 0;
     for (const count of batches) {
-      const completed = first + count;
-      transactions.push({ ...base, id: `prepare:${first}:${count}`, kind: "prepare", data: encodeFunctionData({ abi: launchLifecycleAbi, functionName: "prepareMarkets", args: [plan, first, count] }), value: 0n, dependencies: [], marketStart: first, marketCount: count, postconditions: [{ kind: "launch", phase: completed === plan.markets.length ? "Ready" : "Preparing", preparedMarkets: completed }] });
-      first = completed;
+      transactions.push(buildLifecycleCommand(plan, { kind: "prepare", first, count }, ufg));
+      first += count;
     }
-    transactions.push({ ...base, id: "activate", kind: "activate", data: encodeFunctionData({ abi: launchLifecycleAbi, functionName: "activateLaunch", args: [plan] }), value: 0n, dependencies: [], postconditions: [{ kind: "launch", phase: "Active", preparedMarkets: plan.markets.length }] });
+    transactions.push(buildLifecycleCommand(plan, { kind: "activate" }, ufg));
   }
   return transactions.map((transaction, index) => ({ ...transaction, calldataBytes: (transaction.data.length - 2) / 2, dependencies: index === 0 ? [] : [transactions[index - 1]!.id] }));
 }
+
+/** Pure unsigned core commands, with no account nonce assigned by the SDK. */
+export function buildLaunchTransactions(options: BuildLaunchTransactionsOptions): LifecycleTransaction[] {
+  return buildLifecycleCommands(options);
+}