@black-market/sdk 0.6.0 → 0.6.1

package/dist/lifecycle/progress.js

@@ -2,7 +2,7 @@ import { concatHex, decodeFunctionData, encodeAbiParameters, encodeFunctionData,
 import { abyssLifecycleAdapterAbi, launchLifecycleAbi, lifecycleAdapterAbi, lifecycleDirectoryAbi, lifecycleErc20Abi, lifecycleOracleFactoryAbi, lifecycleRegistryAbi, poolFeeCollectorFactoryV1Abi, lifecycleV4HookAbi, lifecycleV4LockerAbi, poolHookDeployerV1Abi, sharedHookDeployerV1Abi, fixedFeePoolHookV1Abi, poolMarketAdapterV1Abi, sharedMarketAdapterV1Abi } from "./abi.js";
 import { decodePoolBoundV4LifecycleMarketConfig, encodePoolBoundHookParameters, hasLifecycleV4HookPermissions, hashPoolBoundV4MarketCommitment, poolBoundHookInitCodeHash, predictPoolBoundHookAddress, validateV4LifecycleMarket, V4_LIFECYCLE_CONFIG_SCHEMA, V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA } from "./markets.js";
 import { hashLaunchIdentity, hashLaunchPlan, hashLaunchBounds, hashLaunchDependencies, hashLifecycleProfile, launchProgressV1Components, LifecycleMode, LifecyclePhase, LifecycleVenue, LIFECYCLE_REQUIRED_CAPABILITIES, LIFECYCLE_ERC404_CAPABILITY, LIFECYCLE_MULTI_POSITION_CAPABILITY } from "./schema.js";
-import { assertLifecycleBlock, lifecycleRpc, readLifecycleBlock, readLifecycleContract, readLifecycleProfileTopology, rpcHex, rpcObject, rpcQuantity } from "./rpc.js";
+import { assertLifecycleBlock, lifecyclePinnedRpc, lifecycleRpc, readLifecycleBlock, readLifecycleContract, readLifecycleProfileTopology, rpcHex, rpcObject, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
 import { LifecyclePlanningError } from "./types.js";
 export const ABYSS_LIFECYCLE_CONFIG_SCHEMA = keccak256(stringToHex("(uint8,uint24,bytes32,uint160,(int24,int24,uint128,uint256)[])"));
 export async function predictLifecycleToken(options) {
@@ -12,7 +12,7 @@ export async function predictLifecycleToken(options) {
     return token;
 }
 async function readDependencyCode(client, address, block) {
-    const code = rpcHex(await lifecycleRpc(client, "eth_getCode", [address, toHex(block.number)]), "lifecycle dependency code");
+    const code = rpcHex(await lifecyclePinnedRpc(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;
@@ -26,19 +26,23 @@ async function certifyLifecycleProfile(client, orchestrator, registry, id, regis
     const version = shared ? 4 : bound ? 5 : 1;
     if (adapter.configVersion !== version || topology.configVersion !== version || topology.hookTopology !== (shared ? 1 : bound ? 2 : 0))
         throw new LifecyclePlanningError("UNCERTIFIED_TOPOLOGY", "Registry topology/version differs from the supported config schema");
-    const implementationCode = await readDependencyCode(client, adapter.implementation, block);
+    const [implementationCode, authority, digest] = await Promise.all([
+        readDependencyCode(client, adapter.implementation, block),
+        readLifecycleContract(client, adapter.implementation, lifecycleAdapterAbi, "core", [], block),
+        readLifecycleContract(client, adapter.implementation, lifecycleAdapterAbi, "dependencyDigest", [], block),
+    ]);
     if (keccak256(implementationCode).toLowerCase() !== adapter.codeHash.toLowerCase())
         throw new LifecyclePlanningError("PROFILE_CODE_HASH", "Adapter code hash differs from immutable registry approval");
-    const authority = await readLifecycleContract(client, adapter.implementation, lifecycleAdapterAbi, "core", [], block);
-    const digest = await readLifecycleContract(client, adapter.implementation, lifecycleAdapterAbi, "dependencyDigest", [], block);
     if (authority.toLowerCase() !== orchestrator.toLowerCase() || digest.toLowerCase() !== registration.dependencyDigest.toLowerCase())
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Adapter authority or dependency digest differs from immutable registry approval");
     if (abyss) {
         if (topology.hookDeployer !== zeroAddress || topology.hookCreationCodeHash !== zeroHash)
             throw new LifecyclePlanningError("UNCERTIFIED_TOPOLOGY", "Abyss does not admit a V4 hook deployment graph");
-        const factory = await readLifecycleContract(client, adapter.implementation, abyssLifecycleAdapterAbi, "factory", [], block);
-        const schema = await readLifecycleContract(client, adapter.implementation, abyssLifecycleAdapterAbi, "CONFIG_SCHEMA", [], block);
-        const actualVersion = await readLifecycleContract(client, adapter.implementation, abyssLifecycleAdapterAbi, "CONFIG_VERSION", [], block);
+        const [factory, schema, actualVersion] = await Promise.all([
+            readLifecycleContract(client, adapter.implementation, abyssLifecycleAdapterAbi, "factory", [], block),
+            readLifecycleContract(client, adapter.implementation, abyssLifecycleAdapterAbi, "CONFIG_SCHEMA", [], block),
+            readLifecycleContract(client, adapter.implementation, abyssLifecycleAdapterAbi, "CONFIG_VERSION", [], block),
+        ]);
         const domain = keccak256(stringToHex("BLACK_MARKET_ABYSS_CANONICAL_PROFILE_V1"));
         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 || schema.toLowerCase() !== ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() || actualVersion !== 1 || registration.factory.toLowerCase() !== factory.toLowerCase() || registration.venue.toLowerCase() !== factory.toLowerCase() || registration.hook !== zeroAddress)
@@ -62,40 +66,49 @@ async function certifyLifecycleProfile(client, orchestrator, registry, id, regis
         envelope.protocolTreasury === zeroAddress || (envelope.protocolFeeDenominator !== 0 && (envelope.protocolFeeDenominator < 4 || envelope.protocolFeeDenominator > 10)))
         throw new LifecyclePlanningError("PROFILE_BOUNDS", "Registry envelope has unsupported executable bounds");
     const abi = bound ? poolMarketAdapterV1Abi : sharedMarketAdapterV1Abi;
-    for (const [getter, expected] of [["PROFILE_ID", id], ["CONFIG_SCHEMA", registration.configSchema], ["implementationRegistry", registry]]) {
-        const actual = await readLifecycleContract(client, adapter.implementation, abi, getter, [], block);
-        if (actual.toLowerCase() !== expected.toLowerCase())
+    const [metadata, actualVersion] = await Promise.all([
+        Promise.all(["PROFILE_ID", "CONFIG_SCHEMA", "implementationRegistry"].map((getter) => readLifecycleContract(client, adapter.implementation, abi, getter, [], block))),
+        readLifecycleContract(client, adapter.implementation, abi, "CONFIG_VERSION", [], block),
+    ]);
+    for (const [index, expected] of [id, registration.configSchema, registry].entries()) {
+        if (metadata[index]?.toLowerCase() !== expected.toLowerCase())
             throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Reviewed adapter metadata differs from registry certification");
     }
-    if (await readLifecycleContract(client, adapter.implementation, abi, "CONFIG_VERSION", [], block) !== version)
+    if (actualVersion !== version)
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Reviewed adapter config version differs from certification");
     const g = envelope.graph;
     if (registration.factory !== zeroAddress || registration.venue.toLowerCase() !== g.manager.toLowerCase() || registration.hook.toLowerCase() !== g.hookRoot.toLowerCase() ||
         topology.hookDeployer.toLowerCase() !== g.hookDeployer.toLowerCase() || topology.hookCreationCodeHash.toLowerCase() !== g.hookCreationCodeHash.toLowerCase())
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Reviewed venue/topology differs from the frozen envelope graph");
-    for (const [getter, expected] of [["poolManager", g.manager], ["hookRoot", g.hookRoot], ["oracleFactory", g.oracleFactory], ["locker", g.locker], ["collectorFactory", g.collectorFactory], ["hookDeployer", g.hookDeployer]]) {
-        const actual = await readLifecycleContract(client, adapter.implementation, abi, getter, [], block);
-        if (actual.toLowerCase() !== expected.toLowerCase())
+    const deployerAbi = shared ? sharedHookDeployerV1Abi : poolHookDeployerV1Abi;
+    const codeBindings = [[orchestrator, g.coreCodeHash], [g.manager, g.managerCodeHash], [g.oracleFactory, g.oracleFactoryCodeHash],
+        [g.locker, g.lockerCodeHash], [g.collectorFactory, g.collectorFactoryCodeHash], [g.collectorDeployer, g.collectorDeployerCodeHash],
+        [g.hookDeployer, g.hookDeployerCodeHash]];
+    const [dependencies, dependencyCodes, collectorDeployer, launcher, lockerManager, creationCodeHash, chunk0, chunk1] = await Promise.all([
+        Promise.all(["poolManager", "hookRoot", "oracleFactory", "locker", "collectorFactory", "hookDeployer"].map((getter) => readLifecycleContract(client, adapter.implementation, abi, getter, [], block))),
+        Promise.all(codeBindings.map(([address]) => readDependencyCode(client, address, block))),
+        readLifecycleContract(client, g.collectorFactory, poolFeeCollectorFactoryV1Abi, "collectorDeployer", [], block),
+        readLifecycleContract(client, g.locker, lifecycleV4LockerAbi, "launcher", [], block),
+        readLifecycleContract(client, g.locker, lifecycleV4LockerAbi, "poolManager", [], block),
+        readLifecycleContract(client, g.hookDeployer, deployerAbi, "creationCodeHash", [], block),
+        readLifecycleContract(client, g.hookDeployer, deployerAbi, "codeChunk0", [], block),
+        readLifecycleContract(client, g.hookDeployer, deployerAbi, "codeChunk1", [], block),
+    ]);
+    for (const [index, expected] of [g.manager, g.hookRoot, g.oracleFactory, g.locker, g.collectorFactory, g.hookDeployer].entries()) {
+        if (dependencies[index]?.toLowerCase() !== expected.toLowerCase())
             throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Live adapter dependency differs from the frozen reviewed graph");
     }
-    for (const [address, expectedHash] of [[orchestrator, g.coreCodeHash], [g.manager, g.managerCodeHash], [g.oracleFactory, g.oracleFactoryCodeHash],
-        [g.locker, g.lockerCodeHash], [g.collectorFactory, g.collectorFactoryCodeHash], [g.collectorDeployer, g.collectorDeployerCodeHash],
-        [g.hookDeployer, g.hookDeployerCodeHash]]) {
-        if (keccak256(await readDependencyCode(client, address, block)).toLowerCase() !== expectedHash.toLowerCase())
+    for (const [index, [, expectedHash]] of codeBindings.entries()) {
+        if (keccak256(dependencyCodes[index]).toLowerCase() !== expectedHash.toLowerCase())
             throw new LifecyclePlanningError("PROFILE_CODE_HASH", "Live runtime differs from the frozen reviewed graph hash");
     }
-    const collectorDeployer = await readLifecycleContract(client, g.collectorFactory, poolFeeCollectorFactoryV1Abi, "collectorDeployer", [], block);
-    const launcher = await readLifecycleContract(client, g.locker, lifecycleV4LockerAbi, "launcher", [], block);
-    const lockerManager = await readLifecycleContract(client, g.locker, lifecycleV4LockerAbi, "poolManager", [], block);
     if (collectorDeployer.toLowerCase() !== g.collectorDeployer.toLowerCase() || launcher.toLowerCase() !== adapter.implementation.toLowerCase() ||
         lockerManager.toLowerCase() !== g.manager.toLowerCase() || g.locker.toLowerCase() === g.manager.toLowerCase() || g.locker.toLowerCase() === g.hookRoot.toLowerCase())
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Reviewed collector or locker authority differs from the frozen graph");
-    const deployerAbi = shared ? sharedHookDeployerV1Abi : poolHookDeployerV1Abi;
-    const creationCodeHash = await readLifecycleContract(client, g.hookDeployer, deployerAbi, "creationCodeHash", [], block);
-    const chunk0 = await readLifecycleContract(client, g.hookDeployer, deployerAbi, "codeChunk0", [], block);
-    const chunk1 = await readLifecycleContract(client, g.hookDeployer, deployerAbi, "codeChunk1", [], block);
-    const chunk0Code = await readDependencyCode(client, chunk0, block);
-    const chunk1Code = chunk1 === zeroAddress ? "0x" : await readDependencyCode(client, chunk1, block);
+    const [chunk0Code, chunk1Code] = await Promise.all([
+        readDependencyCode(client, chunk0, block),
+        chunk1 === zeroAddress ? Promise.resolve("0x") : readDependencyCode(client, chunk1, block),
+    ]);
     if (chunk0.toLowerCase() !== g.codeChunk0.toLowerCase() || chunk1.toLowerCase() !== g.codeChunk1.toLowerCase() || chunk0.toLowerCase() === chunk1.toLowerCase() ||
         !chunk0Code.startsWith("0x00") || chunk0Code.length <= 4 || (chunk0Code.length - 2) / 2 > 24576 ||
         (chunk1 !== zeroAddress && (!chunk1Code.startsWith("0x00") || chunk1Code.length <= 4 || (chunk1Code.length - 2) / 2 > 24576 || (chunk0Code.length - 2) / 2 !== 24576)) ||
@@ -107,20 +120,24 @@ async function certifyLifecycleProfile(client, orchestrator, registry, id, regis
         hashLaunchDependencies({ chainId, core: orchestrator, registry, registrar: adapter.implementation, graph: g }).toLowerCase() !== digest.toLowerCase())
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Reviewed creation artifact, constructor bound or graph digest differs from admission");
     if (shared) {
-        const rootCode = await readDependencyCode(client, g.hookRoot, block);
-        const recordedHash = await readLifecycleContract(client, g.hookDeployer, deployerAbi, "deployedCodeHash", [g.hookRoot], block);
+        const [rootCode, recordedHash, remotePrediction, dependencies, requiredFlags, allFlags] = await Promise.all([
+            readDependencyCode(client, g.hookRoot, block),
+            readLifecycleContract(client, g.hookDeployer, deployerAbi, "deployedCodeHash", [g.hookRoot], block),
+            readLifecycleContract(client, g.hookDeployer, sharedHookDeployerV1Abi, "predict", [g.manager, adapter.implementation, g.oracleFactory, g.sharedHookSalt], block),
+            Promise.all(["registrar", "poolManager", "oracleFactory"].map((getter) => readLifecycleContract(client, g.hookRoot, lifecycleV4HookAbi, getter, [], block))),
+            readLifecycleContract(client, g.hookRoot, lifecycleV4HookAbi, "REQUIRED_HOOK_FLAGS", [], block),
+            readLifecycleContract(client, g.hookRoot, lifecycleV4HookAbi, "ALL_HOOK_MASK", [], block),
+        ]);
         const initCodeHash = keccak256(concatHex([creationCode, encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "address" }], [g.manager, adapter.implementation, g.oracleFactory])]));
         const prediction = predictPoolBoundHookAddress({ deployer: g.hookDeployer, initCodeHash, salt: g.sharedHookSalt });
-        const remotePrediction = await readLifecycleContract(client, g.hookDeployer, sharedHookDeployerV1Abi, "predict", [g.manager, adapter.implementation, g.oracleFactory, g.sharedHookSalt], block);
         if (recordedHash === zeroHash || recordedHash.toLowerCase() !== g.hookRuntimeCodeHash.toLowerCase() || keccak256(rootCode).toLowerCase() !== recordedHash.toLowerCase() ||
             !hasLifecycleV4HookPermissions(g.hookRoot) || prediction.toLowerCase() !== g.hookRoot.toLowerCase() || remotePrediction.toLowerCase() !== prediction.toLowerCase())
             throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Shared root lacks exact typed-deployer runtime and constructor/salt provenance");
-        for (const [getter, expected] of [["registrar", adapter.implementation], ["poolManager", g.manager], ["oracleFactory", g.oracleFactory]]) {
-            if ((await readLifecycleContract(client, g.hookRoot, lifecycleV4HookAbi, getter, [], block)).toLowerCase() !== expected.toLowerCase())
+        for (const [index, expected] of [adapter.implementation, g.manager, g.oracleFactory].entries()) {
+            if (dependencies[index]?.toLowerCase() !== expected.toLowerCase())
                 throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Shared hook immutable graph differs from admission");
         }
-        if (await readLifecycleContract(client, g.hookRoot, lifecycleV4HookAbi, "REQUIRED_HOOK_FLAGS", [], block) !== 0x1afcn ||
-            await readLifecycleContract(client, g.hookRoot, lifecycleV4HookAbi, "ALL_HOOK_MASK", [], block) !== 0x3fffn)
+        if (requiredFlags !== 0x1afcn || allFlags !== 0x3fffn)
             throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Shared hook callbacks differ from admission");
     }
     else if (g.hookRoot !== zeroAddress || g.hookRuntimeCodeHash !== zeroHash || g.sharedHookSalt !== zeroHash)
@@ -140,55 +157,77 @@ export async function validateV4LifecycleOracle(options) {
     }
 }
 export async function readLifecycleProfiles(options, pinnedBlock) {
-    const block = pinnedBlock ?? await readLifecycleBlock(options.client);
-    const chainId = rpcQuantity(await lifecycleRpc(options.client, "eth_chainId"), "chain ID");
-    const registry = await readLifecycleContract(options.client, options.orchestrator, launchLifecycleAbi, "registry", [], block);
-    if ((await readLifecycleContract(options.client, registry, lifecycleRegistryAbi, "core", [], block)).toLowerCase() !== options.orchestrator.toLowerCase())
-        throw new LifecyclePlanningError("REGISTRY_BINDING", "Registry is not bound to the selected lifecycle orchestrator");
-    const offset = options.offset ?? 0n;
-    const limit = options.limit ?? 100n;
-    if (offset < 0n || limit < 0n || limit > 100n)
-        throw new LifecyclePlanningError("INVALID_PROFILE_PAGE", "Registry profile pages require unsigned offset and limit at most 100");
-    const ids = options.profileIds ?? await readLifecycleContract(options.client, registry, lifecycleRegistryAbi, "profileIds", [offset, limit], block);
-    const protocolMaximumDeveloperFeeBps = await readLifecycleContract(options.client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block);
-    const profiles = [];
-    for (const id of ids) {
-        const registration = await readLifecycleContract(options.client, registry, lifecycleRegistryAbi, "profile", [id], block);
-        const adapter = await readLifecycleContract(options.client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block);
-        const schema = registration.configSchema.toLowerCase();
-        const venueKind = schema === V4_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() || schema === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? "uniswap-v4" : schema === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? "abyss" : "unknown";
-        let topology = { hookTopology: 0, configVersion: adapter.configVersion, hookDeployer: zeroAddress, hookCreationCodeHash: zeroHash };
-        let envelope;
-        let developerTerms;
-        let admitted = false;
-        let reason;
-        try {
-            if (venueKind === "unknown")
-                throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${registration.configSchema}`);
-            topology = await readLifecycleProfileTopology(options.client, registry, id, block);
-            if (venueKind === "uniswap-v4") {
-                envelope = await readLifecycleContract(options.client, registry, lifecycleRegistryAbi, "profileEnvelope", [id], block);
-                const [implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled] = await readLifecycleContract(options.client, registry, lifecycleRegistryAbi, "developerTerms", [id], block);
-                developerTerms = { adapter: implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled };
-                if (implementation.toLowerCase() !== adapter.implementation.toLowerCase() || beneficiary.toLowerCase() !== envelope.beneficiary.toLowerCase() ||
-                    termsDigest.toLowerCase() !== envelope.termsDigest.toLowerCase() || maximumDeveloperFeeBps !== envelope.maximumDeveloperFeeBps ||
-                    maximumDeveloperFeeBps > protocolMaximumDeveloperFeeBps)
-                    throw new LifecyclePlanningError("PROFILE_TERMS", "Registry developer terms differ from the frozen reviewed envelope");
+    return withLifecycleReadClient(options.client, async (client) => {
+        const [block, chainIdValue] = await Promise.all([
+            pinnedBlock ?? readLifecycleBlock(client),
+            lifecycleRpc(client, "eth_chainId"),
+        ]);
+        const chainId = rpcQuantity(chainIdValue, "chain ID");
+        const registry = await readLifecycleContract(client, options.orchestrator, launchLifecycleAbi, "registry", [], block);
+        const offset = options.offset ?? 0n;
+        const limit = options.limit ?? 100n;
+        if (offset < 0n || limit < 0n || limit > 100n)
+            throw new LifecyclePlanningError("INVALID_PROFILE_PAGE", "Registry profile pages require unsigned offset and limit at most 100");
+        const [authority, ids] = await Promise.all([
+            readLifecycleContract(client, registry, lifecycleRegistryAbi, "core", [], block),
+            options.profileIds ?? readLifecycleContract(client, registry, lifecycleRegistryAbi, "profileIds", [offset, limit], block),
+        ]);
+        if (authority.toLowerCase() !== options.orchestrator.toLowerCase())
+            throw new LifecyclePlanningError("REGISTRY_BINDING", "Registry is not bound to the selected lifecycle orchestrator");
+        let protocolMaximumDeveloperFeeBpsPromise;
+        const readProtocolMaximumDeveloperFeeBps = () => protocolMaximumDeveloperFeeBpsPromise ??=
+            readLifecycleContract(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block);
+        const profiles = await Promise.all(ids.map(async (id) => {
+            const registration = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "profile", [id], block);
+            const adapter = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block);
+            const schema = registration.configSchema.toLowerCase();
+            const venueKind = schema === V4_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() || schema === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? "uniswap-v4" : schema === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? "abyss" : "unknown";
+            let topology = { hookTopology: 0, configVersion: adapter.configVersion, hookDeployer: zeroAddress, hookCreationCodeHash: zeroHash };
+            let envelope;
+            let developerTerms;
+            let protocolMaximumDeveloperFeeBps;
+            let admitted = false;
+            let reason;
+            try {
+                if (venueKind === "unknown")
+                    throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${registration.configSchema}`);
+                const [recordedTopology, reviewed] = await Promise.all([
+                    readLifecycleProfileTopology(client, registry, id, block),
+                    venueKind === "uniswap-v4" ? Promise.all([
+                        readLifecycleContract(client, registry, lifecycleRegistryAbi, "profileEnvelope", [id], block),
+                        readLifecycleContract(client, registry, lifecycleRegistryAbi, "developerTerms", [id], block),
+                        readProtocolMaximumDeveloperFeeBps(),
+                    ]) : undefined,
+                ]);
+                topology = recordedTopology;
+                if (reviewed !== undefined) {
+                    envelope = reviewed[0];
+                    protocolMaximumDeveloperFeeBps = reviewed[2];
+                    const [implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled] = reviewed[1];
+                    developerTerms = { adapter: implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled };
+                    if (implementation.toLowerCase() !== adapter.implementation.toLowerCase() || beneficiary.toLowerCase() !== envelope.beneficiary.toLowerCase() ||
+                        termsDigest.toLowerCase() !== envelope.termsDigest.toLowerCase() || maximumDeveloperFeeBps !== envelope.maximumDeveloperFeeBps ||
+                        maximumDeveloperFeeBps > reviewed[2])
+                        throw new LifecyclePlanningError("PROFILE_TERMS", "Registry developer terms differ from the frozen reviewed envelope");
+                }
+                await certifyLifecycleProfile(client, options.orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId);
+                const eligible = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, topology.configVersion, LIFECYCLE_REQUIRED_CAPABILITIES], block);
+                if (eligible.toLowerCase() !== adapter.implementation.toLowerCase() || (developerTerms !== undefined && !developerTerms.enabled))
+                    throw new LifecyclePlanningError("INELIGIBLE_PROFILE", "Registry refuses this profile for pending source admission");
+                admitted = true;
             }
-            await certifyLifecycleProfile(options.client, options.orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId);
-            const eligible = await readLifecycleContract(options.client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, topology.configVersion, LIFECYCLE_REQUIRED_CAPABILITIES], block);
-            if (eligible.toLowerCase() !== adapter.implementation.toLowerCase() || (developerTerms !== undefined && !developerTerms.enabled))
-                throw new LifecyclePlanningError("INELIGIBLE_PROFILE", "Registry refuses this profile for pending source admission");
-            admitted = true;
-        }
-        catch (failure) {
-            reason = failure instanceof Error ? failure.message : String(failure);
-        }
-        profiles.push({ id, registration, adapter, topology, envelope, developerTerms, protocolMaximumDeveloperFeeBps: venueKind === "uniswap-v4" ? protocolMaximumDeveloperFeeBps : undefined, admitted, reason, venueKind });
-    }
-    if (pinnedBlock === undefined)
-        await assertLifecycleBlock(options.client, block);
-    return profiles;
+            catch (failure) {
+                reason = failure instanceof Error ? failure.message : String(failure);
+            }
+            return { id, registration, adapter, topology, envelope, developerTerms, protocolMaximumDeveloperFeeBps: venueKind === "uniswap-v4" ? protocolMaximumDeveloperFeeBps : undefined, admitted, reason, venueKind };
+        }));
+        // A required V4 cap read still rejects the invocation on failure; Abyss has no developer-fee terms.
+        if (protocolMaximumDeveloperFeeBpsPromise !== undefined)
+            await protocolMaximumDeveloperFeeBpsPromise;
+        if (pinnedBlock === undefined)
+            await assertLifecycleBlock(client, block, chainId);
+        return profiles;
+    });
 }
 async function readPoolBoundHookDeploymentDetails(options, block) {
     const { client, plan, marketIndex } = options;
@@ -199,20 +238,25 @@ async function readPoolBoundHookDeploymentDetails(options, block) {
     if (chainId !== plan.chainId)
         throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed plan");
     const registry = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block);
-    if ((await readLifecycleContract(client, registry, lifecycleRegistryAbi, "core", [], block)).toLowerCase() !== plan.orchestrator.toLowerCase())
+    const [authority, registration] = await Promise.all([
+        readLifecycleContract(client, registry, lifecycleRegistryAbi, "core", [], block),
+        readLifecycleContract(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 registration = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "profile", [market.profileId], block);
     const adapter = await readLifecycleContract(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 = await readLifecycleProfileTopology(client, registry, market.profileId, block);
-    const envelope = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "profileEnvelope", [market.profileId], block);
-    const [implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled] = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "developerTerms", [market.profileId], block);
-    const protocolMaximumDeveloperFeeBps = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block);
+    const [recorded, envelope, [implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled], protocolMaximumDeveloperFeeBps, token] = await Promise.all([
+        readLifecycleProfileTopology(client, registry, market.profileId, block),
+        readLifecycleContract(client, registry, lifecycleRegistryAbi, "profileEnvelope", [market.profileId], block),
+        readLifecycleContract(client, registry, lifecycleRegistryAbi, "developerTerms", [market.profileId], block),
+        readLifecycleContract(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block),
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "predictToken", [plan], block),
+    ]);
     const { boundGraph } = await certifyLifecycleProfile(client, plan.orchestrator, registry, market.profileId, registration, adapter, recorded, envelope, block, chainId);
     if (boundGraph === undefined)
         throw new LifecyclePlanningError("UNCERTIFIED_TOPOLOGY", "Market does not have a certified pool-bound deployer graph");
-    const token = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "predictToken", [plan], block);
     const config = decodePoolBoundV4LifecycleMarketConfig(market.config);
     validateV4LifecycleMarket({ market, config, token, profile: {
             id: market.profileId, registration, adapter, topology: recorded, envelope,
@@ -228,37 +272,39 @@ async function readPoolBoundHookDeploymentDetails(options, block) {
         marketCommitment: hashPoolBoundV4MarketCommitment({ chainId, core: plan.orchestrator, registrar: adapter.implementation, token, market }),
         expectedPositionCount: config.positions.length,
     };
-    const [parameters, parameterSalt] = await readLifecycleContract(client, boundGraph.collectorFactory, poolFeeCollectorFactoryV1Abi, "poolBoundHookParameters", [adapter.implementation, token, market], block);
-    const [deployer, initCodeHash, salt, predictedHook] = await readLifecycleContract(client, adapter.implementation, poolMarketAdapterV1Abi, "hookDeploymentMetadata", [token, market], block);
-    const remoteInitCodeHash = await readLifecycleContract(client, boundGraph.deployer, poolHookDeployerV1Abi, "initCodeHash", [expected], block);
-    const remotePrediction = await readLifecycleContract(client, boundGraph.deployer, poolHookDeployerV1Abi, "predict", [expected, config.hookSalt], block);
+    const [[parameters, parameterSalt], [deployer, initCodeHash, salt, predictedHook], remoteInitCodeHash, remotePrediction] = await Promise.all([
+        readLifecycleContract(client, boundGraph.collectorFactory, poolFeeCollectorFactoryV1Abi, "poolBoundHookParameters", [adapter.implementation, token, market], block),
+        readLifecycleContract(client, adapter.implementation, poolMarketAdapterV1Abi, "hookDeploymentMetadata", [token, market], block),
+        readLifecycleContract(client, boundGraph.deployer, poolHookDeployerV1Abi, "initCodeHash", [expected], block),
+        readLifecycleContract(client, boundGraph.deployer, poolHookDeployerV1Abi, "predict", [expected, config.hookSalt], block),
+    ]);
     const localInitCodeHash = poolBoundHookInitCodeHash(boundGraph.creationCode, expected);
     const localPrediction = predictPoolBoundHookAddress({ deployer: boundGraph.deployer, initCodeHash: localInitCodeHash, salt: config.hookSalt });
     if (encodePoolBoundHookParameters(parameters).toLowerCase() !== encodePoolBoundHookParameters(expected).toLowerCase() || parameterSalt.toLowerCase() !== config.hookSalt.toLowerCase() || salt.toLowerCase() !== config.hookSalt.toLowerCase() || deployer.toLowerCase() !== boundGraph.deployer.toLowerCase() || initCodeHash.toLowerCase() !== localInitCodeHash.toLowerCase() || remoteInitCodeHash.toLowerCase() !== localInitCodeHash.toLowerCase() || predictedHook.toLowerCase() !== localPrediction.toLowerCase() || remotePrediction.toLowerCase() !== localPrediction.toLowerCase())
         throw new LifecyclePlanningError("HOOK_DEPLOYMENT_CHANGED", "Bound hook metadata differs from the exact certified constructor economics, factory, initcode, salt or CREATE2 prediction");
-    const hookCode = rpcHex(await lifecycleRpc(client, "eth_getCode", [predictedHook, toHex(block.number)]), "bound hook code");
+    const hookCode = rpcHex(await lifecyclePinnedRpc(client, "eth_getCode", [predictedHook, toHex(block.number)], block), "bound hook code");
     if (hookCode !== "0x") {
-        const deployedCodeHash = await readLifecycleContract(client, deployer, poolHookDeployerV1Abi, "deployedCodeHash", [predictedHook], block);
+        const [deployedCodeHash, dependencies, requiredFlags, allFlags, actualPoolId, deploymentConfigHash, marketCommitment, opening, positions] = await Promise.all([
+            readLifecycleContract(client, deployer, poolHookDeployerV1Abi, "deployedCodeHash", [predictedHook], block),
+            Promise.all(["poolManager", "registrar", "oracleFactory", "core", "liquidityLocker", "token"].map((getter) => readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, getter, [], block))),
+            readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "REQUIRED_HOOK_FLAGS", [], block),
+            readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "ALL_HOOK_MASK", [], block),
+            readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "boundPoolId", [], block),
+            readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "deploymentConfigHash", [], block),
+            readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "marketCommitment", [], block),
+            readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "openingSqrtPriceX96", [], block),
+            readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "expectedPositionCount", [], block),
+        ]);
         if ((hookCode.length - 2) / 2 > 24576 || deployedCodeHash === zeroHash || deployedCodeHash.toLowerCase() !== keccak256(hookCode).toLowerCase())
             throw new LifecyclePlanningError("HOOK_DEPLOYMENT_CHANGED", "Existing hook lacks this exact typed deployer's bounded runtime-code provenance");
-        for (const [getter, expectedAddress] of [
-            ["poolManager", expected.poolManager], ["registrar", expected.registrar], ["oracleFactory", expected.oracleFactory],
-            ["core", expected.core], ["liquidityLocker", expected.liquidityLocker], ["token", expected.token],
-        ]) {
-            const actual = await readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, getter, [], block);
-            if (actual.toLowerCase() !== expectedAddress.toLowerCase())
+        for (const [index, expectedAddress] of [expected.poolManager, expected.registrar, expected.oracleFactory, expected.core, expected.liquidityLocker, expected.token].entries()) {
+            if (dependencies[index]?.toLowerCase() !== expectedAddress.toLowerCase())
                 throw new LifecyclePlanningError("HOOK_DEPLOYMENT_CHANGED", "Existing hook immutable dependency graph differs from the committed constructor");
         }
-        if (await readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "REQUIRED_HOOK_FLAGS", [], block) !== 0x1afcn ||
-            await readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "ALL_HOOK_MASK", [], block) !== 0x3fffn)
+        if (requiredFlags !== 0x1afcn || allFlags !== 0x3fffn)
             throw new LifecyclePlanningError("HOOK_DEPLOYMENT_CHANGED", "Existing bound hook callback declarations differ from the reviewed envelope");
         const [currency0, currency1] = BigInt(token) < BigInt(market.quoteAsset) ? [token, market.quoteAsset] : [market.quoteAsset, token];
         const expectedPoolId = keccak256(encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint24" }, { type: "int24" }, { type: "address" }], [currency0, currency1, config.lpFeePips, config.tickSpacing, predictedHook]));
-        const actualPoolId = await readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "boundPoolId", [], block);
-        const deploymentConfigHash = await readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "deploymentConfigHash", [], block);
-        const marketCommitment = await readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "marketCommitment", [], block);
-        const opening = await readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "openingSqrtPriceX96", [], block);
-        const positions = await readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "expectedPositionCount", [], block);
         if (actualPoolId.toLowerCase() !== expectedPoolId.toLowerCase() || deploymentConfigHash.toLowerCase() !== keccak256(encodePoolBoundHookParameters(expected)).toLowerCase() || marketCommitment.toLowerCase() !== expected.marketCommitment.toLowerCase() || opening !== expected.sqrtPriceX96 || positions !== expected.expectedPositionCount)
             throw new LifecyclePlanningError("HOOK_DEPLOYMENT_CHANGED", "Existing hook key, economic commitment or immutable opening geometry changed");
     }
@@ -268,24 +314,28 @@ async function readPoolBoundHookDeploymentDetails(options, block) {
 export async function readPoolBoundHookDeployment(options, pinnedBlock) {
     const commitment = hashLaunchPlan(options.plan);
     const block = pinnedBlock ?? await readLifecycleBlock(options.client);
-    const { deployment } = await readPoolBoundHookDeploymentDetails(options, block);
-    if (hashLaunchPlan(options.plan) !== commitment)
-        throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed while reading hook deployment metadata");
-    if (pinnedBlock === undefined)
-        await assertLifecycleBlock(options.client, block);
-    return deployment;
+    return withLifecycleReadClient(options.client, async (client) => {
+        const { deployment } = await readPoolBoundHookDeploymentDetails({ ...options, client }, block);
+        if (hashLaunchPlan(options.plan) !== commitment)
+            throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed while reading hook deployment metadata");
+        if (pinnedBlock === undefined)
+            await assertLifecycleBlock(client, block, options.plan.chainId);
+        return deployment;
+    });
 }
 /** Optional permissionless predeployment calldata; no token deployment, pool registration or wallet broadcast. */
 export async function buildPoolBoundHookDeploymentTransaction(options) {
     const commitment = hashLaunchPlan(options.plan);
     const block = await readLifecycleBlock(options.client);
-    const { deployment, parameters } = await readPoolBoundHookDeploymentDetails(options, block);
-    if (!hasLifecycleV4HookPermissions(deployment.predictedHook))
-        throw new LifecyclePlanningError("INVALID_HOOK_BITS", "Finalize a salt with the exact lifecycle hook permissions before predeployment");
-    if (hashLaunchPlan(options.plan) !== commitment)
-        throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed while constructing hook deployment calldata");
-    await assertLifecycleBlock(options.client, block);
-    return { to: deployment.deployer, data: encodeFunctionData({ abi: poolHookDeployerV1Abi, functionName: "deploy", args: [parameters, deployment.salt] }), value: 0n, deployment };
+    return withLifecycleReadClient(options.client, async (client) => {
+        const { deployment, parameters } = await readPoolBoundHookDeploymentDetails({ ...options, client }, block);
+        if (!hasLifecycleV4HookPermissions(deployment.predictedHook))
+            throw new LifecyclePlanningError("INVALID_HOOK_BITS", "Finalize a salt with the exact lifecycle hook permissions before predeployment");
+        if (hashLaunchPlan(options.plan) !== commitment)
+            throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed while constructing hook deployment calldata");
+        await assertLifecycleBlock(client, block, options.plan.chainId);
+        return { to: deployment.deployer, data: encodeFunctionData({ abi: poolHookDeployerV1Abi, functionName: "deploy", args: [parameters, deployment.salt] }), value: 0n, deployment };
+    });
 }
 export function validateLifecycleMarketIdentity(identity, plan, token, marketIndex) {
     const market = plan.markets[marketIndex];
@@ -352,8 +402,10 @@ async function readReceipt(reference, options, block) {
         if (observed === null || rpcHex(rpcObject(observed, "observed receipt block").hash, "observed receipt block hash").toLowerCase() !== reference.observedBlockHash.toLowerCase())
             return { ...base, status: "reorged", blockNumber: observedNumber, blockHash: reference.observedBlockHash };
     }
-    const receiptValue = await lifecycleRpc(options.client, "eth_getTransactionReceipt", [effectiveHash]);
-    const transactionValue = await lifecycleRpc(options.client, "eth_getTransactionByHash", [effectiveHash]);
+    const [receiptValue, transactionValue] = await Promise.all([
+        lifecycleRpc(options.client, "eth_getTransactionReceipt", [effectiveHash]),
+        lifecycleRpc(options.client, "eth_getTransactionByHash", [effectiveHash]),
+    ]);
     if (receiptValue === null) {
         // An absent receipt with an unchanged canonical observed block is not a
         // reorg: the transaction is simply not (yet) mined. A missing/changed
@@ -389,8 +441,11 @@ async function readReceipt(reference, options, block) {
 }
 /** Reads confirmation-bound canonical state and receipt provenance; local step counters are never used. */
 export async function readLaunchProgress(options, pinnedBlock) {
-    const { client, planned } = options;
-    const block = pinnedBlock ?? await readLifecycleBlock(client);
+    const block = pinnedBlock ?? await readLifecycleBlock(options.client);
+    return withLifecycleReadClient(options.client, (client) => readLaunchProgressAtBlock(options, client, block, pinnedBlock === undefined));
+}
+async function readLaunchProgressAtBlock(options, client, block, checkBlock) {
+    const { planned } = options;
     const confirmationDepth = options.confirmations ?? planned.confirmations;
     if (!Number.isSafeInteger(confirmationDepth) || confirmationDepth < 1)
         throw new LifecyclePlanningError("INVALID_CONFIRMATIONS", "Confirmation depth must be a positive integer");
@@ -403,9 +458,15 @@ export async function readLaunchProgress(options, pinnedBlock) {
         throw new LifecyclePlanningError("ACCOUNT_MISMATCH", "Execution account must be the committed creator/payer/refund account");
     if (hashLaunchPlan(planned.plan).toLowerCase() !== planned.planHash.toLowerCase() || hashLaunchIdentity(planned.plan).toLowerCase() !== planned.launchId.toLowerCase())
         throw new LifecyclePlanningError("PLAN_MUTATED", "Stored economic plan no longer matches its commitment");
-    const head = await readLifecycleContract(client, planned.plan.orchestrator, launchLifecycleAbi, "readLaunchProgress", [planned.launchId], block, planned.account);
-    const canonical = confirmedNumber === block.number ? head : await readLifecycleContract(client, planned.plan.orchestrator, launchLifecycleAbi, "readLaunchProgress", [planned.launchId], confirmedBlock, planned.account);
-    const token = await readLifecycleContract(client, planned.plan.orchestrator, launchLifecycleAbi, "predictToken", [planned.plan], block);
+    const [head, confirmedProgress, token, confirmedNonce, headNonce, pendingNonce] = await Promise.all([
+        readLifecycleContract(client, planned.plan.orchestrator, launchLifecycleAbi, "readLaunchProgress", [planned.launchId], block, planned.account),
+        confirmedNumber === block.number ? undefined : readLifecycleContract(client, planned.plan.orchestrator, launchLifecycleAbi, "readLaunchProgress", [planned.launchId], confirmedBlock, planned.account),
+        readLifecycleContract(client, planned.plan.orchestrator, launchLifecycleAbi, "predictToken", [planned.plan], block),
+        lifecycleRpc(client, "eth_getTransactionCount", [planned.account, toHex(confirmedBlock.number)]),
+        confirmedNumber === block.number ? undefined : lifecycleRpc(client, "eth_getTransactionCount", [planned.account, toHex(block.number)]),
+        lifecycleRpc(client, "eth_getTransactionCount", [planned.account, "pending"]),
+    ]);
+    const canonical = confirmedProgress ?? head;
     if (token.toLowerCase() !== planned.predictedToken.toLowerCase())
         throw new LifecyclePlanningError("TOKEN_IDENTITY", "Predicted token changed for the committed token configuration");
     for (const progress of [canonical, head])
@@ -417,33 +478,33 @@ export async function readLaunchProgress(options, pinnedBlock) {
             if (progress.preparedMarkets > progress.marketCount || progress.phase === LifecyclePhase.Activating || (progress.phase === LifecyclePhase.Ready && progress.preparedMarkets !== progress.marketCount))
                 throw new LifecyclePlanningError("INVALID_PROGRESS", "Canonical progress violates the committed ordered state machine");
         }
-    const confirmedAccountNonce = rpcQuantity(await lifecycleRpc(client, "eth_getTransactionCount", [planned.account, toHex(confirmedBlock.number)]), "confirmed account nonce");
-    const headAccountNonce = confirmedNumber === block.number ? confirmedAccountNonce : rpcQuantity(await lifecycleRpc(client, "eth_getTransactionCount", [planned.account, toHex(block.number)]), "head account nonce");
-    const pendingAccountNonce = rpcQuantity(await lifecycleRpc(client, "eth_getTransactionCount", [planned.account, "pending"]), "pending account nonce");
+    const confirmedAccountNonce = rpcQuantity(confirmedNonce, "confirmed account nonce");
+    const headAccountNonce = headNonce === undefined ? confirmedAccountNonce : rpcQuantity(headNonce, "head account nonce");
+    const pendingAccountNonce = rpcQuantity(pendingNonce, "pending account nonce");
     const progressParameters = [{ type: "tuple", components: launchProgressV1Components }];
     const confirmationSafe = confirmedAccountNonce === headAccountNonce && pendingAccountNonce === headAccountNonce && keccak256(encodeAbiParameters(progressParameters, [canonical])) === keccak256(encodeAbiParameters(progressParameters, [head]));
-    const receipts = [];
-    for (const reference of options.receipts ?? [])
-        receipts.push(await readReceipt({ ...reference, confirmations: Math.max(reference.confirmations ?? 1, confirmationDepth) }, options, block));
-    const markets = [];
+    const receipts = await Promise.all((options.receipts ?? []).map((reference) => readReceipt({ ...reference, confirmations: Math.max(reference.confirmations ?? 1, confirmationDepth) }, { ...options, client }, block)));
+    let markets = [];
     if (canonical.preparedMarkets > 0) {
         const directory = await readLifecycleContract(client, planned.plan.orchestrator, launchLifecycleAbi, "directory", [], confirmedBlock);
-        for (let index = 0; index < canonical.preparedMarkets; index += 1) {
+        markets = await Promise.all(Array.from({ length: canonical.preparedMarkets }, async (_, index) => {
             const [adapter, prepared] = await readLifecycleContract(client, directory, lifecycleDirectoryAbi, "market", [planned.launchId, index], confirmedBlock);
             validateLifecycleMarketIdentity(prepared.identity, planned.plan, token, index);
             try {
                 const live = await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "readMarket", [planned.launchId, index], confirmedBlock);
-                markets.push({ index, prepared, live });
+                return { index, prepared, live };
             }
             catch (failure) {
-                markets.push({ index, prepared, error: failure instanceof Error ? failure.message : String(failure) });
+                return { index, prepared, error: failure instanceof Error ? failure.message : String(failure) };
             }
-        }
+        }));
     }
-    if (pinnedBlock === undefined)
-        await assertLifecycleBlock(client, block);
+    if (checkBlock)
+        await assertLifecycleBlock(client, block, chainId);
     if (confirmedNumber !== block.number)
-        await assertLifecycleBlock(client, confirmedBlock);
+        await assertLifecycleBlock(client, confirmedBlock, chainId);
+    if (hashLaunchPlan(planned.plan).toLowerCase() !== planned.planHash.toLowerCase() || hashLaunchIdentity(planned.plan).toLowerCase() !== planned.launchId.toLowerCase())
+        throw new LifecyclePlanningError("PLAN_MUTATED", "Stored economic plan changed during asynchronous progress reads");
     return { canonical, head, confirmationDepth, confirmedBlockNumber: confirmedBlock.number, confirmedBlockHash: confirmedBlock.hash, confirmedAccountNonce, headAccountNonce, pendingAccountNonce, confirmationSafe, token, planHash: planned.planHash, launchId: planned.launchId, chainId, blockNumber: block.number, blockHash: block.hash, markets, receipts };
 }
 //# sourceMappingURL=progress.js.map