@black-market/sdk 0.5.2 → 0.6.1

package/README.md

@@ -40,6 +40,14 @@ Launch examples spend real funds and publish to your configured API.
 Plans, transaction hashes, receipts, and errors are saved in `launch-results/`.
 Keep `.env` and private recovery files out of Git.
 
+Lifecycle planning proves exact stateful execution without requiring a policy service.
+Robinhood admission reads native Nitro compute/poster evidence; optional caller caps
+only tighten it. Build-next can separately preflight the immediate unsigned envelope
+with an active `submissionClient`. Execution proof is not guaranteed wallet submission.
+
 [Example setup](https://github.com/abysshopper/black-market-node-sdk/tree/main/examples)
 · [API guide](https://github.com/abysshopper/black-market-node-sdk/blob/main/docs/launch-lifecycle.md)
 · [MIT license](https://github.com/abysshopper/black-market-node-sdk/blob/main/LICENSE)
+
+[Agent guide](https://github.com/abysshopper/black-market-node-sdk/blob/main/AGENTS.md)
+· [Skills](https://github.com/abysshopper/black-market-node-sdk/tree/main/.agents/skills)

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

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

package/dist/lifecycle/planner.js

@@ -3,7 +3,7 @@ import { launchLifecycleAbi, lifecycleAdapterAbi, lifecycleErc20Abi, lifecycleFu
 import { hashLaunchIdentity, hashLaunchPlan, LifecycleFundingKind, LifecycleMode, LifecyclePhase, LifecycleRewardMode, LifecycleTokenKind, LifecycleVenue, LIFECYCLE_ERC404_CAPABILITY, LIFECYCLE_MAX_REWARD_ERC20_SUPPLY, LIFECYCLE_MAX_ERC404_SUPPLY, LIFECYCLE_MULTI_POSITION_CAPABILITY, LIFECYCLE_REQUIRED_CAPABILITIES, marketIdentityV1Components, parseLaunchPlan, serializeLaunchPlan } from "./schema.js";
 import { ABYSS_LIFECYCLE_CONFIG_SCHEMA, readLaunchProgress, readLifecycleProfiles, readPoolBoundHookDeployment, validateLifecycleMarketIdentity, validateV4LifecycleOracle } from "./progress.js";
 import { decodeAbyssLifecycleMarketConfig, decodePoolBoundV4LifecycleMarketConfig, decodeV4LifecycleMarketConfig, encodePoolBoundV4LifecycleMarketConfig, hasLifecycleV4HookPermissions, minePoolBoundHookSalt, predictPoolBoundHookAddress, validateV4LifecycleMarket, V4_LIFECYCLE_CONFIG_SCHEMA, V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA } from "./markets.js";
-import { assertLifecycleBlock, lifecycleRpc, readLifecycleBlock, readLifecycleContract, resolveLifecycleLimits, rpcHex, rpcQuantity } from "./rpc.js";
+import { assertLifecycleBlock, lifecyclePinnedRpc, lifecycleRpc, readLifecycleBlock, readLifecycleContract, resolveLifecycleLimits, rpcHex, rpcQuantity, withLifecycleReadClient } from "./rpc.js";
 import { simulateLaunchTransactions } from "./simulation.js";
 import { LifecyclePlanningError } from "./types.js";
 function validatePlanShape(plan) {
@@ -74,47 +74,59 @@ function validatePlanShape(plan) {
     }
 }
 async function readFunding(client, plan, block) {
-    const escrow = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "fundingEscrow", [], block);
-    if ((await readLifecycleContract(client, escrow, lifecycleFundingEscrowAbi, "core", [], block)).toLowerCase() !== plan.orchestrator.toLowerCase())
+    const [escrow, registry, balanceValue] = await Promise.all([
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "fundingEscrow", [], block),
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block),
+        lifecyclePinnedRpc(client, "eth_getBalance", [plan.creator, toHex(block.number)], block),
+    ]);
+    const nativeBalance = rpcQuantity(balanceValue, "creator native balance");
+    const [authority, observations] = await Promise.all([
+        readLifecycleContract(client, escrow, lifecycleFundingEscrowAbi, "core", [], block),
+        Promise.all(plan.funding.map(async (funding) => {
+            const native = funding.kind === LifecycleFundingKind.NativeWrap || (funding.kind === LifecycleFundingKind.Swap && funding.inputAsset === zeroAddress);
+            const [input, wrapped, target] = await Promise.all([
+                native ? [nativeBalance, undefined] : Promise.all([
+                    readLifecycleContract(client, funding.inputAsset, lifecycleErc20Abi, "balanceOf", [plan.creator], block),
+                    readLifecycleContract(client, funding.inputAsset, lifecycleErc20Abi, "allowance", [plan.creator, escrow], block),
+                ]),
+                funding.kind === LifecycleFundingKind.NativeWrap ? readLifecycleContract(client, escrow, lifecycleFundingEscrowAbi, "wrappedNative", [], block) : undefined,
+                funding.kind === LifecycleFundingKind.Swap ? Promise.all([
+                    readLifecycleContract(client, registry, lifecycleRegistryAbi, "fundingTarget", [funding.target], block),
+                    lifecyclePinnedRpc(client, "eth_getCode", [funding.target, toHex(block.number)], block),
+                ]) : undefined,
+            ]);
+            let reason;
+            if (wrapped !== undefined && (wrapped === zeroAddress || wrapped.toLowerCase() !== funding.asset.toLowerCase()))
+                reason = "Committed native-wrap output is not the escrow's supported wrapped native asset";
+            if (target !== undefined) {
+                const [[spender, codeHash, enabled], codeValue] = target;
+                const code = rpcHex(codeValue, "funding target code");
+                if (!enabled || spender === zeroAddress || code === "0x" || keccak256(code).toLowerCase() !== codeHash.toLowerCase())
+                    reason = "Committed funding conversion target is not currently allowlisted with its immutable code hash";
+            }
+            const prerequisite = { funding, inputBalance: input[0], requiredInput: funding.inputAmount, allowance: input[1], spender: escrow, nativeValue: native ? funding.inputAmount : 0n, conversion: funding.kind === LifecycleFundingKind.NativeWrap ? "native-wrap" : funding.kind === LifecycleFundingKind.Swap ? "allowlisted-swap" : "none" };
+            return { prerequisite, reason };
+        })),
+    ]);
+    if (authority.toLowerCase() !== plan.orchestrator.toLowerCase())
         throw new LifecyclePlanningError("FUNDING_BINDING", "Funding escrow authority differs from the committed orchestrator");
-    const registry = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block);
-    const nativeBalance = rpcQuantity(await lifecycleRpc(client, "eth_getBalance", [plan.creator, toHex(block.number)]), "creator native balance");
     const totals = new Map();
     const prerequisites = [];
     const approvals = [];
     const reasons = [];
     let nativeValue = 0n;
-    for (const funding of plan.funding) {
-        const native = funding.kind === LifecycleFundingKind.NativeWrap || (funding.kind === LifecycleFundingKind.Swap && funding.inputAsset === zeroAddress);
-        let inputBalance = nativeBalance;
-        let allowance;
-        if (native)
-            nativeValue += funding.inputAmount;
-        else {
+    for (const { prerequisite, reason } of observations) {
+        prerequisites.push(prerequisite);
+        if (reason !== undefined)
+            reasons.push(reason);
+        nativeValue += prerequisite.nativeValue;
+        if (prerequisite.allowance !== undefined) {
+            const { funding } = prerequisite;
             const key = funding.inputAsset.toLowerCase();
-            let total = totals.get(key);
-            if (total === undefined) {
-                inputBalance = await readLifecycleContract(client, funding.inputAsset, lifecycleErc20Abi, "balanceOf", [plan.creator], block);
-                allowance = await readLifecycleContract(client, funding.inputAsset, lifecycleErc20Abi, "allowance", [plan.creator, escrow], block);
-                total = { asset: funding.inputAsset, amount: 0n, balance: inputBalance, allowance };
-                totals.set(key, total);
-            }
+            const total = totals.get(key) ?? { asset: funding.inputAsset, amount: 0n, balance: prerequisite.inputBalance, allowance: prerequisite.allowance };
             total.amount += funding.inputAmount;
-            inputBalance = total.balance;
-            allowance = total.allowance;
+            totals.set(key, total);
         }
-        if (funding.kind === LifecycleFundingKind.NativeWrap) {
-            const wrapped = await readLifecycleContract(client, escrow, lifecycleFundingEscrowAbi, "wrappedNative", [], block);
-            if (wrapped === zeroAddress || wrapped.toLowerCase() !== funding.asset.toLowerCase())
-                reasons.push("Committed native-wrap output is not the escrow's supported wrapped native asset");
-        }
-        if (funding.kind === LifecycleFundingKind.Swap) {
-            const [spender, codeHash, enabled] = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "fundingTarget", [funding.target], block);
-            const code = rpcHex(await lifecycleRpc(client, "eth_getCode", [funding.target, toHex(block.number)]), "funding target code");
-            if (!enabled || spender === zeroAddress || code === "0x" || keccak256(code).toLowerCase() !== codeHash.toLowerCase())
-                reasons.push("Committed funding conversion target is not currently allowlisted with its immutable code hash");
-        }
-        prerequisites.push({ funding, inputBalance, requiredInput: funding.inputAmount, allowance, spender: escrow, nativeValue: native ? funding.inputAmount : 0n, conversion: funding.kind === LifecycleFundingKind.NativeWrap ? "native-wrap" : funding.kind === LifecycleFundingKind.Swap ? "allowlisted-swap" : "none" });
     }
     if (nativeBalance < nativeValue)
         reasons.push("Creator native balance does not cover committed native funding inputs");
@@ -131,17 +143,6 @@ async function readFunding(client, plan, block) {
 }
 async function validatePendingInputs(client, planned, progress, block) {
     const { plan } = planned;
-    const profiles = await readLifecycleProfiles({ client, orchestrator: plan.orchestrator, profileIds: [...new Set(plan.markets.map((market) => market.profileId))] }, block);
-    const registry = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block);
-    const reasons = profiles.filter((profile) => !profile.admitted).map((profile) => profile.reason ?? "Implementation/profile is unavailable");
-    if (block.timestamp > plan.deadline)
-        reasons.push("The immutable launch deadline has expired; cancellation remains available");
-    for (const policy of plan.feeAssets)
-        if (policy.burnBps !== 0 && policy.asset.toLowerCase() !== planned.predictedToken.toLowerCase())
-            reasons.push("Only the launch token may have a burn fee share");
-    if (!plan.feeAssets.some((policy) => policy.asset.toLowerCase() === planned.predictedToken.toLowerCase()))
-        reasons.push("The launch token must have a committed fee policy");
-    const hookDeployments = [];
     const assets = new Set();
     for (const policy of plan.feeAssets)
         if (policy.asset.toLowerCase() !== planned.predictedToken.toLowerCase())
@@ -153,90 +154,131 @@ async function validatePendingInputs(client, planned, progress, block) {
         if (funding.kind !== LifecycleFundingKind.NativeWrap && funding.inputAsset !== zeroAddress)
             assets.add(funding.inputAsset);
     }
-    for (const asset of assets)
-        if (rpcHex(await lifecycleRpc(client, "eth_getCode", [asset, toHex(block.number)]), "asset code") === "0x")
+    const [profiles, registry, assetCodes] = await Promise.all([
+        readLifecycleProfiles({ client, orchestrator: plan.orchestrator, profileIds: [...new Set(plan.markets.map((market) => market.profileId))] }, block),
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "registry", [], block),
+        Promise.all([...assets].map(async (asset) => ({ asset, code: rpcHex(await lifecyclePinnedRpc(client, "eth_getCode", [asset, toHex(block.number)], block), "asset code") }))),
+    ]);
+    const reasons = profiles.filter((profile) => !profile.admitted).map((profile) => profile.reason ?? "Implementation/profile is unavailable");
+    if (block.timestamp > plan.deadline)
+        reasons.push("The immutable launch deadline has expired; cancellation remains available");
+    for (const policy of plan.feeAssets)
+        if (policy.burnBps !== 0 && policy.asset.toLowerCase() !== planned.predictedToken.toLowerCase())
+            reasons.push("Only the launch token may have a burn fee share");
+    if (!plan.feeAssets.some((policy) => policy.asset.toLowerCase() === planned.predictedToken.toLowerCase()))
+        reasons.push("The launch token must have a committed fee policy");
+    for (const { asset, code } of assetCodes)
+        if (code === "0x")
             reasons.push(`Asset ${asset} has no contract code`);
-    for (const funding of plan.funding) {
+    const required = LIFECYCLE_REQUIRED_CAPABILITIES | (plan.token.kind === LifecycleTokenKind.ERC404 ? LIFECYCLE_ERC404_CAPABILITY : 0n);
+    const [allowedInputs, markets, escrowBalances] = await Promise.all([
+        Promise.all(plan.funding.map((funding) => funding.kind === LifecycleFundingKind.Swap && funding.inputAsset !== zeroAddress
+            ? readLifecycleContract(client, registry, lifecycleRegistryAbi, "fundingInputAllowed", [funding.inputAsset], block) : true)),
+        Promise.all(plan.markets.map(async (market, index) => {
+            const profile = profiles.find((item) => item.id.toLowerCase() === market.profileId.toLowerCase());
+            let positions = 0;
+            let deployment;
+            let identity;
+            let reason;
+            if (profile === undefined || !profile.admitted)
+                return { positions, deployment, identity, reason };
+            try {
+                if (market.adapterId.toLowerCase() !== profile.registration.adapterId.toLowerCase() || market.configVersion !== profile.topology.configVersion)
+                    throw new LifecyclePlanningError("INVALID_MARKET", "Market adapter or version differs from exact certified profile");
+                if (market.quoteAsset.toLowerCase() === planned.predictedToken.toLowerCase() || !plan.feeAssets.some((policy) => policy.asset.toLowerCase() === market.quoteAsset.toLowerCase()))
+                    throw new LifecyclePlanningError("INVALID_MARKET", "Each distinct quote requires its committed fee policy");
+                const schema = profile.registration.configSchema.toLowerCase();
+                const config = schema === V4_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodeV4LifecycleMarketConfig(market.config) : schema === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodePoolBoundV4LifecycleMarketConfig(market.config) : schema === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodeAbyssLifecycleMarketConfig(market.config) : undefined;
+                if (config === undefined)
+                    throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${profile.registration.configSchema}`);
+                if ("developerFeeBps" in config) {
+                    validateV4LifecycleMarket({ market, config, profile, token: planned.predictedToken });
+                    if (config.version === 4)
+                        await validateV4LifecycleOracle({ client, envelope: profile.envelope, oracleConfigId: config.oracleConfigId, block });
+                }
+                if (config.positions.length === 0 || config.positions.length > 32)
+                    throw new LifecyclePlanningError("INVALID_POSITION_COUNT", "A launch commits at most 32 positive positions across every market/venue");
+                positions = config.positions.length;
+                const rewards = progress.canonical.rewards === zeroAddress && plan.token.rewardMode === LifecycleRewardMode.Dividends ? planned.predictedToken : progress.canonical.rewards;
+                if ("treasury" in config && rewards !== zeroAddress && config.treasury.toLowerCase() === rewards.toLowerCase() && config.hookFeePips !== 0 && config.protocolFeeDenominator !== 0)
+                    throw new LifecyclePlanningError("INVALID_FEE_POLICY", "Hook protocol treasury cannot be the launch rewards contract");
+                const capabilities = required | (positions > 1 ? LIFECYCLE_MULTI_POSITION_CAPABILITY : 0n);
+                const [adapter, boundDeployment] = await Promise.all([
+                    readLifecycleContract(client, registry, lifecycleRegistryAbi, "requireEligible", [market.adapterId, market.profileId, market.configVersion, capabilities], block),
+                    profile.topology.hookTopology === 2 ? readPoolBoundHookDeployment({ client, plan, marketIndex: index }, block) : undefined,
+                ]);
+                if (adapter.toLowerCase() !== profile.adapter.implementation.toLowerCase())
+                    throw new LifecyclePlanningError("MARKET_IDENTITY", "Eligible adapter differs from the certified profile implementation");
+                if (boundDeployment !== undefined) {
+                    if (!hasLifecycleV4HookPermissions(boundDeployment.predictedHook))
+                        throw new LifecyclePlanningError("INVALID_HOOK_BITS", "Finalize the pool-bound salt with the exact lifecycle hook permission bits before planning wallet execution");
+                    deployment = { marketIndex: index, ...boundDeployment };
+                }
+                identity = await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "resolve", [planned.launchId, planned.predictedToken, market], block);
+                validateLifecycleMarketIdentity(identity, plan, planned.predictedToken, index);
+                const expectedHook = deployment?.predictedHook ?? profile.registration.hook;
+                if (identity.factory.toLowerCase() !== profile.registration.factory.toLowerCase() || identity.hook.toLowerCase() !== expectedHook.toLowerCase() || (identity.venue === LifecycleVenue.UniswapV4 && (identity.manager.toLowerCase() !== profile.registration.venue.toLowerCase() || profile.topology.hookTopology === 0)) || (identity.venue === LifecycleVenue.Abyss && (identity.factory.toLowerCase() !== profile.registration.venue.toLowerCase() || profile.topology.hookTopology !== 0)))
+                    throw new LifecyclePlanningError("MARKET_IDENTITY", "Canonical venue dependencies differ from exact immutable profile/topology approval");
+                const prepared = progress.markets.find((item) => item.index === index);
+                if (prepared !== undefined) {
+                    const resolvedHash = keccak256(encodeAbiParameters([{ type: "tuple", components: marketIdentityV1Components }], [identity]));
+                    const preparedHash = keccak256(encodeAbiParameters([{ type: "tuple", components: marketIdentityV1Components }], [prepared.prepared.identity]));
+                    if (resolvedHash !== preparedHash || prepared.live === undefined || prepared.live.publicTrading || prepared.live.liquidity !== 0n || prepared.live.sqrtPriceX96 !== identity.openingSqrtPriceX96)
+                        throw new LifecyclePlanningError("OPENING_CHANGED", "Prepared market is not at its committed empty canonical opening state");
+                    await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "validatePrepared", [planned.launchId, index, planned.predictedToken, market, prepared.prepared.identity], block);
+                }
+            }
+            catch (failure) {
+                reason = failure instanceof Error ? failure.message : String(failure);
+            }
+            return { positions, deployment, identity, reason };
+        })),
+        progress.canonical.phase === LifecyclePhase.None ? [] : Promise.all(plan.funding.map((funding) => readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "escrowBalance", [planned.launchId, funding.asset], block))),
+    ]);
+    for (const [index, funding] of plan.funding.entries()) {
         if (funding.asset.toLowerCase() === planned.predictedToken.toLowerCase() || (funding.kind === LifecycleFundingKind.Swap && funding.inputAsset.toLowerCase() === planned.predictedToken.toLowerCase()))
             reasons.push("Launch-token inventory cannot be an external funding output or conversion input");
-        if (funding.kind === LifecycleFundingKind.Swap && funding.inputAsset !== zeroAddress && !await readLifecycleContract(client, registry, lifecycleRegistryAbi, "fundingInputAllowed", [funding.inputAsset], block))
+        if (!allowedInputs[index])
             reasons.push(`Conversion input ${funding.inputAsset} is not currently admitted`);
     }
-    const required = LIFECYCLE_REQUIRED_CAPABILITIES | (plan.token.kind === LifecycleTokenKind.ERC404 ? LIFECYCLE_ERC404_CAPABILITY : 0n);
+    const hookDeployments = [];
     const identities = new Set();
     const v4Quotes = new Set();
     let positionCount = 0;
-    for (let index = 0; index < plan.markets.length; index += 1) {
-        const market = plan.markets[index];
-        if (market === undefined)
-            throw new LifecyclePlanningError("INVALID_PLAN", "Market missing from ordered plan");
-        const profile = profiles.find((item) => item.id.toLowerCase() === market.profileId.toLowerCase());
-        if (profile === undefined || !profile.admitted)
+    for (const [index, result] of markets.entries()) {
+        if (positionCount + result.positions > 32) {
+            reasons.push("A launch commits at most 32 positive positions across every market/venue");
             continue;
-        try {
-            if (market.adapterId.toLowerCase() !== profile.registration.adapterId.toLowerCase() || market.configVersion !== profile.topology.configVersion)
-                throw new LifecyclePlanningError("INVALID_MARKET", "Market adapter or version differs from exact certified profile");
-            if (market.quoteAsset.toLowerCase() === planned.predictedToken.toLowerCase() || !plan.feeAssets.some((policy) => policy.asset.toLowerCase() === market.quoteAsset.toLowerCase()))
-                throw new LifecyclePlanningError("INVALID_MARKET", "Each distinct quote requires its committed fee policy");
-            const schema = profile.registration.configSchema.toLowerCase();
-            const config = schema === V4_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodeV4LifecycleMarketConfig(market.config) : schema === V4_POOL_BOUND_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodePoolBoundV4LifecycleMarketConfig(market.config) : schema === ABYSS_LIFECYCLE_CONFIG_SCHEMA.toLowerCase() ? decodeAbyssLifecycleMarketConfig(market.config) : undefined;
-            if (config === undefined)
-                throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${profile.registration.configSchema}`);
-            if ("developerFeeBps" in config) {
-                validateV4LifecycleMarket({ market, config, profile, token: planned.predictedToken });
-                if (config.version === 4)
-                    await validateV4LifecycleOracle({ client, envelope: profile.envelope, oracleConfigId: config.oracleConfigId, block });
-            }
-            if (config.positions.length === 0 || config.positions.length > 32 || positionCount + config.positions.length > 32)
-                throw new LifecyclePlanningError("INVALID_POSITION_COUNT", "A launch commits at most 32 positive positions across every market/venue");
-            positionCount += config.positions.length;
-            const rewards = progress.canonical.rewards === zeroAddress && plan.token.rewardMode === LifecycleRewardMode.Dividends ? planned.predictedToken : progress.canonical.rewards;
-            if ("treasury" in config && rewards !== zeroAddress && config.treasury.toLowerCase() === rewards.toLowerCase() && config.hookFeePips !== 0 && config.protocolFeeDenominator !== 0)
-                throw new LifecyclePlanningError("INVALID_FEE_POLICY", "Hook protocol treasury cannot be the launch rewards contract");
-            const capabilities = required | (config.positions.length > 1 ? LIFECYCLE_MULTI_POSITION_CAPABILITY : 0n);
-            const adapter = await readLifecycleContract(client, registry, lifecycleRegistryAbi, "requireEligible", [market.adapterId, market.profileId, market.configVersion, capabilities], block);
-            if (adapter.toLowerCase() !== profile.adapter.implementation.toLowerCase())
-                throw new LifecyclePlanningError("MARKET_IDENTITY", "Eligible adapter differs from the certified profile implementation");
-            const deployment = profile.topology.hookTopology === 2 ? await readPoolBoundHookDeployment({ client, plan, marketIndex: index }, block) : undefined;
-            if (deployment !== undefined) {
-                if (!hasLifecycleV4HookPermissions(deployment.predictedHook))
-                    throw new LifecyclePlanningError("INVALID_HOOK_BITS", "Finalize the pool-bound salt with the exact lifecycle hook permission bits before planning wallet execution");
-                hookDeployments.push({ marketIndex: index, ...deployment });
-            }
-            const identity = await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "resolve", [planned.launchId, planned.predictedToken, market], block);
-            validateLifecycleMarketIdentity(identity, plan, planned.predictedToken, index);
-            const expectedHook = deployment?.predictedHook ?? profile.registration.hook;
-            if (identity.factory.toLowerCase() !== profile.registration.factory.toLowerCase() || identity.hook.toLowerCase() !== expectedHook.toLowerCase() || (identity.venue === LifecycleVenue.UniswapV4 && (identity.manager.toLowerCase() !== profile.registration.venue.toLowerCase() || profile.topology.hookTopology === 0)) || (identity.venue === LifecycleVenue.Abyss && (identity.factory.toLowerCase() !== profile.registration.venue.toLowerCase() || profile.topology.hookTopology !== 0)))
-                throw new LifecyclePlanningError("MARKET_IDENTITY", "Canonical venue dependencies differ from exact immutable profile/topology approval");
-            if (identity.venue === LifecycleVenue.UniswapV4) {
-                const quote = market.quoteAsset.toLowerCase();
-                if (v4Quotes.has(quote))
-                    throw new LifecyclePlanningError("DUPLICATE_V4_QUOTE", "Only one V4 market per quote asset is allowed, regardless of adapter, manager, profile or salt");
-                v4Quotes.add(quote);
-            }
-            if (identities.has(identity.canonicalId.toLowerCase()))
-                throw new LifecyclePlanningError("DUPLICATE_MARKET", "Two committed markets resolve to the same canonical pool");
-            identities.add(identity.canonicalId.toLowerCase());
-            const prepared = progress.markets.find((item) => item.index === index);
-            if (prepared !== undefined) {
-                const resolvedHash = keccak256(encodeAbiParameters([{ type: "tuple", components: marketIdentityV1Components }], [identity]));
-                const preparedHash = keccak256(encodeAbiParameters([{ type: "tuple", components: marketIdentityV1Components }], [prepared.prepared.identity]));
-                if (resolvedHash !== preparedHash || prepared.live === undefined || prepared.live.publicTrading || prepared.live.liquidity !== 0n || prepared.live.sqrtPriceX96 !== identity.openingSqrtPriceX96)
-                    throw new LifecyclePlanningError("OPENING_CHANGED", "Prepared market is not at its committed empty canonical opening state");
-                await readLifecycleContract(client, adapter, lifecycleAdapterAbi, "validatePrepared", [planned.launchId, index, planned.predictedToken, market, prepared.prepared.identity], block);
+        }
+        positionCount += result.positions;
+        if (result.deployment !== undefined)
+            hookDeployments.push(result.deployment);
+        if (result.reason !== undefined) {
+            reasons.push(result.reason);
+            continue;
+        }
+        if (result.identity === undefined)
+            continue;
+        if (result.identity.venue === LifecycleVenue.UniswapV4) {
+            const quote = plan.markets[index].quoteAsset.toLowerCase();
+            if (v4Quotes.has(quote)) {
+                reasons.push("Only one V4 market per quote asset is allowed, regardless of adapter, manager, profile or salt");
+                continue;
             }
+            v4Quotes.add(quote);
         }
-        catch (failure) {
-            reasons.push(failure instanceof Error ? failure.message : String(failure));
+        const identity = result.identity.canonicalId.toLowerCase();
+        if (identities.has(identity)) {
+            reasons.push("Two committed markets resolve to the same canonical pool");
+            continue;
         }
+        identities.add(identity);
     }
-    if (progress.canonical.phase !== LifecyclePhase.None) {
-        for (const funding of plan.funding) {
-            const balance = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "escrowBalance", [planned.launchId, funding.asset], block);
-            const needed = plan.buys.filter((buy) => plan.markets[buy.marketIndex]?.quoteAsset.toLowerCase() === funding.asset.toLowerCase()).reduce((sum, buy) => sum + buy.quoteAmountIn, 0n);
-            if (balance < needed)
-                reasons.push(`Launch-isolated ${funding.asset} escrow cannot cover every committed buy`);
-        }
+    for (const [index, balance] of escrowBalances.entries()) {
+        const funding = plan.funding[index];
+        const needed = plan.buys.filter((buy) => plan.markets[buy.marketIndex]?.quoteAsset.toLowerCase() === funding.asset.toLowerCase()).reduce((sum, buy) => sum + buy.quoteAmountIn, 0n);
+        if (balance < needed)
+            reasons.push(`Launch-isolated ${funding.asset} escrow cannot cover every committed buy`);
     }
     return { profiles, hookDeployments, reasons };
 }
@@ -267,13 +309,17 @@ function orderedTransactions(plan, mode, progress, approvals, nativeValue, batch
 function attachEstimates(transactions, simulation) {
     return transactions.map((transaction) => {
         const estimate = simulation.steps.find((step) => step.transactionId === transaction.id)?.estimate;
-        return { ...transaction, gas: estimate?.gasLimit, gasPrice: estimate?.gasPrice, estimate, admission: { admitted: simulation.admitted, confidence: simulation.confidence, reason: simulation.reason, limits: simulation.limits } };
+        return { ...transaction, gas: estimate?.gasLimit, gasPrice: estimate?.gasPrice, estimate, admission: { admitted: simulation.admitted, confidence: simulation.confidence, executionProof: simulation.executionProof, protocolFit: simulation.protocolFit, transportPreflight: simulation.transportPreflight, blockNumber: simulation.blockNumber, blockHash: simulation.blockHash, account: simulation.account, chainId: simulation.chainId, reason: simulation.reason, limits: simulation.limits } };
     });
 }
 async function readTokenFactoryBinding(client, orchestrator, block) {
     const tokenFactory = await readLifecycleContract(client, orchestrator, launchLifecycleAbi, "tokenFactory", [], block);
-    const code = rpcHex(await lifecycleRpc(client, "eth_getCode", [tokenFactory, toHex(block.number)]), "token factory code");
-    if (tokenFactory === zeroAddress || code === "0x" || (await readLifecycleContract(client, tokenFactory, lifecycleAdapterAbi, "core", [], block)).toLowerCase() !== orchestrator.toLowerCase())
+    const [codeValue, authority] = await Promise.all([
+        lifecyclePinnedRpc(client, "eth_getCode", [tokenFactory, toHex(block.number)], block),
+        readLifecycleContract(client, tokenFactory, lifecycleAdapterAbi, "core", [], block),
+    ]);
+    const code = rpcHex(codeValue, "token factory code");
+    if (tokenFactory === zeroAddress || code === "0x" || authority.toLowerCase() !== orchestrator.toLowerCase())
         throw new LifecyclePlanningError("TOKEN_FACTORY_BINDING", "Token factory is not live and bound to the exact lifecycle core");
     return { tokenFactory, tokenFactoryCodeHash: keccak256(code) };
 }
@@ -357,7 +403,15 @@ export async function preparePoolBoundLifecyclePlan(options) {
 }
 /** Exact economic commitment with explicit execution mode and current-state admission. No broadcasts. */
 export async function planLaunch(options) {
-    const { client, plan, account, mode } = options;
+    return withLifecycleReadClient(options.client, async (client) => {
+        const planned = await planLaunchWithReads(options, client);
+        if (hashLaunchPlan(planned.plan).toLowerCase() !== planned.planHash.toLowerCase() || hashLaunchIdentity(planned.plan).toLowerCase() !== planned.launchId.toLowerCase())
+            throw new LifecyclePlanningError("PLAN_MUTATED", "Economic plan changed during asynchronous planning; previous reads and simulation are invalid");
+        return planned;
+    });
+}
+async function planLaunchWithReads(options, client) {
+    const { plan, account, mode } = options;
     if (mode !== "atomic" && mode !== "staged")
         throw new LifecyclePlanningError("EXPLICIT_MODE_REQUIRED", "Choose atomic or staged explicitly; staged is never silently substituted");
     if (account.toLowerCase() !== plan.creator.toLowerCase())
@@ -365,19 +419,24 @@ export async function planLaunch(options) {
     if (plan.chainId > BigInt(Number.MAX_SAFE_INTEGER) || plan.chainId <= 0n)
         throw new LifecyclePlanningError("CHAIN_MISMATCH", "Chain ID must be a positive exact JavaScript integer");
     validatePlanShape(plan);
-    const block = await readLifecycleBlock(client);
-    if (rpcQuantity(await lifecycleRpc(client, "eth_chainId"), "chain ID") !== plan.chainId)
-        throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed plan");
     const planHash = hashLaunchPlan(plan);
     const launchId = hashLaunchIdentity(plan);
-    const remoteHash = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "hashPlan", [plan], block);
-    const remoteIdentity = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "launchIdOf", [plan], block);
+    const [block, chainIdValue] = await Promise.all([
+        readLifecycleBlock(client),
+        lifecycleRpc(client, "eth_chainId"),
+    ]);
+    if (rpcQuantity(chainIdValue, "chain ID") !== plan.chainId)
+        throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain differs from the committed plan");
+    const [remoteHash, remoteIdentity, predictedToken, { tokenFactory, tokenFactoryCodeHash }, { limits }] = await Promise.all([
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "hashPlan", [plan], block),
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "launchIdOf", [plan], block),
+        readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "predictToken", [plan], block),
+        readTokenFactoryBinding(client, plan.orchestrator, block),
+        resolveLifecycleLimits({ client, account, orchestrator: plan.orchestrator, block, chainId: plan.chainId }, options.limits),
+    ]);
     if (remoteHash.toLowerCase() !== planHash.toLowerCase() || remoteIdentity.toLowerCase() !== launchId.toLowerCase())
         throw new LifecyclePlanningError("ABI_DOMAIN_MISMATCH", "Selected contract does not implement the exact lifecycle V1 plan domain/schema");
-    const predictedToken = await readLifecycleContract(client, plan.orchestrator, launchLifecycleAbi, "predictToken", [plan], block);
-    const { tokenFactory, tokenFactoryCodeHash } = await readTokenFactoryBinding(client, plan.orchestrator, block);
-    const { limits } = await resolveLifecycleLimits({ client, account, orchestrator: plan.orchestrator, block, chainId: plan.chainId }, options.limits);
-    const placeholder = { backend: "unavailable", confidence: "provisional", admitted: false, blockNumber: block.number, blockHash: block.hash, account, chainId: plan.chainId, limits, steps: [] };
+    const placeholder = { backend: "unavailable", confidence: "provisional", admitted: false, executionProof: "unavailable", protocolFit: "unknown", transportPreflight: "not-requested", blockNumber: block.number, blockHash: block.hash, account, chainId: plan.chainId, limits, steps: [] };
     const identity = { plan, planHash, launchId, predictedToken, account, mode, confirmations: options.confirmations ?? 1 };
     const progress = await readLaunchProgress({ client, planned: identity, receipts: options.receipts }, block);
     let planned = { ...identity, tokenFactory, tokenFactoryCodeHash, chainId: plan.chainId, transactions: [], prerequisites: [], profiles: [], hookDeployments: [], progress, simulation: placeholder, atomicAttempt: placeholder, preparationBatchSize: plan.markets.length, limits: options.limits };
@@ -390,20 +449,22 @@ export async function planLaunch(options) {
         }
         // Receipt/nonce gates never silently drop the finalized deployment baseline on reload.
         const waiting = { ...placeholder, confidence: "stateful", reason: !progress.confirmationSafe ? "Canonical confirmed progress/account nonce has not caught up with head or pending transactions; wait for the selected confirmation depth" : "Wait for canonical receipt confirmations or resolve replacement before requesting another transaction" };
-        await assertLifecycleBlock(client, block);
+        await assertLifecycleBlock(client, block, plan.chainId);
         return { ...planned, hookDeployments, simulation: waiting, atomicAttempt: waiting };
     }
     if (progress.canonical.phase === LifecyclePhase.Active || progress.canonical.phase === LifecyclePhase.Cancelled) {
-        await assertLifecycleBlock(client, block);
-        return { ...planned, simulation: { ...placeholder, confidence: "stateful", admitted: true, reason: "Canonical launch is terminal; no transaction remains" } };
+        await assertLifecycleBlock(client, block, plan.chainId);
+        return { ...planned, simulation: { ...placeholder, confidence: "stateful", executionProof: "proved", protocolFit: "proved", admitted: true, reason: "Canonical launch is terminal; no transaction remains" } };
     }
-    const prerequisites = progress.canonical.phase === LifecyclePhase.None ? await readFunding(client, plan, block) : { prerequisites: [], approvals: [], nativeValue: 0n, reasons: [] };
-    const validation = await validatePendingInputs(client, planned, progress, block);
+    const [prerequisites, validation] = await Promise.all([
+        progress.canonical.phase === LifecyclePhase.None ? readFunding(client, plan, block) : { prerequisites: [], approvals: [], nativeValue: 0n, reasons: [] },
+        validatePendingInputs(client, planned, progress, block),
+    ]);
     const reasons = [...prerequisites.reasons, ...validation.reasons];
     planned = { ...planned, prerequisites: prerequisites.prerequisites, profiles: validation.profiles, hookDeployments: validation.hookDeployments };
     if (reasons.length > 0) {
         const rejected = { ...placeholder, confidence: "stateful", reason: reasons.join("; ") };
-        await assertLifecycleBlock(client, block);
+        await assertLifecycleBlock(client, block, plan.chainId);
         return { ...planned, simulation: rejected, atomicAttempt: rejected, transactions: orderedTransactions(plan, mode, progress, prerequisites.approvals, prerequisites.nativeValue, planned.preparationBatchSize) };
     }
     let atomicAttempt = { ...placeholder, reason: "Atomic execution cannot be evaluated from an already begun staged launch" };
@@ -428,6 +489,40 @@ export async function planLaunch(options) {
         simulation = { ...simulation, reason: `${simulation.reason ?? "Final activation failed"}; final mint/lock/all-buys/public-opening is indivisible and will not be partitioned` };
     return { ...planned, atomicAttempt, simulation, preparationBatchSize, transactions: attachEstimates(transactions, simulation) };
 }
+async function preflightNextTransaction(options, next, simulation) {
+    if (next.gas === undefined || next.gas <= 0n || next.gas >= 1n << 64n || next.gasPrice === undefined || next.gasPrice < 0n ||
+        simulation.executionProof !== "proved" || simulation.protocolFit !== "proved" || !simulation.admitted ||
+        next.estimate === undefined || next.estimate.gasLimit !== next.gas || next.estimate.gasPrice !== next.gasPrice ||
+        simulation.limits.transactionGasCeiling !== undefined && next.gas > simulation.limits.transactionGasCeiling) {
+        throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Next transaction has no current-state exact gas/headroom/fee-envelope proof", simulation);
+    }
+    const submissionClient = options.submissionClient;
+    if (submissionClient === undefined)
+        return { ...next, dependencies: [] };
+    try {
+        if (rpcQuantity(await lifecycleRpc(submissionClient, "eth_chainId"), "submission chain ID") !== simulation.chainId)
+            throw new Error("Active submission RPC chain differs from the reviewed transaction");
+        const estimated = rpcQuantity(await lifecycleRpc(submissionClient, "eth_estimateGas", [{
+                from: next.from, to: next.to, data: next.data, value: toHex(next.value), gas: toHex(next.gas), gasPrice: toHex(next.gasPrice),
+            }, "latest"]), "submission gas estimate");
+        if (estimated <= 0n || estimated > next.gas)
+            throw new Error("Submission RPC gas estimate exceeds the exact reviewed envelope or is zero");
+        if (rpcQuantity(await lifecycleRpc(submissionClient, "eth_chainId"), "submission chain ID") !== simulation.chainId)
+            throw new Error("Active submission RPC chain changed during preflight");
+    }
+    catch (failure) {
+        const reason = `Exact next-transaction submission preflight failed: ${failure instanceof Error ? failure.message : String(failure)}`;
+        throw new LifecyclePlanningError("SUBMISSION_PREFLIGHT_FAILED", reason, { ...simulation, transportPreflight: "failed", reason });
+    }
+    const canonical = await readLifecycleBlock(options.client, toHex(simulation.blockNumber));
+    if (canonical.hash.toLowerCase() !== simulation.blockHash.toLowerCase())
+        throw new LifecyclePlanningError("STATE_REORGED", "Pinned launch proof changed during submission preflight; rebuild from canonical progress");
+    if (rpcQuantity(await lifecycleRpc(options.client, "eth_chainId"), "chain ID") !== simulation.chainId)
+        throw new LifecyclePlanningError("CHAIN_MISMATCH", "Source RPC chain changed during submission preflight");
+    if (next.admission === undefined)
+        throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Next transaction omitted its exact simulation admission", simulation);
+    return { ...next, dependencies: [], admission: { ...next.admission, transportPreflight: "passed" } };
+}
 /** Re-reads canonical state, revalidates all prerequisites, and proves the remaining sequence afresh. */
 export async function buildNextTransaction(options) {
     const block = await readLifecycleBlock(options.client);
@@ -448,21 +543,22 @@ export async function buildNextTransaction(options) {
             throw new LifecyclePlanningError("NOT_STARTED", "An unstarted plan has no launch escrow to cancel");
         const { planned } = options;
         const transaction = { id: "cancel", kind: "cancel", chainId: Number(planned.chainId), from: planned.account, to: planned.plan.orchestrator, data: encodeFunctionData({ abi: launchLifecycleAbi, functionName: "cancelLaunch", args: [planned.plan] }), value: 0n, dependencies: [], postconditions: [{ kind: "launch", phase: "Cancelled", preparedMarkets: progress.canonical.preparedMarkets }] };
-        const simulation = await simulateLaunchTransactions({ client: options.client, planned, limits: options.limits ?? planned.limits, fork: options.fork }, [transaction], block);
+        const simulation = await simulateLaunchTransactions({ client: options.client, planned, limits: options.limits === undefined ? planned.limits : options.limits, fork: options.fork }, [transaction], block);
         if (!simulation.admitted)
             throw new LifecyclePlanningError("CANCEL_NOT_ADMITTED", simulation.reason ?? "Cancellation could not be proved against current canonical state", simulation);
-        return attachEstimates([transaction], simulation)[0];
+        const next = attachEstimates([transaction], simulation)[0];
+        if (next === undefined)
+            throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Cancellation omitted its exact simulation admission", simulation);
+        return preflightNextTransaction(options, next, simulation);
     }
-    const refreshed = await planLaunch({ client: options.client, plan: options.planned.plan, account: options.planned.account, mode: options.planned.mode, limits: options.limits ?? options.planned.limits, fork: options.fork, receipts: options.receipts, confirmations: options.confirmations ?? options.planned.confirmations });
+    const refreshed = await planLaunch({ client: options.client, plan: options.planned.plan, account: options.planned.account, mode: options.planned.mode, limits: options.limits === undefined ? options.planned.limits : options.limits, fork: options.fork, receipts: options.receipts, confirmations: options.confirmations ?? options.planned.confirmations });
     if (!refreshed.simulation.admitted)
         throw new LifecyclePlanningError("PLAN_NOT_ADMITTED", refreshed.simulation.reason ?? "Remaining exact launch sequence is not admitted", refreshed.simulation);
     assertPlannedDeploymentBindings(options.planned, refreshed);
     const next = refreshed.transactions[0];
     if (next === undefined)
         return undefined;
-    if (next.gas === undefined || next.gasPrice === undefined || next.gas > refreshed.simulation.limits.executionGasCeiling)
-        throw new LifecyclePlanningError("MISSING_GAS_PROOF", "Next transaction has no current-state exact gas/headroom/fee-envelope proof");
-    return { ...next, dependencies: [] };
+    return preflightNextTransaction(options, next, refreshed.simulation);
 }
 /** Re-simulates only canonical unfinished work with the same submitted receipt
  * evidence and confirmation depth as build-next, never silently dropping context. */
@@ -472,7 +568,7 @@ export async function simulateLaunchPlan(options) {
         throw new LifecyclePlanningError("PLAN_MUTATED", "Stored economic plan no longer matches its commitment");
     const current = await planLaunch({
         client, plan: planned.plan, account: planned.account, mode: planned.mode,
-        limits: options.limits ?? planned.limits, fork: options.fork,
+        limits: options.limits === undefined ? planned.limits : options.limits, fork: options.fork,
         receipts: options.receipts, confirmations: options.confirmations ?? planned.confirmations,
     });
     assertPlannedDeploymentBindings(planned, current);