gate-evm-tools 1.0.27 → 1.0.31

package/runtime/workflow/run.ts

@@ -1,8 +1,8 @@
+import { resolvePendingUupsReuse } from "./lib/pendingDeploymentReuse";
 import { bindExecutionRuntime } from "./lib/runtimeVersion";
 import fs from "fs";
 import path from "path";
-import type { Signer } from "ethers";
-import { artifacts, config as hardhatConfig, ethers, network } from "../projectHardhat";
+import hardhat, { artifacts, config as hardhatConfig, ethers, network } from "../projectHardhat";
 import {
   loadConfig,
   resolveAdmin,
@@ -17,6 +17,7 @@ import {
   ParameterLockExecution,
   readParameterLockExecution,
   writeParameterLock,
+  recordParameterLockImplementationSalts,
 } from "./lib/lock";
 import {
   loadManifest,
@@ -44,8 +45,6 @@ import {
 } from "./lib/releaseParameters";
 import { WorkflowReporter } from "./lib/reporter";
 import {
-  ExternalCall,
-  ExternalExecutionRequired,
   writeExternalExecutionPackage,
 } from "./lib/external";
 import { classifyWorkflowError } from "./lib/errors";
@@ -54,7 +53,6 @@ import {
   setupSimulationFork,
   assertSimulationSourceInfrastructure,
   simulationForkEvidence,
-  SimulationFork,
   verifySimulationForkSnapshot,
   WorkflowMode,
 } from "./lib/simulation";
@@ -66,14 +64,8 @@ import {
 import { loadSimulationCallerNetwork } from "./lib/simulationCallers";
 import { WorkflowState } from "./lib/state";
 import { DeploymentRecorder } from "./lib/deploymentRecords";
-import { runDeployStep } from "./steps/deploy";
-import { runCallStep } from "./steps/call";
-import { runUpgradeStep } from "./steps/upgrade";
-import { runViewStep } from "./steps/view";
-import { runCheckStep } from "./steps/check";
 import { runCustomStep } from "./steps/custom";
 import {
-  ExecutionSegmentDeferred,
   loadReleaseExecutionPlan,
   ReleaseExecutionPlan,
   ReleaseExecutionPlanner,
@@ -84,32 +76,9 @@ import {
 import { writeOperatorExecutionResult } from "./lib/operatorExecution";
 import { loadCompletedExecutionPrefix } from "./lib/executionProgress";
 
-export interface WorkflowContext {
-  root: string;
-  taskId: string;
-  executionId: string;
-  taskDir: string;
-  targetId: string;
-  target: TargetConfig & Record<string, unknown> & { id: string };
-  targetParams: Record<string, unknown>;
-  existingDeploymentPolicies: ExistingDeploymentPolicies;
-  releaseArtifactHash?: string;
-  parameterLockExecutionId?: string;
-  parameterLockOperator?: string;
-  config: ReturnType<typeof loadConfig>;
-  mode: WorkflowMode;
-  simulation: SimulationFork;
-  signer?: Signer;
-  signerAddress?: string;
-  configuredSimulationCaller?: boolean;
-  state: WorkflowState;
-  reporter: WorkflowReporter;
-  deploymentRecorder?: DeploymentRecorder;
-  executionPlanner?: ReleaseExecutionPlanner;
-  lockedExecutionPlan?: ReleaseExecutionPlan;
-  externalCalls: ExternalCall[];
-  operatorReceipts: Array<{ transactionId: string; transactionHash: string }>;
-}
+import type { WorkflowContext } from "./lib/context";
+import { runWorkflowSteps, validateWorkflowStepsForMode } from "./engine";
+export type { WorkflowContext } from "./lib/context";
 
 const parseArgs = (argv: string[]): Record<string, string | boolean> => {
   const args: Record<string, string | boolean> = {};
@@ -186,31 +155,6 @@ const selectSteps = (
   return steps;
 };
 
-const runStep = async (context: WorkflowContext, step: WorkflowStep): Promise<void> => {
-  switch (step.kind) {
-    case "deploy":
-      await runDeployStep(context, step);
-      return;
-    case "call":
-      await runCallStep(context, step);
-      return;
-    case "upgrade":
-      await runUpgradeStep(context, step);
-      return;
-    case "view":
-      await runViewStep(context, step);
-      return;
-    case "check":
-      await runCheckStep(context, step);
-      return;
-    case "custom":
-      await runCustomStep(context, step);
-      return;
-    default:
-      throw new Error(`Unsupported step kind: ${step.kind}`);
-  }
-};
-
 interface PreparedReleaseExecution {
   sourceSuperTaskId: string;
   mergeCommit: string;
@@ -571,12 +515,7 @@ async function main(): Promise<void> {
     if (mode === "simulate" && steps.length === 0) {
       throw new Error("Simulation must select at least one workflow step");
     }
-    if (mode === "verify") {
-      const unsupported = steps.find((step) => step.kind !== "view" && step.kind !== "check");
-      if (unsupported) {
-        throw new Error(`verify mode only supports view and check steps; ${unsupported.id} is ${unsupported.kind}`);
-      }
-    }
+    validateWorkflowStepsForMode(mode, steps);
     const releaseExecution = await prepareReleaseExecution(
       args,
       mode,
@@ -637,17 +576,20 @@ async function main(): Promise<void> {
             useLock: booleanArg(args, "useLock"),
           })
       : undefined;
-    const simulation = mode === "simulate" ? await setupSimulationFork(targetId) : {};
+    const simulation = mode === "simulate" ? await setupSimulationFork(hardhat, targetId, {
+      snapshotJson: process.env.GATE_SIMULATION_FORK_SNAPSHOT_JSON,
+      sourceRpcUrl: process.env.GATE_SIMULATION_SOURCE_RPC_URL,
+    }) : {};
     if (mode === "simulate") {
-      await assertSimulationSourceInfrastructure(targetId, target, simulation);
+      await assertSimulationSourceInfrastructure(ethers.provider, targetId, target, simulation);
     }
     const signer = mode === "verify"
       ? undefined
       : mode === "simulate"
       ? simulationCallerBinding
         ? undefined
-        : await impersonateWorkflowSimulationSigner(simulationSignerAddress!)
-      : await resolveWorkflowSigner(mode, {
+        : await impersonateWorkflowSimulationSigner(hardhat, simulationSignerAddress!)
+      : await resolveWorkflowSigner(hardhat, mode, {
           taskAddress: taskMetadata.deploymentSignerAddress,
         });
     const signerAddress = simulationCallerBinding?.defaultAddress
@@ -721,7 +663,7 @@ async function main(): Promise<void> {
       });
     }
 
-    const context: WorkflowContext = {
+    const context: WorkflowContext & { executionPlanner?: ReleaseExecutionPlanner } = {
       root,
       taskId,
       executionId,
@@ -733,9 +675,28 @@ async function main(): Promise<void> {
         ? releaseExecution.existingDeploymentPolicies
         : parseExistingDeploymentPolicies(args),
       releaseArtifactHash: releaseExecution?.releaseFingerprint.artifactHash,
-      parameterLockExecutionId: releaseExecution ? executionId : undefined,
-      parameterLockOperator: releaseExecution?.lockedExecution?.operator,
+      pendingUupsReuse: releaseExecution ? {
+        resolve: async (input) => {
+          const result = await resolvePendingUupsReuse({ ...input, root, taskDir, currentExecutionId: executionId });
+          return result ? { implementationAddress: result.implementationAddress, implementationSalt: result.implementationSalt,
+            proxyAddress: result.proxyAddress, artifactDigest: result.evidence.artifactDigest, legacyEvidence: result.evidence } : undefined;
+        },
+      } : undefined,
       config,
+      runtime: {
+        hre: hardhat,
+        ...(mode === "simulate" ? {
+          localFork: {
+            provider: network.provider,
+            impersonate: (address) => impersonateWorkflowSimulationSigner(hardhat, address),
+          },
+        } : {}),
+      },
+      bindings: releaseExecution ? {
+        recordOrAssertDerivedValue: (key, value) => recordParameterLockImplementationSalts(
+          taskDir, executionId, { [key]: value },
+        ),
+      } : undefined,
       mode,
       simulation,
       signer,
@@ -759,7 +720,6 @@ async function main(): Promise<void> {
             completedTransactions: completedExecutionPrefix,
           })
         : undefined,
-      lockedExecutionPlan,
       externalCalls: [],
       operatorReceipts: [],
     };
@@ -787,103 +747,10 @@ async function main(): Promise<void> {
       });
     }
 
-    let executionSegmentDeferred = false;
-    stepLoop: for (const step of steps) {
-      if (
-        context.mode === "execute"
-        && context.externalCalls.length > 0
-        && (step.kind === "view" || step.kind === "check" || step.kind === "custom")
-      ) {
-        reporter.event("step.deferred_until_external_execution", {
-          stepId: step.id,
-          kind: step.kind,
-        });
-        break;
-      }
-      const configuredCaller = simulationCallerBinding?.resolved.find(
-        (entry) => entry.stepId === step.id,
-      );
-      const stepContext: WorkflowContext = configuredCaller
-        ? {
-            ...context,
-            signer: await impersonateWorkflowSimulationSigner(configuredCaller.callerAddress),
-            signerAddress: configuredCaller.callerAddress,
-            configuredSimulationCaller: true,
-          }
-        : context;
-      if (configuredCaller) {
-        reporter.setSimulationCallerAddress(configuredCaller.callerAddress);
-      }
-      try {
-        reporter.event("step.started", { stepId: step.id, kind: step.kind });
-        try {
-          await runStep(stepContext, step);
-        } catch (error) {
-          if (context.mode === "execute" && error instanceof ExecutionSegmentDeferred) {
-            executionSegmentDeferred = true;
-            reporter.event("execution.segment.deferred", {
-              transactionId: error.transactionId,
-            });
-            break stepLoop;
-          }
-          if (
-            context.mode === "execute"
-            && error instanceof ExternalExecutionRequired
-          ) {
-            if (!context.executionPlanner) {
-              throw new Error(
-                "External execution requires a locked mixed-authority plan; run final simulation and execute mode",
-              );
-            }
-            for (const call of error.calls) {
-              let planned;
-              try {
-                planned = context.executionPlanner.add({
-                  stepId: call.stepId,
-                  executor: call.executor,
-                  to: call.to,
-                  value: call.value,
-                  data: call.data,
-                  operation: call.operation,
-                });
-              } catch (planError) {
-                if (planError instanceof ExecutionSegmentDeferred) {
-                  executionSegmentDeferred = true;
-                  reporter.event("execution.segment.deferred", {
-                    transactionId: planError.transactionId,
-                  });
-                  break;
-                }
-                throw planError;
-              }
-              if (planned.route !== "external") {
-                throw new Error(
-                  `Step ${call.stepId} requested external execution for an operator route`,
-                );
-              }
-              if (planned.executionAction !== "replay") {
-                context.externalCalls.push({
-                  ...call,
-                  transactionId: planned.transactionId,
-                  stepId: planned.stepId,
-                  executor: planned.executor,
-                  to: planned.to,
-                  value: planned.value,
-                  data: planned.data,
-                  operation: planned.operation,
-                });
-              }
-            }
-            if (executionSegmentDeferred) break stepLoop;
-            continue;
-          }
-          throw error;
-        }
-        reporter.event("step.completed", { stepId: step.id, kind: step.kind });
-      } finally {
-        if (configuredCaller) reporter.clearSimulationCallerAddress();
-      }
-    }
+    const { executionSegmentDeferred } = await runWorkflowSteps(context, steps, {
+      simulationCallers: simulationCallerBinding?.resolved,
+      runCustomStep,
+    });
 
     const plannedBody = context.executionPlanner?.complete({
       allowPartial: executionSegmentDeferred,
@@ -893,7 +760,7 @@ async function main(): Promise<void> {
       : lockedExecutionPlan;
 
     if (mode === "simulate") {
-      await verifySimulationForkSnapshot(context.simulation);
+      await verifySimulationForkSnapshot(hardhat, context.simulation);
     }
     if (completedPlan && mode === "execute") {
       writeOperatorExecutionResult({

package/runtime/workflow/staticValidate.ts

@@ -2,8 +2,10 @@ import { runStaticValidation } from "./lib/staticValidation";
 
 const taskAt = process.argv.findIndex((item) => item === "--task");
 const deploymentId = taskAt >= 0 ? process.argv[taskAt + 1] : process.env.WORKFLOW_TASK;
-const networkAt = process.argv.findIndex((item) => item === "--network");
-const selectedNetwork = networkAt >= 0 ? process.argv[networkAt + 1] : undefined;
+const evmAt = process.argv.findIndex((item) => item === "--evm-network");
+const zkAt = process.argv.findIndex((item) => item === "--zksync-network");
+const evmNetwork = evmAt >= 0 ? process.argv[evmAt + 1] : undefined;
+const zkNetwork = zkAt >= 0 ? process.argv[zkAt + 1] : undefined;
 
 if (!deploymentId) {
   console.error("workflow:static-validate requires --task <deploymentId> or WORKFLOW_TASK");
@@ -12,7 +14,10 @@ if (!deploymentId) {
   void runStaticValidation({
     root: process.cwd(),
     deploymentId,
-    network: selectedNetwork,
+    compileTargets: evmNetwork && zkNetwork ? [
+      { scheme: "evm", network: evmNetwork },
+      { scheme: "zksync-eravm", network: zkNetwork },
+    ] : [],
   }).then((result) => {
     console.log(JSON.stringify(result));
     if (result.status !== "passed") process.exitCode = 1;

package/runtime/workflow/steps/call.ts

@@ -1,4 +1,4 @@
-import { WorkflowContext } from "../run";
+import type { WorkflowContext } from "../lib/context";
 import { WorkflowStep } from "../lib/parameters";
 import { runContractWriteCalls } from "../lib/calls";
 

package/runtime/workflow/steps/check.ts

@@ -1,4 +1,4 @@
-import { WorkflowContext } from "../run";
+import type { WorkflowContext } from "../lib/context";
 import { WorkflowStep } from "../lib/parameters";
 import { runContractCheckCalls } from "../lib/calls";
 

package/runtime/workflow/steps/custom.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import { createRequire } from "module";
-import type { WorkflowContext } from "../run";
+import type { WorkflowContext } from "../lib/context";
 import type { WorkflowStep } from "../lib/parameters";
 
 type CustomStepRunner = (

package/runtime/workflow/steps/deploy.ts

@@ -1,12 +1,14 @@
+import { resolveWorkflowValue } from '../lib/validation';
+import { recordPreparedDeployment } from "../lib/preparationEvidence";
+import { CONTROLLED_MULTICALL_AUTHORITY_ABI } from "../lib/controlledMulticallAbi";
 import path from "path";
-import { ethers, network } from "../../projectHardhat";
 import type {
   GateToolDeploymentPlan,
   GateToolPreparationPlanV1,
   GateToolPreparationRequestV1,
   GateToolTransactionPlan,
 } from "gate-evm-tools/workflow";
-import type { WorkflowContext } from "../run";
+import type { WorkflowContext } from "../lib/context";
 import {
   requireExistingDeploymentPolicy,
   resolveExistingDeploymentPolicyAction,
@@ -28,27 +30,20 @@ import {
 } from "../lib/create2";
 import { assertReusableDeployment } from "../lib/checkCodeReport";
 import { getERC1967Implementation } from "../lib/erc1967";
-import { recordParameterLockImplementationSalts } from "../lib/lock";
 import {
   deriveImplementationSalt,
   FirstUpgradeOptions,
   ProxyOptions,
 } from "../lib/proxy";
 import { decideControlledMulticallAuthority } from "../lib/authority";
-import { impersonateWorkflowSimulationSigner } from "../lib/signer";
+import { impersonateLocalForkSigner } from "../lib/runtime";
 import { prepareGateToolWorkflow } from "../lib/gateTool";
 import { syncGateToolUups } from "../lib/gateToolSync";
-import { resolvePendingUupsReuse } from "../lib/pendingDeploymentReuse";
 
 const resolveInContext = (
   context: WorkflowContext,
   value: unknown,
-): unknown => resolveValue(value, {
-  targetId: context.targetId,
-  target: context.target,
-  params: context.targetParams,
-  state: context.state,
-});
+): unknown => resolveWorkflowValue(context, value);
 
 const resolveArray = (
   context: WorkflowContext,
@@ -167,7 +162,7 @@ const applyExistingDeploymentPolicy = async (
   const existing = findDeploymentAddress(context.root, context.config, context.targetId, saveAs);
   if (!existing) return { completed: false, create2Options };
   const policy = requireExistingDeploymentPolicy(context.existingDeploymentPolicies, saveAs);
-  const implementationAddress = await getERC1967Implementation(ethers.provider, existing);
+  const implementationAddress = await getERC1967Implementation(context.runtime.hre.ethers.provider, existing);
   const action = resolveExistingDeploymentPolicyAction(policy, {
     instanceId: saveAs,
     existingAddress: existing,
@@ -187,8 +182,10 @@ const applyExistingDeploymentPolicy = async (
       address: existing,
       artifactHash: context.releaseArtifactHash,
     });
-    context.deploymentRecorder?.prepare(preparedChange);
-    context.deploymentRecorder?.apply({
+    if (context.preparations || context.validation) throw new Error("Delivery registry reuse requires bound preparation evidence; cannot omit expected transactions");
+    const recorder = context.mode === "execute" ? context.deploymentRecorder : undefined;
+    recorder?.prepare(preparedChange);
+    recorder?.apply({
       ...preparedChange,
       address: existing,
       proxyAddress: implementationAddress ? existing : undefined,
@@ -242,10 +239,11 @@ const deploymentForRole = (
 };
 
 const assertDeployedCode = async (
+  context: WorkflowContext,
   label: string,
   address: string,
 ): Promise<void> => {
-  const code = await ethers.provider.getCode(address);
+  const code = await context.runtime.hre.ethers.provider.getCode(address);
   if (!code || code === "0x") {
     throw new Error(`${label} is missing deployed code at ${address}`);
   }
@@ -285,8 +283,8 @@ const runGateToolControlledMulticall = async (
     })),
     create2.scheme,
   );
-  const multicall = await ethers.getContractAt(
-    "Multicall3",
+  const multicall = await context.runtime.hre.ethers.getContractAt(
+    CONTROLLED_MULTICALL_AUTHORITY_ABI,
     create2.controlledMulticall,
     context.signer,
   );
@@ -326,6 +324,7 @@ const runGateToolControlledMulticall = async (
     ...(prepared.scheme === undefined ? {} : { scheme: prepared.scheme }),
     ...(prepared.factoryDeps === undefined ? {} : { factoryDeps: prepared.factoryDeps }),
   });
+  context.preparations?.bind(step.id, { transactionId: planned.transactionId, gateToolTransactionIds: transactions.map(t => t.id), kind: "multicall" });
   if (planned.executionAction === "replay") {
     return {
       external: planned.route === "external",
@@ -349,9 +348,10 @@ const runGateToolControlledMulticall = async (
     return { external: true, transactionId: planned.transactionId };
   }
   const selectedSigner = planned.route === "external"
-    ? await impersonateWorkflowSimulationSigner(planned.executor)
+    ? await impersonateLocalForkSigner(context.runtime, planned.executor)
     : context.signer;
   const transaction = await sendPreparedControlledMulticallTransaction(prepared, selectedSigner);
+  context.transactionObserver?.record({ transactionId: planned.transactionId, transactionHash: transaction.hash });
   if (context.mode === "execute" && planned.route === "operator") {
     context.operatorReceipts.push({
       transactionId: planned.transactionId,
@@ -448,31 +448,26 @@ export const runDeployStep = async (
     );
     if (existingResolution.completed) return;
     const effectiveCreate2 = existingResolution.create2Options;
-    const pendingReuse = context.parameterLockExecutionId
-      ? await resolvePendingUupsReuse({
-          root: context.root,
-          taskDir: context.taskDir,
-          taskId: context.taskId,
-          currentExecutionId: context.parameterLockExecutionId,
-          network: context.targetId,
-          stepId: step.id,
-          instanceId: saveAs,
-          actualContract,
-          contractInfoKey: registryKey,
-          scheme: effectiveCreate2.scheme,
-          factory: effectiveCreate2.factory,
-          multicall: effectiveCreate2.controlledMulticall!,
-          proxySalt: effectiveCreate2.salt,
-          expectedAddress: effectiveCreate2.expectedAddress,
-          placeholderImplementationAddress: effectiveCreate2.uupsPlaceholderImplementation!,
-          provider: ethers.provider,
-          blockTag: context.mode === "simulate"
-            ? context.simulation.snapshot?.blockNumber
-            : undefined,
-        })
-      : undefined;
+    const pendingReuse = await context.pendingUupsReuse?.resolve({
+      taskId: context.taskId,
+      network: context.targetId,
+      stepId: step.id,
+      instanceId: saveAs,
+      actualContract,
+      contractInfoKey: registryKey,
+      scheme: effectiveCreate2.scheme,
+      factory: effectiveCreate2.factory,
+      multicall: effectiveCreate2.controlledMulticall!,
+      proxySalt: effectiveCreate2.salt,
+      expectedAddress: effectiveCreate2.expectedAddress,
+      placeholderImplementationAddress: effectiveCreate2.uupsPlaceholderImplementation!,
+      provider: context.runtime.hre.ethers.provider,
+      blockTag: context.mode === "simulate"
+        ? context.simulation.snapshot?.blockNumber
+        : undefined,
+    });
     const implementationSalt = pendingReuse?.implementationSalt ?? deriveImplementationSalt(
-      context.executionId,
+      context.bindings?.derivationSeed ?? context.executionId,
       firstUpgrade.contractName,
       effectiveCreate2.salt,
     );
@@ -480,7 +475,7 @@ export const runDeployStep = async (
       version: 1,
       kind: "uups-placeholder-deploy",
       scheme: effectiveCreate2.scheme,
-      network: network.name,
+      network: context.runtime.hre.network.name,
       target: context.targetId,
       contract: firstUpgrade.contractName,
       constructorArgs: firstUpgrade.constructorArgs || [],
@@ -500,10 +495,13 @@ export const runDeployStep = async (
         : {}),
     };
     const prepared = await prepareGateToolWorkflow({
+      hre: context.runtime.hre,
+      validation: context.validation,
       root: context.root,
       evidenceDir: gateToolEvidenceDir(context),
       evidenceName: step.id,
       request,
+      expected: context.preparations?.expected(step.id, request),
       readBlockTag: context.mode === "simulate"
         ? context.simulation.snapshot?.blockNumber
         : undefined,
@@ -511,8 +509,8 @@ export const runDeployStep = async (
     const implementation = deploymentForRole(prepared.plan, "implementation");
     const proxyDeployment = deploymentForRole(prepared.plan, "proxy");
     if (pendingReuse && (
-      prepared.plan.transactions.length !== 0
-      || prepared.plan.artifact.digest !== pendingReuse.evidence.artifactDigest
+      (!pendingReuse.binding && prepared.plan.transactions.length !== 0)
+      || prepared.plan.artifact.digest !== pendingReuse.artifactDigest
       || implementation.address.toLowerCase() !== pendingReuse.implementationAddress.toLowerCase()
       || proxyDeployment.address.toLowerCase() !== pendingReuse.proxyAddress.toLowerCase()
     )) {
@@ -535,6 +533,7 @@ export const runDeployStep = async (
     const plannedChange: DeploymentChange = {
       ...preparedChange,
       salt: effectiveCreate2.salt,
+      expectedAddress: effectiveCreate2.expectedAddress,
       previousAddress: existingResolution.existingAddress,
       redeployReason: existingResolution.redeployReason,
       implementationAddress: implementation.address,
@@ -542,16 +541,11 @@ export const runDeployStep = async (
       constructorArgs: firstUpgrade.constructorArgs || [],
       predictedAddress: proxyDeployment.address,
       gateTool,
-      ...(pendingReuse ? { pendingReuse: pendingReuse.evidence } : {}),
+      ...(pendingReuse?.legacyEvidence ? { pendingReuse: pendingReuse.legacyEvidence } : {}),
     };
-    if (context.parameterLockExecutionId) {
-      recordParameterLockImplementationSalts(
-        context.taskDir,
-        context.parameterLockExecutionId,
-        { [`${step.id}.implementation`]: implementationSalt },
-      );
-    }
+    context.bindings?.recordOrAssertDerivedValue(`${step.id}.implementation`, implementationSalt);
     recorder?.prepare(plannedChange);
+    recordPreparedDeployment(context, plannedChange, prepared, [`${step.id}.implementation`]);
     if (context.mode === "execute") {
       recorder?.stageAddressCandidate(plannedChange, proxyDeployment.address);
     }
@@ -566,12 +560,13 @@ export const runDeployStep = async (
     }
     if (!execution.external) {
       await assertDeployedCode(
+        context,
         `${firstUpgrade.contractName} implementation`,
         implementation.address,
       );
-      await assertDeployedCode("ERC1967Proxy", proxyDeployment.address);
+      await assertDeployedCode(context, "ERC1967Proxy", proxyDeployment.address);
       const currentImplementation = await getERC1967Implementation(
-        ethers.provider,
+        context.runtime.hre.ethers.provider,
         proxyDeployment.address,
       );
       if (
@@ -587,11 +582,12 @@ export const runDeployStep = async (
       && !execution.external
       && proxyDeployment.status !== "reused"
       ? await syncGateToolUups({
+          hre: context.runtime.hre,
           root: context.root,
           evidenceDir: gateToolEvidenceDir(context),
           evidenceName: step.id,
           scheme: prepared.plan.scheme,
-          network: network.name,
+          network: context.runtime.hre.network.name,
           target: context.targetId,
           manifestDir: context.target.openzeppelin.manifestDir,
           proxy: proxyDeployment.address,
@@ -643,7 +639,7 @@ export const runDeployStep = async (
       txHash: execution.txHash,
       gateToolPlan: gateTool.outputPath,
       gateToolSync: gateToolSync?.outputPath,
-      pendingReuse: pendingReuse?.evidence,
+      pendingReuse: pendingReuse?.legacyEvidence ?? pendingReuse?.binding,
     });
     return;
   }
@@ -678,7 +674,7 @@ export const runDeployStep = async (
     version: 1,
     kind: "create2-deploy",
     scheme: effectiveCreate2.scheme,
-    network: network.name,
+    network: context.runtime.hre.network.name,
     target: context.targetId,
     contract: contractName,
     constructorArgs: args,
@@ -695,10 +691,13 @@ export const runDeployStep = async (
       : {}),
   };
   const prepared = await prepareGateToolWorkflow({
+    hre: context.runtime.hre,
+    validation: context.validation,
     root: context.root,
     evidenceDir: gateToolEvidenceDir(context),
     evidenceName: step.id,
     request,
+    expected: context.preparations?.expected(step.id, request),
     readBlockTag: context.mode === "simulate"
       ? context.simulation.snapshot?.blockNumber
       : undefined,
@@ -722,6 +721,7 @@ export const runDeployStep = async (
     gateTool,
   };
   recorder?.prepare(preparedChange);
+  recordPreparedDeployment(context, preparedChange, prepared, []);
   if (context.mode === "execute") {
     recorder?.stageAddressCandidate(preparedChange, deployment.address);
   }
@@ -732,7 +732,7 @@ export const runDeployStep = async (
     prepared.plan.transactions,
   );
   if (!execution.external) {
-    await assertDeployedCode(contractName, deployment.address);
+    await assertDeployedCode(context, contractName, deployment.address);
   }
   if (context.mode === "execute" && !execution.external) {
     recorder?.applyAddress({