@black-market/sdk 0.7.1 → 0.8.0

package/examples/{launch-lifecycle-smoke.mjs → launch-lifecycle-smoke.ts}

@@ -12,7 +12,7 @@ import {
   simulateLaunchPlan, isPoolBoundV4ConfigVersion,
 } from "@black-market/sdk/lifecycle";
 const [manifestFile, plansFile] = process.argv.slice(2);
-if (!manifestFile || !plansFile) throw new Error("Usage: node examples/launch-lifecycle-smoke.mjs manifest.json sdk-plans.json");
+if (!manifestFile || !plansFile) throw new Error("Usage: node examples/launch-lifecycle-smoke.ts manifest.json sdk-plans.json");
 const manifest = JSON.parse(await readFile(manifestFile, "utf8"));
 const exported = JSON.parse(await readFile(plansFile, "utf8"));
 const rpcUrl = process.env.LAUNCH_LIFECYCLE_RPC_URL;

package/examples/{launch.mjs → launch.ts}

@@ -9,7 +9,7 @@ const args = process.argv.slice(2);
 const option = (name) => { const index = args.indexOf(name); return index === -1 ? undefined : args[index + 1]; };
 const planFile = option("--plan"), rpcUrl = option("--rpc"), mode = option("--mode");
 if (!planFile || !rpcUrl || !["atomic", "staged"].includes(mode)) {
-  throw new Error("Usage: node examples/launch.mjs --plan plan.json --rpc RPC_URL --mode atomic|staged [--limits current-limits.json] [--receipts receipts.json] [--confirmations N] [--fork-rpc LOOPBACK_RPC_URL] [--mine]");
+  throw new Error("Usage: node examples/launch.ts --plan plan.json --rpc RPC_URL --mode atomic|staged [--limits current-limits.json] [--receipts receipts.json] [--confirmations N] [--fork-rpc LOOPBACK_RPC_URL] [--mine]");
 }
 const client = createPublicClient({ transport: http(rpcUrl) });
 const plan = parseLaunchPlan(await readFile(planFile, "utf8"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@black-market/sdk",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "TypeScript SDK for Abyss token launches, swaps, and lending.",
   "license": "MIT",
   "repository": {
@@ -39,7 +39,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
-    "examples": "pnpm build && node examples/quickstart.mjs",
+    "examples": "pnpm build && node examples/quickstart.ts",
     "lint": "tsc -p tsconfig.json --noEmit",
     "prepublishOnly": "pnpm build",
     "test": "pnpm test:unit",

package/src/launch.ts

@@ -43,9 +43,9 @@ export type LaunchPositionRangesInput = {
   /** Source-defined Black Market inventory weights, widths and gaps. */
   distributionPreset: "early-scarcity" | "staircase" | "smooth-ramp";
   positionCount?: number;
-  /** Defaults to source-gaps; adjacent removes only Staircase's empty shelf gaps. */
-  staircaseBoundaries?: "source-gaps" | "adjacent";
-  /** Defaults to false; extends only the final band's far endpoint. */
+  /** Defaults to source-gaps for Staircase/Early Scarcity; adjacent removes their gaps. */
+  positionGaps?: "source-gaps" | "adjacent";
+  /** Defaults to true; extends only the final band's far endpoint. */
   extendFinalRangeToBoundary?: boolean;
 };
 
@@ -78,6 +78,21 @@ export type LaunchPositionRanges = {
   maxLiquidityPerTick: bigint;
 };
 
+export type LaunchTopologyPosition = {
+  tickLower: number; tickUpper: number;
+} & ({ maxTokenAmount: bigint } | { tokenAmountMaximum: bigint });
+
+export type LaunchTopologyCoverageInput = {
+  positions: readonly LaunchTopologyPosition[];
+  /** Canonical tick derived from the market's opening sqrtPriceX96. */
+  openingTick: number;
+  tickSpacing: number;
+  /** Existing launch convention: true means the launched token is token0. */
+  launchedTokenIsQuote: boolean;
+  /** Defaults to false; opening containment and the permanent tail remain required. */
+  allowInteriorGaps?: boolean;
+};
+
 export type LaunchBuySqrtPriceLimitInput = {
   launchSqrtPriceX96: bigint;
   launchedTokenIsQuote: boolean;
@@ -196,7 +211,7 @@ export function getSqrtRatioAtTick(tick: number): bigint {
   return (ratio >> 32n) + (ratio % Q32 === 0n ? 0n : 1n);
 }
 
-function getTickAtSqrtRatio(sqrtPriceX96: bigint): number {
+export function getTickAtSqrtRatio(sqrtPriceX96: bigint): number {
   assertCanonicalSqrtPrice(sqrtPriceX96, "sqrtPriceX96");
 
   let low = MIN_TICK;
@@ -242,6 +257,56 @@ function launchBand(
   return { tickLower, tickUpper };
 }
 
+/**
+ * Requires opening buy-side liquidity, continuous forward coverage and a funded
+ * permanent tail at the usable protocol boundary. Overlaps and adjacency are valid.
+ * Token1 containment includes the upper endpoint crossed by the first downward buy.
+ * Input positions are never reordered or mutated.
+ */
+export function assertLaunchTopologyCoverage(input: LaunchTopologyCoverageInput): void {
+  const { positions, openingTick, tickSpacing, launchedTokenIsQuote } = input;
+  if (!Number.isInteger(tickSpacing) || tickSpacing < 1 || tickSpacing > 32767) throw new Error("tickSpacing must be 1..32767");
+  if (typeof launchedTokenIsQuote !== "boolean") throw new Error("launchedTokenIsQuote must be a boolean");
+  const allowInteriorGaps = input.allowInteriorGaps ?? false;
+  if (typeof allowInteriorGaps !== "boolean") throw new Error("allowInteriorGaps must be a boolean");
+  getSqrtRatioAtTick(openingTick);
+  const band = launchBand(openingTick, tickSpacing, launchedTokenIsQuote);
+  const boundaryTick = launchedTokenIsQuote ? band.tickUpper : band.tickLower;
+  let containsOpening = false;
+  let hasPermanentTail = false;
+  for (const position of positions) {
+    const { tickLower, tickUpper } = position;
+    if (!Number.isInteger(tickLower) || !Number.isInteger(tickUpper) ||
+      tickLower % tickSpacing !== 0 || tickUpper % tickSpacing !== 0) {
+      throw new Error("TOPOLOGY_OFF_GRID_TICK: Every position endpoint must be spacing-aligned");
+    }
+    getSqrtRatioAtTick(tickLower);
+    getSqrtRatioAtTick(tickUpper);
+    if (tickLower >= tickUpper) throw new Error("TOPOLOGY_OPENING_GAP: Every position must have a nonempty tick range");
+    if (launchedTokenIsQuote ? tickLower <= openingTick && openingTick < tickUpper : tickLower < openingTick && openingTick <= tickUpper) {
+      containsOpening = true;
+    }
+    const tokenMaximum = "maxTokenAmount" in position ? position.maxTokenAmount : position.tokenAmountMaximum;
+    if ((launchedTokenIsQuote ? tickUpper : tickLower) === boundaryTick && tokenMaximum > 0n) hasPermanentTail = true;
+  }
+  if (!containsOpening) throw new Error("TOPOLOGY_OPENING_GAP: No opening buy-side band contains the launch tick");
+  const sorted = [...positions].sort(launchedTokenIsQuote
+    ? (left, right) => left.tickLower - right.tickLower
+    : (left, right) => right.tickUpper - left.tickUpper);
+  let coveredTo = openingTick;
+  for (const position of sorted) {
+    const near = launchedTokenIsQuote ? position.tickLower : position.tickUpper;
+    const far = launchedTokenIsQuote ? position.tickUpper : position.tickLower;
+    if (launchedTokenIsQuote ? far <= coveredTo : far >= coveredTo) continue;
+    if (!allowInteriorGaps && (launchedTokenIsQuote ? near > coveredTo : near < coveredTo)) {
+      throw new Error(`TOPOLOGY_INTERIOR_GAP: Uncovered interval between ticks ${coveredTo} and ${near}`);
+    }
+    coveredTo = far;
+    if (coveredTo === boundaryTick) break;
+  }
+  if (!hasPermanentTail) throw new Error(`MISSING_PERMANENT_TAIL: A positive token allocation must reach tick ${boundaryTick}`);
+}
+
 function liquidityForAmount0(amount0: bigint, sqrtLowerX96: bigint, sqrtUpperX96: bigint): bigint {
   return (((amount0 * sqrtLowerX96) / Q96) * sqrtUpperX96) / (sqrtUpperX96 - sqrtLowerX96);
 }
@@ -333,8 +398,8 @@ function apportionLaunchInventory(total: number, scores: readonly number[]): num
 /**
  * Source-defined one-sided Black Market presets, ordered toward higher launch-token
  * prices. The first position starts at launch; later bands are contiguous or leave
- * the preset's intentional gaps. Only an explicit final-tail adaptation reaches
- * the usable protocol boundary; no equal-tick extrapolation is applied.
+ * the preset's intentional gaps. By default the final band reaches the usable
+ * protocol boundary; no equal-tick extrapolation is applied to earlier bands.
  * Supply allocation across pools belongs to the caller: pass each pool's share.
  * Budget caps floor all but the final allocation, which receives the remainder.
  * Exact rational funding floors guarantee canonical rounded-up mint debits fit
@@ -356,14 +421,16 @@ export function deriveLaunchPositionRanges(input: LaunchPositionRangesInput): La
   }
   const positionCount = input.positionCount ?? 5;
   if (!Number.isInteger(positionCount) || positionCount < 2 || positionCount > 16) throw new Error("positionCount must be 2..16");
-  const extendFinalRangeToBoundary = input.extendFinalRangeToBoundary ?? false;
+  const extendFinalRangeToBoundary = input.extendFinalRangeToBoundary ?? true;
   if (typeof extendFinalRangeToBoundary !== "boolean") throw new Error("extendFinalRangeToBoundary must be a boolean");
-  const staircaseBoundaries = input.staircaseBoundaries === undefined ? "source-gaps" : input.staircaseBoundaries;
-  if (staircaseBoundaries !== "source-gaps" && staircaseBoundaries !== "adjacent") {
-    throw new Error("staircaseBoundaries must be source-gaps or adjacent");
+  const positionGaps = input.positionGaps === undefined
+    ? distributionPreset === "smooth-ramp" ? "adjacent" : "source-gaps"
+    : input.positionGaps;
+  if (positionGaps !== "source-gaps" && positionGaps !== "adjacent") {
+    throw new Error("positionGaps must be source-gaps or adjacent");
   }
-  if (input.staircaseBoundaries !== undefined && distributionPreset !== "staircase") {
-    throw new Error("staircaseBoundaries is only valid for the staircase preset");
+  if (distributionPreset === "smooth-ramp" && positionGaps === "source-gaps") {
+    throw new Error("smooth-ramp positions are always adjacent");
   }
   const launchTick = getTickAtSqrtRatio(input.launchSqrtPriceX96);
   if (launchTick % tickSpacing !== 0 || getSqrtRatioAtTick(launchTick) !== input.launchSqrtPriceX96) {
@@ -403,10 +470,10 @@ export function deriveLaunchPositionRanges(input: LaunchPositionRangesInput): La
       : (input.tokenBudget * BigInt(weight)) / 10_000n;
     if (allocatedTokenAmount <= 0n) throw new Error("Every position must have a positive allocated token cap");
     allocated += allocatedTokenAmount;
-    if (index > 0) {
+    if (index > 0 && positionGaps === "source-gaps") {
       if (distributionPreset === "early-scarcity") {
         distance += 2 + Math.floor((4 * index) / (positionCount - 1));
-      } else if (distributionPreset === "staircase" && staircaseBoundaries === "source-gaps" &&
+      } else if (distributionPreset === "staircase" &&
         Math.floor((index * 4) / positionCount) !== Math.floor(((index - 1) * 4) / positionCount)) {
         distance += 3;
       }

package/src/lifecycle/abi.ts

@@ -305,6 +305,8 @@ export const lifecycleV4LockerAbi = [
   { type: "function", name: "launcher", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
   { type: "function", name: "positionCount", stateMutability: "view", inputs: [{ type: "bytes32" }], outputs: [{ type: "uint256" }] },
   { type: "function", name: "isSealed", stateMutability: "view", inputs: [{ type: "bytes32" }], outputs: [{ type: "bool" }] },
+  // Present on the deployed V2 locker; read for permanent-custody verification.
+  { type: "function", name: "feeRecipient", stateMutability: "view", inputs: [{ type: "bytes32" }], outputs: [{ type: "address" }] },
 ] as const;
 const poolFeeCollectorFactoryCommonAbi = [
   { type: "function", name: "collectorDeployer", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
@@ -359,6 +361,8 @@ export const lifecycleErc404Abi = [
   { type: "function", name: "unit", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
   { type: "function", name: "baseURI", stateMutability: "view", inputs: [], outputs: [{ type: "string" }] },
   { type: "function", name: "mirrorERC721", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+  // Present on LaunchERC404V1; read for ERC404 supply/custody verification.
+  { type: "function", name: "maxNFTSupply", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
 ] as const;
 export const lifecycleErc404MirrorAbi = [
   { type: "function", name: "baseERC20", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },

package/src/lifecycle/index.ts

@@ -8,4 +8,6 @@ export * from "./fork.js";
 export * from "./authors.js";
 export * from "./presets.js";
 export * from "./transactions.js";
+export { createLifecycleSessionCache } from "./rpc.js";
 export { planLaunch, simulateLaunchPlan, buildNextTransaction, prepareAndPlanLifecycleLaunch } from "./planner.js";
+export { assertLaunchTopologyCoverage, getTickAtSqrtRatio, type LaunchTopologyCoverageInput, type LaunchTopologyPosition } from "../launch.js";

package/src/lifecycle/planner.ts

@@ -1,9 +1,11 @@
 import { encodeFunctionData, keccak256, toHex, zeroAddress, type Address, type Hex } from "viem";
+import { ABYSS_FEE_TIERS } from "../abyss.js";
+import { assertLaunchTopologyCoverage, getTickAtSqrtRatio } from "../launch.js";
 import { launchLifecycleAbi, lifecycleAdapterAbi, lifecycleErc20Abi } from "./abi.js";
 import { hashLaunchIdentity, hashLaunchPlan, LifecycleFundingKind, LifecyclePhase, LifecycleRewardMode, LifecycleTokenKind, LIFECYCLE_MAX_REWARD_ERC20_SUPPLY, LIFECYCLE_MAX_ERC404_SUPPLY, parseLaunchPlan, serializeLaunchPlan, type LaunchPlanV1 } from "./schema.js";
 import { readLaunchProgress, readLifecycleProfiles, readLifecycleTokenAtBlock, readPoolBoundHookDeployment } from "./progress.js";
-import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, encodePoolBoundV4LifecycleMarketConfig, isPoolBoundV4ConfigVersion, minePoolBoundHookSalt, type V4LifecycleMarketConfig, type V4PoolBoundLifecycleMarketConfig } from "./markets.js";
-import { assertLifecycleBlock, assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleRpc, lifecycleStage, readLifecycleBlock, readLifecycleChainId, readLifecycleContract, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
+import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, encodePoolBoundV4LifecycleMarketConfig, isPoolBoundV4ConfigVersion, minePoolBoundHookSalt, type AbyssLifecycleMarketConfig, type V4LifecycleMarketConfig, type V4PoolBoundLifecycleMarketConfig } from "./markets.js";
+import { assertLifecycleBlock, assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleStaticRpc, lifecycleRpc, lifecycleStage, readLifecycleBlock, readLifecycleChainId, readLifecycleContract, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
 import { prepareLaunchSimulation, simulateLaunchTransactions, type NextTransactionEnvelope } from "./simulation.js";
 import { LifecyclePlanningError, type BuildNextTransactionOptions, type CanonicalLaunchProgress, type LifecycleBlock, type LifecycleConstructionProfile, type LifecycleFundingPrerequisite, type LifecyclePoolBoundHookDeployment, type LifecycleProfile, type LifecycleRpcClient, type LifecycleSimulation, type LifecycleTransaction, type PlannedLaunch, type PlanLaunchOptions, type PrepareAndPlanLifecycleLaunchOptions, type SimulateLaunchPlanOptions } from "./types.js";
 import { deriveKnownPoolBoundHookDeployment, protectOrderedBuyMinimums, validateBuySlippageBps } from "./calibration.js";
@@ -11,7 +13,12 @@ import { getKnownLifecycleDeployment, getKnownLifecycleProfile } from "./presets
 import { buildLaunchTransactions } from "./transactions.js";
 import { assertLifecycleMarketAllocation, assertLifecycleSupplyAllocation } from "./allocations.js";
 
-function validatePlanShape(plan: LaunchPlanV1): Hex {
+type ValidatedPlanShape = {
+  commitment: Hex;
+  marketConfigs: (AbyssLifecycleMarketConfig | V4LifecycleMarketConfig | V4PoolBoundLifecycleMarketConfig)[];
+};
+
+function validatePlanShape(plan: LaunchPlanV1): ValidatedPlanShape {
   // Encoding checks all exact integer widths, addresses, byte strings and tuple fields.
   const commitment = hashLaunchPlan(plan);
   if (plan.markets.length === 0 || plan.markets.length > 16 || plan.buys.length > 64 || plan.funding.length > 8 || plan.feeAssets.length === 0 || plan.feeAssets.length > 8 || plan.token.supply <= 0n || plan.token.inventoryRecipient === zeroAddress || plan.token.inventoryRecipient.toLowerCase() === plan.orchestrator.toLowerCase() || plan.executorFeeBps > 1000) throw new LifecyclePlanningError("INVALID_PLAN", "Plan exceeds lifecycle bounds or lacks positive token economics");
@@ -36,6 +43,7 @@ function validatePlanShape(plan: LaunchPlanV1): Hex {
   }
   const v4Quotes = new Set<string>();
   let positionCount = 0;
+  const marketConfigs: ValidatedPlanShape["marketConfigs"] = [];
   for (const market of plan.markets) {
     if (market.tokenBudget <= 0n || market.config === "0x" || (market.config.length - 2) / 2 > 16384) throw new LifecyclePlanningError("INVALID_MARKET", "Each market needs a positive token budget and bounded versioned config");
     let config: V4LifecycleMarketConfig | V4PoolBoundLifecycleMarketConfig | undefined;
@@ -49,8 +57,13 @@ function validatePlanShape(plan: LaunchPlanV1): Hex {
       v4Quotes.add(quote);
       if (config.lpFeePips >= 1000000 || (config.version === 6 ? config.hookFeePips > 1000000 : config.hookFeePips >= 1000000) || config.feeMode > 1 || config.tickSpacing < 1 || config.tickSpacing > 32767 || config.sqrtPriceX96 < 4295128739n || config.sqrtPriceX96 >= 1461446703485210103287273052203988822378723970342n || (config.protocolFeeDenominator !== 0 && (config.protocolFeeDenominator < 4 || config.protocolFeeDenominator > 10 || config.treasury === zeroAddress))) throw new LifecyclePlanningError("INVALID_MARKET", "V4 market violates lifecycle fee, price, treasury or position bounds");
       positionCount += assertLifecycleMarketAllocation(market, config.positions);
+      marketConfigs.push(config);
+    }
+    else {
+      const abyss = decodeAbyssLifecycleMarketConfig(market.config);
+      positionCount += assertLifecycleMarketAllocation(market, abyss.positions);
+      marketConfigs.push(abyss);
     }
-    else positionCount += assertLifecycleMarketAllocation(market, decodeAbyssLifecycleMarketConfig(market.config).positions);
     if (positionCount > 32) throw new LifecyclePlanningError("INVALID_POSITION_COUNT", "A launch commits at most 32 total positions across every venue");
   }
   assertLifecycleSupplyAllocation(plan);
@@ -59,7 +72,7 @@ function validatePlanShape(plan: LaunchPlanV1): Hex {
     const funding = plan.funding.find((item) => item.asset.toLowerCase() === market.quoteAsset.toLowerCase());
     if (required > (funding?.amount ?? 0n)) throw new LifecyclePlanningError("INVALID_FUNDING", "Quote funding does not cover all ordered buys for its asset");
   }
-  return commitment;
+  return { commitment, marketConfigs };
 }
 
 async function readFunding(client: LifecycleRpcClient, plan: LaunchPlanV1, block: LifecycleBlock): Promise<{ prerequisites: LifecycleFundingPrerequisite[]; approvals: LifecycleTransaction[] }> {
@@ -180,7 +193,7 @@ function assertReviewedTransactionUnchanged(options: BuildNextTransactionOptions
 async function readTokenFactoryBinding(client: LifecycleRpcClient, orchestrator: Address, block: LifecycleBlock): Promise<Pick<PlannedLaunch, "tokenFactory" | "tokenFactoryCodeHash">> {
   const tokenFactory = await readLifecycleContract<Address>(client, orchestrator, launchLifecycleAbi, "tokenFactory", [], block);
   const [codeValue, authority] = await Promise.all([
-    lifecyclePinnedRpc(client, "eth_getCode", [tokenFactory, toHex(block.number)], block),
+    lifecycleStaticRpc(client, "eth_getCode", [tokenFactory, toHex(block.number)], block),
     readLifecycleContract<Address>(client, tokenFactory, lifecycleAdapterAbi, "core", [], block),
   ]);
   const code = rpcHex(codeValue, "token factory code");
@@ -202,7 +215,7 @@ function assertPlanningActive(signal?: AbortSignal): void {
   if (signal?.aborted) throw Object.assign(new Error("Lifecycle launch planning cancelled"), { name: "AbortError" });
 }
 
-function validatePlanningIntent(options: PlanLaunchOptions): Hex {
+function validatePlanningIntent(options: PlanLaunchOptions): ValidatedPlanShape {
   const { plan, account, mode } = options;
   assertPlanningActive(options.signal);
   if (mode !== "atomic" && mode !== "staged") throw new LifecyclePlanningError("EXPLICIT_MODE_REQUIRED", "Choose atomic or staged explicitly; staged is never silently substituted");
@@ -211,15 +224,45 @@ function validatePlanningIntent(options: PlanLaunchOptions): Hex {
   return validatePlanShape(plan);
 }
 
+function validatePlanTopology(options: PlanLaunchOptions, marketConfigs: ValidatedPlanShape["marketConfigs"], token: Address): void {
+  for (const [marketIndex, config] of marketConfigs.entries()) {
+    try {
+      let tickSpacing: number;
+      let openingSqrtPriceX96: bigint;
+      if ("version" in config) {
+        tickSpacing = config.tickSpacing;
+        openingSqrtPriceX96 = config.sqrtPriceX96;
+      } else {
+        const tier = ABYSS_FEE_TIERS.find(({ feePips }) => feePips === config.fee);
+        if (tier === undefined) throw new LifecyclePlanningError("INVALID_MARKET", "Abyss market fee must select a canonical tick-spacing tier");
+        tickSpacing = tier.tickSpacing;
+        openingSqrtPriceX96 = config.openingSqrtPriceX96;
+      }
+      assertLaunchTopologyCoverage({ positions: config.positions, openingTick: getTickAtSqrtRatio(openingSqrtPriceX96), tickSpacing,
+        launchedTokenIsQuote: BigInt(token) < BigInt(options.plan.markets[marketIndex]!.quoteAsset),
+        allowInteriorGaps: options.allowTopologyGaps === true });
+    } catch (error) {
+      if (!(error instanceof Error)) throw error;
+      const code = error.message.slice(0, error.message.indexOf(":"));
+      if (code === "MISSING_PERMANENT_TAIL" && options.allowMissingPermanentTail === true) continue;
+      if (code === "TOPOLOGY_OPENING_GAP" || code === "TOPOLOGY_INTERIOR_GAP" ||
+        code === "MISSING_PERMANENT_TAIL" || code === "TOPOLOGY_OFF_GRID_TICK") {
+        throw new LifecyclePlanningError(code, `Market ${marketIndex}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+}
+
 function assertFinalPlan(planned: PlannedLaunch, signal?: AbortSignal): void {
   assertPlanningActive(signal);
   if (hashLaunchPlan(planned.plan).toLowerCase() !== planned.planHash.toLowerCase() || hashLaunchIdentity(planned.plan).toLowerCase() !== planned.launchId.toLowerCase()) throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed during asynchronous planning; previous reads and simulation are invalid");
 }
 
 /** One owner constructs and mines, optionally measures actual ordered buy outputs,
- * then proves only the final protected commitment. No certificates or skip flags. */
+ * then proves only the final protected commitment. No cached execution certificates. */
 export async function prepareAndPlanLifecycleLaunch(options: PrepareAndPlanLifecycleLaunchOptions): Promise<PlannedLaunch> {
-  const commitment = validatePlanningIntent(options);
+  const { commitment } = validatePlanningIntent(options);
   if (options.buySlippageBps !== undefined) validateBuySlippageBps(options.buySlippageBps);
   const needsMining = options.plan.markets.some((market) => isPoolBoundV4ConfigVersion(market.configVersion));
   const needsProtection = options.buySlippageBps !== undefined && options.plan.buys.length !== 0;
@@ -293,7 +336,7 @@ export async function planLaunch(options: PlanLaunchOptions): Promise<PlannedLau
 
 async function planLaunchWithReads(options: PlanLaunchOptions, client: LifecycleRpcClient, pinnedBlock?: LifecycleBlock, ownedProgress?: CanonicalLaunchProgress, diagnostic = false, reviewed?: ReviewedNextTransaction): Promise<PlannedLaunch> {
   const { plan, account, mode } = options;
-  const planHash = validatePlanningIntent(options);
+  const { commitment: planHash, marketConfigs } = validatePlanningIntent(options);
   const launchId = hashLaunchIdentity(plan);
   const [block, chainId] = await lifecycleStage(client, "plan.context", () => Promise.all([
     pinnedBlock ?? readLifecycleBlock(client), readLifecycleChainId(client),
@@ -322,7 +365,8 @@ async function planLaunchWithReads(options: PlanLaunchOptions, client: Lifecycle
   ]));
   assertPlanningActive(options.signal);
   const placeholder: LifecycleSimulation = { backend: "unavailable", confidence: "provisional", admitted: false, executionProof: "unavailable", protocolFit: "unknown", transportPreflight: "not-requested", blockNumber: block.number, blockHash: block.hash, account, chainId: plan.chainId, limits, steps: [] };
-  let planned: PlannedLaunch = { ...identity, tokenFactory, tokenFactoryCodeHash, chainId: plan.chainId, transactions: [], totalCalldataBytes: 0, prerequisites: [], profiles: [], hookDeployments: [], progress, simulation: placeholder, preparationBatchSize: plan.markets.length, limits: options.limits };
+  let planned: PlannedLaunch = { ...identity, tokenFactory, tokenFactoryCodeHash, chainId: plan.chainId, transactions: [], totalCalldataBytes: 0, prerequisites: [], profiles: [], hookDeployments: [], progress, simulation: placeholder, preparationBatchSize: plan.markets.length, limits: options.limits,
+    allowTopologyGaps: options.allowTopologyGaps === true, allowMissingPermanentTail: options.allowMissingPermanentTail === true };
   const receiptsPending = progress.receipts.some((receipt) => receipt.status === "pending" || receipt.status === "unconfirmed");
   if (!progress.confirmationSafe || receiptsPending) {
     const hookDeployments: LifecyclePoolBoundHookDeployment[] = [];
@@ -340,6 +384,9 @@ async function planLaunchWithReads(options: PlanLaunchOptions, client: Lifecycle
     await assertLifecycleBlock(client, block, plan.chainId);
     return { ...planned, simulation: { ...placeholder, confidence: "stateful", executionProof: "proved", protocolFit: "proved", admitted: true, reason: "Canonical launch is terminal; no transaction remains" } };
   }
+  // Topology is a creation policy, not a retroactive obstacle to recovery of
+  // immutable onchain commitments. Waiting and terminal launches returned above.
+  if (progress.canonical.phase === LifecyclePhase.None && progress.head.phase === LifecyclePhase.None) validatePlanTopology(options, marketConfigs, identity.predictedToken);
   const [funding, metadata] = await lifecycleStage(client, "plan.inputs", () => Promise.all([
     progress.canonical.phase === LifecyclePhase.None ? readFunding(client, plan, block) : { prerequisites: [], approvals: [] },
     readPlanMetadata(client, plan, identity.predictedToken, block),
@@ -459,7 +506,8 @@ export async function buildNextTransaction(options: BuildNextTransactionOptions)
       if (next === undefined) throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Cancellation omitted its exact simulation admission", simulation);
       return preflightNextTransaction(options, next, simulation, reviewed);
     }
-    const refreshed = await lifecycleStage(client, "plan", () => planLaunchWithReads({ client, plan: options.planned.plan, account: options.planned.account, mode: options.planned.mode, limits: options.limits === undefined ? options.planned.limits : options.limits, fork: options.fork, receipts: options.receipts, confirmations: options.confirmations ?? options.planned.confirmations, signal: options.signal }, client, block, progress, false, reviewed));
+    const refreshed = await lifecycleStage(client, "plan", () => planLaunchWithReads({ client, plan: options.planned.plan, account: options.planned.account, mode: options.planned.mode, limits: options.limits === undefined ? options.planned.limits : options.limits, fork: options.fork, receipts: options.receipts, confirmations: options.confirmations ?? options.planned.confirmations, signal: options.signal,
+      allowTopologyGaps: options.planned.allowTopologyGaps, allowMissingPermanentTail: options.planned.allowMissingPermanentTail }, client, block, progress, false, reviewed));
     assertFinalPlan(refreshed, options.signal);
     if (!refreshed.simulation.admitted) throw new LifecyclePlanningError("PLAN_NOT_ADMITTED", refreshed.simulation.reason ?? "Remaining exact launch sequence is not admitted", refreshed.simulation);
     assertPlannedDeploymentBindings(options.planned, refreshed);
@@ -478,6 +526,7 @@ export async function simulateLaunchPlan(options: SimulateLaunchPlanOptions): Pr
     client, plan: planned.plan, account: planned.account, mode: planned.mode,
     limits: options.limits === undefined ? planned.limits : options.limits, fork: options.fork,
     receipts: options.receipts, confirmations: options.confirmations ?? planned.confirmations, signal: options.signal,
+    allowTopologyGaps: planned.allowTopologyGaps, allowMissingPermanentTail: planned.allowMissingPermanentTail,
   });
   assertPlannedDeploymentBindings(planned, current);
   return current.simulation;

package/src/lifecycle/progress.ts

@@ -2,7 +2,7 @@ import { concatHex, decodeFunctionData, encodeAbiParameters, encodeFunctionData,
 import { launchLifecycleAbi, lifecycleAdapterAbi, lifecycleDirectoryAbi, lifecycleErc20Abi, lifecycleOracleFactoryAbi, lifecycleRegistryAbi, poolFeeCollectorFactoryV1Abi, poolFeeCollectorFactoryConfigV6Abi, lifecycleV4HookAbi, lifecycleV4LockerAbi, poolHookDeployerV1Abi, poolHookDeployerConfigV6Abi, sharedHookDeployerV1Abi, fixedFeePoolHookV1Abi, fixedFeePoolHookConfigV6Abi, poolMarketAdapterV1Abi, sharedMarketAdapterV1Abi } from "./abi.js";
 import { buildPoolBoundHookParameters, decodePoolBoundV4LifecycleMarketConfig, encodePoolBoundHookParameters, hasLifecycleV4HookPermissions, isPoolBoundV4ConfigVersion, poolBoundHookInitCodeHash, predictPoolBoundHookAddress, validateV4LifecycleMarket, V4_LIFECYCLE_CONFIG_SCHEMA, V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA_V5, V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA_V6, type PoolBoundHookParameters, type PoolBoundLifecycleConfigVersion } from "./markets.js";
 import { hashLaunchIdentity, hashLaunchPlan, hashLaunchBounds, hashLaunchDependencies, hashLifecycleProfile, lifecycleTokenComponents, launchProgressV1Components, LifecycleMode, LifecyclePhase, LifecycleVenue, LIFECYCLE_REQUIRED_CAPABILITIES, LIFECYCLE_ERC404_CAPABILITY, LIFECYCLE_MULTI_POSITION_CAPABILITY, type AdapterRegistrationV1, type LaunchPlanV1, type LaunchProgressV1, type MarketIdentityV1, type MarketLiveStateV1, type PreparedMarketV1, type ProfileRegistrationV1, type ProfileTopologyV1, type LaunchEnvelopeV2, type LifecycleDeveloperTerms } from "./schema.js";
-import { assertLifecycleBlock, assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleRpc, lifecycleStage, readLifecycleBlock, readLifecycleChainId, readLifecycleContract, readLifecycleProfileTopology, rpcHex, rpcObject, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
+import { assertLifecycleBlock, assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleStaticRpc, lifecycleRpc, lifecycleStage, readLifecycleBlock, readLifecycleChainId, readLifecycleContract, readLifecycleStaticContract, readLifecycleProfileTopology, rpcHex, rpcObject, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
 import { LifecyclePlanningError, type CanonicalLaunchProgress, type LifecycleBlock, type LifecycleMarketProgress, type LifecycleProfile, type LifecycleReceiptReference, type LifecycleReceiptStatus, type LifecycleRpcClient, type PoolBoundHookDeployment, type ReadLaunchProgressOptions } from "./types.js";
 import { deriveKnownPoolBoundHookDeployment } from "./calibration.js";
 import { getKnownLifecycleDeployment, getKnownLifecycleProfile } from "./presets.js";
@@ -76,7 +76,7 @@ function lifecycleProfileCertificateKey(orchestrator: Address, registry: Address
 }
 
 async function readDependencyCode(client: LifecycleRpcClient, address: Address, block: LifecycleBlock): Promise<Hex> {
-  const code = rpcHex(await lifecyclePinnedRpc(client, "eth_getCode", [address, toHex(block.number)], block), "lifecycle dependency code");
+  const code = rpcHex(await lifecycleStaticRpc(client, "eth_getCode", [address, toHex(block.number)], block), "lifecycle dependency code");
   if (address === zeroAddress || code === "0x") throw new LifecyclePlanningError("PROFILE_DEPENDENCY", `Lifecycle dependency ${address} has no deployed code`);
   return code;
 }
@@ -118,7 +118,7 @@ async function certifyLifecycleProfileFresh(client: LifecycleRpcClient, orchestr
     const known = [0, 1, 2, 3].some((variant) => keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "uint256" }, { type: "address" }, { type: "uint8" }], [domain, chainId, factory, variant])).toLowerCase() === id.toLowerCase());
     if (!known || registration.venue.toLowerCase() !== factory.toLowerCase() || registration.hook !== zeroAddress) throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Abyss profile is not the exact canonical factory/variant/schema binding");
     if (eligibility !== undefined && "failure" in eligibility) throw eligibility.failure;
-    const eligible = eligibility?.eligible ?? await readLifecycleContract<Address>(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, version, LIFECYCLE_REQUIRED_CAPABILITIES], block);
+    const eligible = eligibility?.eligible ?? await readLifecycleStaticContract<Address>(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, version, LIFECYCLE_REQUIRED_CAPABILITIES], block);
     if (eligible.toLowerCase() !== adapter.implementation.toLowerCase()) throw new LifecyclePlanningError("INELIGIBLE_PROFILE", "Registry refuses this profile for pending source admission");
     return Object.freeze({ topology: Object.freeze({ ...topology }) });
   }
@@ -147,28 +147,28 @@ async function certifyLifecycleProfileFresh(client: LifecycleRpcClient, orchestr
   // Frozen graph addresses permit independent evidence reads. Getter results
   // still have to match that graph; none of these observations is caller authority.
   const [eligible, metadata, actualVersion, dependencies, dependencyCodes, collectorDeployer, launcher, lockerManager, creationCodeHash, chunk0, chunk1, chunkCodes, sharedRoot] = await Promise.all([
-    readLifecycleContract<Address>(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, version, LIFECYCLE_REQUIRED_CAPABILITIES], block),
-    Promise.all((["PROFILE_ID", "CONFIG_SCHEMA", "implementationRegistry"] as const).map((getter) => readLifecycleContract<Hex>(client, adapter.implementation, abi, getter, [], block))),
-    readLifecycleContract<number>(client, adapter.implementation, abi, "CONFIG_VERSION", [], block),
-    Promise.all((["poolManager", "hookRoot", "oracleFactory", "locker", "collectorFactory", "hookDeployer"] as const).map((getter) => readLifecycleContract<Address>(client, adapter.implementation, abi, getter, [], block))),
+    readLifecycleStaticContract<Address>(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, version, LIFECYCLE_REQUIRED_CAPABILITIES], block),
+    Promise.all((["PROFILE_ID", "CONFIG_SCHEMA", "implementationRegistry"] as const).map((getter) => readLifecycleStaticContract<Hex>(client, adapter.implementation, abi, getter, [], block))),
+    readLifecycleStaticContract<number>(client, adapter.implementation, abi, "CONFIG_VERSION", [], block),
+    Promise.all((["poolManager", "hookRoot", "oracleFactory", "locker", "collectorFactory", "hookDeployer"] as const).map((getter) => readLifecycleStaticContract<Address>(client, adapter.implementation, abi, getter, [], block))),
     Promise.all(codeBindings.map(([address]) => readDependencyCode(client, address, block))),
-    readLifecycleContract<Address>(client, g.collectorFactory, poolFeeCollectorFactoryV1Abi, "collectorDeployer", [], block),
-    readLifecycleContract<Address>(client, g.locker, lifecycleV4LockerAbi, "launcher", [], block),
-    readLifecycleContract<Address>(client, g.locker, lifecycleV4LockerAbi, "poolManager", [], block),
-    readLifecycleContract<Hex>(client, g.hookDeployer, deployerAbi, "creationCodeHash", [], block),
-    readLifecycleContract<Address>(client, g.hookDeployer, deployerAbi, "codeChunk0", [], block),
-    readLifecycleContract<Address>(client, g.hookDeployer, deployerAbi, "codeChunk1", [], block),
+    readLifecycleStaticContract<Address>(client, g.collectorFactory, poolFeeCollectorFactoryV1Abi, "collectorDeployer", [], block),
+    readLifecycleStaticContract<Address>(client, g.locker, lifecycleV4LockerAbi, "launcher", [], block),
+    readLifecycleStaticContract<Address>(client, g.locker, lifecycleV4LockerAbi, "poolManager", [], block),
+    readLifecycleStaticContract<Hex>(client, g.hookDeployer, deployerAbi, "creationCodeHash", [], block),
+    readLifecycleStaticContract<Address>(client, g.hookDeployer, deployerAbi, "codeChunk0", [], block),
+    readLifecycleStaticContract<Address>(client, g.hookDeployer, deployerAbi, "codeChunk1", [], block),
     Promise.all([
       readDependencyCode(client, g.codeChunk0, block),
       g.codeChunk1 === zeroAddress ? Promise.resolve<Hex>("0x") : readDependencyCode(client, g.codeChunk1, block),
     ]),
     shared ? Promise.all([
       readDependencyCode(client, g.hookRoot, block),
-      readLifecycleContract<Hex>(client, g.hookDeployer, deployerAbi, "deployedCodeHash", [g.hookRoot], block),
-      readLifecycleContract<Address>(client, g.hookDeployer, sharedHookDeployerV1Abi, "predict", [g.manager, adapter.implementation, g.oracleFactory, g.sharedHookSalt], block),
-      Promise.all((["registrar", "poolManager", "oracleFactory"] as const).map((getter) => readLifecycleContract<Address>(client, g.hookRoot, lifecycleV4HookAbi, getter, [], block))),
-      readLifecycleContract<bigint>(client, g.hookRoot, lifecycleV4HookAbi, "REQUIRED_HOOK_FLAGS", [], block),
-      readLifecycleContract<bigint>(client, g.hookRoot, lifecycleV4HookAbi, "ALL_HOOK_MASK", [], block),
+      readLifecycleStaticContract<Hex>(client, g.hookDeployer, deployerAbi, "deployedCodeHash", [g.hookRoot], block),
+      readLifecycleStaticContract<Address>(client, g.hookDeployer, sharedHookDeployerV1Abi, "predict", [g.manager, adapter.implementation, g.oracleFactory, g.sharedHookSalt], block),
+      Promise.all((["registrar", "poolManager", "oracleFactory"] as const).map((getter) => readLifecycleStaticContract<Address>(client, g.hookRoot, lifecycleV4HookAbi, getter, [], block))),
+      readLifecycleStaticContract<bigint>(client, g.hookRoot, lifecycleV4HookAbi, "REQUIRED_HOOK_FLAGS", [], block),
+      readLifecycleStaticContract<bigint>(client, g.hookRoot, lifecycleV4HookAbi, "ALL_HOOK_MASK", [], block),
     ]) : undefined,
   ]);
   if (eligible.toLowerCase() !== adapter.implementation.toLowerCase()) throw new LifecyclePlanningError("INELIGIBLE_PROFILE", "Registry refuses this profile for pending source admission");
@@ -214,7 +214,7 @@ export async function validateV4LifecycleOracle(options: {
 }): Promise<void> {
   const { client, envelope, oracleConfigId, block } = options;
   if (oracleConfigId.toLowerCase() === zeroHash) throw new LifecyclePlanningError("INVALID_ORACLE_CONFIG", "Market oracle configuration must be nonzero");
-  const [move, cardinality] = await readLifecycleContract<readonly [number, number]>(client, envelope.graph.oracleFactory, lifecycleOracleFactoryAbi, "oracleConfigs", [oracleConfigId], block);
+  const [move, cardinality] = await readLifecycleStaticContract<readonly [number, number]>(client, envelope.graph.oracleFactory, lifecycleOracleFactoryAbi, "oracleConfigs", [oracleConfigId], block);
   if (move <= 0 || move > 887272 || cardinality < 2 || cardinality > envelope.bounds.maximumOracleCardinality) {
     throw new LifecyclePlanningError("INVALID_ORACLE_CONFIG", "Selected market oracle is unregistered or exceeds the admitted cardinality bounds");
   }
@@ -234,25 +234,25 @@ export async function readLifecycleProfiles(options: { client: LifecycleRpcClien
         if (offset < 0n || limit < 0n || limit > 100n) throw new LifecyclePlanningError("INVALID_PROFILE_PAGE", "Registry profile pages require unsigned offset and limit at most 100");
         let protocolMaximumDeveloperFeeBpsPromise: Promise<number> | undefined;
         const readProtocolMaximumDeveloperFeeBps = () => protocolMaximumDeveloperFeeBpsPromise ??=
-          readLifecycleContract<number>(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block);
+          readLifecycleStaticContract<number>(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block);
         const readProfile = async (id: Hex): Promise<LifecycleProfile> => {
-          const registration = await readLifecycleContract<ProfileRegistrationV1>(client, registry, lifecycleRegistryAbi, "profile", [id], block);
+          const registration = await readLifecycleStaticContract<ProfileRegistrationV1>(client, registry, lifecycleRegistryAbi, "profile", [id], block);
           const schema = registration.configSchema.toLowerCase();
           const venueKind = schema === V4_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() || schema === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA_V5.toLowerCase() || schema === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA_V6.toLowerCase() ? "uniswap-v4" : schema === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? "abyss" : "unknown";
           const [adapter, certification] = await Promise.all([
-            readLifecycleContract<AdapterRegistrationV1>(client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block),
+            readLifecycleStaticContract<AdapterRegistrationV1>(client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block),
             venueKind === "unknown" ? undefined : Promise.all([
               readLifecycleProfileTopology(client, registry, id, block),
               venueKind === "uniswap-v4" ? Promise.all([
-                readLifecycleContract<LaunchEnvelopeV2>(client, registry, lifecycleRegistryAbi, "profileEnvelope", [id], block),
-                readLifecycleContract<readonly [Address, Address, number, Hex, boolean]>(client, registry, lifecycleRegistryAbi, "developerTerms", [id], block),
+                readLifecycleStaticContract<LaunchEnvelopeV2>(client, registry, lifecycleRegistryAbi, "profileEnvelope", [id], block),
+                readLifecycleStaticContract<readonly [Address, Address, number, Hex, boolean]>(client, registry, lifecycleRegistryAbi, "developerTerms", [id], block),
                 readProtocolMaximumDeveloperFeeBps(),
               ]) : undefined,
               // The exact Abyss arguments follow from registration, independently
               // of adapter/topology responses. Handle refusal immediately, but
               // keep its original place after canonical/schema/topology checks.
               venueKind === "abyss" ? chainIdPromise.then(() =>
-                readLifecycleContract<Address>(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, 1, LIFECYCLE_REQUIRED_CAPABILITIES], block)
+                readLifecycleStaticContract<Address>(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, 1, LIFECYCLE_REQUIRED_CAPABILITIES], block)
               ).then((eligible) => ({ eligible }), (failure: unknown) => ({ failure })) : undefined,
             ]).then((values) => ({ values }), (failure: unknown) => ({ failure })),
           ]);
@@ -345,16 +345,16 @@ async function readPoolBoundHookDeploymentDetailsFresh(options: { client: Lifecy
   const registry = await readLifecycleContract<Address>(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block);
   const [authority, registration] = await Promise.all([
     readLifecycleContract<Address>(client, registry, lifecycleRegistryAbi, "core", [], block),
-    readLifecycleContract<ProfileRegistrationV1>(client, registry, lifecycleRegistryAbi, "profile", [market.profileId], block),
+    readLifecycleStaticContract<ProfileRegistrationV1>(client, registry, lifecycleRegistryAbi, "profile", [market.profileId], block),
   ]);
   if (authority.toLowerCase() !== plan.orchestrator.toLowerCase()) throw new LifecyclePlanningError("REGISTRY_BINDING", "Registry is not bound to this lifecycle core");
-  const adapter = await readLifecycleContract<AdapterRegistrationV1>(client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block);
+  const adapter = await readLifecycleStaticContract<AdapterRegistrationV1>(client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block);
   if (registration.adapterId.toLowerCase() !== market.adapterId.toLowerCase()) throw new LifecyclePlanningError("INVALID_BOUND_MARKET", "Market adapter differs from the profile's immutable registration");
   const [recorded, envelope, [implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled], protocolMaximumDeveloperFeeBps, token] = await Promise.all([
     readLifecycleProfileTopology(client, registry, market.profileId, block),
-    readLifecycleContract<LaunchEnvelopeV2>(client, registry, lifecycleRegistryAbi, "profileEnvelope", [market.profileId], block),
-    readLifecycleContract<readonly [Address, Address, number, Hex, boolean]>(client, registry, lifecycleRegistryAbi, "developerTerms", [market.profileId], block),
-    readLifecycleContract<number>(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block),
+    readLifecycleStaticContract<LaunchEnvelopeV2>(client, registry, lifecycleRegistryAbi, "profileEnvelope", [market.profileId], block),
+    readLifecycleStaticContract<readonly [Address, Address, number, Hex, boolean]>(client, registry, lifecycleRegistryAbi, "developerTerms", [market.profileId], block),
+    readLifecycleStaticContract<number>(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block),
     readLifecycleContract<Address>(client, plan.orchestrator, launchLifecycleAbi, "predictToken", [plan], block),
   ]);
   const { boundGraph } = await certifyLifecycleProfile(client, plan.orchestrator, registry, market.profileId, registration, adapter, recorded, envelope, block, chainId);
@@ -374,10 +374,10 @@ async function readPoolBoundHookDeploymentDetailsFresh(options: { client: Lifecy
   const deployerAbi = config.version === 5 ? poolHookDeployerV1Abi : poolHookDeployerConfigV6Abi;
   const collectorAbi = config.version === 5 ? poolFeeCollectorFactoryV1Abi : poolFeeCollectorFactoryConfigV6Abi;
   const [[parameters, parameterSalt], [deployer, initCodeHash, salt, predictedHook], remoteInitCodeHash, remotePrediction] = await Promise.all([
-    readLifecycleContract<readonly [PoolBoundHookParameters, Hex]>(client, boundGraph.collectorFactory, collectorAbi, "poolBoundHookParameters", [adapter.implementation, token, market], block),
-    readLifecycleContract<readonly [Address, Hex, Hex, Address]>(client, adapter.implementation, poolMarketAdapterV1Abi, "hookDeploymentMetadata", [token, market], block),
-    readLifecycleContract<Hex>(client, boundGraph.deployer, deployerAbi, "initCodeHash", [expected], block),
-    readLifecycleContract<Address>(client, boundGraph.deployer, deployerAbi, "predict", [expected, config.hookSalt], block),
+    readLifecycleStaticContract<readonly [PoolBoundHookParameters, Hex]>(client, boundGraph.collectorFactory, collectorAbi, "poolBoundHookParameters", [adapter.implementation, token, market], block),
+    readLifecycleStaticContract<readonly [Address, Hex, Hex, Address]>(client, adapter.implementation, poolMarketAdapterV1Abi, "hookDeploymentMetadata", [token, market], block),
+    readLifecycleStaticContract<Hex>(client, boundGraph.deployer, deployerAbi, "initCodeHash", [expected], block),
+    readLifecycleStaticContract<Address>(client, boundGraph.deployer, deployerAbi, "predict", [expected, config.hookSalt], block),
   ]);
   const localInitCodeHash = poolBoundHookInitCodeHash(boundGraph.creationCode, expected, config.version);
   const localPrediction = predictPoolBoundHookAddress({ deployer: boundGraph.deployer, initCodeHash: localInitCodeHash, salt: config.hookSalt });
@@ -385,7 +385,7 @@ async function readPoolBoundHookDeploymentDetailsFresh(options: { client: Lifecy
   const hookCode = rpcHex(await lifecyclePinnedRpc(client, "eth_getCode", [predictedHook, toHex(block.number)], block), "bound hook code");
   if (hookCode !== "0x") {
     const [deployedCodeHash, dependencies, requiredFlags, allFlags, actualPoolId, deploymentConfigHash, marketCommitment, opening, positions, feePolicy] = await Promise.all([
-      readLifecycleContract<Hex>(client, deployer, deployerAbi, "deployedCodeHash", [predictedHook], block),
+      readLifecycleStaticContract<Hex>(client, deployer, deployerAbi, "deployedCodeHash", [predictedHook], block),
       Promise.all((["poolManager", "registrar", "oracleFactory", "core", "liquidityLocker", "token"] as const).map((getter) => readLifecycleContract<Address>(client, predictedHook, fixedFeePoolHookV1Abi, getter, [], block))),
       readLifecycleContract<bigint>(client, predictedHook, fixedFeePoolHookV1Abi, "REQUIRED_HOOK_FLAGS", [], block),
       readLifecycleContract<bigint>(client, predictedHook, fixedFeePoolHookV1Abi, "ALL_HOOK_MASK", [], block),