@black-market/sdk 0.15.1 → 0.16.1

package/docs/reference.md

@@ -2,7 +2,7 @@
 
 Use the [launch guide](launch-lifecycle.md) for the end-to-end flow and the
 [runner reference](../examples/README.md) for environment and recovery artifacts.
-This page covers SDK **0.14.1** addresses, limits, wire formats, fees, and diagnostics.
+This page covers SDK **0.16.1** addresses, limits, wire formats, fees, and diagnostics.
 
 ## Deployed infrastructure
 
@@ -20,6 +20,7 @@ start historical log queries there, in chunks of at most **10M blocks**.
 | `UFG_TREASURY_FACTORY_ADDRESS` | `0x26Aa5D52134c8E6c4C01E9fb53A7568c0C64901F` |
 | `UFG_UPSTREAM_FACTORY_ADDRESS` | `0xA170b5A58C111334A7237F2Ea2c428ec5022f68E` |
 | Known deployment `launchLens` | `0xcb4bb3caca71fe52eace8170cf83e901418646f8` |
+| `RAETO_PAYOUT_REGISTRY_ADDRESS` | `0xBEC2C0e91612090F82df6743F31CDF18B4386b50` |
 
 `getKnownLifecycleDeployment`, `getKnownLifecycleProfile`, and
 `listKnownLifecycleProfiles` are pure selectors keyed by chain/core. Unknown
@@ -134,8 +135,8 @@ UFG adds a canonical dynamic tuple via `encodeUfgLaunchConfig`:
 `decodeUfgLaunchConfig` rejects alternate encodings and extra bytes;
 `hashUfgLaunchConfig` hashes the tuple. Config6 appends typed `ufgLaunchConfig`
 for UFG profiles only; Abyss carries no UFG tail. Full plan hashes bind every
-auxiliary tail. HMM/UFG constructor economics hash the zero-salt prefix; the
-auto-compounding profiles below hash the zero-salt prefix **and** their tail.
+auxiliary tail. HMM/UFG/Raeto constructor economics hash the zero-salt prefix;
+auto-compounding profiles hash the zero-salt prefix **and** their tail.
 
 ## Auto-compounding profiles
 
@@ -160,7 +161,7 @@ The disabled `0x1e41…1d68` / `0x53dd…e0d7` profiles are not supported.
 `AUTO_COMPOUND_CONFIG_VERSION = keccak256("black-market.auto-compound.config.v1")`.
 The decoder requires the exact version, length and canonical narrow-integer
 padding. Config6's typed `autoCompoundConfig` selects this tail only for these
-two profiles; HMM and UFG tails cannot be combined with it.
+two profiles; HMM, UFG and Raeto tails cannot be combined with it.
 `validateAutoCompoundConfig`, the market codec and `validateV4LifecycleMarket`
 reject invalid shares; the market boundaries also require zero LP/developer fees.
 Both InputToken and QuoteOnly fee modes are supported.
@@ -170,6 +171,60 @@ for these profiles. Never mine against a prefix-only commitment or append a shar
 after mining. Use [the launch guide](launch-lifecycle.md#configure-auto-compounding)
 for selection and gas behavior.
 
+## Raeto profiles
+
+All of the following are exported from `@black-market/sdk/lifecycle` (and the
+root). These presets are supported on the known Robinhood 4663 deployment.
+
+| Profile key / identity constant | Profile ID |
+| --- | --- |
+| `V4RaetoFixedPool` / `RAETO_FIXED_PROFILE_ID` | `0x9161833b162e7ca8160b11c64aedb307561e19a9136fd32f99cd797aab6da3ca` |
+| `V4RaetoDynamicPool` / `RAETO_DYNAMIC_PROFILE_ID` | `0x08387d00ee4f75f860810cc8fb434087328592c2f39ea3321109e589039f80e1` |
+
+`RAETO_FIXED_ADAPTER_ID` is
+`0x911d7ecefe56489d329235e3484829717dc00400d4181902f0f2de45f9338615`;
+`RAETO_DYNAMIC_ADAPTER_ID` is
+`0x8ab9c8c9b8fd4c8bbf12b780d9474463fa0fa52e3b450f0d5f68fd067dc1674d`.
+`isRaetoProfile(profileId)` compares IDs case-insensitively.
+`RAETO_PAYOUT_REGISTRY_ADDRESS` identifies the controller-managed payout registry.
+`RAETO_QUOTE_ASSETS` is the frozen checksummed `[WETH, USDG]` tuple:
+`0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73`,
+`0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168`.
+
+`RAETO_SHARE_BPS_OPTIONS` is readonly `[500, 1000, 2500, 5000, 7500]`.
+`RaetoLaunchConfigV1 = { shareBps: number }`, `validateRaetoLaunchConfig`,
+`encodeRaetoLaunchTail` and `decodeRaetoLaunchTail` enforce exactly that menu and
+exactly `abi.encode(uint16 shareBps)` (one 32-byte word). Noncanonical uint16
+padding, extra/missing bytes, zero and non-menu shares throw
+`INVALID_RAETO_CONFIG`. V6 `raetoLaunchConfig` is mutually exclusive with all
+other tails; Raeto requires QuoteOnly, zero LP/developer fees and allowed quotes.
+`validateRaetoLaunchPlan(plan)` checks **every** market and throws
+`INVALID_RAETO_PLAN`, including for wrong profiles/adapters, schemas or quotes.
+It adds no UFG token/reward/proxy restrictions.
+
+`raetoFeeCollectorV1Abi` is generated from verified standard-output and includes
+`shareBps()`, `owed(address)`, `launchToken()`, `quoteAsset()`,
+`setShareBps(uint16)`, `claimRaeto(address)` and the exact three Raeto events.
+See [fee ownership and collection semantics](launch-lifecycle.md#configure-raeto).
+
+`test/fixtures/raeto-registry-readback.json` preserves admission bytes/receipts,
+runtime hashes, factory metadata, verified ABI provenance and real factory
+`eth_call` share-menu results at **101,180,179**
+(`0xe778e5d89ca2cab5843eedeb8c27b10f5463313d4b95b8971986ac72e297933c`).
+The deployed source commit is `a39c958` (go-live record `02e5cf3`), **not** the
+later local `80ea8c8` share-range change. The generator proves hook creation bytes
+equal the SDK's existing fixed and zero-royalty dynamic bytecode.
+
+```sh
+# Offline, deterministic regeneration from saved evidence (Node 24+):
+node --experimental-transform-types scripts/generate-raeto-presets.mjs
+# Explicit read-only refresh, checking the preserved go-live records:
+node --experimental-transform-types scripts/generate-raeto-presets.mjs \
+  --readback /path/to/black-market
+pnpm build
+node --test test/integration/raeto.live.test.mjs
+```
+
 ## Choose a fee tier
 
 One million pips is 100%; 10,000 pips is 1%. Basis points use a 10,000 denominator.
@@ -206,17 +261,20 @@ NodeInterface oracle. See [capacity and poster evidence](lifecycle-gas-profiles.
 
 `computeLifecycleLaunchGasBounds({ plan, predictedToken, ufg? })` returns conservative
 atomic/activation compute upper bounds, excluding poster, or undefined for unknown
-coverage. These select modes, not gas limits. Atomic is a preference that may select
-staged; persist returned `planned.mode`. A large upper bound is uncertain, not
-proof of overflow. Unknown activation gets full-sequence execution before begin.
-Conversion-carrying commands/consuming activation always retain exact execution.
-
-Only an immediate launch command receives a final gas/price/estimate/admission.
-Suffix execution metrics stay provisional; build-next constructs only the canonical
-next command at the same native ceiling with fresh fees and required admission.
-There are no sizing passes or funds-only retries. Balance must cover value plus
-the entire ceiling fee even when actual execution uses less gas. Incomplete proof
-cannot authorize begin; explicit aggregate policies still refuse excessive work.
+coverage. These select modes, not gas limits. Atomic is a preference: one known-profile
+market may fit, including an empirical2M compute reserve per Swap before at-least-25%
+padding, full encoded-calldata costs and poster allocation. That reserve is not a
+universal bound on arbitrary router execution. Multiple markets and explicit staged
+remain staged; persist returned `planned.mode`. Unknown coverage refuses, and an
+oversized unsplittable activation budget refuses before begin. A large conservative
+bound is not proof of actual overflow. No launch calldata is simulated.
+
+Only an immediate launch command receives fresh gas/price/estimate/assessment.
+Build-next constructs only the canonical next command at the same native ceiling
+with fresh inputs, capacity and fees. There are no sizing passes or funds-only
+retries. Balance must cover value plus the entire ceiling fee even when actual
+execution uses less gas. Routers enforce conversion floors/deadlines on-chain;
+`assessment.ready` does not establish execution.
 
 On Nitro, `estimate.posterGas` / `posterFee` are buffered allocations **inside**
 `gasLimit`; `dataFeeIncludedInGas` is true, `dataFee` is zero, and `totalFee` equals

package/examples/README.md

@@ -1,6 +1,6 @@
 # Run the examples
 
-These commands use the checkout's built `@black-market/sdk` **0.15.1** and viem.
+These commands use the checkout's built `@black-market/sdk` **0.16.1** and viem.
 Use **Node 24+** for direct TypeScript execution. Start with the one-market
 `launch-erc20-abyss.ts`; larger cases require staged preparation and a bounded activation.
 For valuation, token ordering, ranges, and buy protection, read the
@@ -20,7 +20,7 @@ chmod 600 .env
 Launch wrappers load `.env` from the working directory with `process.loadEnvFile`.
 Existing environment values take precedence. Values are literal; shell interpolation
 is not applied. Use the matching SDK version when copying wrappers into a consumer project:
-`pnpm add @black-market/sdk@0.14.1 viem`.
+`pnpm add @black-market/sdk@0.16.1 viem`.
 Copy `launch-example.ts`, `launch-example-support.ts`, and `launch-example-kyber.ts` with the wrapper.
 
 ### Configure the environment
@@ -126,7 +126,10 @@ be combined or duplicated. Resume is an execution authorization; omit `--broadca
 
 Every launch transaction uses the native ceiling,32M total on4663. Capacity profiles
 only choose mode/chunks and reject oversized activation; exact local ordered math
-protects opening buys. Multiple markets or conversion funding always stage.
+protects opening buys. Multiple markets always stage; a single known-profile market
+can stay atomic when its padded compute, including an empirical2M reserve per Swap,
+plus poster allocation fits. Explicit staged stays staged; the conversion reserve
+does not prove arbitrary router execution.
 There is no launch simulation, including Kyber. Routers enforce conversion minima
 and deadlines on-chain; `assessment.ready` is not a receipt or guaranteed execution.
 See [coverage and migration](../docs/lifecycle-gas-profiles.md).

package/package.json

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

package/src/lifecycle/deployments/raeto-dynamic-pool-v1-20261029.ts

@@ -0,0 +1,74 @@
+import type { LaunchEnvelopeV2, AdapterRegistrationV1, ProfileRegistrationV1, ProfileTopologyV1 } from "../schema.js";
+
+// Generated by scripts/generate-raeto-presets.mjs from admission and registry readback.
+// Robinhood block 101180179, 0xe778e5d89ca2cab5843eedeb8c27b10f5463313d4b95b8971986ac72e297933c; admission 0x3148a6696c36bb1de00f8142b2aa6480681ded86203ffa6486a44c4e985c3b31.
+export const raetoDynamicEnvelope = Object.freeze({
+  artifactDigest: "0xd448a4117b78714cc4f96824356c6a90ec666449fde5c57e2b7bbe072f5e4a7a",
+  reviewManifestDigest: "0x9edfb13596015293cd41cf887758bb3799b121d680fac092191afcc0d29a6194",
+  configBoundsDigest: "0x11ec57e16f972e0ac5f687d4078d785a51de11d421bcf97e2ba129dfd83fe7b4",
+  termsDigest: "0x458cf6674ee60f1e56086a12d0d981db2c1ed815109f552318b1d8fd27a80ba2",
+  topology: 2,
+  configVersion: 6,
+  economicVersion: 3,
+  capabilities: 123n,
+  flags: 0n,
+  callbackFlags: 6908,
+  callbackMask: 16383,
+  protocolTreasury: "0x961981916AB6575C3af3eeCecbf6A3b7Fad7C9e1",
+  protocolFeeDenominator: 6,
+  beneficiary: "0x7cb44b8693b3C350A2BcD4b681aF85365aa27783",
+  maximumDeveloperFeeBps: 0,
+  bounds: Object.freeze({
+    minimumTickSpacing: 1,
+    maximumTickSpacing: 32767,
+    maximumPositions: 32,
+    maximumOracleCardinality: 4096,
+    feeModeFlags: 2,
+  }),
+  graph: Object.freeze({
+    manager: "0x8366a39CC670B4001A1121B8F6A443A643e40951",
+    hookRoot: "0x0000000000000000000000000000000000000000",
+    oracleFactory: "0xe7feF2BC860B25bbdEB6F6AB96d88bAAa77ddad7",
+    locker: "0xBF9005094bDa89d5a119A324d6e609A2d8217C1C",
+    collectorFactory: "0x3E201A0d72221A9F8c0AEd06EdAE850E27226166",
+    collectorDeployer: "0x796E8899824999f6Da8740f712A709dBC65cbEd7",
+    hookDeployer: "0x788b88E46be3051633792896F3000EB2Ca57F97E",
+    coreCodeHash: "0x9fb8f46c3b980b9db25dfdb487a69a308a86be145860269b4036a4e74480787b",
+    managerCodeHash: "0xbd3881180b547f5fe817545743cfb4343e96b1bc6640dcd70c106b0066e95626",
+    hookRuntimeCodeHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    oracleFactoryCodeHash: "0x974fb5c72d91ccb99f1eb4679a5d4432c82bbaa0906b1c2917ec4da3499b7b98",
+    lockerCodeHash: "0x0990b18576da69dcf545010ddd7abc2252018a1bb0406b07a14e55a2315c6b27",
+    collectorFactoryCodeHash: "0xf5a1dea71122eeb3db1b925d7311a3bc89609a218ba8501038936c18fde8c892",
+    collectorDeployerCodeHash: "0xb2d108fe4ab95e42ca012cc8a48734a0fcf8cb65325e4874568a6d145dc9e617",
+    hookDeployerCodeHash: "0xb71fc43dc8000386815e3d1c5c54be6840b83281ca294db9929867d0862d118f",
+    hookCreationCodeHash: "0xd448a4117b78714cc4f96824356c6a90ec666449fde5c57e2b7bbe072f5e4a7a",
+    codeChunk0: "0x8F8756D9A50fD968a0207a09B997D4ec32525062",
+    codeChunk0Hash: "0x818c56bf10ae21129fe54f1b8991d6f807ce4ccef35b34c56251c1fd2d7d623f",
+    codeChunk1: "0xdfA2F95713d09a13d1861f09CBD4a94274b18c87",
+    codeChunk1Hash: "0xbc73944bfa7e74df5968907a05fe2579a17ab155d3a0db407588d1baff51b4de",
+    sharedHookSalt: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  }),
+}) satisfies LaunchEnvelopeV2;
+export const raetoDynamicAdapter = Object.freeze({
+  implementation: "0xfc1502090D8326AB9b70aa93a01c93bEBb6f4910",
+  codeHash: "0x1ee51eb5074c356255713d5f66c9fac07e028a6d20161c623a1f409920598a16",
+  capabilities: 123n,
+  configVersion: 6,
+  enabled: true,
+}) satisfies AdapterRegistrationV1;
+export const raetoDynamicRegistration = Object.freeze({
+  adapterId: "0x8ab9c8c9b8fd4c8bbf12b780d9474463fa0fa52e3b450f0d5f68fd067dc1674d",
+  configSchema: "0x51c5ca14c40012f78425cd1afb1ea77980da3fed0490a00911a8a4ed34792045",
+  dependencyDigest: "0x2709d930b96f60427579a60cb9801b5ce5aadbda95e261a963fc783e4d2036de",
+  venue: "0x8366a39CC670B4001A1121B8F6A443A643e40951",
+  factory: "0x0000000000000000000000000000000000000000",
+  hook: "0x0000000000000000000000000000000000000000",
+  capabilities: 123n,
+  enabled: true,
+}) satisfies ProfileRegistrationV1;
+export const raetoDynamicTopology = Object.freeze({
+  hookTopology: 2,
+  configVersion: 6,
+  hookDeployer: "0x788b88E46be3051633792896F3000EB2Ca57F97E",
+  hookCreationCodeHash: "0xd448a4117b78714cc4f96824356c6a90ec666449fde5c57e2b7bbe072f5e4a7a",
+}) satisfies ProfileTopologyV1;

package/src/lifecycle/deployments/raeto-fixed-pool-v1-20261029.ts

@@ -0,0 +1,74 @@
+import type { LaunchEnvelopeV2, AdapterRegistrationV1, ProfileRegistrationV1, ProfileTopologyV1 } from "../schema.js";
+
+// Generated by scripts/generate-raeto-presets.mjs from admission and registry readback.
+// Robinhood block 101180179, 0xe778e5d89ca2cab5843eedeb8c27b10f5463313d4b95b8971986ac72e297933c; admission 0x99089e4418bcf59fc4a2efb5dd36c95f92331a079401dcfaae36d1c94a08326a.
+export const raetoFixedEnvelope = Object.freeze({
+  artifactDigest: "0x11c4c7b1f265ed708b7d53ab828c89d237ca821333daa808f1913986c6f8f1ab",
+  reviewManifestDigest: "0x684131bdefed80771e37364f9d5af4969591a31345fbe57c503a4839b4050be2",
+  configBoundsDigest: "0x11ec57e16f972e0ac5f687d4078d785a51de11d421bcf97e2ba129dfd83fe7b4",
+  termsDigest: "0x22ac34826ee23febf81eb209a7c0ab4c0a44be4744410a3e0b5b1720b93aaacc",
+  topology: 2,
+  configVersion: 6,
+  economicVersion: 3,
+  capabilities: 123n,
+  flags: 0n,
+  callbackFlags: 6908,
+  callbackMask: 16383,
+  protocolTreasury: "0x961981916AB6575C3af3eeCecbf6A3b7Fad7C9e1",
+  protocolFeeDenominator: 6,
+  beneficiary: "0x7cb44b8693b3C350A2BcD4b681aF85365aa27783",
+  maximumDeveloperFeeBps: 0,
+  bounds: Object.freeze({
+    minimumTickSpacing: 1,
+    maximumTickSpacing: 32767,
+    maximumPositions: 32,
+    maximumOracleCardinality: 4096,
+    feeModeFlags: 2,
+  }),
+  graph: Object.freeze({
+    manager: "0x8366a39CC670B4001A1121B8F6A443A643e40951",
+    hookRoot: "0x0000000000000000000000000000000000000000",
+    oracleFactory: "0xe7feF2BC860B25bbdEB6F6AB96d88bAAa77ddad7",
+    locker: "0x12985Fa618974b45a5de8fA40c1DE90d15E9c5c8",
+    collectorFactory: "0xb2f84D9f31cBCfA75E998852B1dCcF176BeaAeDC",
+    collectorDeployer: "0xb07558776a71C0b58779F1CAF89775d8E466c173",
+    hookDeployer: "0xfdB07076Cab21715244Bc9699A381b4F461157ea",
+    coreCodeHash: "0x9fb8f46c3b980b9db25dfdb487a69a308a86be145860269b4036a4e74480787b",
+    managerCodeHash: "0xbd3881180b547f5fe817545743cfb4343e96b1bc6640dcd70c106b0066e95626",
+    hookRuntimeCodeHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    oracleFactoryCodeHash: "0x974fb5c72d91ccb99f1eb4679a5d4432c82bbaa0906b1c2917ec4da3499b7b98",
+    lockerCodeHash: "0x304fff24ef51d2a583541fcdeddcc2cb256fe6911bbb737d68871195d14e6cc6",
+    collectorFactoryCodeHash: "0xe1ee1bfb72f9e652c121945a9ecf312d92258f937b3defd60be34d692fd1487b",
+    collectorDeployerCodeHash: "0xb2d108fe4ab95e42ca012cc8a48734a0fcf8cb65325e4874568a6d145dc9e617",
+    hookDeployerCodeHash: "0xd291bbfbbf60fb0b5eaf2569a3300408b7ac81f102a092872fd54e76b8bc766a",
+    hookCreationCodeHash: "0x11c4c7b1f265ed708b7d53ab828c89d237ca821333daa808f1913986c6f8f1ab",
+    codeChunk0: "0x46B4C3a2D205C220A20B4432e857a3254B4D051c",
+    codeChunk0Hash: "0xe5f56287276954b21f4211cabf2d9c251aae68836c5fa86ce68091ffccdee26b",
+    codeChunk1: "0x629Ab46e20f87db9ae761E75EEa733E0B396638D",
+    codeChunk1Hash: "0x76efd61e1a109a85140ce3473c43694a83f490eaac54d18673c17872a5262a47",
+    sharedHookSalt: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  }),
+}) satisfies LaunchEnvelopeV2;
+export const raetoFixedAdapter = Object.freeze({
+  implementation: "0x995Da3cB2b643A9D986f28179F62511BE8757e58",
+  codeHash: "0x9b6d2c83d25a6cad137ccab7bbe17c948aa1ce27a03b53ed5a4ac7f18d06d5ec",
+  capabilities: 123n,
+  configVersion: 6,
+  enabled: true,
+}) satisfies AdapterRegistrationV1;
+export const raetoFixedRegistration = Object.freeze({
+  adapterId: "0x911d7ecefe56489d329235e3484829717dc00400d4181902f0f2de45f9338615",
+  configSchema: "0x51c5ca14c40012f78425cd1afb1ea77980da3fed0490a00911a8a4ed34792045",
+  dependencyDigest: "0x52beccb89ebac17f1028986ef4ee2e4646b23edc7779400b82976af7e35bc41c",
+  venue: "0x8366a39CC670B4001A1121B8F6A443A643e40951",
+  factory: "0x0000000000000000000000000000000000000000",
+  hook: "0x0000000000000000000000000000000000000000",
+  capabilities: 123n,
+  enabled: true,
+}) satisfies ProfileRegistrationV1;
+export const raetoFixedTopology = Object.freeze({
+  hookTopology: 2,
+  configVersion: 6,
+  hookDeployer: "0xfdB07076Cab21715244Bc9699A381b4F461157ea",
+  hookCreationCodeHash: "0x11c4c7b1f265ed708b7d53ab828c89d237ca821333daa808f1913986c6f8f1ab",
+}) satisfies ProfileTopologyV1;

package/src/lifecycle/gas-profile.ts

@@ -9,18 +9,19 @@ import { buildLifecycleCommand, LIFECYCLE_CAPACITY_PADDING_BPS, preparationCalld
 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-capacity-v3";
+export const LIFECYCLE_GAS_PROFILE_VERSION = "robinhood-4663-capacity-v5";
 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 };
+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 abyss = market.configVersion === 1;
     const config = abyss ? decodeAbyssLifecycleMarketConfig(market.config) : decodePoolBoundV4LifecycleMarketConfig(market.config, 6);
-    return { abyss, hmm: isHmmProfile(market.profileId), ufgHook: isUfgProfile(market.profileId), positions: config.positions.length };
+    return { abyss, hmm: isHmmProfile(market.profileId), ufgHook: isUfgProfile(market.profileId), raeto: isRaetoProfile(market.profileId), autoCompound: isAutoCompoundProfile(market.profileId), positions: config.positions.length };
   });
 }
 
@@ -51,6 +52,8 @@ 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;
@@ -62,17 +65,29 @@ const activationCosts = {
 /** 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 ? 22_000_000n + tokenCreationGas(plan.token) + (ufgRoute ? 6_500_000n : 0n)
+  // 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);
+  // Escrow executes each Swap during begin, including within atomic. This
+  // empirical2M reserve is padded below, not a proof for arbitrary router code.
+  if (atomic) for (const funding of plan.funding) if (funding.kind === LifecycleFundingKind.Swap) gas += 2_000_000n;
   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);
     else {
-      const cost = market.abyss ? activationCosts.abyss : activationCosts.v4;
+      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);
     }
   }
   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]!;
+    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);
 }
@@ -87,14 +102,11 @@ export type ProfiledLaunchCapacity = {
 export function deriveLifecycleLaunchCapacity(options: CapacityOptions, openingBuys?: readonly LifecycleOpeningBuyQuote[]): ProfiledLaunchCapacity | undefined {
   const { plan, ufg } = options;
   if (!hasProfiledOpeningMath(plan) || (plan.creator.toLowerCase() === UFG_LAUNCH_PROXY_ADDRESS.toLowerCase()) !== (ufg !== undefined)) return undefined;
-  // Auto-compounding templates have no measured gas yet; never invent their budgets.
-  if (plan.markets.some((market) => isAutoCompoundProfile(market.profileId))) 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 and 10000 basis points");
   const initialBuys = openingBuys ?? computeLifecycleOpeningBuys(options);
   const route = ufg === undefined ? undefined : { account: ufgPlanPrincipal(plan), config: ufg.config };
-  const atomic = plan.markets.length === 1 && !plan.funding.some((funding) => funding.kind === LifecycleFundingKind.Swap)
-    ? buildLifecycleCommand(plan, { kind: "atomic" }, route) : undefined;
+  const atomic = plan.markets.length === 1 ? buildLifecycleCommand(plan, { kind: "atomic" }, route) : undefined;
   const activation = buildLifecycleCommand(plan, { kind: "activate" }, route);
   const markets = marketGas(plan), reserve = hmmV2ForwardingReserve(plan);
   const bound = (transaction: LifecycleTransaction) => {

package/src/lifecycle/index.ts

@@ -6,6 +6,8 @@ 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";

package/src/lifecycle/markets.ts

@@ -4,6 +4,7 @@ import { LifecyclePlanningError, type LifecycleProfile, type PoolBoundHookSaltPr
 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;
@@ -48,6 +49,7 @@ export type V4PoolBoundLifecycleMarketConfigV6 = Omit<V4LifecycleMarketConfig, "
   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)[])"));
@@ -96,15 +98,27 @@ 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) throw new LifecyclePlanningError("INVALID_AUTO_COMPOUND_CONFIG", "Auto-compounding profiles cannot carry HMM or UFG tails");
+  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)]);
@@ -145,6 +159,10 @@ 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)}`);
@@ -180,6 +198,10 @@ export function validateV4LifecycleMarket(options: {
   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 ||

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 || preset.key === KnownLifecycleProfile.V4AutoCompoundDynamicPool;
+    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>();

package/src/lifecycle/planner.ts

@@ -2,7 +2,7 @@ import { encodeFunctionData, keccak256, toHex, zeroAddress, type Address, type H
 import { ABYSS_FEE_TIERS } from "../abyss.js";
 import { assertLaunchTopologyCoverage, getTickAtSqrtRatio } from "../launch.js";
 import { launchLifecycleAbi, lifecycleAdapterAbi, lifecycleErc20Abi } from "./abi.js";
-import { hashLaunchIdentity, hashLaunchPlan, LifecycleFundingKind, LifecyclePhase, LifecycleRewardMode, LifecycleTokenKind, LIFECYCLE_MAX_REWARD_ERC20_SUPPLY, LIFECYCLE_MAX_ERC404_SUPPLY, parseLaunchPlan, serializeLaunchPlan, type LaunchPlanV1 } from "./schema.js";
+import { hashLaunchIdentity, hashLaunchPlan, LifecycleFundingKind, LifecyclePhase, LifecycleRewardMode, LifecycleTokenKind, LIFECYCLE_MAX_ERC404_SUPPLY, LIFECYCLE_MAX_REWARD_ERC20_SUPPLY, parseLaunchPlan, serializeLaunchPlan, type LaunchPlanV1, type MarketConfigV1 } from "./schema.js";
 import { readLaunchProgress, readLifecycleExecutionProgress, readLifecycleHeadProgress, readLifecycleProfiles, readLifecycleTokenAtBlock, readPoolBoundHookDeployment } from "./progress.js";
 import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, encodePoolBoundV4LifecycleMarketConfig, isPoolBoundV4ConfigVersion, type AbyssLifecycleMarketConfig, type V4LifecycleMarketConfig, type V4PoolBoundLifecycleMarketConfig } from "./markets.js";
 import { lifecyclePinnedRpc, lifecycleStaticRpc, lifecycleStage, nitroPosterGasBound, readLifecycleChainId, readLifecycleContract, readNitroPrices, registerLifecycleFinalCheck, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
@@ -18,6 +18,7 @@ import { mineLifecycleHooks } from "./mining.js";
 import { computeLifecycleOpeningBuys, hasProfiledOpeningMath } from "./opening-buys.js";
 import { assessLifecycleTransactions, deriveLifecycleLaunchCapacity, type NextTransactionEnvelope, type ProfiledLaunchCapacity } from "./gas-profile.js";
 import type { LifecycleOpeningBuyQuote } from "./types.js";
+import { isRaetoProfile, RAETO_QUOTE_ASSETS } from "./raeto.js";
 
 type ValidatedPlanShape = {
   commitment: Hex;
@@ -38,7 +39,7 @@ function observedFields<T extends object>(value: T): () => boolean {
 
 async function selectLaunchMode(requested: "atomic" | "staged", plan: LaunchPlanV1, capacity: ProfiledLaunchCapacity | undefined,
   limits: ResolvedLifecycleLimits, client: LifecycleRpcClient, block: LifecycleBlock): Promise<"atomic" | "staged"> {
-  if (requested !== "atomic" || plan.markets.length !== 1 || plan.funding.some((funding) => funding.kind === LifecycleFundingKind.Swap) ||
+  if (requested !== "atomic" || plan.markets.length !== 1 ||
     capacity?.atomic === undefined || capacity.bounds.atomicComputeGasUpperBound === undefined) return "staged";
   const poster = limits.protocol === "nitro" ? nitroPosterGasBound(capacity.atomic, await readNitroPrices(client, block)).posterGas : 0n;
   return capacity.bounds.atomicComputeGasUpperBound + poster <= limits.executionGasCeiling ? "atomic" : "staged";
@@ -53,6 +54,20 @@ async function preparationBatches(plan: LaunchPlanV1, prepared: number, ufg: Pla
   return packPreparationBatches(plan, prepared, limits.executionGasCeiling - poster, limits.headroomBps);
 }
 
+/** Preserve Raeto's outer quote/profile binding even on known-preset recovery. */
+function validateRaetoMarketContext(market: MarketConfigV1, config?: V4LifecycleMarketConfig | V4PoolBoundLifecycleMarketConfig): void {
+  if (!isRaetoProfile(market.profileId)) return;
+  if (market.configVersion !== 6 || !RAETO_QUOTE_ASSETS.some((quote) => quote.toLowerCase() === market.quoteAsset.toLowerCase())) {
+    throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "Raeto requires config6 and a WETH or USDG quote");
+  }
+  // Normal planning supplies its already decoded config. Continuation must also
+  // reject malformed fee/share tails before reading or building its next command.
+  const decoded = config ?? decodePoolBoundV4LifecycleMarketConfig(market.config, 6);
+  if (decoded.version !== 6 || decoded.profileId.toLowerCase() !== market.profileId.toLowerCase()) {
+    throw new LifecyclePlanningError("INVALID_RAETO_CONFIG", "Raeto config must bind its market's Raeto profile");
+  }
+}
+
 function validatePlanShape(plan: LaunchPlanV1): ValidatedPlanShape {
   // Encoding checks all exact integer widths, addresses, byte strings and tuple fields.
   const commitment = hashLaunchPlan(plan);
@@ -85,6 +100,7 @@ function validatePlanShape(plan: LaunchPlanV1): ValidatedPlanShape {
     if (market.configVersion !== 1 && market.configVersion !== 4 && !isPoolBoundV4ConfigVersion(market.configVersion)) throw new LifecyclePlanningError("UNSUPPORTED_CONFIG_VERSION", "Encode reviewed SharedV4 version 4 or pool-bound version 5/6 only on its exact matching deployment");
     if (market.configVersion === 4) config = decodeV4LifecycleMarketConfig(market.config);
     else if (isPoolBoundV4ConfigVersion(market.configVersion)) config = decodePoolBoundV4LifecycleMarketConfig(market.config, market.configVersion);
+    validateRaetoMarketContext(market, config);
     if (config !== undefined) {
       if (config.profileId.toLowerCase() !== market.profileId.toLowerCase()) throw new LifecyclePlanningError("PROFILE_TERMS_MISMATCH", "Inner config profile differs from the committed market profile");
       const quote = market.quoteAsset.toLowerCase();
@@ -455,6 +471,7 @@ function finalizeNextTransaction(options: BuildNextTransactionOptions, next: Lif
 /** Recovery observes actual canonical receipts, then constructs and budgets only
  * the next command. No launch transaction is executed during planning. */
 export async function buildNextTransaction(options: BuildNextTransactionOptions): Promise<LifecycleTransaction | undefined> {
+  if (options.action !== "cancel") for (const market of options.planned.plan.markets) validateRaetoMarketContext(market);
   const original = options.planned, matches = observedFields(original);
   const assertInput = () => {
     if (options.planned !== original || !matches()) throw new LifecyclePlanningError("PLAN_MUTATED", "Stored launch context changed while constructing its next transaction");

package/src/lifecycle/presets.ts

@@ -14,6 +14,9 @@ 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";
+import { raetoFixedEnvelope, raetoFixedAdapter, raetoFixedRegistration } from "./deployments/raeto-fixed-pool-v1-20261029.js";
+import { raetoDynamicEnvelope, raetoDynamicAdapter, raetoDynamicRegistration } from "./deployments/raeto-dynamic-pool-v1-20261029.js";
+import { RAETO_FIXED_PROFILE_ID, RAETO_DYNAMIC_PROFILE_ID } from "./raeto.js";
 
 export enum KnownLifecycleProfile {
   Abyss0 = "abyss-0",
@@ -28,6 +31,8 @@ export enum KnownLifecycleProfile {
   V4UfgDynamicPool = "v4-ufg-dynamic-pool",
   V4AutoCompoundStaticPool = "v4-auto-compound-static-pool",
   V4AutoCompoundDynamicPool = "v4-auto-compound-dynamic-pool",
+  V4RaetoFixedPool = "v4-raeto-fixed-pool",
+  V4RaetoDynamicPool = "v4-raeto-dynamic-pool",
 }
 
 export enum KnownLifecycleHook {
@@ -360,6 +365,8 @@ const knownDeployment: LifecycleDeploymentPreset = Object.freeze({
     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),
+    poolBoundPreset(KnownLifecycleProfile.V4RaetoFixedPool, RAETO_FIXED_PROFILE_ID, raetoFixedEnvelope, raetoFixedAdapter, raetoFixedRegistration, fixedFeePoolHookV1CreationCode),
+    poolBoundPreset(KnownLifecycleProfile.V4RaetoDynamicPool, RAETO_DYNAMIC_PROFILE_ID, raetoDynamicEnvelope, raetoDynamicAdapter, raetoDynamicRegistration, dynamicFeePoolHookV1CreationCode),
   ]),
   provenance: Object.freeze({ sourceCommit: "e174ce695c7010f50ca9211b07b9f178c990beac", deploymentBlock: 82880546n }),
 });
@@ -389,7 +396,7 @@ export function getKnownLifecycleProfile(options: KnownLifecycleDeploymentIdenti
   return undefined;
 }
 
-/** Stable, frozen order: Abyss, fixed/dynamic V4, HMM, UFG, then auto-compounding. */
+/** Stable, frozen order: Abyss, fixed/dynamic V4, HMM, UFG, auto-compounding, then Raeto. */
 export function listKnownLifecycleProfiles(options: KnownLifecycleDeploymentIdentity): readonly LifecycleProfilePreset[] {
   return getKnownLifecycleDeployment(options)?.profiles ?? noProfiles;
 }