@black-market/sdk 0.6.3 → 0.6.4

package/src/lifecycle/progress.ts

@@ -141,63 +141,69 @@ export async function validateV4LifecycleOracle(options: {
 
 export async function readLifecycleProfiles(options: { client: LifecycleRpcClient; orchestrator: Address; profileIds?: readonly Hex[]; offset?: bigint; limit?: bigint }, pinnedBlock?: LifecycleBlock): Promise<LifecycleProfile[]> {
   return withLifecycleReadClient(options.client, (client) => lifecycleStage(client, "profile.certification", async () => {
-    const [block, chainIdValue] = await Promise.all([
-      pinnedBlock ?? readLifecycleBlock(client),
-      lifecycleRpc(client, "eth_chainId"),
+    const chainIdPromise = lifecycleRpc(client, "eth_chainId").then((value) => rpcQuantity(value, "chain ID"));
+    // Block-bound discovery does not depend on chain identity. Join both branches
+    // immediately so a failed chain read cannot become detached or a profile refusal.
+    const [chainId, { block, profiles }] = await Promise.all([
+      chainIdPromise,
+      (async () => {
+        const block = pinnedBlock ?? await readLifecycleBlock(client);
+        const registry = await readLifecycleContract<Address>(client, options.orchestrator, launchLifecycleAbi, "registry", [], block);
+        const offset = options.offset ?? 0n; const limit = options.limit ?? 100n;
+        if (offset < 0n || limit < 0n || limit > 100n) throw new LifecyclePlanningError("INVALID_PROFILE_PAGE", "Registry profile pages require unsigned offset and limit at most 100");
+        let protocolMaximumDeveloperFeeBpsPromise: Promise<number> | undefined;
+        const readProtocolMaximumDeveloperFeeBps = () => protocolMaximumDeveloperFeeBpsPromise ??=
+          readLifecycleContract<number>(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block);
+        const readProfile = async (id: Hex): Promise<LifecycleProfile> => {
+          const registration = await readLifecycleContract<ProfileRegistrationV1>(client, registry, lifecycleRegistryAbi, "profile", [id], block);
+          const 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 [adapter, certification] = await Promise.all([
+            readLifecycleContract<AdapterRegistrationV1>(client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block),
+            venueKind === "unknown" ? undefined : Promise.all([
+              readLifecycleProfileTopology(client, registry, id, block),
+              venueKind === "uniswap-v4" ? Promise.all([
+                readLifecycleContract<LaunchEnvelopeV2>(client, registry, lifecycleRegistryAbi, "profileEnvelope", [id], block),
+                readLifecycleContract<readonly [Address, Address, number, Hex, boolean]>(client, registry, lifecycleRegistryAbi, "developerTerms", [id], block),
+                readProtocolMaximumDeveloperFeeBps(),
+              ]) : undefined,
+            ]).then((values) => ({ values }), (failure: unknown) => ({ failure })),
+          ]);
+          const chainId = await chainIdPromise;
+          let topology: ProfileTopologyV1 = { hookTopology: 0, configVersion: adapter.configVersion, hookDeployer: zeroAddress, hookCreationCodeHash: zeroHash };
+          let envelope: LaunchEnvelopeV2 | undefined; let developerTerms: LifecycleDeveloperTerms | undefined;
+          let protocolMaximumDeveloperFeeBps: number | undefined;
+          let admitted = false; let reason: string | undefined;
+          try {
+            if (certification === undefined) throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${registration.configSchema}`);
+            if ("failure" in certification) throw certification.failure;
+            const [recordedTopology, reviewed] = certification.values;
+            topology = recordedTopology;
+            if (reviewed !== undefined) {
+              envelope = reviewed[0];
+              protocolMaximumDeveloperFeeBps = reviewed[2];
+              const [implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled] = reviewed[1];
+              developerTerms = { adapter: implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled };
+              if (implementation.toLowerCase() !== adapter.implementation.toLowerCase() || beneficiary.toLowerCase() !== envelope.beneficiary.toLowerCase() ||
+                termsDigest.toLowerCase() !== envelope.termsDigest.toLowerCase() || maximumDeveloperFeeBps !== envelope.maximumDeveloperFeeBps ||
+                maximumDeveloperFeeBps > reviewed[2]) throw new LifecyclePlanningError("PROFILE_TERMS", "Registry developer terms differ from the frozen reviewed envelope");
+            }
+            await certifyLifecycleProfile(client, options.orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId);
+            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); }
+          return { id, registration, adapter, topology, envelope, developerTerms, protocolMaximumDeveloperFeeBps: venueKind === "uniswap-v4" ? protocolMaximumDeveloperFeeBps : undefined, admitted, reason, venueKind };
+        };
+        const [authority, profiles] = await Promise.all([
+          readLifecycleContract<Address>(client, registry, lifecycleRegistryAbi, "core", [], block),
+          Promise.resolve(options.profileIds ?? readLifecycleContract<readonly Hex[]>(client, registry, lifecycleRegistryAbi, "profileIds", [offset, limit], block)).then((ids) => Promise.all(ids.map(readProfile))),
+        ]);
+        if (authority.toLowerCase() !== options.orchestrator.toLowerCase()) throw new LifecyclePlanningError("REGISTRY_BINDING", "Registry is not bound to the selected lifecycle orchestrator");
+        // A required V4 cap read still rejects the invocation on failure; Abyss has no developer-fee terms.
+        if (protocolMaximumDeveloperFeeBpsPromise !== undefined) await protocolMaximumDeveloperFeeBpsPromise;
+        return { block, profiles };
+      })(),
     ]);
-    const chainId = rpcQuantity(chainIdValue, "chain ID");
-    const registry = await readLifecycleContract<Address>(client, options.orchestrator, launchLifecycleAbi, "registry", [], block);
-    const offset = options.offset ?? 0n; const limit = options.limit ?? 100n;
-    if (offset < 0n || limit < 0n || limit > 100n) throw new LifecyclePlanningError("INVALID_PROFILE_PAGE", "Registry profile pages require unsigned offset and limit at most 100");
-    let protocolMaximumDeveloperFeeBpsPromise: Promise<number> | undefined;
-    const readProtocolMaximumDeveloperFeeBps = () => protocolMaximumDeveloperFeeBpsPromise ??=
-      readLifecycleContract<number>(client, registry, lifecycleRegistryAbi, "protocolMaximumDeveloperFeeBps", [], block);
-    const readProfile = async (id: Hex): Promise<LifecycleProfile> => {
-      const registration = await readLifecycleContract<ProfileRegistrationV1>(client, registry, lifecycleRegistryAbi, "profile", [id], block);
-      const 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 [adapter, certification] = await Promise.all([
-        readLifecycleContract<AdapterRegistrationV1>(client, registry, lifecycleRegistryAbi, "adapter", [registration.adapterId], block),
-        venueKind === "unknown" ? undefined : Promise.all([
-          readLifecycleProfileTopology(client, registry, id, block),
-          venueKind === "uniswap-v4" ? Promise.all([
-            readLifecycleContract<LaunchEnvelopeV2>(client, registry, lifecycleRegistryAbi, "profileEnvelope", [id], block),
-            readLifecycleContract<readonly [Address, Address, number, Hex, boolean]>(client, registry, lifecycleRegistryAbi, "developerTerms", [id], block),
-            readProtocolMaximumDeveloperFeeBps(),
-          ]) : undefined,
-        ]).then((values) => ({ values }), (failure: unknown) => ({ failure })),
-      ]);
-      let topology: ProfileTopologyV1 = { hookTopology: 0, configVersion: adapter.configVersion, hookDeployer: zeroAddress, hookCreationCodeHash: zeroHash };
-      let envelope: LaunchEnvelopeV2 | undefined; let developerTerms: LifecycleDeveloperTerms | undefined;
-      let protocolMaximumDeveloperFeeBps: number | undefined;
-      let admitted = false; let reason: string | undefined;
-      try {
-        if (certification === undefined) throw new LifecyclePlanningError("UNSUPPORTED_SCHEMA", `Unsupported lifecycle config schema ${registration.configSchema}`);
-        if ("failure" in certification) throw certification.failure;
-        const [recordedTopology, reviewed] = certification.values;
-        topology = recordedTopology;
-        if (reviewed !== undefined) {
-          envelope = reviewed[0];
-          protocolMaximumDeveloperFeeBps = reviewed[2];
-          const [implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled] = reviewed[1];
-          developerTerms = { adapter: implementation, beneficiary, maximumDeveloperFeeBps, termsDigest, enabled };
-          if (implementation.toLowerCase() !== adapter.implementation.toLowerCase() || beneficiary.toLowerCase() !== envelope.beneficiary.toLowerCase() ||
-            termsDigest.toLowerCase() !== envelope.termsDigest.toLowerCase() || maximumDeveloperFeeBps !== envelope.maximumDeveloperFeeBps ||
-            maximumDeveloperFeeBps > reviewed[2]) throw new LifecyclePlanningError("PROFILE_TERMS", "Registry developer terms differ from the frozen reviewed envelope");
-        }
-        await certifyLifecycleProfile(client, options.orchestrator, registry, id, registration, adapter, topology, envelope, block, chainId);
-        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); }
-      return { id, registration, adapter, topology, envelope, developerTerms, protocolMaximumDeveloperFeeBps: venueKind === "uniswap-v4" ? protocolMaximumDeveloperFeeBps : undefined, admitted, reason, venueKind };
-    };
-    const [authority, profiles] = await Promise.all([
-      readLifecycleContract<Address>(client, registry, lifecycleRegistryAbi, "core", [], block),
-      Promise.resolve(options.profileIds ?? readLifecycleContract<readonly Hex[]>(client, registry, lifecycleRegistryAbi, "profileIds", [offset, limit], block)).then((ids) => Promise.all(ids.map(readProfile))),
-    ]);
-    if (authority.toLowerCase() !== options.orchestrator.toLowerCase()) throw new LifecyclePlanningError("REGISTRY_BINDING", "Registry is not bound to the selected lifecycle orchestrator");
-    // A required V4 cap read still rejects the invocation on failure; Abyss has no developer-fee terms.
-    if (protocolMaximumDeveloperFeeBpsPromise !== undefined) await protocolMaximumDeveloperFeeBpsPromise;
     if (pinnedBlock === undefined) await assertLifecycleBlock(client, block, chainId);
     return profiles;
   }));
@@ -391,8 +397,11 @@ async function readLaunchProgressAtBlock(options: ReadLaunchProgressOptions, cli
   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 = confirmedNumber === block.number ? block : await readLifecycleBlock(client, toHex(confirmedNumber));
-  const chainId = rpcQuantity(await lifecycleRpc(client, "eth_chainId"), "chain ID");
+  const [confirmedBlock, chainIdValue] = await Promise.all([
+    confirmedNumber === block.number ? block : readLifecycleBlock(client, toHex(confirmedNumber)),
+    lifecycleRpc(client, "eth_chainId"),
+  ]);
+  const chainId = rpcQuantity(chainIdValue, "chain ID");
   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()) throw new LifecyclePlanningError("ACCOUNT_MISMATCH", "Execution account must be the committed creator/payer/refund account");
   if (hashLaunchPlan(planned.plan).toLowerCase() !== planned.planHash.toLowerCase() || hashLaunchIdentity(planned.plan).toLowerCase() !== planned.launchId.toLowerCase()) throw new LifecyclePlanningError("PLAN_MUTATED", "Stored economic plan no longer matches its commitment");

package/src/lifecycle/simulation.ts

@@ -2,7 +2,7 @@ import { decodeEventLog, decodeFunctionResult, encodeFunctionData, encodeFunctio
 import { launchLifecycleAbi, lifecycleErc20Abi } from "./abi.js";
 import { LifecyclePhase, type LaunchProgressV1, type LaunchReceiptV1 } from "./schema.js";
 import { assertLifecycleBlock, lifecyclePinnedRpc, lifecycleRpc, lifecycleSourceClient, lifecycleStage, nitroArbSys, nitroArbSysAbi, nitroGasInfo, nitroGasInfoAbi, readLifecycleBlock, readNitroPosterGas, resolveLifecycleLimits, rpcHex, rpcObject, rpcQuantity } from "./rpc.js";
-import { LifecyclePlanningError, type ControlledLifecycleFork, type LifecycleBlock, type LifecyclePostcondition, type LifecycleRpcClient, type LifecycleSimulation, type LifecycleSimulationStep, type LifecycleTransaction, type PlannedLaunch, type ResolvedLifecycleLimits, type SimulateLaunchPlanOptions } from "./types.js";
+import { LifecyclePlanningError, type ControlledLifecycleFork, type LifecycleBlock, type LifecycleLimitContext, type LifecycleLimits, type LifecyclePostcondition, type LifecycleRpcClient, type LifecycleSimulation, type LifecycleSimulationStep, type LifecycleTransaction, type PlannedLaunch, type ResolvedLifecycleLimits, type SimulateLaunchPlanOptions } from "./types.js";
 
 function conditionRequest(condition: LifecyclePostcondition, planned: PlannedLaunch): { to: Hex; data: Hex } {
   if (condition.kind === "allowance") return {
@@ -233,18 +233,54 @@ async function simulateForkPass(fork: ControlledLifecycleFork, planned: PlannedL
   }
 }
 
-export async function simulateLaunchTransactions(options: SimulateLaunchPlanOptions, transactions: readonly LifecycleTransaction[], pinnedBlock?: LifecycleBlock): Promise<LifecycleSimulation> {
+/** Internal one-shot continuation. Only SDK reads can produce its context; callers
+ * cannot supply resolved policy or account/chain observations as authority. */
+export function prepareLaunchSimulation(options: SimulateLaunchPlanOptions, block: LifecycleBlock, hasTransactions = true): (transactions: readonly LifecycleTransaction[]) => Promise<LifecycleSimulation> {
   const { client, planned } = options;
   const sourceClient = lifecycleSourceClient(client);
-  if (options.fork !== undefined && lifecycleSourceClient(options.fork.client) === sourceClient) throw new LifecyclePlanningError("UNSAFE_FORK", "Source RPC must never receive controlled simulation transactions/snapshots/resets");
-  const block = pinnedBlock ?? await readLifecycleBlock(client);
+  const blockNumber = block.number, blockHash = block.hash;
   const context = { client, account: planned.account, orchestrator: planned.plan.orchestrator, block, chainId: planned.chainId };
-  const [{ limits, configuration }, chainId, accountCodeValue, gasPriceValue] = await lifecycleStage(client, "simulation.context", () => Promise.all([
-    resolveLifecycleLimits(context, options.limits === undefined ? planned.limits : options.limits),
-    lifecycleRpc(client, "eth_chainId"),
-    lifecyclePinnedRpc(client, "eth_getCode", [planned.account, toHex(block.number)], block),
-    transactions.length === 0 ? undefined : lifecycleRpc(client, "eth_gasPrice"),
-  ]));
+  const pending = (async () => {
+    if (options.fork !== undefined && lifecycleSourceClient(options.fork.client) === sourceClient) throw new LifecyclePlanningError("UNSAFE_FORK", "Source RPC must never receive controlled simulation transactions/snapshots/resets");
+    return lifecycleStage(client, "simulation.context", () => Promise.all([
+      resolveLifecycleLimits(context, options.limits === undefined ? planned.limits : options.limits),
+      lifecycleRpc(client, "eth_chainId"),
+      lifecyclePinnedRpc(client, "eth_getCode", [context.account, toHex(block.number)], block),
+      hasTransactions ? lifecycleRpc(client, "eth_gasPrice") : undefined,
+    ]));
+  })().then((observations) => ({ observations }), (failure: unknown) => ({ failure }));
+  // Attach the failure handler before input validation can refuse or throw.
+  // Preparation is read-only; no probe, measurement, replay or fork work starts.
+  let consumed = false;
+  return async (transactions) => {
+    if (consumed) throw new LifecyclePlanningError("INVALID_SIMULATION", "Prepared simulation context is invocation-local and may only be consumed once");
+    consumed = true;
+    const result = await pending;
+    if ("failure" in result) throw result.failure;
+    if (options.client !== client || options.planned !== planned || context.client !== client || context.block !== block || lifecycleSourceClient(client) !== sourceClient ||
+      planned.account !== context.account || planned.plan.orchestrator !== context.orchestrator || planned.chainId !== context.chainId ||
+      block.number !== blockNumber || block.hash !== blockHash) throw new LifecyclePlanningError("LIMIT_CONTEXT_MISMATCH", "Prepared simulation context differs from the bound source/chain/account/core/block");
+    return simulateLaunchTransactionsWithContext(options, transactions, context, result.observations);
+  };
+}
+
+export async function simulateLaunchTransactions(options: SimulateLaunchPlanOptions, transactions: readonly LifecycleTransaction[], pinnedBlock?: LifecycleBlock): Promise<LifecycleSimulation> {
+  // Standalone calls always produce fresh context, including live chain and fees.
+  if (options.fork !== undefined && lifecycleSourceClient(options.fork.client) === lifecycleSourceClient(options.client)) throw new LifecyclePlanningError("UNSAFE_FORK", "Source RPC must never receive controlled simulation transactions/snapshots/resets");
+  const block = pinnedBlock ?? await readLifecycleBlock(options.client);
+  return prepareLaunchSimulation(options, block, transactions.length !== 0)(transactions);
+}
+
+async function simulateLaunchTransactionsWithContext(
+  options: SimulateLaunchPlanOptions,
+  transactions: readonly LifecycleTransaction[],
+  context: LifecycleLimitContext,
+  observations: [{ limits: ResolvedLifecycleLimits; configuration: LifecycleLimits }, unknown, unknown, unknown],
+): Promise<LifecycleSimulation> {
+  const { client, planned } = options;
+  const sourceClient = lifecycleSourceClient(client);
+  const { block } = context;
+  const [{ limits, configuration }, chainId, accountCodeValue, gasPriceValue] = observations;
   const base = { confidence: "stateful" as const, executionProof: "failed" as const, protocolFit: "unknown" as const, transportPreflight: "not-requested" as const, blockNumber: block.number, blockHash: block.hash, account: planned.account, chainId: planned.chainId, limits };
   if (rpcQuantity(chainId, "chain ID") !== planned.chainId) throw new LifecyclePlanningError("CHAIN_MISMATCH", "RPC chain changed before sequential simulation");
   const accountCode = rpcHex(accountCodeValue, "account code");