@black-market/sdk 0.6.4 → 0.7.1

package/dist/lifecycle/progress.js

@@ -1,15 +1,69 @@
 import { concatHex, decodeFunctionData, encodeAbiParameters, encodeFunctionData, keccak256, stringToHex, toHex, zeroAddress, zeroHash } from "viem";
-import { 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, lifecyclePinnedRpc, lifecycleRpc, lifecycleStage, readLifecycleBlock, readLifecycleContract, readLifecycleProfileTopology, rpcHex, rpcObject, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
+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 } from "./markets.js";
+import { hashLaunchIdentity, hashLaunchPlan, hashLaunchBounds, hashLaunchDependencies, hashLifecycleProfile, lifecycleTokenComponents, launchProgressV1Components, LifecycleMode, LifecyclePhase, LifecycleVenue, LIFECYCLE_REQUIRED_CAPABILITIES, LIFECYCLE_ERC404_CAPABILITY, LIFECYCLE_MULTI_POSITION_CAPABILITY } from "./schema.js";
+import { assertLifecycleBlock, assertLifecycleReadClientOpen, lifecycleFailureReason, lifecyclePinnedRpc, lifecycleRpc, lifecycleStage, readLifecycleBlock, readLifecycleChainId, readLifecycleContract, readLifecycleProfileTopology, rpcHex, rpcObject, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
 import { LifecyclePlanningError } from "./types.js";
+import { deriveKnownPoolBoundHookDeployment } from "./calibration.js";
+import { getKnownLifecycleDeployment, getKnownLifecycleProfile } from "./presets.js";
 export const ABYSS_LIFECYCLE_CONFIG_SCHEMA = keccak256(stringToHex("(uint8,uint24,bytes32,uint160,(int24,int24,uint128,uint256)[])"));
+const lifecycleTokenPredictionAbi = [{
+        type: "function", name: "predictToken", stateMutability: "view",
+        inputs: [{ name: "launchId", type: "bytes32" }, { name: "config", type: "tuple", components: lifecycleTokenComponents }],
+        outputs: [{ type: "address" }],
+    }];
+/** The known immutable factory accepts only launch identity and token config,
+ * avoiding full-plan prediction reads after salts or buy minima change. */
+export async function readLifecycleTokenAtBlock(client, plan, block) {
+    const deployment = getKnownLifecycleDeployment({ chainId: plan.chainId, orchestrator: plan.orchestrator });
+    return deployment === undefined
+        ? readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "predictToken", [plan], block)
+        : readLifecycleContract(client, deployment.tokenFactory, lifecycleTokenPredictionAbi, "predictToken", [hashLaunchIdentity(plan), plan.token], block);
+}
 export async function predictLifecycleToken(options) {
-    const block = await readLifecycleBlock(options.client);
-    const token = await readLifecycleContract(options.client, options.plan.orchestrator, launchLifecycleAbi, "predictToken", [options.plan], block);
-    await assertLifecycleBlock(options.client, block);
-    return token;
+    return withLifecycleReadClient(options.client, async (client) => {
+        const block = await readLifecycleBlock(client);
+        const token = await readLifecycleTokenAtBlock(client, options.plan, block);
+        await assertLifecycleBlock(client, block, options.plan.chainId);
+        return token;
+    });
+}
+const certifiedProfilesByInvocation = new WeakMap();
+const boundDeploymentsByInvocation = new WeakMap();
+function assertDerivedReadClientOpen(client) {
+    try {
+        return assertLifecycleReadClientOpen(client);
+    }
+    catch (failure) {
+        certifiedProfilesByInvocation.delete(client);
+        boundDeploymentsByInvocation.delete(client);
+        throw failure;
+    }
+}
+function lifecycleProfileCertificateKey(orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId) {
+    const g = envelope?.graph;
+    const b = envelope?.bounds;
+    // Fixed ABI field order preserves every scalar, including flags delegated to
+    // registry eligibility. Keys never rehash runtime, chunk or creation bytes.
+    return JSON.stringify([
+        block.number.toString(), block.hash.toLowerCase(), chainId.toString(), orchestrator.toLowerCase(), registry.toLowerCase(), id.toLowerCase(),
+        [registration.adapterId.toLowerCase(), registration.configSchema.toLowerCase(), registration.dependencyDigest.toLowerCase(),
+            registration.venue.toLowerCase(), registration.factory.toLowerCase(), registration.hook.toLowerCase(), registration.capabilities.toString(), registration.enabled],
+        [adapter.implementation.toLowerCase(), adapter.codeHash.toLowerCase(), adapter.capabilities.toString(), adapter.configVersion, adapter.enabled],
+        [topology.hookTopology, topology.configVersion, topology.hookDeployer.toLowerCase(), topology.hookCreationCodeHash.toLowerCase()],
+        envelope === undefined ? null : [
+            envelope.artifactDigest.toLowerCase(), envelope.reviewManifestDigest.toLowerCase(), envelope.configBoundsDigest.toLowerCase(), envelope.termsDigest.toLowerCase(),
+            envelope.topology, envelope.configVersion, envelope.economicVersion, envelope.capabilities.toString(), envelope.flags.toString(),
+            envelope.callbackFlags, envelope.callbackMask, envelope.protocolTreasury.toLowerCase(), envelope.protocolFeeDenominator,
+            envelope.beneficiary.toLowerCase(), envelope.maximumDeveloperFeeBps,
+            [b.minimumTickSpacing, b.maximumTickSpacing, b.maximumPositions, b.maximumOracleCardinality, b.feeModeFlags],
+            [g.manager.toLowerCase(), g.hookRoot.toLowerCase(), g.oracleFactory.toLowerCase(), g.locker.toLowerCase(), g.collectorFactory.toLowerCase(),
+                g.collectorDeployer.toLowerCase(), g.hookDeployer.toLowerCase(), g.coreCodeHash.toLowerCase(), g.managerCodeHash.toLowerCase(),
+                g.hookRuntimeCodeHash.toLowerCase(), g.oracleFactoryCodeHash.toLowerCase(), g.lockerCodeHash.toLowerCase(), g.collectorFactoryCodeHash.toLowerCase(),
+                g.collectorDeployerCodeHash.toLowerCase(), g.hookDeployerCodeHash.toLowerCase(), g.hookCreationCodeHash.toLowerCase(),
+                g.codeChunk0.toLowerCase(), g.codeChunk0Hash.toLowerCase(), g.codeChunk1.toLowerCase(), g.codeChunk1Hash.toLowerCase(), g.sharedHookSalt.toLowerCase()],
+        ],
+    ]);
 }
 async function readDependencyCode(client, address, block) {
     const code = rpcHex(await lifecyclePinnedRpc(client, "eth_getCode", [address, toHex(block.number)], block), "lifecycle dependency code");
@@ -17,13 +71,39 @@ async function readDependencyCode(client, address, block) {
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", `Lifecycle dependency ${address} has no deployed code`);
     return code;
 }
-async function certifyLifecycleProfile(client, orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId) {
+async function certifyLifecycleProfile(client, orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId, eligibility) {
+    if (!assertDerivedReadClientOpen(client))
+        return certifyLifecycleProfileFresh(client, orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId, eligibility);
+    const key = lifecycleProfileCertificateKey(orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId);
+    let certificates = certifiedProfilesByInvocation.get(client);
+    if (certificates === undefined) {
+        certificates = new Map();
+        certifiedProfilesByInvocation.set(client, certificates);
+    }
+    let pending = certificates.get(key);
+    if (pending === undefined) {
+        pending = certifyLifecycleProfileFresh(client, orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId, eligibility);
+        certificates.set(key, pending);
+        const owned = pending;
+        void pending.catch(() => { if (certificates.get(key) === owned)
+            certificates.delete(key); });
+    }
+    try {
+        return await pending;
+    }
+    finally {
+        assertDerivedReadClientOpen(client);
+    }
+}
+async function certifyLifecycleProfileFresh(client, orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId, eligibility) {
     const shared = registration.configSchema.toLowerCase() === V4_LIFECYCLE_CONFIG_SCHEMA.toLowerCase();
-    const bound = registration.configSchema.toLowerCase() === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA.toLowerCase();
+    const boundVersion = registration.configSchema.toLowerCase() === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA_V5.toLowerCase() ? 5
+        : registration.configSchema.toLowerCase() === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA_V6.toLowerCase() ? 6 : undefined;
+    const bound = boundVersion !== undefined;
     const abyss = registration.configSchema.toLowerCase() === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase();
     if (!shared && !bound && !abyss)
         throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${registration.configSchema}`);
-    const version = shared ? 4 : bound ? 5 : 1;
+    const version = shared ? 4 : boundVersion ?? 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");
     if (abyss) {
@@ -36,10 +116,12 @@ async function certifyLifecycleProfile(client, orchestrator, registry, id, regis
         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");
-        const eligible = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, version, LIFECYCLE_REQUIRED_CAPABILITIES], block);
+        if (eligibility !== undefined && "failure" in eligibility)
+            throw eligibility.failure;
+        const eligible = eligibility?.eligible ?? await readLifecycleContract(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 { topology };
+        return Object.freeze({ topology: Object.freeze({ ...topology }) });
     }
     if (envelope === undefined || envelope.topology !== topology.hookTopology || envelope.configVersion !== version || envelope.economicVersion !== 3 ||
         envelope.flags !== 0n || envelope.callbackFlags !== 0x1afc || envelope.callbackMask !== 0x3fff ||
@@ -61,7 +143,7 @@ async function certifyLifecycleProfile(client, orchestrator, registry, id, regis
     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");
-    const deployerAbi = shared ? sharedHookDeployerV1Abi : poolHookDeployerV1Abi;
+    const deployerAbi = shared ? sharedHookDeployerV1Abi : boundVersion === 5 ? poolHookDeployerV1Abi : poolHookDeployerConfigV6Abi;
     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]];
@@ -118,7 +200,7 @@ async function certifyLifecycleProfile(client, orchestrator, registry, id, regis
         keccak256(chunk0Code).toLowerCase() !== g.codeChunk0Hash.toLowerCase() || (chunk1 === zeroAddress ? zeroHash : keccak256(chunk1Code)).toLowerCase() !== g.codeChunk1Hash.toLowerCase())
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Reviewed deployer chunks differ from exact immutable STOP-prefixed bytecode evidence");
     const creationCode = concatHex([`0x${chunk0Code.slice(4)}`, chunk1 === zeroAddress ? "0x" : `0x${chunk1Code.slice(4)}`]);
-    if ((creationCode.length - 2) / 2 + (shared ? 96 : 576) > 49152 || creationCodeHash === zeroHash ||
+    if ((creationCode.length - 2) / 2 + (shared ? 96 : boundVersion === 5 ? 576 : 640) > 49152 || creationCodeHash === zeroHash ||
         creationCodeHash.toLowerCase() !== g.hookCreationCodeHash.toLowerCase() || keccak256(creationCode).toLowerCase() !== creationCodeHash.toLowerCase() ||
         hashLaunchDependencies({ chainId, core: orchestrator, registry, registrar: adapter.implementation, graph: g }).toLowerCase() !== registration.dependencyDigest.toLowerCase())
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Reviewed creation artifact, constructor bound or graph digest differs from admission");
@@ -140,7 +222,7 @@ async function certifyLifecycleProfile(client, orchestrator, registry, id, regis
         throw new LifecyclePlanningError("PROFILE_DEPENDENCY", "Bound topology cannot reuse a shared root");
     if ([zeroAddress, orchestrator, registry, adapter.implementation, g.manager, g.hookRoot, g.locker, g.collectorFactory, g.collectorDeployer, g.hookDeployer].some((address) => address.toLowerCase() === envelope.beneficiary.toLowerCase()))
         throw new LifecyclePlanningError("PROFILE_TERMS", "Stable author identity is an excluded reviewed graph destination");
-    return { topology, boundGraph: bound ? { manager: g.manager, oracleFactory: g.oracleFactory, locker: g.locker, collectorFactory: g.collectorFactory, deployer: g.hookDeployer, creationCode } : undefined };
+    return Object.freeze({ topology: Object.freeze({ ...topology }), boundGraph: bound ? Object.freeze({ manager: g.manager, oracleFactory: g.oracleFactory, locker: g.locker, collectorFactory: g.collectorFactory, deployer: g.hookDeployer, creationCode }) : undefined });
 }
 /** Validate the market-selected registered oracle against the certified factory at the pinned block. */
 export async function validateV4LifecycleOracle(options) {
@@ -172,7 +254,7 @@ export async function readLifecycleProfiles(options, pinnedBlock) {
                 const readProfile = async (id) => {
                     const registration = await readLifecycleContract(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.toLowerCase() ? "uniswap-v4" : schema === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? "abyss" : "unknown";
+                    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(client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block),
                         venueKind === "unknown" ? undefined : Promise.all([
@@ -182,6 +264,10 @@ export async function readLifecycleProfiles(options, pinnedBlock) {
                                 readLifecycleContract(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(client, registry, lifecycleRegistryAbi, "requireEligible", [registration.adapterId, id, 1, LIFECYCLE_REQUIRED_CAPABILITIES], block)).then((eligible) => ({ eligible }), (failure) => ({ failure })) : undefined,
                         ]).then((values) => ({ values }), (failure) => ({ failure })),
                     ]);
                     const chainId = await chainIdPromise;
@@ -196,7 +282,7 @@ export async function readLifecycleProfiles(options, pinnedBlock) {
                             throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${registration.configSchema}`);
                         if ("failure" in certification)
                             throw certification.failure;
-                        const [recordedTopology, reviewed] = certification.values;
+                        const [recordedTopology, reviewed, eligibility] = certification.values;
                         topology = recordedTopology;
                         if (reviewed !== undefined) {
                             envelope = reviewed[0];
@@ -208,13 +294,13 @@ export async function readLifecycleProfiles(options, pinnedBlock) {
                                 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);
+                        await certifyLifecycleProfile(client, options.orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId, eligibility);
                         if (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);
+                        reason = lifecycleFailureReason(failure);
                     }
                     return { id, registration, adapter, topology, envelope, developerTerms, protocolMaximumDeveloperFeeBps: venueKind === "uniswap-v4" ? protocolMaximumDeveloperFeeBps : undefined, admitted, reason, venueKind };
                 };
@@ -235,14 +321,67 @@ export async function readLifecycleProfiles(options, pinnedBlock) {
         return profiles;
     }));
 }
-async function readPoolBoundHookDeploymentDetails(options, block) {
+async function readPoolBoundHookDeploymentDetails(options, block, commitment) {
     const { client, plan, marketIndex } = options;
     const market = plan.markets[marketIndex];
-    if (market === undefined || market.configVersion !== 5)
-        throw new LifecyclePlanningError("INVALID_BOUND_MARKET", "Market index must select reviewed pool-bound config version 5");
-    const chainId = rpcQuantity(await lifecycleRpc(client, "eth_chainId"), "chain ID");
+    if (market === undefined || !isPoolBoundV4ConfigVersion(market.configVersion))
+        throw new LifecyclePlanningError("INVALID_BOUND_MARKET", "Market index must select explicit pool-bound config version 5 or 6");
+    let chainId;
+    try {
+        chainId = rpcQuantity(await lifecycleRpc(client, "eth_chainId"), "chain ID");
+    }
+    finally {
+        assertDerivedReadClientOpen(client);
+    }
+    if (hashLaunchPlan(plan) !== commitment)
+        throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed while observing the hook deployment chain");
     if (chainId !== plan.chainId)
         throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed plan");
+    if (getKnownLifecycleProfile({ chainId, orchestrator: plan.orchestrator, profileId: market.profileId }) !== undefined) {
+        const token = await readLifecycleTokenAtBlock(client, plan, block);
+        const details = deriveKnownPoolBoundHookDeployment({ plan, marketIndex, token });
+        if (details === undefined)
+            throw new LifecyclePlanningError("INVALID_BOUND_MARKET", "Known profile has no bound-hook construction metadata");
+        if (hashLaunchPlan(plan) !== commitment)
+            throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed while deriving hook deployment metadata");
+        assertDerivedReadClientOpen(client);
+        return Object.freeze({ deployment: Object.freeze(details.deployment), parameters: Object.freeze(details.parameters), configVersion: details.configVersion });
+    }
+    if (!assertDerivedReadClientOpen(client)) {
+        const details = await readPoolBoundHookDeploymentDetailsFresh(options, block, chainId);
+        if (hashLaunchPlan(plan) !== commitment)
+            throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed while reading hook deployment metadata");
+        return details;
+    }
+    const key = JSON.stringify([block.number.toString(), block.hash.toLowerCase(), chainId.toString(), commitment.toLowerCase(), marketIndex]);
+    let deployments = boundDeploymentsByInvocation.get(client);
+    if (deployments === undefined) {
+        deployments = new Map();
+        boundDeploymentsByInvocation.set(client, deployments);
+    }
+    let pending = deployments.get(key);
+    if (pending === undefined) {
+        pending = readPoolBoundHookDeploymentDetailsFresh(options, block, chainId).then((details) => {
+            if (hashLaunchPlan(plan) !== commitment)
+                throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed while reading hook deployment metadata");
+            assertDerivedReadClientOpen(client);
+            return details;
+        });
+        deployments.set(key, pending);
+        const owned = pending;
+        void pending.catch(() => { if (deployments.get(key) === owned)
+            deployments.delete(key); });
+    }
+    try {
+        return await pending;
+    }
+    finally {
+        assertDerivedReadClientOpen(client);
+    }
+}
+async function readPoolBoundHookDeploymentDetailsFresh(options, block, chainId) {
+    const { client, plan, marketIndex } = options;
+    const market = plan.markets[marketIndex];
     const registry = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block);
     const [authority, registration] = await Promise.all([
         readLifecycleContract(client, registry, lifecycleRegistryAbi, "core", [], block),
@@ -263,35 +402,35 @@ async function readPoolBoundHookDeploymentDetails(options, 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 config = decodePoolBoundV4LifecycleMarketConfig(market.config);
+    if (!isPoolBoundV4ConfigVersion(market.configVersion))
+        throw new LifecyclePlanningError("INVALID_BOUND_MARKET", "Market must select an explicit pool-bound version");
+    const config = decodePoolBoundV4LifecycleMarketConfig(market.config, market.configVersion);
     validateV4LifecycleMarket({ market, config, token, profile: {
             id: market.profileId, registration, adapter, topology: recorded, envelope,
             developerTerms: { adapter: implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled },
             protocolMaximumDeveloperFeeBps, venueKind: "uniswap-v4", admitted: enabled,
         } });
     await validateV4LifecycleOracle({ client, envelope, oracleConfigId: config.oracleConfigId, block });
-    const expected = {
-        poolManager: boundGraph.manager, registrar: adapter.implementation, oracleFactory: boundGraph.oracleFactory, core: plan.orchestrator,
-        liquidityLocker: boundGraph.locker, token, quoteCurrency: market.quoteAsset, lpFeePips: config.lpFeePips, tickSpacing: config.tickSpacing,
-        sqrtPriceX96: config.sqrtPriceX96, hookFeePips: config.hookFeePips, feeMode: config.feeMode, protocolFeeDenominator: config.protocolFeeDenominator,
-        treasury: config.treasury, externalLiquidityDisabled: config.externalLiquidityDisabled, oracleConfigId: config.oracleConfigId,
-        marketCommitment: hashPoolBoundV4MarketCommitment({ chainId, core: plan.orchestrator, registrar: adapter.implementation, token, market }),
-        expectedPositionCount: config.positions.length,
-    };
+    const expected = buildPoolBoundHookParameters({
+        chainId, core: plan.orchestrator, poolManager: boundGraph.manager, registrar: adapter.implementation,
+        oracleFactory: boundGraph.oracleFactory, liquidityLocker: boundGraph.locker, token, market, config,
+    });
+    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(client, boundGraph.collectorFactory, poolFeeCollectorFactoryV1Abi, "poolBoundHookParameters", [adapter.implementation, token, market], block),
+        readLifecycleContract(client, boundGraph.collectorFactory, collectorAbi, "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),
+        readLifecycleContract(client, boundGraph.deployer, deployerAbi, "initCodeHash", [expected], block),
+        readLifecycleContract(client, boundGraph.deployer, deployerAbi, "predict", [expected, config.hookSalt], block),
     ]);
-    const localInitCodeHash = poolBoundHookInitCodeHash(boundGraph.creationCode, expected);
+    const localInitCodeHash = poolBoundHookInitCodeHash(boundGraph.creationCode, expected, config.version);
     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");
+    if (encodePoolBoundHookParameters(parameters, config.version).toLowerCase() !== encodePoolBoundHookParameters(expected, config.version).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 version, constructor economics, factory, initcode, salt or CREATE2 prediction");
     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] = await Promise.all([
-            readLifecycleContract(client, deployer, poolHookDeployerV1Abi, "deployedCodeHash", [predictedHook], block),
+        const [deployedCodeHash, dependencies, requiredFlags, allFlags, actualPoolId, deploymentConfigHash, marketCommitment, opening, positions, feePolicy] = await Promise.all([
+            readLifecycleContract(client, deployer, deployerAbi, "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),
@@ -300,6 +439,10 @@ async function readPoolBoundHookDeploymentDetails(options, block) {
             readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "marketCommitment", [], block),
             readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "openingSqrtPriceX96", [], block),
             readLifecycleContract(client, predictedHook, fixedFeePoolHookV1Abi, "expectedPositionCount", [], block),
+            config.version === 6 ? Promise.all([
+                readLifecycleContract(client, predictedHook, fixedFeePoolHookConfigV6Abi, "minimumHookFeePips", [], block),
+                readLifecycleContract(client, predictedHook, fixedFeePoolHookConfigV6Abi, "feeSensitivityPipsSecondsPerTick", [], block),
+            ]) : undefined,
         ]);
         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");
@@ -311,22 +454,24 @@ async function readPoolBoundHookDeploymentDetails(options, block) {
             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]));
-        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");
+        if (actualPoolId.toLowerCase() !== expectedPoolId.toLowerCase() || deploymentConfigHash.toLowerCase() !== keccak256(encodePoolBoundHookParameters(expected, config.version)).toLowerCase() || marketCommitment.toLowerCase() !== expected.marketCommitment.toLowerCase() || opening !== expected.sqrtPriceX96 || positions !== expected.expectedPositionCount ||
+            (config.version === 6 && (feePolicy?.[0] !== config.minimumHookFeePips || feePolicy?.[1] !== config.feeSensitivityPipsSecondsPerTick)))
+            throw new LifecyclePlanningError("HOOK_DEPLOYMENT_CHANGED", "Existing hook key, economic commitment, versioned fee policy or immutable opening geometry changed");
     }
-    return { deployment: { deployer, initCodeHash, salt, predictedHook }, parameters: expected };
+    return Object.freeze({ deployment: Object.freeze({ deployer, initCodeHash, salt, predictedHook }), parameters: Object.freeze(expected), configVersion: config.version });
 }
-/** Works with an unmined candidate salt and after preparation; never accepts a caller-selected root. */
+/** Known identities use frozen local construction data; unlisted identities use
+ * explicit live certification. Exact launch execution, not either DTO, authorizes. */
 export async function readPoolBoundHookDeployment(options, pinnedBlock) {
     const commitment = hashLaunchPlan(options.plan);
     const block = pinnedBlock ?? await readLifecycleBlock(options.client);
     return withLifecycleReadClient(options.client, async (client) => {
-        const { deployment } = await readPoolBoundHookDeploymentDetails({ ...options, client }, block);
+        const { deployment } = await readPoolBoundHookDeploymentDetails({ ...options, client }, block, commitment);
         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;
+        return { ...deployment };
     });
 }
 /** Optional permissionless predeployment calldata; no token deployment, pool registration or wallet broadcast. */
@@ -334,13 +479,14 @@ export async function buildPoolBoundHookDeploymentTransaction(options) {
     const commitment = hashLaunchPlan(options.plan);
     const block = await readLifecycleBlock(options.client);
     return withLifecycleReadClient(options.client, async (client) => {
-        const { deployment, parameters } = await readPoolBoundHookDeploymentDetails({ ...options, client }, block);
+        const { deployment, parameters, configVersion } = await readPoolBoundHookDeploymentDetails({ ...options, client }, block, commitment);
         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 };
+        const abi = configVersion === 5 ? poolHookDeployerV1Abi : poolHookDeployerConfigV6Abi;
+        return { to: deployment.deployer, data: encodeFunctionData({ abi, functionName: "deploy", args: [parameters, deployment.salt] }), value: 0n, deployment: { ...deployment } };
     });
 }
 export function validateLifecycleMarketIdentity(identity, plan, token, marketIndex) {
@@ -447,20 +593,28 @@ 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) {
+    if (options.signal?.aborted)
+        throw Object.assign(new Error("Lifecycle progress read cancelled"), { name: "AbortError" });
     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 assertActive = () => {
+        if (options.signal?.aborted)
+            throw Object.assign(new Error("Lifecycle progress read cancelled"), { name: "AbortError" });
+    };
+    assertActive();
     const confirmationDepth = options.confirmations ?? planned.confirmations;
     if (!Number.isSafeInteger(confirmationDepth) || confirmationDepth < 1)
         throw new LifecyclePlanningError("INVALID_CONFIRMATIONS", "Confirmation depth must be a positive integer");
     const confirmedNumber = block.number >= BigInt(confirmationDepth - 1) ? block.number - BigInt(confirmationDepth - 1) : 0n;
     const [confirmedBlock, chainIdValue] = await Promise.all([
         confirmedNumber === block.number ? block : readLifecycleBlock(client, toHex(confirmedNumber)),
-        lifecycleRpc(client, "eth_chainId"),
+        readLifecycleChainId(client),
     ]);
-    const chainId = rpcQuantity(chainIdValue, "chain ID");
+    assertActive();
+    const chainId = chainIdValue;
     if (chainId !== planned.plan.chainId)
         throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed launch");
     if (planned.account.toLowerCase() !== planned.plan.creator.toLowerCase())
@@ -470,11 +624,12 @@ async function readLaunchProgressAtBlock(options, client, block, checkBlock) {
     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),
+        readLifecycleTokenAtBlock(client, 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"]),
     ]);
+    assertActive();
     const canonical = confirmedProgress ?? head;
     if (token.toLowerCase() !== planned.predictedToken.toLowerCase())
         throw new LifecyclePlanningError("TOKEN_IDENTITY", "Predicted token changed for the committed token configuration");
@@ -493,6 +648,7 @@ async function readLaunchProgressAtBlock(options, client, block, checkBlock) {
     const progressParameters = [{ type: "tuple", components: launchProgressV1Components }];
     const confirmationSafe = confirmedAccountNonce === headAccountNonce && pendingAccountNonce === headAccountNonce && keccak256(encodeAbiParameters(progressParameters, [canonical])) === keccak256(encodeAbiParameters(progressParameters, [head]));
     const receipts = await Promise.all((options.receipts ?? []).map((reference) => readReceipt({ ...reference, confirmations: Math.max(reference.confirmations ?? 1, confirmationDepth) }, { ...options, client }, block)));
+    assertActive();
     let markets = [];
     if (canonical.preparedMarkets > 0) {
         const directory = await readLifecycleContract(client, planned.plan.orchestrator, launchLifecycleAbi, "directory", [], confirmedBlock);
@@ -504,7 +660,9 @@ async function readLaunchProgressAtBlock(options, client, block, checkBlock) {
                 return { index, prepared, live };
             }
             catch (failure) {
-                return { index, prepared, error: failure instanceof Error ? failure.message : String(failure) };
+                if (failure instanceof Error && failure.name === "AbortError")
+                    throw failure;
+                return { index, prepared, error: lifecycleFailureReason(failure) };
             }
         }));
     }
@@ -514,6 +672,7 @@ async function readLaunchProgressAtBlock(options, client, block, checkBlock) {
         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");
+    assertActive();
     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