@black-market/sdk 0.15.0 → 0.16.0

package/src/lifecycle/gas-profile.ts

@@ -1,42 +1,27 @@
-import { toHex, zeroAddress, type Address } from "viem";
-import { AUCTION_QUOTE_OPTIONS } from "../auction.js";
-import { getTickAtSqrtRatio } from "../launch.js";
+import { toHex, type Address } from "viem";
 import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig } from "./markets.js";
 import { computeLifecycleOpeningBuys, hasProfiledOpeningMath } from "./opening-buys.js";
-import { getKnownLifecycleProfile, hmmV2ForwardingReserve } from "./presets.js";
-import { lifecyclePinnedRpc, lifecycleSessionRead, nitroPosterGasBound, readNitroPrices, registerLifecycleFinalCheck, resolveLifecycleLimits, rpcHex, rpcQuantity } from "./rpc.js";
+import { hmmV2ForwardingReserve } from "./presets.js";
+import { lifecyclePinnedRpc, lifecycleSourceClient, nitroPosterGasBound, readLifecycleGasPrice, readNitroPrices, registerLifecycleFinalCheck, resolveLifecycleLimits, rpcQuantity } from "./rpc.js";
 import { LifecycleFundingKind, LifecycleRewardMode, LifecycleTokenKind, type LaunchPlanV1 } from "./schema.js";
-import { buildLifecycleCommand } from "./transactions.js";
-import { UFG_LAUNCH_PROXY_ADDRESS, ufgPlanPrincipal, type UfgLaunchConfig } from "./ufg-config.js";
-import type { NextTransactionEnvelope } from "./simulation.js";
-import { LifecyclePlanningError, type LifecycleBlock, type LifecycleLaunchGasBounds, type LifecycleOpeningBuyQuote, type LifecycleSimulation, type LifecycleTransaction, type SimulateLaunchPlanOptions } from "./types.js";
+import { isAutoCompoundProfile } from "./auto-compound.js";
+import { buildLifecycleCommand, LIFECYCLE_CAPACITY_PADDING_BPS, preparationCalldataGas, preparationGasEstimate } from "./transactions.js";
+import { UFG_LAUNCH_PROXY_ADDRESS, isUfgProfile, ufgPlanPrincipal, type UfgLaunchConfig } from "./ufg-config.js";
+import { LifecyclePlanningError, type LifecycleBlock, type LifecycleLaunchGasBounds, type LifecycleLimitSource, type LifecycleOpeningBuyQuote, type LifecyclePlanningAssessment, type LifecycleRpcClient, type LifecycleTransaction, type PlannedLaunch } from "./types.js";
+import { isHmmProfile } from "./hmm.js";
+import { isRaetoProfile } from "./raeto.js";
 
-export const LIFECYCLE_GAS_PROFILE_VERSION = "robinhood-4663-arbos61-v1";
-
-// Coverage, not token admission: unlisted currencies still use exact execution.
-const profiledQuotes = new Set<string>();
-for (const quote of AUCTION_QUOTE_OPTIONS) if (quote.address !== zeroAddress) profiledQuotes.add(quote.address.toLowerCase());
+export const LIFECYCLE_GAS_PROFILE_VERSION = "robinhood-4663-capacity-v4";
+export type NextTransactionEnvelope = Readonly<{ gas: bigint; gasPrice: bigint }>;
 const ceil = (value: bigint, divisor: bigint) => (value + divisor - 1n) / divisor;
 const approval = (transaction: LifecycleTransaction) => transaction.kind === "approve" || transaction.kind === "approve-reset";
-type MarketGas = { abyss: boolean; hmm: boolean; ufgHook: boolean; positions: number; spacing: number; openingTick: number; ticks: number[] };
-
-function covered(plan: LaunchPlanV1): boolean {
-  return plan.chainId === 4663n && hasProfiledOpeningMath(plan) &&
-    plan.markets.every((market) => profiledQuotes.has(market.quoteAsset.toLowerCase())) &&
-    plan.funding.every((funding) => funding.kind !== LifecycleFundingKind.ERC20 || profiledQuotes.has(funding.inputAsset.toLowerCase()));
-}
+type MarketGas = { abyss: boolean; hmm: boolean; ufgHook: boolean; raeto: boolean; autoCompound: boolean; positions: number };
 
 function marketGas(plan: LaunchPlanV1): MarketGas[] {
   return plan.markets.map((market) => {
-    const preset = getKnownLifecycleProfile({ chainId: plan.chainId, orchestrator: plan.orchestrator, profileId: market.profileId })!;
     const abyss = market.configVersion === 1;
     const config = abyss ? decodeAbyssLifecycleMarketConfig(market.config) : decodePoolBoundV4LifecycleMarketConfig(market.config, 6);
-    const price = "openingSqrtPriceX96" in config ? config.openingSqrtPriceX96 : config.sqrtPriceX96;
-    const spacing = "tickSpacing" in config ? config.tickSpacing : config.fee === 100 ? 1 : config.fee === 500 ? 10 : config.fee === 3000 ? 60 : 200;
-    const ticks = new Set<number>();
-    for (const position of config.positions) { ticks.add(position.tickLower); ticks.add(position.tickUpper); }
-    return { abyss, hmm: preset.key.includes("hmm"), ufgHook: preset.key.includes("ufg"), positions: config.positions.length,
-      spacing, openingTick: getTickAtSqrtRatio(price), ticks: [...ticks] };
+    return { abyss, hmm: isHmmProfile(market.profileId), ufgHook: isUfgProfile(market.profileId), raeto: isRaetoProfile(market.profileId), autoCompound: isAutoCompoundProfile(market.profileId), positions: config.positions.length };
   });
 }
 
@@ -55,121 +40,157 @@ function utf8Bytes(value: string): number {
 function tokenCreationGas(token: LaunchPlanV1["token"]): bigint {
   return (token.kind === LifecycleTokenKind.ERC404 ? 2_500_000n : 0n) +
     (token.rewardMode === LifecycleRewardMode.Staking ? 2_500_000n : token.rewardMode === LifecycleRewardMode.Dividends ? 500_000n : 0n) +
-    22_000n * BigInt(Math.ceil(utf8Bytes(token.name) / 32) + Math.ceil(utf8Bytes(token.symbol) / 32) + Math.ceil(utf8Bytes(token.metadataURI) / 32));
+    25_000n * BigInt(Math.ceil(utf8Bytes(token.name) / 32) + Math.ceil(utf8Bytes(token.symbol) / 32) + Math.ceil(utf8Bytes(token.metadataURI) / 32));
 }
 
-/** Capacity classification only. No value returned here ever sets a transaction gas limit. */
+// Max observed compute: native Abyss atomic21,584,262; V4 fixed20,833,003;
+// HMM26,395,772; UFG27,941,420 (historical-receipts.json,195 transactions).
+// fork-matrix.json: Abyss activation8 positions11.08M/32 positions39.72M;
+// fork-v4-matrix.json: dynamic V4 eight positions5,906,285.
+// Native mixed HMM8/Abyss8/HMM8 activation23,883,893 (0xf05e…fe98).
+const activationCosts = {
+  call: 1_500_000n,
+  abyss: { market: 500_000n, position: 1_250_000n },
+  v4: { market: 250_000n, position: 500_000n },
+  raeto: { market: 500_000n, position: 500_000n },
+  autoCompound: { market: 750_000n, position: 500_000n },
+  hmm: 1_000_000n,
+  ufg: 250_000n,
+  // Fork Abyss32: 64 buys78.44M minimum versus one buy47.49M;
+  // max observed marginal is below0.5M/buy. ERC404 pairs add below0.1M/NFT.
+  buy: 500_000n,
+  nft: 100_000n,
+} as const;
+
+/** Measured-max template budgets, never gas-limit sizing or execution evidence. */
 function capacityBasis(plan: LaunchPlanV1, transaction: LifecycleTransaction, markets: readonly MarketGas[], quotes: readonly LifecycleOpeningBuyQuote[], ufgRoute: boolean): bigint {
   const atomic = transaction.kind === "atomic";
-  let gas = atomic ? 19_500_000n + tokenCreationGas(plan.token) + (ufgRoute ? 6_500_000n : 0n) : 1_000_000n;
-  for (const [index, market] of markets.entries()) {
-    if (!atomic) gas += market.abyss ? 2_500_000n + 1_600_000n * BigInt(market.positions) : 2_000_000n + 600_000n * BigInt(market.positions);
-    else gas += (index === 0 ? market.hmm ? 7_000_000n : market.ufgHook ? 1_000_000n : market.abyss ? 500_000n : 0n
-      : market.hmm ? 15_000_000n : market.ufgHook ? 9_000_000n : 8_000_000n) +
+  // template-gas-matrix.json: Raeto/auto-compound atomic1 <=19.60M,
+  // atomic8 <=23.99M; atomic32 exceeds32M. The18M calibration base plus
+  // position/buy work and25% padding bounds compute and forwarding envelopes.
+  let gas = atomic ? (markets[0]!.raeto || markets[0]!.autoCompound ? 18_000_000n : 22_000_000n) + tokenCreationGas(plan.token) + (ufgRoute ? 6_500_000n : 0n)
+    : activationCosts.call + (ufgRoute ? activationCosts.ufg : 0n);
+  for (const market of markets) {
+    if (atomic) gas += (market.hmm ? 7_000_000n : market.ufgHook ? 1_000_000n : market.abyss ? 500_000n : 0n) +
       (market.abyss ? 1_500_000n : 600_000n) * BigInt(market.positions - 1);
-    if (!atomic && market.hmm) gas += 6_000_000n;
+    else {
+      const cost = market.abyss ? activationCosts.abyss : market.raeto ? activationCosts.raeto : market.autoCompound ? activationCosts.autoCompound : activationCosts.v4;
+      gas += cost.market + cost.position * BigInt(market.positions) + (market.hmm ? activationCosts.hmm : market.ufgHook ? activationCosts.ufg : 0n);
+    }
   }
-  const ticks = markets.map((market) => market.openingTick);
+  gas += activationCosts.buy * BigInt(quotes.length);
+  // These collectors revalidate the prepared position set for each buy. At32
+  // positions the measured marginal exceeds1M/buy; flat0.5M is insufficient.
   for (const quote of quotes) {
-    const market = markets[quote.marketIndex]!, before = ticks[quote.marketIndex]!, after = getTickAtSqrtRatio(quote.sqrtPriceAfterX96);
-    const low = Math.min(before, after), high = Math.max(before, after);
-    const words = Math.abs(Math.floor(after / (market.spacing * 256)) - Math.floor(before / (market.spacing * 256))) + 2;
-    let crossings = 0;
-    for (const tick of market.ticks) if (tick >= low && tick <= high) crossings += 1;
-    gas += 300_000n + 8_000n * BigInt(words) + 80_000n * BigInt(crossings);
-    if (plan.token.kind === LifecycleTokenKind.ERC404) gas += 70_000n * ceil(quote.tokenOut, plan.token.nftUnit);
-    ticks[quote.marketIndex] = after;
+    const market = markets[quote.marketIndex]!;
+    if (market.raeto || market.autoCompound) gas += 25_000n * BigInt(market.positions);
   }
+  if (plan.token.kind === LifecycleTokenKind.ERC404) for (const quote of quotes) gas += activationCosts.nft * ceil(quote.tokenOut, plan.token.nftUnit);
   return gas + 24n * BigInt((transaction.data.length - 2) / 2) + 100_000n * BigInt(plan.feeAssets.length);
 }
 
 type CapacityOptions = { plan: LaunchPlanV1; predictedToken: Address; ufg?: { config: UfgLaunchConfig }; headroomBps?: number };
 export type ProfiledLaunchCapacity = {
   bounds: LifecycleLaunchGasBounds; initialBuys: readonly LifecycleOpeningBuyQuote[]; headroomBps: number;
-  atomic: LifecycleTransaction; activation: LifecycleTransaction;
+  atomic?: LifecycleTransaction; activation: LifecycleTransaction;
 };
 
-/** Internal shared computation; callers reuse both compiled commands and ordered math. */
+/** No quote-token allowlist: costs and exact curve math belong to the release template. */
 export function deriveLifecycleLaunchCapacity(options: CapacityOptions, openingBuys?: readonly LifecycleOpeningBuyQuote[]): ProfiledLaunchCapacity | undefined {
   const { plan, ufg } = options;
-  if (!covered(plan) || plan.funding.some((funding) => funding.kind === LifecycleFundingKind.Swap) ||
-    (plan.creator.toLowerCase() === UFG_LAUNCH_PROXY_ADDRESS.toLowerCase()) !== (ufg !== undefined)) return undefined;
+  if (!hasProfiledOpeningMath(plan) || (plan.creator.toLowerCase() === UFG_LAUNCH_PROXY_ADDRESS.toLowerCase()) !== (ufg !== undefined)) return undefined;
   const headroomBps = options.headroomBps ?? 1500;
-  if (!Number.isSafeInteger(headroomBps) || headroomBps < 0 || headroomBps > 10000) throw new LifecyclePlanningError("INVALID_LIMITS", "Headroom must be between zero and10000 basis points");
+  if (!Number.isSafeInteger(headroomBps) || headroomBps < 0 || headroomBps > 10000) throw new LifecyclePlanningError("INVALID_LIMITS", "Headroom must be between zero and 10000 basis points");
   const initialBuys = openingBuys ?? computeLifecycleOpeningBuys(options);
   const route = ufg === undefined ? undefined : { account: ufgPlanPrincipal(plan), config: ufg.config };
-  const atomic = buildLifecycleCommand(plan, { kind: "atomic" }, route), activation = buildLifecycleCommand(plan, { kind: "activate" }, route);
+  const atomic = plan.markets.length === 1 && !plan.funding.some((funding) => funding.kind === LifecycleFundingKind.Swap)
+    ? buildLifecycleCommand(plan, { kind: "atomic" }, route) : undefined;
+  const activation = buildLifecycleCommand(plan, { kind: "activate" }, route);
   const markets = marketGas(plan), reserve = hmmV2ForwardingReserve(plan);
   const bound = (transaction: LifecycleTransaction) => {
     const basis = capacityBasis(plan, transaction, markets, initialBuys, ufg !== undefined);
-    const buffered = ceil(basis * BigInt(10000 + headroomBps), 10000n);
+    const buffered = ceil(basis * BigInt(10000 + Math.max(LIFECYCLE_CAPACITY_PADDING_BPS, headroomBps)), 10000n);
     return buffered > basis + reserve ? buffered : basis + reserve;
   };
-  return { bounds: { atomicComputeGasUpperBound: bound(atomic), activationComputeGasUpperBound: bound(activation) }, initialBuys, headroomBps, atomic, activation };
+  return { bounds: { ...(atomic === undefined ? {} : { atomicComputeGasUpperBound: bound(atomic) }), activationComputeGasUpperBound: bound(activation) }, initialBuys, headroomBps, atomic, activation };
 }
 
-/** Pure, versioned conservative compute bounds for mode/builder capacity, excluding poster gas.
- * Undefined means unprofiled, not unavailable functionality. A large upper bound is uncertain. */
+/** Pure release-template budgets with headroom, excluding poster allocation.
+ * Missing coverage refuses planning; there is no execution fallback. */
 export function computeLifecycleLaunchGasBounds(options: CapacityOptions): LifecycleLaunchGasBounds | undefined {
   return deriveLifecycleLaunchCapacity(options)?.bounds;
 }
 
-export type ProfiledLifecycleTransactions = { simulation: LifecycleSimulation; profileOnly: boolean };
+export type LifecycleBudgetOptions = { client: LifecycleRpcClient; planned: PlannedLaunch; limits?: LifecycleLimitSource; signal?: AbortSignal };
 
-/** Native ceilings determine every launch envelope. Profiles decide capacity only;
- * conversions and uncertain activation shapes still require exact execution. */
-export async function profileLifecycleTransactions(options: SimulateLaunchPlanOptions, transactions: readonly LifecycleTransaction[], block: LifecycleBlock,
-  reviewed?: NextTransactionEnvelope, openingBuys?: readonly LifecycleOpeningBuyQuote[], capacity?: ProfiledLaunchCapacity): Promise<ProfiledLifecycleTransactions | undefined> {
+/** Checks pinned inputs and deterministic capacity only. Never executes launch calldata. */
+export async function assessLifecycleTransactions(options: LifecycleBudgetOptions, transactions: readonly LifecycleTransaction[], block: LifecycleBlock,
+  reviewed?: NextTransactionEnvelope, openingBuys?: readonly LifecycleOpeningBuyQuote[], capacity?: ProfiledLaunchCapacity): Promise<LifecyclePlanningAssessment> {
   const { client, planned } = options, plan = planned.plan;
-  const onlyApprovals = transactions.every(approval);
-  if (planned.chainId !== 4663n || !onlyApprovals && !covered(plan)) return undefined;
   const context = { client, account: planned.account, orchestrator: plan.orchestrator, block, chainId: planned.chainId };
   const observed = await resolveLifecycleLimits(context, options.limits === undefined ? planned.limits : options.limits);
-  if (!onlyApprovals && observed.limits.arbOSVersion !== 61n) return undefined;
-  const [prices, balanceValue, accountCode] = await Promise.all([
-    readNitroPrices(client, block),
+  const [recommendation, balanceValue, prices] = await Promise.all([
+    readLifecycleGasPrice(client, block, planned.chainId),
     lifecyclePinnedRpc(client, "eth_getBalance", [planned.account, toHex(block.number)], block),
-    lifecycleSessionRead(client, `${planned.chainId}:account-code:${planned.account.toLowerCase()}`, () => lifecyclePinnedRpc(client, "eth_getCode", [planned.account, toHex(block.number)], block)),
+    observed.limits.protocol === "nitro" ? readNitroPrices(client, block) : undefined,
   ]);
-  if (rpcHex(accountCode, "account code") !== "0x") return undefined;
   options.signal?.throwIfAborted(); observed.assertCurrent(); registerLifecycleFinalCheck(client, observed.assertCurrent);
-  const { limits } = observed, baseFee = block.baseFeePerGas ?? 0n;
-  const requiredGasPrice = prices[5] > baseFee ? prices[5] : baseFee;
-  const gasPrice = reviewed?.gasPrice ?? (prices[5] > baseFee * 2n ? prices[5] : baseFee * 2n);
-  if (reviewed !== undefined && !onlyApprovals && reviewed.gas !== limits.executionGasCeiling) throw new LifecyclePlanningError("STALE_REVIEWED_GAS", "Reviewed gas differs from the native transaction ceiling; review the launch again");
-  const needsBuys = transactions.some((transaction) => transaction.kind === "atomic" || transaction.kind === "activate");
-  const currentCapacity = needsBuys ? capacity?.headroomBps === limits.headroomBps ? capacity : deriveLifecycleLaunchCapacity({ plan, predictedToken: planned.predictedToken, ufg: planned.ufg, headroomBps: limits.headroomBps }, openingBuys) : undefined;
-  if (needsBuys && currentCapacity === undefined) return undefined;
-  const quotes = currentCapacity?.initialBuys ?? [], bounds = currentCapacity?.bounds;
-  let profileOnly = !plan.funding.some((funding) => funding.kind === LifecycleFundingKind.Swap) ||
-    !transactions.some((transaction) => transaction.kind === "begin" || transaction.kind === "atomic" || transaction.kind === "activate");
+  const { limits } = observed, baseFee = block.baseFeePerGas ?? 0n, gasLimit = limits.executionGasCeiling;
+  const requiredGasPrice = limits.protocol === "nitro" && recommendation > baseFee ? recommendation : baseFee;
+  const gasPrice = reviewed?.gasPrice ?? (recommendation > baseFee * 2n ? recommendation : baseFee * 2n);
+  if (reviewed !== undefined && reviewed.gas !== gasLimit) throw new LifecyclePlanningError("STALE_REVIEWED_GAS", "Reviewed gas differs from the native transaction ceiling. Refresh the review before continuing.");
+  const cancelOnly = transactions.every((transaction) => transaction.kind === "cancel");
+  const currentCapacity = cancelOnly ? undefined : capacity?.headroomBps === limits.headroomBps ? capacity
+    : deriveLifecycleLaunchCapacity({ plan, predictedToken: planned.predictedToken, ufg: planned.ufg, headroomBps: limits.headroomBps }, openingBuys);
+  const immediate = transactions[0], launch = transactions.find((transaction) => !approval(transaction));
+  const poster = (transaction: LifecycleTransaction) => prices === undefined ? 0n : nitroPosterGasBound(transaction, prices).posterGas;
+  const assessment: LifecyclePlanningAssessment = { ready: true, blockNumber: block.number, blockHash: block.hash,
+    account: planned.account, chainId: planned.chainId, limits,
+    ...(currentCapacity === undefined ? {} : { gasProfile: { version: LIFECYCLE_GAS_PROFILE_VERSION, bounds: currentCapacity.bounds, initialBuys: currentCapacity.initialBuys } }) };
+  const refuse = (code: string, reason: string, failureCategory: LifecyclePlanningAssessment["failureCategory"], capacityConstraint?: LifecyclePlanningAssessment["capacityConstraint"], failedTransactionId?: string): LifecyclePlanningAssessment =>
+    ({ ...assessment, ready: false, code, reason, failureCategory, capacityConstraint, failedTransactionId });
+  if (!cancelOnly && currentCapacity === undefined) return refuse("UNKNOWN_GAS_PROFILE", "Gas budgets are unavailable for this launch profile. Use a supported profile or update the SDK.", "capacity");
+  if (!cancelOnly && currentCapacity!.bounds.activationComputeGasUpperBound + poster(currentCapacity!.activation) > gasLimit) {
+    return refuse("ACTIVATION_GAS_LIMIT", "Too many positions or pools for one activation. Reduce them to fit the native transaction ceiling.", "capacity", "activation", "activate");
+  }
   for (const transaction of transactions) {
-    if (transaction.kind !== "atomic" && transaction.kind !== "activate") continue;
-    const compute = transaction.kind === "atomic" ? bounds!.atomicComputeGasUpperBound : bounds!.activationComputeGasUpperBound;
-    if (compute + nitroPosterGasBound(transaction, prices).posterGas > limits.executionGasCeiling) profileOnly = false;
+    if (transaction.kind === "atomic" && (currentCapacity?.bounds.atomicComputeGasUpperBound === undefined || currentCapacity.bounds.atomicComputeGasUpperBound + poster(transaction) > gasLimit))
+      return refuse("STAGED_EXECUTION_REQUIRED", "This launch requires staged execution. Refresh the review before continuing.", "capacity", "gas-envelope", transaction.id);
+    if (transaction.kind === "prepare" && ceil((preparationGasEstimate(plan, transaction.marketStart!, transaction.marketCount!) + preparationCalldataGas(transaction.data)) * BigInt(10000 + Math.max(LIFECYCLE_CAPACITY_PADDING_BPS, limits.headroomBps)), 10000n) + poster(transaction) > gasLimit)
+      return refuse("PREPARATION_GAS_LIMIT", "This preparation batch exceeds the gas budget. Refresh the review to split it.", "capacity", "preparation", transaction.id);
+    if (limits.maxCalldataBytes !== undefined && (transaction.data.length - 2) / 2 > limits.maxCalldataBytes)
+      return refuse("CALLDATA_LIMIT", "The launch exceeds the transaction data limit. Reduce its positions or pools.", "capacity", "calldata", transaction.id);
   }
-  const launch = transactions.find((transaction) => !approval(transaction));
-  const immediate = transactions[0], gasLimit = limits.executionGasCeiling;
-  const envelopeFailure = launch !== undefined && limits.transactionGasCeiling !== undefined && gasLimit > limits.transactionGasCeiling;
-  const calldataFailure = transactions.find((transaction) => limits.maxCalldataBytes !== undefined && (transaction.data.length - 2) / 2 > limits.maxCalldataBytes);
-  const feeFailure = reviewed !== undefined && gasPrice < requiredGasPrice;
-  const affordabilityFailure = launch !== undefined && launch.value + gasLimit * gasPrice > rpcQuantity(balanceValue, "creator native balance");
-  const semanticFailure = quotes.find((quote) => quote.tokenOut < plan.buys[quote.buyIndex]!.minTokenOut);
-  const expired = block.timestamp > plan.deadline && transactions.some((transaction) => transaction.kind !== "cancel");
-  const refused = envelopeFailure || calldataFailure !== undefined || feeFailure || affordabilityFailure || semanticFailure !== undefined || expired;
-  const poster = immediate === undefined || approval(immediate) ? undefined : nitroPosterGasBound(immediate, prices).posterGas;
-  const simulation: LifecycleSimulation = {
-    backend: "profiled", confidence: "profiled", executionProof: "not-run", protocolFit: "profiled", admitted: profileOnly && !refused,
-    blockNumber: block.number, blockHash: block.hash, account: planned.account, chainId: planned.chainId, limits, steps: [], deferredTransactionIds: [],
-    ...(bounds === undefined ? {} : { gasProfile: { version: LIFECYCLE_GAS_PROFILE_VERSION, bounds, initialBuys: quotes } }),
-    ...(immediate === undefined || approval(immediate) ? {} : { estimate: { gasLimit, gasPrice, executionFee: gasLimit * gasPrice, dataFee: 0n, totalFee: gasLimit * gasPrice,
-      posterGas: poster, posterFee: poster! * gasPrice, dataFeeIncludedInGas: true, feeConfidence: "native-ceiling-and-data" as const } }),
-    ...(envelopeFailure ? { failureCategory: "capacity" as const, capacityConstraint: "gas-envelope" as const, failedTransactionId: launch!.id, reason: "Native transaction ceiling exceeds the supplied complete gas policy" } : {}),
-    ...(calldataFailure === undefined ? {} : { failureCategory: "capacity" as const, capacityConstraint: "calldata" as const, failedTransactionId: calldataFailure.id, reason: "Encoded command exceeds the caller's calldata byte policy" }),
-    ...(affordabilityFailure ? { failureCategory: "affordability" as const, failedTransactionId: launch!.id, reason: "Creator native balance cannot reserve transaction value and the native gas ceiling" } : {}),
-    ...(semanticFailure === undefined ? {} : { failureCategory: "semantic" as const, failedTransactionId: transactions.find((transaction) => transaction.kind === "atomic" || transaction.kind === "activate")?.id, reason: "Opening curve output is below the committed minimum" }),
-    ...(expired ? { failureCategory: "semantic" as const, failedTransactionId: transactions.find((transaction) => transaction.kind !== "cancel")?.id, reason: "Launch deadline has expired at the pinned block" } : {}),
-    ...(feeFailure ? { failedTransactionId: immediate?.id, reason: "Reviewed gas price is below the pinned required fee" } : {}),
-  };
-  return { simulation, profileOnly: profileOnly || refused };
+  if (launch !== undefined && limits.transactionGasCeiling !== undefined && gasLimit > limits.transactionGasCeiling)
+    return refuse("GAS_POLICY_LIMIT", "The configured gas limit is below the chain's native transaction ceiling.", "capacity", "gas-envelope", launch.id);
+  if (reviewed !== undefined && gasPrice < requiredGasPrice) return refuse("REVIEWED_FEE_TOO_LOW", "The reviewed gas price is below the current required fee. Refresh the review before continuing.", "semantic", undefined, immediate?.id);
+  const quotes = currentCapacity?.initialBuys ?? [];
+  if (quotes.some((quote) => quote.tokenOut < plan.buys[quote.buyIndex]!.minTokenOut))
+    return refuse("BUY_MINIMUM_NOT_MET", "An opening buy is below its minimum output. Refresh the review before continuing.", "semantic");
+  if (block.timestamp > plan.deadline && !cancelOnly) return refuse("PLAN_EXPIRED", "The launch deadline has passed. Cancel an unfinished launch to recover its funds.", "semantic");
+  const inputs = new Map<string, { required: bigint; balance: bigint }>();
+  for (const prerequisite of planned.prerequisites) {
+    if (prerequisite.allowance === undefined) continue;
+    const key = prerequisite.funding.inputAsset.toLowerCase(), total = inputs.get(key) ?? { required: 0n, balance: prerequisite.inputBalance };
+    total.required += prerequisite.requiredInput; inputs.set(key, total);
+  }
+  if ([...inputs.values()].some((input) => input.required > input.balance)) return refuse("INSUFFICIENT_FUNDING_BALANCE", "There are not enough tokens to fund this launch. Add funds or reduce the purchase.", "affordability");
+  const balance = rpcQuantity(balanceValue, "creator native balance");
+  if (gasPrice >= 1n << 256n || launch !== undefined && launch.value + gasLimit * gasPrice >= 1n << 256n) throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Transaction value and native-ceiling fee must fit uint256");
+  if (launch !== undefined && launch.value + gasLimit * gasPrice > balance) return refuse("INSUFFICIENT_NATIVE_BALANCE", "There is not enough native currency for the launch amount and gas budget. Add funds or reduce the purchase.", "affordability", undefined, launch.id);
+  if (immediate !== undefined && !approval(immediate)) {
+    const source = lifecycleSourceClient(client);
+    const dataFee = limits.protocol === "nitro" ? 0n : observed.configuration.estimateDataFee === undefined ? undefined
+      : await observed.configuration.estimateDataFee({ ...immediate, gas: gasLimit, gasPrice }, source === client ? context : { ...context, client: source });
+    if (dataFee !== undefined && (typeof dataFee !== "bigint" || dataFee < 0n || dataFee >= 1n << 256n)) throw new LifecyclePlanningError("INVALID_DATA_FEE", "Data-fee estimate must be a nonnegative uint256 amount");
+    const executionFee = gasLimit * gasPrice, required = immediate.value + executionFee + (dataFee ?? 0n);
+    if (required >= 1n << 256n) throw new LifecyclePlanningError("INVALID_GAS_ENVELOPE", "Transaction value and gas/data fee budget must fit uint256");
+    if (required > balance) return refuse("INSUFFICIENT_NATIVE_BALANCE", "There is not enough native currency for the launch amount and gas budget. Add funds or reduce the purchase.", "affordability", undefined, immediate.id);
+    const posterGas = prices === undefined ? undefined : poster(immediate);
+    assessment.estimate = { gasLimit, gasPrice, executionFee, dataFee, totalFee: dataFee === undefined ? undefined : executionFee + dataFee,
+      posterGas, posterFee: posterGas === undefined ? undefined : posterGas * gasPrice, dataFeeIncludedInGas: limits.protocol === "nitro",
+      feeConfidence: dataFee === undefined ? "native-ceiling-only" : "native-ceiling-and-data" };
+  }
+  options.signal?.throwIfAborted(); observed.assertCurrent();
+  return assessment;
 }

package/src/lifecycle/index.ts

@@ -1,21 +1,23 @@
-/** Versioned construction metadata and live launch execution calibration. */
+/** Versioned construction metadata, exact local curve math and launch budgets. */
 export * from "./schema.js";
 export * from "./types.js";
 export * from "./abi.js";
 export * from "./markets.js";
 export * from "./hmm.js";
 export * from "./ufg.js";
+export * from "./auto-compound.js";
+export * from "./raeto.js";
+export * from "./raeto-abi.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 { preparationGasEstimate, packPreparationBatches, buildLaunchTransactions } from "./transactions.js";
+export { preparationGasEstimate, packPreparationBatches, buildLaunchTransactions, LIFECYCLE_CAPACITY_PADDING_BPS } 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 { planLaunch, buildNextTransaction, prepareAndPlanLifecycleLaunch } from "./planner.js";
 export { computeLifecycleOpeningBuys } from "./opening-buys.js";
 export { computeLifecycleLaunchGasBounds } from "./gas-profile.js";
 export { assertLaunchTopologyCoverage, getTickAtSqrtRatio, type LaunchTopologyCoverageInput, type LaunchTopologyPosition } from "../launch.js";

package/src/lifecycle/markets.ts

@@ -3,6 +3,8 @@ import type { MarketConfigV1 } from "./schema.js";
 import { LifecyclePlanningError, type LifecycleProfile, type PoolBoundHookSaltProgress } from "./types.js";
 import { decodeHmmLaunchTail, encodeHmmLaunchTail, isHmmProfile, type HmmLaunchConfig } from "./hmm.js";
 import { decodeUfgLaunchConfig, encodeUfgLaunchConfig, isUfgProfile, type UfgLaunchConfig } from "./ufg-config.js";
+import { decodeAutoCompoundTail, encodeAutoCompoundTail, isAutoCompoundProfile, validateAutoCompoundConfig, type AutoCompoundConfigV1 } from "./auto-compound.js";
+import { decodeRaetoLaunchTail, encodeRaetoLaunchTail, isRaetoProfile, RAETO_QUOTE_ASSETS, validateRaetoLaunchConfig, type RaetoLaunchConfigV1 } from "./raeto.js";
 
 export type V4LifecyclePositionConfig = {
   tickLower: number; tickUpper: number; liquidity: bigint; salt: Hex; maxTokenAmount: bigint;
@@ -46,6 +48,8 @@ export type V4PoolBoundLifecycleMarketConfigV6 = Omit<V4LifecycleMarketConfig, "
   version: 6; minimumHookFeePips: number; feeSensitivityPipsSecondsPerTick: number; hookSalt: Hex;
   hmmLaunchConfig?: HmmLaunchConfig;
   ufgLaunchConfig?: UfgLaunchConfig;
+  autoCompoundConfig?: AutoCompoundConfigV1;
+  raetoLaunchConfig?: RaetoLaunchConfigV1;
 };
 export type V4PoolBoundLifecycleMarketConfig = V4PoolBoundLifecycleMarketConfigV5 | V4PoolBoundLifecycleMarketConfigV6;
 export const V4_LIFECYCLE_CONFIG_SCHEMA = keccak256(stringToHex("(uint16,uint24,int24,uint160,uint24,uint8,uint8,address,bool,bytes32,bytes32,bytes32,address,uint16,(int24,int24,uint128,bytes32,uint256)[])"));
@@ -92,9 +96,34 @@ function assertV1HookFeeShape(config: object): void {
   }
 }
 
+function validateAutoCompoundMarket(config: V4LifecycleMarketConfig | V4PoolBoundLifecycleMarketConfig): asserts config is V4PoolBoundLifecycleMarketConfigV6 & { autoCompoundConfig: AutoCompoundConfigV1 } {
+  if (config.version !== 6 || config.autoCompoundConfig === undefined) throw new LifecyclePlanningError("INVALID_AUTO_COMPOUND_CONFIG", "Auto-compounding profiles require config6 and an explicit autoCompoundConfig");
+  if (config.hmmLaunchConfig !== undefined || config.ufgLaunchConfig !== undefined || config.raetoLaunchConfig !== undefined) throw new LifecyclePlanningError("INVALID_AUTO_COMPOUND_CONFIG", "Auto-compounding profiles cannot carry HMM, UFG or Raeto tails");
+  if (config.lpFeePips !== 0) throw new LifecyclePlanningError("INVALID_HOOK_FEES", "Auto-compounding profiles require zero LP fee");
+  if (config.developerFeeBps !== 0) throw new LifecyclePlanningError("DEVELOPER_FEE_CEILING", "Auto-compounding profiles require zero developer fee");
+  validateAutoCompoundConfig(config.autoCompoundConfig);
+}
+
+function validateRaetoMarket(config: V4LifecycleMarketConfig | V4PoolBoundLifecycleMarketConfig): asserts config is V4PoolBoundLifecycleMarketConfigV6 & { raetoLaunchConfig: RaetoLaunchConfigV1 } {
+  if (config.version !== 6 || config.raetoLaunchConfig === undefined) throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "Raeto profiles require config6 and an explicit raetoLaunchConfig");
+  if (config.hmmLaunchConfig !== undefined || config.ufgLaunchConfig !== undefined || config.autoCompoundConfig !== undefined) throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "Raeto profiles cannot carry HMM, UFG or auto-compounding tails");
+  if (config.feeMode !== 1 || config.lpFeePips !== 0 || config.developerFeeBps !== 0) throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "Raeto requires QuoteOnly feeMode 1, zero LP fee and zero developer fee");
+  validateRaetoLaunchConfig(config.raetoLaunchConfig);
+}
+
 /** Auxiliary launch profiles require their typed tail and append it automatically. */
 export function encodePoolBoundV4LifecycleMarketConfig(config: V4PoolBoundLifecycleMarketConfig): Hex {
   const prefix = encodePoolBoundV4Prefix(config);
+  if (isRaetoProfile(config.profileId)) {
+    validateRaetoMarket(config);
+    return concatHex([prefix, encodeRaetoLaunchTail(config.raetoLaunchConfig)]);
+  }
+  if (config.version === 6 && config.raetoLaunchConfig !== undefined) throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "A Raeto tail requires a Raeto profile");
+  if (isAutoCompoundProfile(config.profileId)) {
+    validateAutoCompoundMarket(config);
+    return concatHex([prefix, encodeAutoCompoundTail(config.autoCompoundConfig)]);
+  }
+  if (config.version === 6 && config.autoCompoundConfig !== undefined) throw new LifecyclePlanningError("INVALID_AUTO_COMPOUND_CONFIG", "An auto-compounding tail requires an auto-compounding profile");
   if (isUfgProfile(config.profileId)) {
     if (config.version !== 6 || config.ufgLaunchConfig === undefined) throw new LifecyclePlanningError("INVALID_UFG_CONFIG", "UFG profiles require config6 and an explicit ufgLaunchConfig");
     if (config.hmmLaunchConfig !== undefined) throw new LifecyclePlanningError("INVALID_UFG_CONFIG", "UFG profiles cannot carry an HMM tail");
@@ -130,6 +159,14 @@ export function decodePoolBoundV4LifecycleMarketConfig(encoded: Hex, expectedVer
   const config = version === 5
     ? decodeAbiParameters([{ type: "tuple", components: poolBoundV4LifecycleMarketComponentsV5 }], encoded)[0] as V4PoolBoundLifecycleMarketConfigV5
     : decodeAbiParameters([{ type: "tuple", components: poolBoundV4LifecycleMarketComponentsV6 }], encoded)[0] as V4PoolBoundLifecycleMarketConfigV6;
+  if (isRaetoProfile(config.profileId)) {
+    if (config.version !== 6) throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "Raeto profiles require config6");
+    config.raetoLaunchConfig = decodeRaetoLaunchTail(`0x${encoded.slice(encodePoolBoundV4Prefix(config).length)}`);
+  }
+  if (isAutoCompoundProfile(config.profileId)) {
+    if (config.version !== 6) throw new LifecyclePlanningError("INVALID_AUTO_COMPOUND_CONFIG", "Auto-compounding profiles require config6");
+    config.autoCompoundConfig = decodeAutoCompoundTail(`0x${encoded.slice(encodePoolBoundV4Prefix(config).length)}`);
+  }
   if (isHmmProfile(config.profileId)) {
     if (config.version !== 6) throw new LifecyclePlanningError("INVALID_HMM_CONFIG", "HMM profiles require config6");
     const prefixLength = encodePoolBoundV4Prefix(config).length;
@@ -160,6 +197,11 @@ export function validateV4LifecycleMarket(options: {
   if (config.version !== 4 && !isPoolBoundV4ConfigVersion(config.version)) throw new LifecyclePlanningError("UNSUPPORTED_CONFIG_VERSION", "Reviewed V4 config version must be 4, 5 or 6");
   if (config.version === 6) validatePoolBoundHookFees(config);
   else if (config.version === 5) assertV1HookFeeShape(config);
+  if (isAutoCompoundProfile(config.profileId)) validateAutoCompoundMarket(config);
+  if (isRaetoProfile(config.profileId)) {
+    validateRaetoMarket(config);
+    if (!RAETO_QUOTE_ASSETS.some((quote) => quote.toLowerCase() === market.quoteAsset.toLowerCase())) throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "Raeto quote asset must be WETH or USDG");
+  } else if (config.version === 6 && config.raetoLaunchConfig !== undefined) throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "A Raeto tail requires a Raeto profile");
   const { envelope, developerTerms: terms, protocolMaximumDeveloperFeeBps: protocolCeiling } = profile;
   if (envelope === undefined || terms === undefined || protocolCeiling === undefined || !terms.enabled ||
     profile.topology.hookTopology !== (config.version === 4 ? 1 : 2) || market.configVersion !== config.version ||
@@ -258,9 +300,11 @@ export function hashPoolBoundV4MarketCommitment(options: { chainId: bigint; core
   if (!isPoolBoundV4ConfigVersion(market.configVersion)) throw new LifecyclePlanningError("INVALID_BOUND_MARKET", "Pool-bound V4 market requires explicit config version 5 or 6");
   const config = decodePoolBoundV4LifecycleMarketConfig(market.config, market.configVersion);
   if (config.profileId.toLowerCase() !== market.profileId.toLowerCase()) throw new LifecyclePlanningError("INVALID_BOUND_MARKET", "Config profile differs from the committed market profile");
-  // Collector factories commit only the V6 prefix, not auxiliary launch tails.
-  // The full plan commitment separately binds every byte of those tails.
-  const configHash = keccak256(encodePoolBoundV4Prefix({ ...config, hookSalt: zeroHash }));
+  // Auto-compounding binds its tail into constructor economics; older factories
+  // bind only the prefix. Every full plan commitment also binds every tail byte.
+  const normalized = { ...config, hookSalt: zeroHash };
+  const configHash = keccak256(isAutoCompoundProfile(config.profileId)
+    ? encodePoolBoundV4LifecycleMarketConfig(normalized) : encodePoolBoundV4Prefix(normalized));
   return keccak256(encodeAbiParameters([
     { type: "bytes32" }, { type: "uint256" }, { type: "address" }, { type: "address" }, { type: "address" },
     { type: "bytes32" }, { type: "bytes32" }, { type: "address" }, { type: "uint256" }, { type: "uint32" }, { type: "bytes32" },

package/src/lifecycle/opening-buys.ts

@@ -47,12 +47,12 @@ function openingState(plan: LaunchPlanV1, marketIndex: number): OpeningState {
     price = config.openingSqrtPriceX96; spacing = tier.tickSpacing; lpFee = BigInt(config.fee); positions = config.positions;
   } else {
     // All current release-owned V4 offerings use config6. Dynamic first buys
-    // share the opening block's minimum fee; HMM strategy work starts onOpened,
-    // after the ordered initial buys, never during this unopened curve.
+    // share the opening block's minimum fee. HMM work starts onOpened and
+    // auto-compounding defers until openingCompletedAt, after all opening buys.
     const config = decodePoolBoundV4LifecycleMarketConfig(market.config, 6);
     if (config.profileId.toLowerCase() !== market.profileId.toLowerCase()) throw new LifecyclePlanningError("INVALID_MARKET", "V4 opening config differs from the selected profile");
     price = config.sqrtPriceX96; spacing = config.tickSpacing; lpFee = BigInt(config.lpFeePips); positions = config.positions;
-    const dynamic = preset.key === KnownLifecycleProfile.V4DynamicFeePool || preset.key === KnownLifecycleProfile.V4HmmDynamicPool || preset.key === KnownLifecycleProfile.V4UfgDynamicPool;
+    const dynamic = preset.key === KnownLifecycleProfile.V4DynamicFeePool || preset.key === KnownLifecycleProfile.V4HmmDynamicPool || preset.key === KnownLifecycleProfile.V4UfgDynamicPool || preset.key === KnownLifecycleProfile.V4AutoCompoundDynamicPool || preset.key === KnownLifecycleProfile.V4RaetoDynamicPool;
     hookFee = BigInt(dynamic ? config.minimumHookFeePips! : config.hookFeePips);
   }
   const tick = getTickAtSqrtRatio(price), liquidityNet = new Map<number, bigint>();