@black-market/sdk 0.6.0 → 0.6.2

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

@@ -1 +1 @@
-{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/lifecycle/planner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAyX,KAAK,YAAY,EAAyB,MAAM,aAAa,CAAC;AAK9b,OAAO,EAA0B,KAAK,2BAA2B,EAAwF,KAAK,gCAAgC,EAAyB,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,KAAK,iBAAiB,EAAE,KAAK,qCAAqC,EAAE,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAiOhb,0GAA0G;AAC1G,wBAAsB,6BAA6B,CAAC,OAAO,EAAE;IAC3D,MAAM,EAAE,kBAAkB,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,qCAAqC,KAAK,IAAI,CAAC;CACxE,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,WAAW,EAAE,SAAS,gCAAgC,EAAE,CAAA;CAAE,CAAC,CAiD5F;AAED,yGAAyG;AACzG,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,CA+DnF;AA6BD,yGAAyG;AACzG,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CA4B1H;AAED;qFACqF;AACrF,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAUzG"}
+{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/lifecycle/planner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAyX,KAAK,YAAY,EAAyB,MAAM,aAAa,CAAC;AAK9b,OAAO,EAA0B,KAAK,2BAA2B,EAAwF,KAAK,gCAAgC,EAAyB,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,KAAK,aAAa,EAAE,KAAK,iBAAiB,EAAE,KAAK,qCAAqC,EAAE,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAqQhb,0GAA0G;AAC1G,wBAAsB,6BAA6B,CAAC,OAAO,EAAE;IAC3D,MAAM,EAAE,kBAAkB,CAAC;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,qCAAqC,KAAK,IAAI,CAAC;CACxE,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,WAAW,EAAE,SAAS,gCAAgC,EAAE,CAAA;CAAE,CAAC,CAiD5F;AAED,yGAAyG;AACzG,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,CAMnF;AAyGD,yGAAyG;AACzG,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CA4B1H;AAED;qFACqF;AACrF,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAUzG"}

package/dist/lifecycle/planner.js

@@ -3,7 +3,7 @@ import { launchLifecycleAbi, lifecycleAdapterAbi, lifecycleErc20Abi, lifecycleFu
 import { hashLaunchIdentity, hashLaunchPlan, LifecycleFundingKind, LifecycleMode, LifecyclePhase, LifecycleRewardMode, LifecycleTokenKind, LifecycleVenue, LIFECYCLE_ERC404_CAPABILITY, LIFECYCLE_MAX_REWARD_ERC20_SUPPLY, LIFECYCLE_MAX_ERC404_SUPPLY, LIFECYCLE_MULTI_POSITION_CAPABILITY, LIFECYCLE_REQUIRED_CAPABILITIES, marketIdentityV1Components, parseLaunchPlan, serializeLaunchPlan } from "./schema.js";
 import { ABYSS_LIFECYCLE_CONFIG_SCHEMA, readLaunchProgress, readLifecycleProfiles, readPoolBoundHookDeployment, validateLifecycleMarketIdentity, validateV4LifecycleOracle } from "./progress.js";
 import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, encodePoolBoundV4LifecycleMarketConfig, hasLifecycleV4HookPermissions, minePoolBoundHookSalt, predictPoolBoundHookAddress, validateV4LifecycleMarket, V4_LIFECYCLE_CONFIG_SCHEMA, V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA } from "./markets.js";
-import { assertLifecycleBlock, lifecycleRpc, readLifecycleBlock, readLifecycleContract, resolveLifecycleLimits, rpcHex, rpcQuantity } from "./rpc.js";
+import { assertLifecycleBlock, lifecyclePinnedRpc, lifecycleRpc, lifecycleStage, readLifecycleBlock, readLifecycleContract, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
 import { simulateLaunchTransactions } from "./simulation.js";
 import { LifecyclePlanningError } from "./types.js";
 function validatePlanShape(plan) {
@@ -74,47 +74,59 @@ function validatePlanShape(plan) {
     }
 }
 async function readFunding(client, plan, block) {
-    const escrow = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "fundingEscrow", [], block);
-    if ((await readLifecycleContract(client, escrow, lifecycleFundingEscrowAbi, "core", [], block)).toLowerCase() !== plan.orchestrator.toLowerCase())
+    const [escrow, registry, balanceValue] = await Promise.all([
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "fundingEscrow", [], block),
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block),
+        lifecyclePinnedRpc(client, "eth_getBalance", [plan.creator, toHex(block.number)], block),
+    ]);
+    const nativeBalance = rpcQuantity(balanceValue, "creator native balance");
+    const [authority, observations] = await Promise.all([
+        readLifecycleContract(client, escrow, lifecycleFundingEscrowAbi, "core", [], block),
+        Promise.all(plan.funding.map(async (funding) => {
+            const native = funding.kind === LifecycleFundingKind.NativeWrap || (funding.kind === LifecycleFundingKind.Swap && funding.inputAsset === zeroAddress);
+            const [input, wrapped, target] = await Promise.all([
+                native ? [nativeBalance, undefined] : Promise.all([
+                    readLifecycleContract(client, funding.inputAsset, lifecycleErc20Abi, "balanceOf", [plan.creator], block),
+                    readLifecycleContract(client, funding.inputAsset, lifecycleErc20Abi, "allowance", [plan.creator, escrow], block),
+                ]),
+                funding.kind === LifecycleFundingKind.NativeWrap ? readLifecycleContract(client, escrow, lifecycleFundingEscrowAbi, "wrappedNative", [], block) : undefined,
+                funding.kind === LifecycleFundingKind.Swap ? Promise.all([
+                    readLifecycleContract(client, registry, lifecycleRegistryAbi, "fundingTarget", [funding.target], block),
+                    lifecyclePinnedRpc(client, "eth_getCode", [funding.target, toHex(block.number)], block),
+                ]) : undefined,
+            ]);
+            let reason;
+            if (wrapped !== undefined && (wrapped === zeroAddress || wrapped.toLowerCase() !== funding.asset.toLowerCase()))
+                reason = "Committed native-wrap output is not the escrow's supported wrapped native asset";
+            if (target !== undefined) {
+                const [[spender, codeHash, enabled], codeValue] = target;
+                const code = rpcHex(codeValue, "funding target code");
+                if (!enabled || spender === zeroAddress || code === "0x" || keccak256(code).toLowerCase() !== codeHash.toLowerCase())
+                    reason = "Committed funding conversion target is not currently allowlisted with its immutable code hash";
+            }
+            const prerequisite = { funding, inputBalance: input[0], requiredInput: funding.inputAmount, allowance: input[1], spender: escrow, nativeValue: native ? funding.inputAmount : 0n, conversion: funding.kind === LifecycleFundingKind.NativeWrap ? "native-wrap" : funding.kind === LifecycleFundingKind.Swap ? "allowlisted-swap" : "none" };
+            return { prerequisite, reason };
+        })),
+    ]);
+    if (authority.toLowerCase() !== plan.orchestrator.toLowerCase())
         throw new LifecyclePlanningError("FUNDING_BINDING", "Funding escrow authority differs from the committed orchestrator");
-    const registry = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block);
-    const nativeBalance = rpcQuantity(await lifecycleRpc(client, "eth_getBalance", [plan.creator, toHex(block.number)]), "creator native balance");
     const totals = new Map();
     const prerequisites = [];
     const approvals = [];
     const reasons = [];
     let nativeValue = 0n;
-    for (const funding of plan.funding) {
-        const native = funding.kind === LifecycleFundingKind.NativeWrap || (funding.kind === LifecycleFundingKind.Swap && funding.inputAsset === zeroAddress);
-        let inputBalance = nativeBalance;
-        let allowance;
-        if (native)
-            nativeValue += funding.inputAmount;
-        else {
+    for (const { prerequisite, reason } of observations) {
+        prerequisites.push(prerequisite);
+        if (reason !== undefined)
+            reasons.push(reason);
+        nativeValue += prerequisite.nativeValue;
+        if (prerequisite.allowance !== undefined) {
+            const { funding } = prerequisite;
             const key = funding.inputAsset.toLowerCase();
-            let total = totals.get(key);
-            if (total === undefined) {
-                inputBalance = await readLifecycleContract(client, funding.inputAsset, lifecycleErc20Abi, "balanceOf", [plan.creator], block);
-                allowance = await readLifecycleContract(client, funding.inputAsset, lifecycleErc20Abi, "allowance", [plan.creator, escrow], block);
-                total = { asset: funding.inputAsset, amount: 0n, balance: inputBalance, allowance };
-                totals.set(key, total);
-            }
+            const total = totals.get(key) ?? { asset: funding.inputAsset, amount: 0n, balance: prerequisite.inputBalance, allowance: prerequisite.allowance };
             total.amount += funding.inputAmount;
-            inputBalance = total.balance;
-            allowance = total.allowance;
+            totals.set(key, total);
         }
-        if (funding.kind === LifecycleFundingKind.NativeWrap) {
-            const wrapped = await readLifecycleContract(client, escrow, lifecycleFundingEscrowAbi, "wrappedNative", [], block);
-            if (wrapped === zeroAddress || wrapped.toLowerCase() !== funding.asset.toLowerCase())
-                reasons.push("Committed native-wrap output is not the escrow's supported wrapped native asset");
-        }
-        if (funding.kind === LifecycleFundingKind.Swap) {
-            const [spender, codeHash, enabled] = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "fundingTarget", [funding.target], block);
-            const code = rpcHex(await lifecycleRpc(client, "eth_getCode", [funding.target, toHex(block.number)]), "funding target code");
-            if (!enabled || spender === zeroAddress || code === "0x" || keccak256(code).toLowerCase() !== codeHash.toLowerCase())
-                reasons.push("Committed funding conversion target is not currently allowlisted with its immutable code hash");
-        }
-        prerequisites.push({ funding, inputBalance, requiredInput: funding.inputAmount, allowance, spender: escrow, nativeValue: native ? funding.inputAmount : 0n, conversion: funding.kind === LifecycleFundingKind.NativeWrap ? "native-wrap" : funding.kind === LifecycleFundingKind.Swap ? "allowlisted-swap" : "none" });
     }
     if (nativeBalance < nativeValue)
         reasons.push("Creator native balance does not cover committed native funding inputs");
@@ -131,17 +143,6 @@ async function readFunding(client, plan, block) {
 }
 async function validatePendingInputs(client, planned, progress, block) {
     const { plan } = planned;
-    const profiles = await readLifecycleProfiles({ client, orchestrator: plan.orchestrator, profileIds: [...new Set(plan.markets.map((market) => market.profileId))] }, block);
-    const registry = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block);
-    const reasons = profiles.filter((profile) => !profile.admitted).map((profile) => profile.reason ?? "Implementation/profile is unavailable");
-    if (block.timestamp > plan.deadline)
-        reasons.push("The immutable launch deadline has expired; cancellation remains available");
-    for (const policy of plan.feeAssets)
-        if (policy.burnBps !== 0 && policy.asset.toLowerCase() !== planned.predictedToken.toLowerCase())
-            reasons.push("Only the launch token may have a burn fee share");
-    if (!plan.feeAssets.some((policy) => policy.asset.toLowerCase() === planned.predictedToken.toLowerCase()))
-        reasons.push("The launch token must have a committed fee policy");
-    const hookDeployments = [];
     const assets = new Set();
     for (const policy of plan.feeAssets)
         if (policy.asset.toLowerCase() !== planned.predictedToken.toLowerCase())
@@ -153,90 +154,131 @@ async function validatePendingInputs(client, planned, progress, block) {
         if (funding.kind !== LifecycleFundingKind.NativeWrap && funding.inputAsset !== zeroAddress)
             assets.add(funding.inputAsset);
     }
-    for (const asset of assets)
-        if (rpcHex(await lifecycleRpc(client, "eth_getCode", [asset, toHex(block.number)]), "asset code") === "0x")
+    const [profiles, registry, assetCodes] = await Promise.all([
+        readLifecycleProfiles({ client, orchestrator: plan.orchestrator, profileIds: [...new Set(plan.markets.map((market) => market.profileId))] }, block),
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block),
+        Promise.all([...assets].map(async (asset) => ({ asset, code: rpcHex(await lifecyclePinnedRpc(client, "eth_getCode", [asset, toHex(block.number)], block), "asset code") }))),
+    ]);
+    const reasons = profiles.filter((profile) => !profile.admitted).map((profile) => profile.reason ?? "Implementation/profile is unavailable");
+    if (block.timestamp > plan.deadline)
+        reasons.push("The immutable launch deadline has expired; cancellation remains available");
+    for (const policy of plan.feeAssets)
+        if (policy.burnBps !== 0 && policy.asset.toLowerCase() !== planned.predictedToken.toLowerCase())
+            reasons.push("Only the launch token may have a burn fee share");
+    if (!plan.feeAssets.some((policy) => policy.asset.toLowerCase() === planned.predictedToken.toLowerCase()))
+        reasons.push("The launch token must have a committed fee policy");
+    for (const { asset, code } of assetCodes)
+        if (code === "0x")
             reasons.push(`Asset ${asset} has no contract code`);
-    for (const funding of plan.funding) {
+    const required = LIFECYCLE_REQUIRED_CAPABILITIES | (plan.token.kind === LifecycleTokenKind.ERC404 ? LIFECYCLE_ERC404_CAPABILITY : 0n);
+    const [allowedInputs, markets, escrowBalances] = await Promise.all([
+        Promise.all(plan.funding.map((funding) => funding.kind === LifecycleFundingKind.Swap && funding.inputAsset !== zeroAddress
+            ? readLifecycleContract(client, registry, lifecycleRegistryAbi, "fundingInputAllowed", [funding.inputAsset], block) : true)),
+        Promise.all(plan.markets.map(async (market, index) => {
+            const profile = profiles.find((item) => item.id.toLowerCase() === market.profileId.toLowerCase());
+            let positions = 0;
+            let deployment;
+            let identity;
+            let reason;
+            if (profile === undefined || !profile.admitted)
+                return { positions, deployment, identity, reason };
+            try {
+                if (market.adapterId.toLowerCase() !== profile.registration.adapterId.toLowerCase() || market.configVersion !== profile.topology.configVersion)
+                    throw new LifecyclePlanningError("INVALID_MARKET", "Market adapter or version differs from exact certified profile");
+                if (market.quoteAsset.toLowerCase() === planned.predictedToken.toLowerCase() || !plan.feeAssets.some((policy) => policy.asset.toLowerCase() === market.quoteAsset.toLowerCase()))
+                    throw new LifecyclePlanningError("INVALID_MARKET", "Each distinct quote requires its committed fee policy");
+                const schema = profile.registration.configSchema.toLowerCase();
+                const config = schema === V4_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodeV4LifecycleMarketConfig(market.config) : schema === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodePoolBoundV4LifecycleMarketConfig(market.config) : schema === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodeAbyssLifecycleMarketConfig(market.config) : undefined;
+                if (config === undefined)
+                    throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${profile.registration.configSchema}`);
+                if ("developerFeeBps" in config) {
+                    validateV4LifecycleMarket({ market, config, profile, token: planned.predictedToken });
+                    if (config.version === 4)
+                        await validateV4LifecycleOracle({ client, envelope: profile.envelope, oracleConfigId: config.oracleConfigId, block });
+                }
+                if (config.positions.length === 0 || config.positions.length > 32)
+                    throw new LifecyclePlanningError("INVALID_POSITION_COUNT", "A launch commits at most 32 positive positions across every market/venue");
+                positions = config.positions.length;
+                const rewards = progress.canonical.rewards === zeroAddress && plan.token.rewardMode === LifecycleRewardMode.Dividends ? planned.predictedToken : progress.canonical.rewards;
+                if ("treasury" in config && rewards !== zeroAddress && config.treasury.toLowerCase() === rewards.toLowerCase() && config.hookFeePips !== 0 && config.protocolFeeDenominator !== 0)
+                    throw new LifecyclePlanningError("INVALID_FEE_POLICY", "Hook protocol treasury cannot be the launch rewards contract");
+                const capabilities = required | (positions > 1 ? LIFECYCLE_MULTI_POSITION_CAPABILITY : 0n);
+                const [adapter, boundDeployment] = await Promise.all([
+                    readLifecycleContract(client, registry, lifecycleRegistryAbi, "requireEligible", [market.adapterId, market.profileId, market.configVersion, capabilities], block),
+                    profile.topology.hookTopology === 2 ? readPoolBoundHookDeployment({ client, plan, marketIndex: index }, block) : undefined,
+                ]);
+                if (adapter.toLowerCase() !== profile.adapter.implementation.toLowerCase())
+                    throw new LifecyclePlanningError("MARKET_IDENTITY", "Eligible adapter differs from the certified profile implementation");
+                if (boundDeployment !== undefined) {
+                    if (!hasLifecycleV4HookPermissions(boundDeployment.predictedHook))
+                        throw new LifecyclePlanningError("INVALID_HOOK_BITS", "Finalize the pool-bound salt with the exact lifecycle hook permission bits before planning wallet execution");
+                    deployment = { marketIndex: index, ...boundDeployment };
+                }
+                identity = await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "resolve", [planned.launchId, planned.predictedToken, market], block);
+                validateLifecycleMarketIdentity(identity, plan, planned.predictedToken, index);
+                const expectedHook = deployment?.predictedHook ?? profile.registration.hook;
+                if (identity.factory.toLowerCase() !== profile.registration.factory.toLowerCase() || identity.hook.toLowerCase() !== expectedHook.toLowerCase() || (identity.venue === LifecycleVenue.UniswapV4 && (identity.manager.toLowerCase() !== profile.registration.venue.toLowerCase() || profile.topology.hookTopology === 0)) || (identity.venue === LifecycleVenue.Abyss && (identity.factory.toLowerCase() !== profile.registration.venue.toLowerCase() || profile.topology.hookTopology !== 0)))
+                    throw new LifecyclePlanningError("MARKET_IDENTITY", "Canonical venue dependencies differ from exact immutable profile/topology approval");
+                const prepared = progress.markets.find((item) => item.index === index);
+                if (prepared !== undefined) {
+                    const resolvedHash = keccak256(encodeAbiParameters([{ type: "tuple", components: marketIdentityV1Components }], [identity]));
+                    const preparedHash = keccak256(encodeAbiParameters([{ type: "tuple", components: marketIdentityV1Components }], [prepared.prepared.identity]));
+                    if (resolvedHash !== preparedHash || prepared.live === undefined || prepared.live.publicTrading || prepared.live.liquidity !== 0n || prepared.live.sqrtPriceX96 !== identity.openingSqrtPriceX96)
+                        throw new LifecyclePlanningError("OPENING_CHANGED", "Prepared market is not at its committed empty canonical opening state");
+                    await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "validatePrepared", [planned.launchId, index, planned.predictedToken, market, prepared.prepared.identity], block);
+                }
+            }
+            catch (failure) {
+                reason = failure instanceof Error ? failure.message : String(failure);
+            }
+            return { positions, deployment, identity, reason };
+        })),
+        progress.canonical.phase === LifecyclePhase.None ? [] : Promise.all(plan.funding.map((funding) => readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "escrowBalance", [planned.launchId, funding.asset], block))),
+    ]);
+    for (const [index, funding] of plan.funding.entries()) {
         if (funding.asset.toLowerCase() === planned.predictedToken.toLowerCase() || (funding.kind === LifecycleFundingKind.Swap && funding.inputAsset.toLowerCase() === planned.predictedToken.toLowerCase()))
             reasons.push("Launch-token inventory cannot be an external funding output or conversion input");
-        if (funding.kind === LifecycleFundingKind.Swap && funding.inputAsset !== zeroAddress && !await readLifecycleContract(client, registry, lifecycleRegistryAbi, "fundingInputAllowed", [funding.inputAsset], block))
+        if (!allowedInputs[index])
             reasons.push(`Conversion input ${funding.inputAsset} is not currently admitted`);
     }
-    const required = LIFECYCLE_REQUIRED_CAPABILITIES | (plan.token.kind === LifecycleTokenKind.ERC404 ? LIFECYCLE_ERC404_CAPABILITY : 0n);
+    const hookDeployments = [];
     const identities = new Set();
     const v4Quotes = new Set();
     let positionCount = 0;
-    for (let index = 0; index < plan.markets.length; index += 1) {
-        const market = plan.markets[index];
-        if (market === undefined)
-            throw new LifecyclePlanningError("INVALID_PLAN", "Market missing from ordered plan");
-        const profile = profiles.find((item) => item.id.toLowerCase() === market.profileId.toLowerCase());
-        if (profile === undefined || !profile.admitted)
+    for (const [index, result] of markets.entries()) {
+        if (positionCount + result.positions > 32) {
+            reasons.push("A launch commits at most 32 positive positions across every market/venue");
             continue;
-        try {
-            if (market.adapterId.toLowerCase() !== profile.registration.adapterId.toLowerCase() || market.configVersion !== profile.topology.configVersion)
-                throw new LifecyclePlanningError("INVALID_MARKET", "Market adapter or version differs from exact certified profile");
-            if (market.quoteAsset.toLowerCase() === planned.predictedToken.toLowerCase() || !plan.feeAssets.some((policy) => policy.asset.toLowerCase() === market.quoteAsset.toLowerCase()))
-                throw new LifecyclePlanningError("INVALID_MARKET", "Each distinct quote requires its committed fee policy");
-            const schema = profile.registration.configSchema.toLowerCase();
-            const config = schema === V4_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodeV4LifecycleMarketConfig(market.config) : schema === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodePoolBoundV4LifecycleMarketConfig(market.config) : schema === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodeAbyssLifecycleMarketConfig(market.config) : undefined;
-            if (config === undefined)
-                throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${profile.registration.configSchema}`);
-            if ("developerFeeBps" in config) {
-                validateV4LifecycleMarket({ market, config, profile, token: planned.predictedToken });
-                if (config.version === 4)
-                    await validateV4LifecycleOracle({ client, envelope: profile.envelope, oracleConfigId: config.oracleConfigId, block });
-            }
-            if (config.positions.length === 0 || config.positions.length > 32 || positionCount + config.positions.length > 32)
-                throw new LifecyclePlanningError("INVALID_POSITION_COUNT", "A launch commits at most 32 positive positions across every market/venue");
-            positionCount += config.positions.length;
-            const rewards = progress.canonical.rewards === zeroAddress && plan.token.rewardMode === LifecycleRewardMode.Dividends ? planned.predictedToken : progress.canonical.rewards;
-            if ("treasury" in config && rewards !== zeroAddress && config.treasury.toLowerCase() === rewards.toLowerCase() && config.hookFeePips !== 0 && config.protocolFeeDenominator !== 0)
-                throw new LifecyclePlanningError("INVALID_FEE_POLICY", "Hook protocol treasury cannot be the launch rewards contract");
-            const capabilities = required | (config.positions.length > 1 ? LIFECYCLE_MULTI_POSITION_CAPABILITY : 0n);
-            const adapter = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "requireEligible", [market.adapterId, market.profileId, market.configVersion, capabilities], block);
-            if (adapter.toLowerCase() !== profile.adapter.implementation.toLowerCase())
-                throw new LifecyclePlanningError("MARKET_IDENTITY", "Eligible adapter differs from the certified profile implementation");
-            const deployment = profile.topology.hookTopology === 2 ? await readPoolBoundHookDeployment({ client, plan, marketIndex: index }, block) : undefined;
-            if (deployment !== undefined) {
-                if (!hasLifecycleV4HookPermissions(deployment.predictedHook))
-                    throw new LifecyclePlanningError("INVALID_HOOK_BITS", "Finalize the pool-bound salt with the exact lifecycle hook permission bits before planning wallet execution");
-                hookDeployments.push({ marketIndex: index, ...deployment });
-            }
-            const identity = await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "resolve", [planned.launchId, planned.predictedToken, market], block);
-            validateLifecycleMarketIdentity(identity, plan, planned.predictedToken, index);
-            const expectedHook = deployment?.predictedHook ?? profile.registration.hook;
-            if (identity.factory.toLowerCase() !== profile.registration.factory.toLowerCase() || identity.hook.toLowerCase() !== expectedHook.toLowerCase() || (identity.venue === LifecycleVenue.UniswapV4 && (identity.manager.toLowerCase() !== profile.registration.venue.toLowerCase() || profile.topology.hookTopology === 0)) || (identity.venue === LifecycleVenue.Abyss && (identity.factory.toLowerCase() !== profile.registration.venue.toLowerCase() || profile.topology.hookTopology !== 0)))
-                throw new LifecyclePlanningError("MARKET_IDENTITY", "Canonical venue dependencies differ from exact immutable profile/topology approval");
-            if (identity.venue === LifecycleVenue.UniswapV4) {
-                const quote = market.quoteAsset.toLowerCase();
-                if (v4Quotes.has(quote))
-                    throw new LifecyclePlanningError("DUPLICATE_V4_QUOTE", "Only one V4 market per quote asset is allowed, regardless of adapter, manager, profile or salt");
-                v4Quotes.add(quote);
-            }
-            if (identities.has(identity.canonicalId.toLowerCase()))
-                throw new LifecyclePlanningError("DUPLICATE_MARKET", "Two committed markets resolve to the same canonical pool");
-            identities.add(identity.canonicalId.toLowerCase());
-            const prepared = progress.markets.find((item) => item.index === index);
-            if (prepared !== undefined) {
-                const resolvedHash = keccak256(encodeAbiParameters([{ type: "tuple", components: marketIdentityV1Components }], [identity]));
-                const preparedHash = keccak256(encodeAbiParameters([{ type: "tuple", components: marketIdentityV1Components }], [prepared.prepared.identity]));
-                if (resolvedHash !== preparedHash || prepared.live === undefined || prepared.live.publicTrading || prepared.live.liquidity !== 0n || prepared.live.sqrtPriceX96 !== identity.openingSqrtPriceX96)
-                    throw new LifecyclePlanningError("OPENING_CHANGED", "Prepared market is not at its committed empty canonical opening state");
-                await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "validatePrepared", [planned.launchId, index, planned.predictedToken, market, prepared.prepared.identity], block);
+        }
+        positionCount += result.positions;
+        if (result.deployment !== undefined)
+            hookDeployments.push(result.deployment);
+        if (result.reason !== undefined) {
+            reasons.push(result.reason);
+            continue;
+        }
+        if (result.identity === undefined)
+            continue;
+        if (result.identity.venue === LifecycleVenue.UniswapV4) {
+            const quote = plan.markets[index].quoteAsset.toLowerCase();
+            if (v4Quotes.has(quote)) {
+                reasons.push("Only one V4 market per quote asset is allowed, regardless of adapter, manager, profile or salt");
+                continue;
             }
+            v4Quotes.add(quote);
         }
-        catch (failure) {
-            reasons.push(failure instanceof Error ? failure.message : String(failure));
+        const identity = result.identity.canonicalId.toLowerCase();
+        if (identities.has(identity)) {
+            reasons.push("Two committed markets resolve to the same canonical pool");
+            continue;
         }
+        identities.add(identity);
     }
-    if (progress.canonical.phase !== LifecyclePhase.None) {
-        for (const funding of plan.funding) {
-            const balance = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "escrowBalance", [planned.launchId, funding.asset], block);
-            const needed = plan.buys.filter((buy) => plan.markets[buy.marketIndex]?.quoteAsset.toLowerCase() === funding.asset.toLowerCase()).reduce((sum, buy) => sum + buy.quoteAmountIn, 0n);
-            if (balance < needed)
-                reasons.push(`Launch-isolated ${funding.asset} escrow cannot cover every committed buy`);
-        }
+    for (const [index, balance] of escrowBalances.entries()) {
+        const funding = plan.funding[index];
+        const needed = plan.buys.filter((buy) => plan.markets[buy.marketIndex]?.quoteAsset.toLowerCase() === funding.asset.toLowerCase()).reduce((sum, buy) => sum + buy.quoteAmountIn, 0n);
+        if (balance < needed)
+            reasons.push(`Launch-isolated ${funding.asset} escrow cannot cover every committed buy`);
     }
     return { profiles, hookDeployments, reasons };
 }
@@ -272,8 +314,12 @@ function attachEstimates(transactions, simulation) {
 }
 async function readTokenFactoryBinding(client, orchestrator, block) {
     const tokenFactory = await readLifecycleContract(client, orchestrator, launchLifecycleAbi, "tokenFactory", [], block);
-    const code = rpcHex(await lifecycleRpc(client, "eth_getCode", [tokenFactory, toHex(block.number)]), "token factory code");
-    if (tokenFactory === zeroAddress || code === "0x" || (await readLifecycleContract(client, tokenFactory, lifecycleAdapterAbi, "core", [], block)).toLowerCase() !== orchestrator.toLowerCase())
+    const [codeValue, authority] = await Promise.all([
+        lifecyclePinnedRpc(client, "eth_getCode", [tokenFactory, toHex(block.number)], block),
+        readLifecycleContract(client, tokenFactory, lifecycleAdapterAbi, "core", [], block),
+    ]);
+    const code = rpcHex(codeValue, "token factory code");
+    if (tokenFactory === zeroAddress || code === "0x" || authority.toLowerCase() !== orchestrator.toLowerCase())
         throw new LifecyclePlanningError("TOKEN_FACTORY_BINDING", "Token factory is not live and bound to the exact lifecycle core");
     return { tokenFactory, tokenFactoryCodeHash: keccak256(code) };
 }
@@ -357,7 +403,15 @@ export async function preparePoolBoundLifecyclePlan(options) {
 }
 /** Exact economic commitment with explicit execution mode and current-state admission. No broadcasts. */
 export async function planLaunch(options) {
-    const { client, plan, account, mode } = options;
+    return withLifecycleReadClient(options.client, async (client) => {
+        const planned = await lifecycleStage(client, "plan", () => planLaunchWithReads(options, client));
+        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");
+        return planned;
+    });
+}
+async function planLaunchWithReads(options, client) {
+    const { plan, account, mode } = options;
     if (mode !== "atomic" && mode !== "staged")
         throw new LifecyclePlanningError("EXPLICIT_MODE_REQUIRED", "Choose atomic or staged explicitly; staged is never silently substituted");
     if (account.toLowerCase() !== plan.creator.toLowerCase())
@@ -365,21 +419,30 @@ export async function planLaunch(options) {
     if (plan.chainId > BigInt(Number.MAX_SAFE_INTEGER) || plan.chainId <= 0n)
         throw new LifecyclePlanningError("CHAIN_MISMATCH", "Chain ID must be a positive exact JavaScript integer");
     validatePlanShape(plan);
-    const block = await readLifecycleBlock(client);
-    if (rpcQuantity(await lifecycleRpc(client, "eth_chainId"), "chain ID") !== plan.chainId)
-        throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed plan");
     const planHash = hashLaunchPlan(plan);
     const launchId = hashLaunchIdentity(plan);
-    const remoteHash = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "hashPlan", [plan], block);
-    const remoteIdentity = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "launchIdOf", [plan], block);
+    const [block, chainIdValue] = await lifecycleStage(client, "plan.context", () => Promise.all([
+        readLifecycleBlock(client),
+        lifecycleRpc(client, "eth_chainId"),
+    ]));
+    if (rpcQuantity(chainIdValue, "chain ID") !== plan.chainId)
+        throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed plan");
+    const prediction = readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "predictToken", [plan], block);
+    const [remoteHash, remoteIdentity, { tokenFactory, tokenFactoryCodeHash }, { limits }, { identity, progress }] = await lifecycleStage(client, "plan.domain", () => Promise.all([
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "hashPlan", [plan], block),
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "launchIdOf", [plan], block),
+        readTokenFactoryBinding(client, plan.orchestrator, block),
+        resolveLifecycleLimits({ client, account, orchestrator: plan.orchestrator, block, chainId: plan.chainId }, options.limits),
+        lifecycleStage(client, "plan.progress", async () => {
+            const predictedToken = await prediction;
+            const identity = { plan, planHash, launchId, predictedToken, account, mode, confirmations: options.confirmations ?? 1 };
+            const progress = await readLaunchProgress({ client, planned: identity, receipts: options.receipts }, block);
+            return { identity, progress };
+        }),
+    ]));
     if (remoteHash.toLowerCase() !== planHash.toLowerCase() || remoteIdentity.toLowerCase() !== launchId.toLowerCase())
         throw new LifecyclePlanningError("ABI_DOMAIN_MISMATCH", "Selected contract does not implement the exact lifecycle V1 plan domain/schema");
-    const predictedToken = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "predictToken", [plan], block);
-    const { tokenFactory, tokenFactoryCodeHash } = await readTokenFactoryBinding(client, plan.orchestrator, block);
-    const { limits } = await resolveLifecycleLimits({ client, account, orchestrator: plan.orchestrator, block, chainId: plan.chainId }, options.limits);
     const placeholder = { 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: [] };
-    const identity = { plan, planHash, launchId, predictedToken, account, mode, confirmations: options.confirmations ?? 1 };
-    const progress = await readLaunchProgress({ client, planned: identity, receipts: options.receipts }, block);
     let planned = { ...identity, tokenFactory, tokenFactoryCodeHash, chainId: plan.chainId, transactions: [], prerequisites: [], profiles: [], hookDeployments: [], progress, simulation: placeholder, atomicAttempt: placeholder, preparationBatchSize: plan.markets.length, limits: options.limits };
     const receiptsPending = progress.receipts.some((receipt) => receipt.status === "pending" || receipt.status === "unconfirmed");
     if (!progress.confirmationSafe || receiptsPending) {
@@ -390,20 +453,22 @@ export async function planLaunch(options) {
         }
         // Receipt/nonce gates never silently drop the finalized deployment baseline on reload.
         const waiting = { ...placeholder, confidence: "stateful", reason: !progress.confirmationSafe ? "Canonical confirmed progress/account nonce has not caught up with head or pending transactions; wait for the selected confirmation depth" : "Wait for canonical receipt confirmations or resolve replacement before requesting another transaction" };
-        await assertLifecycleBlock(client, block);
+        await assertLifecycleBlock(client, block, plan.chainId);
         return { ...planned, hookDeployments, simulation: waiting, atomicAttempt: waiting };
     }
     if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled) {
-        await assertLifecycleBlock(client, block);
+        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" } };
     }
-    const prerequisites = progress.canonical.phase === LifecyclePhase.None ? await readFunding(client, plan, block) : { prerequisites: [], approvals: [], nativeValue: 0n, reasons: [] };
-    const validation = await validatePendingInputs(client, planned, progress, block);
+    const [prerequisites, validation] = await lifecycleStage(client, "plan.inputs", () => Promise.all([
+        progress.canonical.phase === LifecyclePhase.None ? readFunding(client, plan, block) : { prerequisites: [], approvals: [], nativeValue: 0n, reasons: [] },
+        validatePendingInputs(client, planned, progress, block),
+    ]));
     const reasons = [...prerequisites.reasons, ...validation.reasons];
     planned = { ...planned, prerequisites: prerequisites.prerequisites, profiles: validation.profiles, hookDeployments: validation.hookDeployments };
     if (reasons.length > 0) {
         const rejected = { ...placeholder, confidence: "stateful", reason: reasons.join("; ") };
-        await assertLifecycleBlock(client, block);
+        await assertLifecycleBlock(client, block, plan.chainId);
         return { ...planned, simulation: rejected, atomicAttempt: rejected, transactions: orderedTransactions(plan, mode, progress, prerequisites.approvals, prerequisites.nativeValue, planned.preparationBatchSize) };
     }
     let atomicAttempt = { ...placeholder, reason: "Atomic execution cannot be evaluated from an already begun staged launch" };