gate-evm-tools 1.0.26 → 1.0.28

package/dist-runtime/workflow/run.js

@@ -0,0 +1,858 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtimeVersion_1 = require("./lib/runtimeVersion");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const projectHardhat_1 = require("../projectHardhat");
+const config_1 = require("./lib/config");
+const executionId_1 = require("./lib/executionId");
+const lock_1 = require("./lib/lock");
+const parameters_1 = require("./lib/parameters");
+const deployments_1 = require("./lib/deployments");
+const release_1 = require("./lib/release");
+const releaseParameters_1 = require("./lib/releaseParameters");
+const reporter_1 = require("./lib/reporter");
+const external_1 = require("./lib/external");
+const errors_1 = require("./lib/errors");
+const simulation_1 = require("./lib/simulation");
+const signer_1 = require("./lib/signer");
+const simulationCallers_1 = require("./lib/simulationCallers");
+const state_1 = require("./lib/state");
+const deploymentRecords_1 = require("./lib/deploymentRecords");
+const deploy_1 = require("./steps/deploy");
+const call_1 = require("./steps/call");
+const upgrade_1 = require("./steps/upgrade");
+const view_1 = require("./steps/view");
+const check_1 = require("./steps/check");
+const custom_1 = require("./steps/custom");
+const executionPlan_1 = require("./lib/executionPlan");
+const operatorExecution_1 = require("./lib/operatorExecution");
+const executionProgress_1 = require("./lib/executionProgress");
+const parseArgs = (argv) => {
+    const args = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const item = argv[index];
+        if (!item.startsWith("--"))
+            continue;
+        const equalIndex = item.indexOf("=");
+        if (equalIndex > 2) {
+            args[item.slice(2, equalIndex)] = item.slice(equalIndex + 1);
+            continue;
+        }
+        const key = item.slice(2);
+        const next = argv[index + 1];
+        if (!next || next.startsWith("--")) {
+            args[key] = true;
+        }
+        else {
+            args[key] = next;
+            index += 1;
+        }
+    }
+    return args;
+};
+const parseEnvArgs = () => {
+    const raw = process.env.WORKFLOW_ARGS_JSON;
+    if (!raw)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`WORKFLOW_ARGS_JSON must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("WORKFLOW_ARGS_JSON must be a JSON object");
+    }
+    const args = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value !== "string" && typeof value !== "boolean") {
+            throw new Error(`WORKFLOW_ARGS_JSON.${key} must be a string or boolean`);
+        }
+        args[key] = value;
+    }
+    return args;
+};
+const assertWalletCredentialForExecution = (mode, targetId) => {
+    if (mode !== "execute")
+        return;
+    if (targetId === "hardhat" || targetId === "localhost")
+        return;
+    if (process.env.WALLET_CREDENTIAL?.trim())
+        return;
+    if (process.env.PRIVATE_KEY?.trim())
+        return;
+    throw new Error(`Missing wallet credential in project .env or process env. Execute mode on "${targetId}" requires a deployment signer.`);
+};
+const selectSteps = (steps, args) => {
+    if (typeof args.step === "string") {
+        return steps.filter((step) => step.id === args.step);
+    }
+    if (typeof args.from === "string") {
+        const index = steps.findIndex((step) => step.id === args.from);
+        if (index < 0)
+            throw new Error(`Unknown --from step: ${args.from}`);
+        return steps.slice(index);
+    }
+    return steps;
+};
+const runStep = async (context, step) => {
+    switch (step.kind) {
+        case "deploy":
+            await (0, deploy_1.runDeployStep)(context, step);
+            return;
+        case "call":
+            await (0, call_1.runCallStep)(context, step);
+            return;
+        case "upgrade":
+            await (0, upgrade_1.runUpgradeStep)(context, step);
+            return;
+        case "view":
+            await (0, view_1.runViewStep)(context, step);
+            return;
+        case "check":
+            await (0, check_1.runCheckStep)(context, step);
+            return;
+        case "custom":
+            await (0, custom_1.runCustomStep)(context, step);
+            return;
+        default:
+            throw new Error(`Unsupported step kind: ${step.kind}`);
+    }
+};
+const booleanArg = (args, key) => {
+    const value = args[key];
+    return value === true || value === "true";
+};
+const requiredStringArg = (args, key) => {
+    const value = args[key];
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error("Missing --" + key + " for release execution");
+    }
+    return value.trim();
+};
+const optionalStringArg = (args, key) => {
+    const value = args[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error("--" + key + " requires a non-empty value");
+    }
+    return value.trim();
+};
+const releaseKindArg = (args) => {
+    const value = requiredStringArg(args, "releaseKind");
+    if (value !== "development" && value !== "admin_release") {
+        throw new Error("--releaseKind must be development or admin_release");
+    }
+    return value;
+};
+const parseParameterOverrides = (args) => {
+    const value = args.parameterOverrides;
+    if (value === undefined)
+        return {};
+    if (typeof value !== "string") {
+        throw new Error("--parameterOverrides must be a JSON object");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error("--parameterOverrides must be valid JSON: "
+            + (error instanceof Error ? error.message : String(error)));
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("--parameterOverrides must be a JSON object");
+    }
+    return parsed;
+};
+const parseExistingDeploymentPolicies = (args) => {
+    const value = args.existingDeploymentPolicies;
+    if (value === undefined)
+        return {};
+    if (typeof value !== "string") {
+        throw new Error("--existingDeploymentPolicies must be a JSON object");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error("--existingDeploymentPolicies must be valid JSON: "
+            + (error instanceof Error ? error.message : String(error)));
+    }
+    return (0, parameters_1.validateExistingDeploymentPolicies)(parsed);
+};
+const manifestContractReferences = (steps) => {
+    const references = new Set();
+    for (const step of steps) {
+        if ((step.kind === "deploy" || step.kind === "upgrade") && typeof step.contract === "string") {
+            references.add(step.contract);
+        }
+        if (step.kind === "deploy" && step.firstUpgrade && typeof step.firstUpgrade === "object") {
+            const contract = step.firstUpgrade.contract;
+            if (typeof contract === "string")
+                references.add(contract);
+        }
+        if (step.kind === "deploy" && step.upgradeableStrategy === "uups-placeholder-proxy") {
+            references.add("@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol:ERC1967Proxy");
+        }
+    }
+    return [...references].sort();
+};
+const loadArtifactFingerprintInputs = async (manifest) => {
+    const inputs = [];
+    for (const contractReference of manifestContractReferences(manifest.steps)) {
+        const artifact = await projectHardhat_1.artifacts.readArtifact(contractReference);
+        const fullyQualifiedName = artifact.sourceName + ":" + artifact.contractName;
+        const buildInfo = await projectHardhat_1.artifacts.getBuildInfo(fullyQualifiedName);
+        if (!buildInfo) {
+            throw new Error("Missing Hardhat build info for " + fullyQualifiedName);
+        }
+        const settings = buildInfo.input.settings;
+        inputs.push({
+            contract: fullyQualifiedName,
+            bytecode: artifact.bytecode,
+            deployedBytecode: artifact.deployedBytecode,
+            linkReferences: artifact.linkReferences,
+            deployedLinkReferences: artifact.deployedLinkReferences,
+            solcVersion: buildInfo.solcVersion,
+            optimizer: settings.optimizer || {},
+            evmVersion: typeof settings.evmVersion === "string" ? settings.evmVersion : undefined,
+        });
+    }
+    return inputs;
+};
+const targetChainId = (targetId) => {
+    const networks = projectHardhat_1.config.networks;
+    return networks[targetId]?.chainId;
+};
+const equalStringArrays = (left, right) => {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+};
+const prepareReleaseExecution = async (args, mode, taskDir, targetId, target, manifest, existingDeploymentInstanceIds, parameters, executionId, selectedStepIds) => {
+    if (!booleanArg(args, "useLock"))
+        return undefined;
+    if (mode !== "simulate"
+        && mode !== "execute"
+        && mode !== "verify") {
+        throw new Error("--useLock only supports simulate, execute, and verify modes");
+    }
+    const release = (0, release_1.loadRelease)(taskDir);
+    const baselineParameters = (0, parameters_1.targetParams)(parameters, targetId);
+    const releaseFingerprint = (0, release_1.buildReleaseFingerprint)({
+        manifest: fs_1.default.readFileSync(path_1.default.join(taskDir, "manifest.yaml"), "utf8"),
+        artifacts: await loadArtifactFingerprintInputs(manifest),
+        parameters: baselineParameters,
+        network: targetId,
+        chainId: targetChainId(targetId),
+        target,
+    });
+    (0, release_1.assertReleaseNetworkReady)(release, targetId, releaseFingerprint);
+    if (mode === "execute" || mode === "verify") {
+        const lockedExecution = (0, lock_1.readParameterLockExecution)(taskDir, executionId);
+        if (lockedExecution.sourceSuperTaskId !== release.sourceSuperTaskId) {
+            throw new Error("Parameter lock sourceSuperTaskId does not match release.json");
+        }
+        const verifySelectionStart = mode === "verify"
+            ? lockedExecution.selectedStepIds.indexOf(selectedStepIds[0])
+            : -1;
+        const selectedStepsMatch = mode === "verify"
+            ? selectedStepIds.length > 0
+                && verifySelectionStart >= 0
+                && equalStringArrays(lockedExecution.selectedStepIds.slice(verifySelectionStart), selectedStepIds)
+            : equalStringArrays(lockedExecution.selectedStepIds, selectedStepIds);
+        if (!selectedStepsMatch) {
+            throw new Error("Parameter lock selectedStepIds do not match this execution");
+        }
+        (0, lock_1.assertParameterLockExecutable)(lockedExecution, targetId, releaseFingerprint);
+        const existingDeploymentPolicies = (0, parameters_1.validateExistingDeploymentPolicies)(lockedExecution.existingDeploymentPolicies);
+        (0, parameters_1.assertExistingDeploymentPoliciesMatchTarget)(existingDeploymentPolicies, targetId, existingDeploymentInstanceIds);
+        return {
+            sourceSuperTaskId: lockedExecution.sourceSuperTaskId,
+            mergeCommit: lockedExecution.mergeCommit,
+            baselineParameters: lockedExecution.baselineParameters,
+            overrides: lockedExecution.overrides,
+            resolvedParameters: lockedExecution.resolvedParameters,
+            releaseFingerprint,
+            existingDeploymentPolicies,
+            lockedExecution,
+        };
+    }
+    const sourceSuperTaskId = requiredStringArg(args, "sourceSuperTaskId");
+    if (sourceSuperTaskId !== release.sourceSuperTaskId) {
+        throw new Error("--sourceSuperTaskId does not match release.json");
+    }
+    const mergeCommit = requiredStringArg(args, "mergeCommit");
+    if (!/^[0-9a-fA-F]{40}$/.test(mergeCommit)) {
+        throw new Error("--mergeCommit must be a 40 character git commit");
+    }
+    const overrides = parseParameterOverrides(args);
+    const existingDeploymentPolicies = parseExistingDeploymentPolicies(args);
+    (0, parameters_1.assertExistingDeploymentPoliciesMatchTarget)(existingDeploymentPolicies, targetId, existingDeploymentInstanceIds);
+    const resolvedParameters = (0, releaseParameters_1.resolveExecutionParameters)(parameters, targetId, overrides, (0, parameters_1.loadParameterSchema)(taskDir));
+    return {
+        sourceSuperTaskId,
+        mergeCommit,
+        baselineParameters,
+        overrides,
+        resolvedParameters,
+        releaseFingerprint,
+        existingDeploymentPolicies,
+    };
+};
+async function main() {
+    const args = {
+        ...parseEnvArgs(),
+        ...parseArgs(process.argv.slice(2)),
+    };
+    const root = process.cwd();
+    const taskId = typeof args.task === "string" ? args.task : process.env.WORKFLOW_TASK;
+    if (!taskId) {
+        throw new Error("Missing task id. Pass --task <taskId> or set WORKFLOW_TASK=<taskId> before running workflow.");
+    }
+    const taskDir = (0, config_1.taskDir)(taskId, root);
+    const mode = (0, simulation_1.resolveWorkflowMode)(args);
+    const targetId = mode === "simulate"
+        ? typeof args.target === "string"
+            ? args.target
+            : ""
+        : projectHardhat_1.network.name;
+    if (!targetId) {
+        throw new Error("Missing target network. Run execute/plan with --network <network>, or simulate with --network hardhat --target <network>.");
+    }
+    const requestedReleaseKind = args.releaseKind === undefined
+        ? undefined
+        : releaseKindArg(args);
+    const gateFlowNodeKey = process.env.GATEFLOW_NODE_KEY?.trim();
+    if (gateFlowNodeKey === "DevelopmentDeployExecute" && mode !== "execute") {
+        throw new Error("GateFlow node DevelopmentDeployExecute only allows workflow --mode execute");
+    }
+    const gateFlowDevelopmentNode = gateFlowNodeKey === "DevelopmentDeploySimulate"
+        || gateFlowNodeKey === "DevelopmentDeployExecute";
+    if (gateFlowDevelopmentNode && requestedReleaseKind !== "development") {
+        throw new Error("GateFlow development deployment nodes require --releaseKind development");
+    }
+    if (gateFlowDevelopmentNode
+        && (typeof args.executionId !== "string" || !args.executionId.trim())) {
+        throw new Error("GateFlow development deployment nodes require an explicit --executionId reused across simulate and execute");
+    }
+    const executionId = (0, executionId_1.validateExecutionId)(args.executionId === undefined ? (0, executionId_1.buildExecutionId)(targetId) : args.executionId);
+    if (mode === "simulate" || mode === "execute")
+        (0, runtimeVersion_1.bindExecutionRuntime)({ taskDir, target: targetId, executionId });
+    const reporter = new reporter_1.WorkflowReporter(taskDir, taskId, executionId, targetId, mode);
+    reporter.initializeResults();
+    let contextForFailure;
+    try {
+        const config = (0, config_1.loadConfig)(root);
+        const manifest = (0, parameters_1.loadManifest)(taskDir);
+        const parameters = (0, parameters_1.loadParameters)(taskDir);
+        const taskMetadata = (0, parameters_1.loadTaskMetadata)(taskDir);
+        const target = (0, config_1.resolveTarget)(config, targetId);
+        if (mode === "execute"
+            && target.environment === "production"
+            && !booleanArg(args, "useLock")) {
+            throw new Error("Production execute requires --useLock and an immutable execution plan");
+        }
+        assertWalletCredentialForExecution(mode, targetId);
+        const steps = selectSteps(manifest.steps, args);
+        const existingDeploymentInstanceIds = manifest.steps
+            .filter((step) => step.kind === "deploy" && typeof step.saveAs === "string")
+            .map((step) => String(step.saveAs))
+            .filter((instanceId) => Boolean((0, deployments_1.findDeploymentAddress)(root, config, targetId, instanceId)));
+        const releaseTargetSimulation = mode === "simulate"
+            && (projectHardhat_1.network.name === "hardhat" || projectHardhat_1.network.name === "zkFork")
+            && typeof args.target === "string"
+            && (taskMetadata.releaseTargetNetworks ?? []).includes(targetId)
+            && !booleanArg(args, "useLock")
+            && requestedReleaseKind === undefined;
+        if (releaseTargetSimulation
+            && (args.step !== undefined || args.from !== undefined)) {
+            throw new Error("Full release-target simulation does not support partial --step or --from selection");
+        }
+        const simulationCallerBinding = releaseTargetSimulation
+            ? (0, simulationCallers_1.loadSimulationCallerNetwork)({
+                taskDir,
+                targetNetworks: taskMetadata.releaseTargetNetworks,
+                network: targetId,
+                manifestText: fs_1.default.readFileSync(path_1.default.join(taskDir, "manifest.yaml"), "utf8"),
+                manifestSteps: manifest.steps,
+            })
+            : undefined;
+        const releaseTargetFingerprint = releaseTargetSimulation
+            ? (0, release_1.buildReleaseFingerprint)({
+                manifest: fs_1.default.readFileSync(path_1.default.join(taskDir, "manifest.yaml"), "utf8"),
+                artifacts: await loadArtifactFingerprintInputs(manifest),
+                parameters: (0, parameters_1.targetParams)(parameters, targetId),
+                network: targetId,
+                chainId: targetChainId(targetId),
+                target,
+            })
+            : undefined;
+        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}`);
+            }
+        }
+        const releaseExecution = await prepareReleaseExecution(args, mode, taskDir, targetId, target, manifest, existingDeploymentInstanceIds, parameters, executionId, steps.map((step) => step.id));
+        if (!releaseExecution && requestedReleaseKind === "admin_release") {
+            throw new Error("admin_release execution requires --useLock");
+        }
+        const developmentPlanExecution = !releaseExecution
+            && requestedReleaseKind === "development";
+        if (developmentPlanExecution
+            && mode !== "simulate"
+            && mode !== "execute") {
+            throw new Error("development releaseKind only supports simulate and execute modes");
+        }
+        const lockedExecutionPlan = releaseExecution?.lockedExecution
+            ? (0, executionPlan_1.loadReleaseExecutionPlan)({
+                root,
+                taskDir,
+                target: targetId,
+                executionId,
+                expectedHash: releaseExecution.lockedExecution.finalSimulation.status === "succeeded"
+                    ? releaseExecution.lockedExecution.finalSimulation.executionPlanHash
+                    : undefined,
+            })
+            : developmentPlanExecution && mode === "execute"
+                ? (0, executionPlan_1.loadReleaseExecutionPlan)({
+                    root,
+                    taskDir,
+                    target: targetId,
+                    executionId,
+                })
+                : undefined;
+        const releaseKind = releaseExecution
+            ? mode === "simulate"
+                ? requestedReleaseKind
+                : lockedExecutionPlan?.releaseKind
+            : developmentPlanExecution
+                ? "development"
+                : undefined;
+        const completedExecutionPrefix = mode === "execute" && lockedExecutionPlan
+            ? (0, executionProgress_1.loadCompletedExecutionPrefix)({ taskDir, plan: lockedExecutionPlan })
+            : [];
+        const simulationSignerAddress = mode === "simulate"
+            ? simulationCallerBinding?.defaultAddress
+                ?? (0, signer_1.resolveSimulationSignerAddress)({
+                    explicitAddress: optionalStringArg(args, "simulationSigner"),
+                    taskAddress: taskMetadata.deploymentSignerAddress,
+                    useLock: booleanArg(args, "useLock"),
+                })
+            : undefined;
+        const simulation = mode === "simulate" ? await (0, simulation_1.setupSimulationFork)(targetId) : {};
+        if (mode === "simulate") {
+            await (0, simulation_1.assertSimulationSourceInfrastructure)(targetId, target, simulation);
+        }
+        const signer = mode === "verify"
+            ? undefined
+            : mode === "simulate"
+                ? simulationCallerBinding
+                    ? undefined
+                    : await (0, signer_1.impersonateWorkflowSimulationSigner)(simulationSignerAddress)
+                : await (0, signer_1.resolveWorkflowSigner)(mode, {
+                    taskAddress: taskMetadata.deploymentSignerAddress,
+                });
+        const signerAddress = simulationCallerBinding?.defaultAddress
+            ?? (signer ? await signer.getAddress() : undefined);
+        const resolvedTarget = {
+            id: targetId,
+            ...target,
+            ...(signerAddress
+                ? {
+                    signer: signerAddress,
+                    admin: (0, config_1.resolveAdmin)(target, signerAddress),
+                }
+                : {}),
+        };
+        if (lockedExecutionPlan
+            && mode === "execute"
+            && signerAddress
+            && lockedExecutionPlan.operator.toLowerCase() !== signerAddress.toLowerCase()) {
+            throw new Error("Execution plan operator does not match the execution signer");
+        }
+        if (releaseExecution && mode === "simulate") {
+            if (!signerAddress || !resolvedTarget.admin) {
+                throw new Error("Final simulation requires a resolved signer and admin");
+            }
+            const create2Config = resolvedTarget.create2 && typeof resolvedTarget.create2 === "object" && !Array.isArray(resolvedTarget.create2)
+                ? resolvedTarget.create2
+                : {};
+            const uupsConfig = resolvedTarget.uups && typeof resolvedTarget.uups === "object" && !Array.isArray(resolvedTarget.uups)
+                ? resolvedTarget.uups
+                : {};
+            const multicallConfig = resolvedTarget.multicall && typeof resolvedTarget.multicall === "object" && !Array.isArray(resolvedTarget.multicall)
+                ? resolvedTarget.multicall
+                : {};
+            (0, lock_1.writeParameterLock)({
+                taskDir,
+                deploymentId: taskId,
+                executionId,
+                sourceSuperTaskId: releaseExecution.sourceSuperTaskId,
+                mergeCommit: releaseExecution.mergeCommit,
+                selectedExecuteNetworks: [targetId],
+                selectedStepIds: steps.map((step) => step.id),
+                operator: signerAddress,
+                baselineParameters: releaseExecution.baselineParameters,
+                overrides: releaseExecution.overrides,
+                resolvedParameters: releaseExecution.resolvedParameters,
+                releaseFingerprint: releaseExecution.releaseFingerprint,
+                finalSimulation: { status: "pending" },
+                existingDeploymentPolicies: releaseExecution.existingDeploymentPolicies,
+                targetSnapshot: {
+                    network: targetId,
+                    signer: signerAddress,
+                    admin: resolvedTarget.admin,
+                    chainId: targetChainId(targetId),
+                    create2Scheme: (0, release_1.normalizeCreate2Scheme)(create2Config.scheme),
+                    create2Factory: typeof create2Config.factory === "string" ? create2Config.factory : undefined,
+                    create2Caller: typeof create2Config.caller === "string" ? create2Config.caller : undefined,
+                    controlledMulticall: typeof multicallConfig.controlledMulticall === "string"
+                        ? multicallConfig.controlledMulticall
+                        : undefined,
+                    uupsPlaceholderImplementation: typeof uupsConfig.placeholderImplementation === "string"
+                        ? uupsConfig.placeholderImplementation
+                        : undefined,
+                    leadingZeroBytes: typeof create2Config.leadingZeroBytes === "number"
+                        ? create2Config.leadingZeroBytes
+                        : undefined,
+                },
+            });
+        }
+        const context = {
+            root,
+            taskId,
+            executionId,
+            taskDir,
+            targetId,
+            target: resolvedTarget,
+            targetParams: releaseExecution?.resolvedParameters || (0, parameters_1.targetParams)(parameters, targetId),
+            existingDeploymentPolicies: releaseExecution
+                ? releaseExecution.existingDeploymentPolicies
+                : parseExistingDeploymentPolicies(args),
+            releaseArtifactHash: releaseExecution?.releaseFingerprint.artifactHash,
+            parameterLockExecutionId: releaseExecution ? executionId : undefined,
+            parameterLockOperator: releaseExecution?.lockedExecution?.operator,
+            config,
+            mode,
+            simulation,
+            signer,
+            signerAddress,
+            state: new state_1.WorkflowState(),
+            reporter,
+            executionPlanner: (releaseExecution || developmentPlanExecution)
+                && releaseKind
+                && (mode === "simulate" || mode === "execute")
+                ? new executionPlan_1.ReleaseExecutionPlanner({
+                    taskId,
+                    target: targetId,
+                    executionId,
+                    releaseKind,
+                    operator: lockedExecutionPlan?.operator
+                        || releaseExecution?.lockedExecution?.operator
+                        || signerAddress,
+                    expectedPlan: lockedExecutionPlan,
+                    segmentedExecution: mode === "execute"
+                        && lockedExecutionPlan?.releaseKind === "admin_release",
+                    completedTransactions: completedExecutionPrefix,
+                })
+                : undefined,
+            lockedExecutionPlan,
+            externalCalls: [],
+            operatorReceipts: [],
+        };
+        contextForFailure = context;
+        reporter.status("running", { mode, stepCount: steps.length });
+        reporter.event("workflow.started", { mode, network: projectHardhat_1.network.name, target: targetId, steps: steps.map((step) => step.id) });
+        if (mode === "execute" &&
+            (Boolean(releaseExecution)
+                || steps.some((step) => step.kind === "deploy" || step.kind === "upgrade"))) {
+            context.deploymentRecorder = new deploymentRecords_1.DeploymentRecorder({
+                root,
+                taskDir,
+                config,
+                taskId,
+                executionId,
+                network: targetId,
+                awaitRegistryCommit: Boolean(releaseExecution || developmentPlanExecution),
+                resume: completedExecutionPrefix.length > 0,
+            });
+        }
+        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 = configuredCaller
+                ? {
+                    ...context,
+                    signer: await (0, signer_1.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 executionPlan_1.ExecutionSegmentDeferred) {
+                        executionSegmentDeferred = true;
+                        reporter.event("execution.segment.deferred", {
+                            transactionId: error.transactionId,
+                        });
+                        break stepLoop;
+                    }
+                    if (context.mode === "execute"
+                        && error instanceof external_1.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 executionPlan_1.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 plannedBody = context.executionPlanner?.complete({
+            allowPartial: executionSegmentDeferred,
+        });
+        const completedPlan = mode === "simulate" && plannedBody
+            ? (0, executionPlan_1.writeReleaseExecutionPlan)({ root, taskDir, plan: plannedBody })
+            : lockedExecutionPlan;
+        if (mode === "simulate") {
+            await (0, simulation_1.verifySimulationForkSnapshot)(context.simulation);
+        }
+        if (completedPlan && mode === "execute") {
+            (0, operatorExecution_1.writeOperatorExecutionResult)({
+                taskDir,
+                plan: completedPlan,
+                receipts: context.operatorReceipts,
+            });
+        }
+        if (releaseExecution && mode === "simulate") {
+            if (!completedPlan)
+                throw new Error("Final simulation did not produce an execution plan");
+            reporter.result("execution", {
+                kind: "release-final-simulation",
+                status: "succeeded",
+                selectedStepIds: steps.map((step) => step.id),
+                releaseFingerprint: releaseExecution.releaseFingerprint,
+                releaseKind: completedPlan.releaseKind,
+                executionPlanHash: completedPlan.planHash,
+                executionPlanPath: (0, executionPlan_1.releaseExecutionPlanRelativePath)(taskDir, completedPlan),
+            });
+        }
+        let deploymentStatus;
+        if (mode === "execute"
+            && completedPlan
+            && context.externalCalls.length > 0) {
+            const externalPackage = (0, external_1.writeExternalExecutionPackage)({
+                taskDir,
+                plan: completedPlan,
+                handoffBlock: await projectHardhat_1.ethers.provider.getBlockNumber(),
+                calls: context.externalCalls,
+            });
+            const externalSegment = externalPackage.package.segments.at(-1);
+            context.deploymentRecorder?.markWaitingExternal({
+                packagePath: path_1.default.relative(root, externalPackage.filePath).split(path_1.default.sep).join("/"),
+                executionPlanHash: completedPlan.planHash,
+                handoffBlock: externalSegment.handoffBlock,
+                transactionIds: externalSegment.transactionIds,
+            });
+            deploymentStatus = "waiting_external";
+        }
+        else {
+            deploymentStatus = context.deploymentRecorder?.complete();
+        }
+        const finalStatus = deploymentStatus === "waiting_code_check"
+            ? "waiting_code_check"
+            : deploymentStatus === "waiting_external"
+                ? "waiting_external"
+                : deploymentStatus === "partial"
+                    ? "partial"
+                    : "completed";
+        if (mode !== "simulate") {
+            reporter.status(finalStatus, { mode, stepCount: steps.length });
+        }
+        reporter.report(mode === "simulate" ? "simulation-report.md" : "execution-report.md", [
+            `# Execution Report`,
+            ``,
+            `Task: ${taskId}`,
+            `Target: ${targetId}`,
+            `Network: ${projectHardhat_1.network.name}`,
+            `Mode: ${mode}`,
+            `Status: ${finalStatus}`,
+            ``,
+            `Steps:`,
+            ...steps.map((step) => `- ${step.id} (${step.kind})`),
+        ]);
+        if (mode === "simulate") {
+            if (!signerAddress) {
+                throw new Error("Simulation completed without a selected signer address");
+            }
+            const simulationCallers = simulationCallerBinding?.resolved.map((entry) => ({
+                stepId: entry.stepId,
+                callerAddress: entry.callerAddress,
+            }));
+            const fork = (0, simulation_1.simulationForkEvidence)(context.simulation);
+            const completionPlan = completedPlan
+                ? { executionPlanHash: completedPlan.planHash }
+                : {};
+            const completionFork = fork ? { fork } : {};
+            reporter.result("execution", simulationCallerBinding
+                ? {
+                    kind: "workflow-simulation-completed",
+                    status: "succeeded",
+                    selectedStepIds: steps.map((step) => step.id),
+                    simulationCallerNetworkHash: simulationCallerBinding.networkHash,
+                    simulationCallers,
+                    ...completionFork,
+                    ...completionPlan,
+                }
+                : {
+                    kind: "workflow-simulation-completed",
+                    status: "succeeded",
+                    selectedStepIds: steps.map((step) => step.id),
+                    signerAddress,
+                    ...completionFork,
+                    ...completionPlan,
+                });
+            const simulationResult = simulationCallerBinding
+                ? reporter.simulationExecutionResultPath({
+                    simulationCallerNetworkHash: simulationCallerBinding.networkHash,
+                    simulationCallers: simulationCallers,
+                })
+                : reporter.simulationExecutionResultPath(signerAddress);
+            if (releaseTargetSimulation) {
+                if (!simulationCallerBinding || !releaseTargetFingerprint) {
+                    throw new Error("Release target simulation evidence binding is missing");
+                }
+                (0, release_1.recordReleaseTargetSimulationSucceeded)({
+                    taskDir,
+                    network: targetId,
+                    executionId,
+                    simulationResult,
+                    simulatedAt: new Date().toISOString(),
+                    simulationCallerNetworkHash: simulationCallerBinding.networkHash,
+                    fingerprint: releaseTargetFingerprint,
+                });
+            }
+            reporter.status(finalStatus, {
+                mode,
+                stepCount: steps.length,
+                simulationResult,
+            });
+            if (releaseExecution) {
+                if (!completedPlan)
+                    throw new Error("Final simulation execution plan is missing");
+                (0, lock_1.markParameterLockSimulationSucceeded)(taskDir, executionId, simulationResult, new Date().toISOString(), signerAddress, completedPlan.planHash, (0, executionPlan_1.releaseExecutionPlanRelativePath)(taskDir, completedPlan));
+            }
+        }
+    }
+    catch (error) {
+        if (contextForFailure?.deploymentRecorder) {
+            try {
+                contextForFailure.deploymentRecorder.markPartial(error);
+            }
+            catch (recordError) {
+                reporter.event("deployment.record.failed", {
+                    message: recordError instanceof Error ? recordError.message : String(recordError),
+                });
+            }
+        }
+        if (mode === "simulate") {
+            try {
+                reporter.clearSimulationCompletionEvidence();
+            }
+            catch {
+                // Preserve the original workflow failure if evidence cleanup also fails.
+            }
+        }
+        const classification = (0, errors_1.classifyWorkflowError)(error);
+        reporter.status("failed", {
+            mode,
+            errorType: classification.errorType,
+            retryable: classification.retryable,
+            message: error instanceof Error ? error.message : String(error),
+        });
+        reporter.event("workflow.failed", {
+            mode,
+            errorType: classification.errorType,
+            retryable: classification.retryable,
+            message: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=run.js.map