@black-market/sdk 0.15.0 → 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,6 +35,8 @@ 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);
@@ -351,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 }),
 });
@@ -380,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/rpc.ts

@@ -22,8 +22,8 @@ type IndependentRead = { params: readonly unknown[]; resolve: (value: unknown) =
 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 = {
@@ -70,7 +70,7 @@ class SessionLifecycleCache implements LifecycleSessionCache {
   }
 }
 
-/** Opt-in pinned read reuse; client-bound identity/capability facts are separate. */
+/** Opt-in pinned read reuse; client-bound identity/deployment facts are separate. */
 export function createLifecycleSessionCache(): LifecycleSessionCache {
   return new SessionLifecycleCache();
 }
@@ -410,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;
@@ -524,9 +524,7 @@ 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 nitroArbSysAbi = parseAbi(["function arbOSVersion() view returns (uint256)"]);
 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)",
@@ -534,7 +532,7 @@ export const nitroGasInfoAbi = parseAbi([
 export type LifecycleNitroPrices = readonly [bigint, bigint, bigint, bigint, bigint, bigint];
 const maxUint64 = (1n << 64n) - 1n;
 
-/** Seeded by the planning aggregate; standalone simulation batches this with limits. */
+/** 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);
 }
@@ -551,12 +549,6 @@ export function nitroPosterGasBound(transaction: Pick<LifecycleTransaction, "dat
   return { posterGas: 2n * ((feeBound + prices[5] - 1n) / prices[5]), feeBound };
 }
 
-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;
-}
 
 export type LifecycleLimitObservation = {
   limits: ResolvedLifecycleLimits;
@@ -591,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");
@@ -604,37 +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;
-  let arbOSVersion: bigint | undefined;
-  if (protocol === "nitro") {
-    try {
-      const rawVersion = await readNitroScalar(context, nitroArbSys, nitroArbSysAbi, "arbOSVersion");
-      // 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;
-    } catch (failure) {
-      if (failure instanceof Error && failure.name === "AbortError") throw failure;
-      throw new LifecyclePlanningError("NITRO_LIMITS_UNAVAILABLE", `Pinned Nitro version could not be established: ${lifecycleFailureReason(failure)}`);
-    }
-    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 = 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, 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,7 +36,6 @@ export async function readLifecyclePlanningBlock(client: LifecycleRpcClient, pla
       if (escrow !== undefined) add(asset, lifecycleErc20Abi, "allowance", [account, escrow]);
     }
   }
-  add(nitroArbSys, nitroArbSysAbi, "arbOSVersion", []);
   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 }) }));

package/src/lifecycle/transactions.ts

@@ -3,27 +3,57 @@ 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 } from "./presets.js";
-import { isHmmProfile } from "./hmm.js";
 import { ufgLaunchProxyV1Abi } from "./ufg-abi.js";
-import { UFG_LAUNCH_PROXY_ADDRESS } from "./ufg-config.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;
+// 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;
   }
@@ -53,7 +83,7 @@ export function buildLifecycleCommand(plan: LaunchPlanV1, command: LifecycleComm
 
 /** 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. */
+ * 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");

package/src/lifecycle/types.ts

@@ -5,13 +5,10 @@ import type {
   MarketLiveStateV1, PreparedMarketV1, ProfileRegistrationV1, ProfileTopologyV1, LaunchEnvelopeV2, LifecycleDeveloperTerms,
 } from "./schema.js";
 
-/** Local opt-in timing only: never contains request arguments, addresses, results or errors.
- * Since 0.14.0, removed replay/envelope stages are represented by simulation.measure,
- * which includes the final validated execution at the returned gas envelope. */
+/** Local opt-in timing only: never contains request arguments, addresses, results or errors. */
 export type LifecycleDiagnosticStage =
   | "plan" | "plan.context" | "plan.domain" | "plan.progress" | "plan.inputs" | "rpc"
-  | "profile.certification" | "simulation.context" | "simulation.nitro"
-  | "simulation.poster" | "simulation.measure" | "session-cache";
+  | "profile.certification" | "session-cache";
 export type LifecycleDiagnosticEvent = {
   stage: LifecycleDiagnosticStage;
   phase: "queued" | "start" | "success" | "failure" | "reuse";
@@ -31,13 +28,13 @@ export type LifecycleRpcClient = {
   request(args: { method: string; params?: readonly unknown[] }): Promise<unknown>;
   /** Opt in to bounded parallel reads only when the supplied transport batches concurrent requests. */
   supportsReadBatching?: boolean;
-  /** Optional local observer. Listener failures cannot change execution or admission. */
+  /** Optional local observer. Listener failures cannot change planning or sending. */
   onDiagnostic?: LifecycleDiagnosticListener;
   /** Caller-owned, opt-in static observations; create with createLifecycleSessionCache(). */
   sessionCache?: LifecycleSessionCache;
 };
 export type LifecycleBlock = { number: bigint; hash: Hash; timestamp: bigint; gasLimit: bigint; baseFeePerGas?: bigint };
-/** A session retains pinned static reads and deployment/backend capability observations. */
+/** A session retains pinned static reads and deployment metadata observations. */
 export type LifecycleSessionCache = {
   readonly block: Readonly<Pick<LifecycleBlock, "number" | "hash">> | undefined;
   /** Call on wallet/chain changes and after every confirmed transaction. */
@@ -48,8 +45,6 @@ export type LifecycleLimits = {
   /** Optional tightening caps on the complete transaction gas envelope, including Nitro poster gas. */
   headroomBps?: number; chainGasLimit?: bigint; rpcGasLimit?: bigint; accountGasLimit?: bigint;
   maxCalldataBytes?: number;
-  /** Optional aggregate gas-used policy ceiling for one simulation request; no SDK-invented default window. */
-  maxSimulationGas?: bigint;
   chainId?: bigint; orchestrator?: Address; account?: Address; observedBlockNumber?: bigint; observedBlockHash?: Hash;
   /** External data fee not already charged in gas, called with exact calldata and the pinned block.
    * Nitro poster fees are already included in gas, bounded locally from same-review ArbGasInfo prices. */
@@ -59,18 +54,10 @@ export type LifecycleLimitSource = LifecycleLimits | ((context: LifecycleLimitCo
 export type ResolvedLifecycleLimits = {
   /** Fixed native transaction ceiling, including poster gas; caller caps may refuse but never resize it. */
   executionGasCeiling: bigint; transactionGasCeiling?: bigint; protocol: "evm" | "nitro";
-  arbOSVersion?: bigint;
-  headroomBps: number; maxCalldataBytes?: number; maxSimulationGas?: bigint;
+  headroomBps: number; maxCalldataBytes?: number;
   blockGasLimit: bigint; chainGasLimit?: bigint; rpcGasLimit?: bigint; accountGasLimit?: bigint;
   unknownExecutionConstraints: readonly string[]; unknownConstraints: readonly string[];
 };
-/** Only explicitly disposable RPCs may execute snapshot-isolated simulation transactions. */
-export type ControlledLifecycleFork = {
-  client: LifecycleRpcClient; isolation: "disposable"; allowTransactions: true;
-  expectedChainId?: bigint; expectedBlockHash?: Hash; impersonation?: "anvil" | "hardhat" | "none";
-  receiptTimeoutMs?: number;
-  sourceRpcUrl: string; forkRpcUrl: string; resetMethod?: "anvil_reset" | "hardhat_reset";
-};
 export type LifecycleTransactionKind = "approve-reset" | "approve" | "atomic" | "begin" | "prepare" | "activate" | "cancel";
 export type LifecyclePostcondition =
   | { kind: "allowance"; asset: Address; spender: Address; minimum: bigint; exact?: bigint }
@@ -81,70 +68,42 @@ export type LifecycleTransaction = {
   marketStart?: number; marketCount?: number; gas?: bigint; gasPrice?: bigint;
   /** Exact encoded byte count; populated on SDK-built commands, including approvals. */
   calldataBytes?: number;
-  /** Only the immediate command receives its current fee and admission.
-   * Executable launch gas is the native ceiling; approvals leave gas to the wallet. */
-  admission?: LifecycleAdmission;
+  /** Only the immediate command receives current planning checks and fees.
+   * Launch gas is the native ceiling; approvals leave gas to the wallet. */
+  assessment?: LifecyclePlanningAssessment;
   estimate?: LifecycleTransactionEstimate;
 };
 export type LifecycleTransactionEstimate = {
-  /** Present only for measured execution; a ceiling budget never fabricates gas usage. */
-  gasUsed?: bigint; gasLimit: bigint; gasPrice: bigint; executionFee: bigint; dataFee?: bigint; totalFee?: bigint;
-  /** Estimated poster allocation within gasLimit, never an exact compute measurement or an extra fee. */
+  gasLimit: bigint; gasPrice: bigint; executionFee: bigint; dataFee?: bigint; totalFee?: bigint;
+  /** Estimated poster allocation within gasLimit, never a measured or additional fee. */
   posterGas?: bigint; posterFee?: bigint; dataFeeIncludedInGas: boolean;
-  feeConfidence: "execution-and-data" | "execution-only" | "native-ceiling-and-data";
-};
-/** Proof scopes are independent: current execution is not guaranteed wallet submission. */
-export type LifecycleProofOutcomes = {
-  executionProof: "proved" | "failed" | "unavailable" | "not-run";
-  protocolFit: "proved" | "failed" | "unknown" | "profiled";
-};
-export type LifecycleAdmission = LifecycleProofOutcomes & {
-  admitted: boolean; confidence: "stateful" | "provisional" | "profiled";
-  blockNumber: bigint; blockHash: Hash; account: Address; chainId: bigint;
-  reason?: string; limits: ResolvedLifecycleLimits;
-};
-export type LifecycleFailureCategory = "semantic" | "capacity" | "opaque" | "source" | "postcondition" | "affordability";
-export type LifecycleCapacityConstraint = "compute" | "gas-envelope" | "calldata" | "simulation-gas" | "activation";
-export type LifecycleSimulationStep = {
-  transactionId: string; success: boolean; gasUsed?: bigint; gasLimit?: bigint; gasRequired?: bigint;
-  returnData?: Hex; error?: string; estimate?: LifecycleTransactionEstimate;
-  /** Suffix proof is historical and provisional; only a fresh build admits
-   * its immediate transaction, still at the native ceiling and current fee. */
-  provisional?: boolean;
-  failureCategory?: LifecycleFailureCategory; decodedError?: string;
-  /** Safe failed-call facts only; native messages and error-data bytes are never copied here. */
-  nativeErrorCode?: number;
-  nativeErrorKind?: "out-of-gas" | "execution-reverted" | "vm-error" | "other" | "missing";
-  nativeErrorDataBytes?: number;
-  /** Explicit native simulator report, not inferred from gas consumption or the requested limit. */
-  nativeGasCapped?: boolean;
+  feeConfidence: "native-ceiling-and-data" | "native-ceiling-only";
 };
+export type LifecycleFailureCategory = "semantic" | "capacity" | "affordability";
+export type LifecycleCapacityConstraint = "gas-envelope" | "calldata" | "activation" | "preparation";
 export type LifecycleOpeningBuyQuote = {
   buyIndex: number; marketIndex: number; quoteAmountIn: bigint; quoteSpent: bigint;
   tokenOut: bigint; sqrtPriceAfterX96: bigint;
 };
-/** Conservative compute bounds used for mode/capacity decisions, never gas-limit sizing.
- * An upper bound above the ceiling is uncertain, not proof of impossibility. */
+/** Versioned compute budgets with headroom, never transaction gas-limit sizing.
+ * Atomic budget is absent when conversion work is outside the template model. */
 export type LifecycleLaunchGasBounds = {
-  atomicComputeGasUpperBound: bigint; activationComputeGasUpperBound: bigint;
+  atomicComputeGasUpperBound?: bigint; activationComputeGasUpperBound: bigint;
 };
-export type LifecycleGasProfileEvidence = {
+export type LifecycleGasProfile = {
   version: string; bounds: LifecycleLaunchGasBounds;
   initialBuys: readonly LifecycleOpeningBuyQuote[];
 };
-export type LifecycleSimulation = LifecycleProofOutcomes & {
-  backend: "eth_simulateV1" | "controlled-fork" | "unavailable" | "profiled";
-  /** Stateful execution or versioned profile coverage; only the immediate envelope is final. */
-  confidence: "stateful" | "provisional" | "profiled"; admitted: boolean;
+/** Pinned input and gas-budget checks only. No transaction is simulated or proved. */
+export type LifecyclePlanningAssessment = {
+  ready: boolean;
   blockNumber: bigint; blockHash: Hash; account: Address; chainId: bigint;
-  steps: readonly LifecycleSimulationStep[]; limits: ResolvedLifecycleLimits;
-  /** Immediate fixed-ceiling fee budget; absent for wallet-prepared approvals. */
+  limits: ResolvedLifecycleLimits;
+  /** Immediate native-ceiling fee budget; absent for wallet-prepared approvals. */
   estimate?: LifecycleTransactionEstimate;
-  gasProfile?: LifecycleGasProfileEvidence;
-  /** Work outside the returned admission, including an RPC-cap failed suffix. */
-  deferredTransactionIds: readonly string[];
-  reason?: string; failedTransactionId?: string;
-  /** A payer must reserve the native ceiling up front even if actual gas usage is lower. */
+  gasProfile?: LifecycleGasProfile;
+  /** Controlled SDK code and user-safe actionable reason, never raw provider errors. */
+  code?: string; reason?: string; failedTransactionId?: string;
   failureCategory?: LifecycleFailureCategory; capacityConstraint?: LifecycleCapacityConstraint;
 };
 export type LifecycleFundingPrerequisite = {
@@ -190,24 +149,24 @@ export type PlannedLaunch = {
   account: Address; chainId: bigint; mode: LaunchExecutionMode; confirmations: number;
   /** Opt-in proxy routing; the committed creator remains the proxy, account is its principal. */
   ufg?: { config: UfgLaunchConfig; configHash: Hash };
-  /** Only transactions[0] has fresh immediate admission/fees. Launch gas is fixed
-   * at the native ceiling; wallet-assigned nonce and approval gas are omitted. */
+  /** Only transactions[0] has fresh immediate planning checks/fees. Launch gas is
+   * the native ceiling; wallet-assigned nonce and approval gas are omitted. */
   transactions: readonly LifecycleTransaction[]; prerequisites: readonly LifecycleFundingPrerequisite[];
   /** Sum of exact calldata bytes across the returned remaining commands, including approvals. */
   totalCalldataBytes: number;
-  profiles: readonly (LifecycleProfile | LifecycleConstructionProfile)[]; simulation: LifecycleSimulation;
+  profiles: readonly (LifecycleProfile | LifecycleConstructionProfile)[]; assessment: LifecyclePlanningAssessment;
   /** Exact CREATE2 metadata captured from the final committed bound markets. */
   hookDeployments: readonly LifecyclePoolBoundHookDeployment[];
   progress: CanonicalLaunchProgress;
   limits?: LifecycleLimitSource;
-  /** Unstarted-launch admission choices only; never part of the committed plan or calldata. */
+  /** Unstarted-launch construction choices; never part of committed calldata. */
   allowTopologyGaps?: boolean; allowMissingPermanentTail?: boolean;
 };
 export type PlanLaunchOptions = {
   client: LifecycleRpcClient; account: Address; plan: LaunchPlanV1;
-  /** Atomic is a preference: conservative capacity may select staged before begin.
-   * Explicit staged and an already-started launch's recorded mode are retained. */
-  mode: LaunchExecutionMode; limits?: LifecycleLimitSource; fork?: ControlledLifecycleFork; receipts?: readonly LifecycleReceiptReference[];
+  /** Atomic requires one market, no conversion and a known budget fitting with headroom.
+   * All other unstarted launches are staged; started launches retain canonical mode. */
+  mode: LaunchExecutionMode; limits?: LifecycleLimitSource; receipts?: readonly LifecycleReceiptReference[];
   confirmations?: number; signal?: AbortSignal;
   /** Opt in to the pinned UFG proxy; sender must match the nonce's principal namespace. */
   ufg?: { config: UfgLaunchConfig };
@@ -218,8 +177,8 @@ export type PlanLaunchOptions = {
 };
 export type PrepareAndPlanLifecycleLaunchOptions = PlanLaunchOptions & {
   onProgress?: (progress: PoolBoundLifecyclePreparationProgress) => void;
-  /** Protect ordered buys from exact local curve outputs or native diagnostics,
-   * rounded down. Omitted preserves committed minima; unstarted launches only. */
+  /** Protect ordered buys from exact local curve outputs, rounded down.
+   * Omitted preserves committed minima; unstarted launches only. */
   buySlippageBps?: number;
 };
 export type BuildLaunchTransactionsOptions = {
@@ -227,29 +186,21 @@ export type BuildLaunchTransactionsOptions = {
   /** Positive ordered preparation counts covering every market exactly. Staged only. */
   preparationBatches?: readonly number[];
 };
-export type SimulateLaunchPlanOptions = {
-  client: LifecycleRpcClient; planned: PlannedLaunch; limits?: LifecycleLimitSource; fork?: ControlledLifecycleFork;
-  /** Submitted receipt evidence and confirmation depth are inherited from the
-   * stored plan when omitted, exactly as build-next consumes them; resimulation
-   * never silently drops submitted-transaction context. */
-  receipts?: readonly LifecycleReceiptReference[]; confirmations?: number;
-  signal?: AbortSignal;
-};
 export type ReadLaunchProgressOptions = {
   client: LifecycleRpcClient; planned: Pick<PlannedLaunch, "plan" | "planHash" | "launchId" | "predictedToken" | "account" | "mode" | "confirmations" | "ufg">;
   receipts?: readonly LifecycleReceiptReference[]; confirmations?: number;
   signal?: AbortSignal;
 };
 export type BuildNextTransactionOptions = ReadLaunchProgressOptions & {
-  planned: PlannedLaunch; action?: "continue" | "cancel"; limits?: LifecycleLimitSource; fork?: ControlledLifecycleFork;
+  planned: PlannedLaunch; action?: "continue" | "cancel"; limits?: LifecycleLimitSource;
   /** Untrusted reviewed intent/fee. Gas differing from the native ceiling is stale;
    * never resize it, bump a held fee or assign a wallet nonce. */
   reviewedTransaction?: LifecycleTransaction;
 };
 export class LifecyclePlanningError extends Error {
   readonly code: string;
-  readonly simulation?: LifecycleSimulation;
-  constructor(code: string, message: string, simulation?: LifecycleSimulation) {
-    super(message); this.name = "LifecyclePlanningError"; this.code = code; this.simulation = simulation;
+  readonly assessment?: LifecyclePlanningAssessment;
+  constructor(code: string, message: string, assessment?: LifecyclePlanningAssessment) {
+    super(message); this.name = "LifecyclePlanningError"; this.code = code; this.assessment = assessment;
   }
 }

package/src/lifecycle/ufg.ts

@@ -10,7 +10,7 @@ import { buildUfgFeeAssetPolicies, encodeUfgLaunchConfig, hashUfgLaunchConfig, i
 
 export { UFG_LAUNCH_PROXY_ADDRESS, UFG_TREASURY_FACTORY_ADDRESS, UFG_UPSTREAM_FACTORY_ADDRESS, UFG_ORCHESTRATOR_ADDRESS, UFG_FIXED_PROFILE_ID, UFG_DYNAMIC_PROFILE_ID, UFG_FIXED_ADAPTER_ID, UFG_DYNAMIC_ADAPTER_ID, isUfgProfile, ufgLaunchConfigComponents, encodeUfgLaunchConfig, decodeUfgLaunchConfig, hashUfgLaunchConfig, validateUfgLaunchConfig, ufgLaunchNonce, buildUfgFeeAssetPolicies, type UfgLaunchConfig } from "./ufg-config.js";
 
-/** Offline proxy-specific admission. Live token/reserve code, registry and transfer checks still require simulation. */
+/** Offline proxy-specific intent checks. Registry, transfers and reserve behavior are enforced on-chain. */
 export function validateUfgLaunchPlan(plan: LaunchPlanV1, config: UfgLaunchConfig, predictedToken: Address): void {
   try {
     ufgPlanPrincipal(plan);

package/dist/lifecycle/fork.d.ts

@@ -1,15 +0,0 @@
-import { type ControlledLifecycleFork } from "./types.js";
-/**
- * Connects an explicitly disposable loopback fork. Only the fork receives resets/transactions;
- * sourceRpcUrl is used by the fork node for read-only canonical state synchronization.
- */
-export declare function createControlledLifecycleFork(options: {
-    sourceRpcUrl: string;
-    forkRpcUrl: string;
-    allowTransactions: true;
-    fetch?: typeof globalThis.fetch;
-    impersonation?: "anvil" | "hardhat" | "none";
-    resetMethod?: "anvil_reset" | "hardhat_reset";
-    receiptTimeoutMs?: number;
-}): ControlledLifecycleFork;
-//# sourceMappingURL=fork.d.ts.map

package/dist/lifecycle/fork.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../../src/lifecycle/fork.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,uBAAuB,EAA2B,MAAM,YAAY,CAAC;AAG3G;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE;IACrD,YAAY,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,IAAI,CAAC;IAClE,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IAC9E,WAAW,CAAC,EAAE,aAAa,GAAG,eAAe,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC1E,GAAG,uBAAuB,CAwB1B"}

package/dist/lifecycle/fork.js

@@ -1,36 +0,0 @@
-import { LifecyclePlanningError } from "./types.js";
-import { rpcObject } from "./rpc.js";
-/**
- * Connects an explicitly disposable loopback fork. Only the fork receives resets/transactions;
- * sourceRpcUrl is used by the fork node for read-only canonical state synchronization.
- */
-export function createControlledLifecycleFork(options) {
-    const source = new URL(options.sourceRpcUrl);
-    const fork = new URL(options.forkRpcUrl);
-    if (!["http:", "https:"].includes(source.protocol) || !["http:", "https:"].includes(fork.protocol))
-        throw new LifecyclePlanningError("UNSAFE_FORK", "Controlled fork RPCs must use HTTP(S)");
-    const loopback = ["localhost", "127.0.0.1", "[::1]", "::1"];
-    const sourcePort = source.port || (source.protocol === "https:" ? "443" : "80");
-    const forkPort = fork.port || (fork.protocol === "https:" ? "443" : "80");
-    if (!loopback.includes(fork.hostname) || (loopback.includes(source.hostname) && sourcePort === forkPort) || source.href === fork.href || options.allowTransactions !== true)
-        throw new LifecyclePlanningError("UNSAFE_FORK", "Controlled fork must be an explicit, distinct disposable loopback RPC, not a localhost/IP alias of the source");
-    const fetch = options.fetch ?? globalThis.fetch;
-    let id = 0;
-    const client = {
-        async request({ method, params }) {
-            const response = await fetch(fork.href, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: ++id, method, params: params ?? [] }) });
-            if (!response.ok)
-                throw new LifecyclePlanningError("FORK_RPC_ERROR", `Disposable fork RPC returned HTTP ${response.status}`);
-            const result = rpcObject(await response.json(), "fork JSON-RPC envelope");
-            if (result.error !== undefined) {
-                const error = rpcObject(result.error, "fork JSON-RPC error");
-                throw new LifecyclePlanningError("FORK_RPC_ERROR", typeof error.message === "string" ? error.message : "Disposable fork RPC returned an error");
-            }
-            if (!("result" in result))
-                throw new LifecyclePlanningError("INVALID_RPC_RESPONSE", "Disposable fork RPC omitted its result");
-            return result.result;
-        },
-    };
-    return { client, isolation: "disposable", allowTransactions: true, sourceRpcUrl: source.href, forkRpcUrl: fork.href, resetMethod: options.resetMethod ?? "anvil_reset", impersonation: options.impersonation ?? "anvil", receiptTimeoutMs: options.receiptTimeoutMs };
-}
-//# sourceMappingURL=fork.js.map

package/dist/lifecycle/fork.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fork.js","sourceRoot":"","sources":["../../src/lifecycle/fork.ts"],"names":[],"mappings":"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"}

package/dist/lifecycle/simulation.d.ts

@@ -1,17 +0,0 @@
-import { type LifecycleBlock, type LifecycleSimulation, type LifecycleTransaction, type SimulateLaunchPlanOptions } from "./types.js";
-/** Internal, operation-local fee envelope for the already matched immediate step. */
-export type NextTransactionEnvelope = Readonly<{
-    gas: bigint;
-    gasPrice: bigint;
-}>;
-export type PreparedLaunchSimulation = ((transactions: readonly LifecycleTransaction[], nextEnvelope?: NextTransactionEnvelope) => Promise<LifecycleSimulation>) & {
-    /** Unadmitted diagnostic results only; final measurement validates exact calldata. */
-    measure(transactions: readonly LifecycleTransaction[]): Promise<LifecycleSimulation>;
-    close(): void;
-};
-export declare function observedFields<T extends object>(value: T): () => boolean;
-/** Internal continuation owned by one SDK read invocation. Only its positive
- * capability proof is reused; every candidate executes its entire economic sequence. */
-export declare function prepareLaunchSimulation(options: SimulateLaunchPlanOptions, block: LifecycleBlock, hasTransactions?: boolean, immediate?: boolean): PreparedLaunchSimulation;
-export declare function simulateLaunchTransactions(options: SimulateLaunchPlanOptions, transactions: readonly LifecycleTransaction[], pinnedBlock?: LifecycleBlock, nextEnvelope?: NextTransactionEnvelope): Promise<LifecycleSimulation>;
-//# sourceMappingURL=simulation.d.ts.map

package/dist/lifecycle/simulation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulation.d.ts","sourceRoot":"","sources":["../../src/lifecycle/simulation.ts"],"names":[],"mappings":"AAIA,OAAO,EAAwD,KAAK,cAAc,EAAoF,KAAK,mBAAmB,EAAgC,KAAK,oBAAoB,EAAoD,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAoS9V,qFAAqF;AACrF,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAClF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,YAAY,EAAE,SAAS,oBAAoB,EAAE,EAAE,YAAY,CAAC,EAAE,uBAAuB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC,GAAG;IACjK,sFAAsF;IACtF,OAAO,CAAC,YAAY,EAAE,SAAS,oBAAoB,EAAE,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACrF,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAEF,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,MAAM,OAAO,CAIxE;AAED;wFACwF;AACxF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,yBAAyB,EAAE,KAAK,EAAE,cAAc,EAAE,eAAe,UAAO,EAAE,SAAS,UAAQ,GAAG,wBAAwB,CAgHtK;AAED,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,yBAAyB,EAAE,YAAY,EAAE,SAAS,oBAAoB,EAAE,EAAE,WAAW,CAAC,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAStO"}