gate-evm-tools 1.0.28 → 1.2.0

package/runtime/workflow/lib/create2.ts

@@ -1,15 +1,14 @@
+import { resolveWorkflowValue, type Create2FieldKind } from './validation';
 import type { Signer } from "ethers";
-import { getAddress, Interface, isAddress } from "ethers";
-import { resolveValue, WorkflowStep } from "./parameters";
-import type { WorkflowContext } from "../run";
-
-const CONTROLLED_MULTICALL_INTERFACE = new Interface([
-  "function aggregate3(tuple(address target,bool allowFailure,bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)",
-  "function aggregate3Value(tuple(address target,bool allowFailure,uint256 value,bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)",
-]);
-
-export type Create2Scheme = "evm" | "zksync-eravm";
-
+import { getAddress, isAddress } from "ethers";
+import { WorkflowStep } from "./parameters";
+import type { WorkflowContext } from "./context";
+
+import { prepareControlledMulticallTransaction } from 'gate-evm-tools/workflow';
+import type { PreparedWorkflowTransaction, PreparedControlledMulticallTransaction } from 'gate-evm-tools/workflow';
+export { prepareControlledMulticallTransaction } from 'gate-evm-tools/workflow';
+export type { PreparedWorkflowTransaction, PreparedControlledMulticallTransaction, ControlledMulticallInnerCall } from 'gate-evm-tools/workflow';
+export type Create2Scheme = 'evm' | 'zksync-eravm';
 export interface Create2Options {
   scheme: Create2Scheme;
   factory: string;
@@ -22,106 +21,7 @@ export interface Create2Options {
   uupsPlaceholderImplementation?: string;
 }
 
-export interface PreparedWorkflowTransaction {
-  target: string;
-  value: string;
-  data: string;
-  operation: 0;
-  scheme?: "zksync-eravm";
-  factoryDeps?: string[];
-}
-
-export interface ControlledMulticallInnerCall {
-  target: string;
-  value: string;
-  data: string;
-  factoryDeps?: string[];
-}
-
-export interface PreparedControlledMulticallTransaction
-  extends PreparedWorkflowTransaction {
-  method: "aggregate3" | "aggregate3Value";
-  calls: Array<{
-    target: string;
-    allowFailure: false;
-    value: string;
-    callData: string;
-  }>;
-}
-
-interface SentTransaction {
-  hash: string;
-  wait: () => Promise<unknown>;
-}
-
-const bigintValue = (value: string | undefined): bigint => {
-  if (!value || value === "0") return 0n;
-  const parsed = BigInt(value);
-  if (parsed < 0n) throw new Error("transaction value must be nonnegative");
-  return parsed;
-};
-
-const normalizeFactoryDeps = (
-  input: string[],
-  label: string,
-): string[] => {
-  const seen = new Set<string>();
-  const output: string[] = [];
-  for (const [index, dependency] of input.entries()) {
-    if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(dependency)) {
-      throw new Error(`${label}[${index}] must be non-empty byte-aligned bytecode`);
-    }
-    const normalized = dependency.toLowerCase();
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    output.push(normalized);
-  }
-  return output;
-};
-
-export const prepareControlledMulticallTransaction = (
-  controlledMulticall: string,
-  inputCalls: ControlledMulticallInnerCall[],
-  scheme: Create2Scheme = "evm",
-): PreparedControlledMulticallTransaction => {
-  if (!isAddress(controlledMulticall)) {
-    throw new Error("controlledMulticall must be an EVM address");
-  }
-  if (inputCalls.length === 0) {
-    throw new Error("controlled multicall requires at least one inner call");
-  }
-  if (scheme === "evm" && inputCalls.some((call) => call.factoryDeps !== undefined)) {
-    throw new Error("factoryDeps are only supported for zkSync transactions");
-  }
-  if (scheme === "zksync-eravm" && inputCalls.some((call) => call.factoryDeps === undefined)) {
-    throw new Error("every zkSync GateTool call must include factoryDeps");
-  }
-  const calls = inputCalls.map((call) => ({
-    target: getAddress(call.target),
-    allowFailure: false as const,
-    value: bigintValue(call.value).toString(10),
-    callData: call.data,
-  }));
-  const totalValue = calls.reduce((sum, call) => sum + BigInt(call.value), 0n);
-  const method = totalValue === 0n ? "aggregate3" as const : "aggregate3Value" as const;
-  const encodedCalls = method === "aggregate3"
-    ? calls.map(({ value: _value, ...call }) => call)
-    : calls;
-  const factoryDeps = scheme === "zksync-eravm"
-    ? normalizeFactoryDeps(inputCalls.flatMap((call) => call.factoryDeps!), "factoryDeps")
-    : undefined;
-  return {
-    target: getAddress(controlledMulticall),
-    value: totalValue.toString(10),
-    data: CONTROLLED_MULTICALL_INTERFACE.encodeFunctionData(method, [encodedCalls]),
-    operation: 0,
-    method,
-    calls,
-    ...(scheme === "zksync-eravm"
-      ? { scheme: "zksync-eravm" as const, factoryDeps: factoryDeps! }
-      : {}),
-  };
-};
+interface SentTransaction { hash:string; wait:()=>Promise<unknown>; }
 
 export const sendPreparedWorkflowTransaction = async (
   prepared: PreparedWorkflowTransaction,
@@ -163,13 +63,10 @@ export const sendPreparedControlledMulticallTransaction = async (
 const resolveObject = (
   context: WorkflowContext,
   value: unknown,
+  kind: Create2FieldKind,
 ): Record<string, unknown> => {
-  const resolved = resolveValue(value || {}, {
-    targetId: context.targetId,
-    target: context.target,
-    params: context.targetParams,
-    state: context.state,
-  });
+  const resolved = resolveWorkflowValue(context, value === undefined ? {} : value);
+  if (context.validation) return context.validation.create2Fields(resolved, kind);
   if (!resolved || typeof resolved !== "object" || Array.isArray(resolved)) return {};
   return resolved as Record<string, unknown>;
 };
@@ -205,10 +102,10 @@ export const resolveCreate2Options = (
   step: WorkflowStep,
 ): Create2Options | undefined => {
   const strategy = typeof step.strategy === "string" ? step.strategy : undefined;
-  const stepCreate2 = resolveObject(context, step.create2);
-  const targetCreate2 = resolveObject(context, context.target.create2);
-  const targetUups = resolveObject(context, context.target.uups);
-  const targetMulticall = resolveObject(context, context.target.multicall);
+  const stepCreate2 = resolveObject(context, step.create2, "step");
+  const targetCreate2 = resolveObject(context, context.target.create2, "target");
+  const targetUups = resolveObject(context, context.target.uups, "uups");
+  const targetMulticall = resolveObject(context, context.target.multicall, "multicall");
   if (strategy !== "create2" && Object.keys(stepCreate2).length === 0) return undefined;
 
   const rawScheme = stringField(targetCreate2, "scheme") || "evm";

package/runtime/workflow/lib/deploymentInfo.ts

@@ -11,6 +11,8 @@ export interface DeploymentInfoEntry {
   actualContract: string;
   proxyKind?: "uups" | "transparent";
   implementationAddress?: string;
+  proxyAdminAddress?: string;
+  proxyAdminOwner?: string;
   source: DeploymentInfoSource;
   updatedAt: string;
 }
@@ -114,6 +116,8 @@ const validateEntry = (value: unknown, label: string): DeploymentInfoEntry => {
     "actualContract",
     "proxyKind",
     "implementationAddress",
+    "proxyAdminAddress",
+    "proxyAdminOwner",
     "source",
     "updatedAt",
   ]);
@@ -140,6 +144,8 @@ const validateEntry = (value: unknown, label: string): DeploymentInfoEntry => {
     ...(value.implementationAddress
       ? { implementationAddress: address(value.implementationAddress, `${label}.implementationAddress`) }
       : {}),
+    ...(value.proxyAdminAddress?{proxyAdminAddress:address(value.proxyAdminAddress,`${label}.proxyAdminAddress`)}:{}),
+    ...(value.proxyAdminOwner?{proxyAdminOwner:address(value.proxyAdminOwner,`${label}.proxyAdminOwner`)}:{}),
     source: validateSource(value.source, `${label}.source`),
     updatedAt: value.updatedAt,
   };
@@ -243,6 +249,7 @@ export function prepareDeploymentInfoFromRecords(input: {
         actualContract,
         ...(proxyKind ? { proxyKind } : {}),
         ...(implementationAddress ? { implementationAddress } : {}),
+        ...(proxyKind === "transparent" ? {proxyAdminAddress:optionalAddress(rawChange.proxyAdminAddress??existing?.proxyAdminAddress,"ProxyAdmin address"),proxyAdminOwner:optionalAddress(rawChange.proxyAdminOwner??existing?.proxyAdminOwner,"ProxyAdmin owner")}:{}),
         source: {
           kind: "deployment" as const,
           deploymentId,
@@ -259,6 +266,7 @@ export function prepareDeploymentInfoFromRecords(input: {
             ...(existing.implementationAddress
               ? { implementationAddress: existing.implementationAddress }
               : {}),
+            ...(existing.proxyKind === "transparent" ? {proxyAdminAddress:existing.proxyAdminAddress,proxyAdminOwner:existing.proxyAdminOwner}:{}),
             source: existing.source,
           }
         : undefined;

package/runtime/workflow/lib/deploymentRecords.ts

@@ -63,6 +63,8 @@ export interface DeploymentChange {
   proxyKind?: string;
   address?: string;
   proxyAddress?: string;
+  proxyAdminAddress?: string;
+  proxyAdminOwner?: string;
   implementationAddress?: string;
   preparedImplementationAddress?: string;
   placeholderImplementationAddress?: string;
@@ -272,7 +274,7 @@ export class DeploymentRecorder {
       throw new Error("Deployment proxy transactionId is invalid");
     }
     const change = this.record.changes.find((entry) => entry.stepId === stepId);
-    if (!change || change.proxyKind !== "uups") {
+    if (!change || (change.proxyKind !== "uups" && change.proxyKind !== "transparent")) {
       throw new Error(`Cannot bind a proxy transaction for deployment change ${stepId}`);
     }
     if (

package/runtime/workflow/lib/deployments.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { isAddress } from "ethers";
-import type { WorkflowConfig } from "./config";
+import type { WorkflowConfiguration } from "./context";
 import { readJsonFile, writeJsonFile } from "./config";
 
 export type ContractInfo = Record<string, Record<string, string>>;
@@ -177,16 +177,8 @@ export const actualContractName = (contractName: string): string => {
   return actual;
 };
 
-export const deploymentInstanceId = (instanceId: string): string => {
-  const normalizedInstanceId = instanceId.trim();
-  if (!normalizedInstanceId) {
-    throw new Error("Deployment saveAs must not be empty");
-  }
-  if (normalizedInstanceId.includes(":")) {
-    throw new Error(`Deployment saveAs "${normalizedInstanceId}" must not contain ":"`);
-  }
-  return normalizedInstanceId;
-};
+export { deploymentInstanceId } from "./operationNames";
+import { deploymentInstanceId } from "./operationNames";
 
 export const contractInfoKey = (instanceId: string, contractName: string): string => {
   const normalizedInstanceId = deploymentInstanceId(instanceId);
@@ -196,7 +188,7 @@ export const contractInfoKey = (instanceId: string, contractName: string): strin
     : `${normalizedInstanceId}:${actual}`;
 };
 
-export const loadContractInfo = (root: string, _config: WorkflowConfig): ContractInfo => {
+export const loadContractInfo = (root: string, _config: WorkflowConfiguration): ContractInfo => {
   const filePath = contractInfoPath(root);
   if (!fs.existsSync(filePath)) return {};
   return validateContractInfo(readJsonFile<unknown>(filePath));
@@ -255,7 +247,7 @@ export const resolveDeployment = (
 
 export const findDeploymentAddress = (
   root: string,
-  config: WorkflowConfig,
+  config: WorkflowConfiguration,
   targetId: string,
   name: string,
 ): string | undefined => {
@@ -264,7 +256,7 @@ export const findDeploymentAddress = (
 
 export const getDeploymentAddress = (
   root: string,
-  config: WorkflowConfig,
+  config: WorkflowConfiguration,
   targetId: string,
   name: string,
 ): string => {

package/runtime/workflow/lib/evidencePorts.ts

@@ -0,0 +1,20 @@
+import type { GateToolPreparationRequestV1 } from 'gate-evm-tools/workflow';
+import type { DeploymentChange } from './deploymentRecords';
+import type { PreparedGateToolWorkflow } from './gateTool';
+export interface PreparationMapping { transactionId: string; gateToolTransactionIds: string[]; kind: 'multicall' | 'direct' }
+export interface PreparationInput { stepId: string; change: DeploymentChange; prepared: PreparedGateToolWorkflow; derivedKeys: string[] }
+export interface PreparationSink {
+  expected(stepId: string, request: GateToolPreparationRequestV1): PreparedGateToolWorkflow | undefined;
+  prepare(input: PreparationInput): void;
+  bind(stepId: string, mapping: PreparationMapping): void;
+  /** No same-fork upgrade until a complete validated OZ baseline is available. */
+  assertUpgradeBaseline(proxy: string): boolean | void;
+}
+export type TypedValue = { type: 'null'; value: null } | { type: 'string' | 'bigint' | 'number' | 'boolean'; value: string | boolean } | { type: 'array'; value: TypedValue[] } | { type: 'object'; value: Record<string, TypedValue> };
+export interface VerificationObservation {
+  stepId: string; callIndex: number; assertionId: string; contract: string; abiName: string;
+  abi: string[]; address: string; method: string; args: TypedValue;
+  definition: { method: string; args: TypedValue; expect: TypedValue };
+  actual: TypedValue; expected: TypedValue;
+}
+export interface VerificationSink { record(input: VerificationObservation): void }

package/runtime/workflow/lib/executionPlan.ts

@@ -1,24 +1,12 @@
+import { TransactionPlanner, normalizeTransaction } from "./transactionPlanner";
+import type { ReleaseExecutionTransaction, ReleaseExecutionTransactionInput, PlannedExecutionTransaction, CompletedExecutionTransaction } from "./transactionPlanner";
+export { ExecutionSegmentDeferred } from "./transactionPlanner";
+export type { ExecutionRoute, ReleaseExecutionTransaction, ReleaseExecutionTransactionInput, PlannedExecutionTransaction, CompletedExecutionTransaction } from "./transactionPlanner";
 import crypto from "crypto";
 import fs from "fs";
 import path from "path";
 
 export type ReleaseKind = "development" | "admin_release";
-export type ExecutionRoute = "operator" | "external";
-
-export interface ReleaseExecutionTransaction {
-  transactionId: string;
-  stepId: string;
-  transactionIndex: number;
-  route: ExecutionRoute;
-  executor: string;
-  to: string;
-  value: string;
-  data: string;
-  operation: 0 | 1;
-  scheme?: "zksync-eravm";
-  factoryDeps?: string[];
-}
-
 export interface ReleaseExecutionPlan {
   version: 1;
   taskId: string;
@@ -33,34 +21,6 @@ export interface ReleaseExecutionPlan {
 
 type PlanBody = Omit<ReleaseExecutionPlan, "planHash" | "createdAt">;
 
-export interface ReleaseExecutionTransactionInput {
-  stepId: string;
-  executor: string;
-  to: string;
-  value: string;
-  data: string;
-  operation: 0 | 1;
-  scheme?: "zksync-eravm";
-  factoryDeps?: string[];
-}
-
-export interface CompletedExecutionTransaction {
-  transactionId: string;
-  transactionHash: string;
-}
-
-export interface PlannedExecutionTransaction extends ReleaseExecutionTransaction {
-  executionAction: "execute" | "package" | "replay";
-  transactionHash?: string;
-}
-
-export class ExecutionSegmentDeferred extends Error {
-  constructor(readonly transactionId: string) {
-    super(`Execution is waiting for the preceding external segment before ${transactionId}`);
-    this.name = "ExecutionSegmentDeferred";
-  }
-}
-
 const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/;
 const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
 const DATA = /^0x(?:[0-9a-fA-F]{2})*$/;
@@ -83,40 +43,6 @@ const address = (value: unknown, label: string): string => {
   return value.toLowerCase();
 };
 
-const value = (raw: unknown, label: string): string => {
-  if (typeof raw !== "string" || !/^(?:0[xX][0-9a-fA-F]+|[0-9]+)$/.test(raw)) {
-    throw new Error(`${label} must be a nonnegative integer string`);
-  }
-  return BigInt(raw).toString(10);
-};
-
-const data = (raw: unknown, label: string): string => {
-  if (typeof raw !== "string" || !DATA.test(raw)) {
-    throw new Error(`${label} must be canonical byte calldata`);
-  }
-  return raw.toLowerCase();
-};
-
-const factoryDeps = (raw: unknown, label: string): string[] => {
-  if (!Array.isArray(raw)) throw new Error(`${label} must be an array`);
-  const seen = new Set<string>();
-  const normalized: string[] = [];
-  for (const [index, dependency] of raw.entries()) {
-    if (typeof dependency !== "string" || !/^0x(?:[0-9a-fA-F]{2})+$/.test(dependency)) {
-      throw new Error(`${label}[${index}] must be non-empty byte-aligned bytecode`);
-    }
-    const value = dependency.toLowerCase();
-    const hash = crypto
-      .createHash("sha256")
-      .update(Buffer.from(value.slice(2), "hex"))
-      .digest("hex");
-    if (seen.has(hash)) continue;
-    seen.add(hash);
-    normalized.push(value);
-  }
-  return normalized;
-};
-
 const exactKeys = (value: Record<string, unknown>, expected: string[], label: string): void => {
   const actual = Object.keys(value).sort();
   const wanted = [...expected].sort();
@@ -132,62 +58,6 @@ const record = (raw: unknown, label: string): Record<string, unknown> => {
   return raw as Record<string, unknown>;
 };
 
-const normalizeTransaction = (
-  raw: unknown,
-  index: number,
-  strict: boolean,
-): ReleaseExecutionTransaction => {
-  const input = record(raw, `transactions[${index}]`);
-  const isZkSync = input.scheme === "zksync-eravm";
-  if (input.scheme !== undefined && !isZkSync) {
-    throw new Error(`transactions[${index}].scheme must be zksync-eravm when present`);
-  }
-  if (isZkSync && input.factoryDeps === undefined) {
-    throw new Error(`transactions[${index}].factoryDeps is required for zkSync`);
-  }
-  if (!isZkSync && input.factoryDeps !== undefined) {
-    throw new Error(`transactions[${index}].factoryDeps is only supported for zkSync`);
-  }
-  if (strict) {
-    exactKeys(input, [
-      "transactionId",
-      "stepId",
-      "transactionIndex",
-      "route",
-      "executor",
-      "to",
-      "value",
-      "data",
-      "operation",
-      ...(isZkSync ? ["scheme", "factoryDeps"] : []),
-    ], `transactions[${index}]`);
-  }
-  if (input.transactionIndex !== index) {
-    throw new Error(`transactions[${index}].transactionIndex must equal ${index}`);
-  }
-  if (input.route !== "operator" && input.route !== "external") {
-    throw new Error(`transactions[${index}].route is invalid`);
-  }
-  if (input.operation !== 0 && input.operation !== 1) {
-    throw new Error(`transactions[${index}].operation must be 0 or 1`);
-  }
-  return {
-    transactionId: safeId(input.transactionId, `transactions[${index}].transactionId`),
-    stepId: safeId(input.stepId, `transactions[${index}].stepId`),
-    transactionIndex: index,
-    route: input.route,
-    executor: address(input.executor, `transactions[${index}].executor`),
-    to: address(input.to, `transactions[${index}].to`),
-    value: value(input.value, `transactions[${index}].value`),
-    data: data(input.data, `transactions[${index}].data`),
-    operation: input.operation,
-    ...(isZkSync ? {
-      scheme: "zksync-eravm" as const,
-      factoryDeps: factoryDeps(input.factoryDeps, `transactions[${index}].factoryDeps`),
-    } : {}),
-  };
-};
-
 const normalizeBody = (raw: unknown, strict: boolean): PlanBody => {
   const input = record(raw, "execution plan");
   if (strict) {
@@ -306,148 +176,27 @@ const writeExclusive = (filePath: string, value: unknown): void => {
 
 export class ReleaseExecutionPlanner {
   private readonly body: Omit<PlanBody, "transactions">;
-  private readonly expected?: PlanBody;
-  private readonly transactions: ReleaseExecutionTransaction[] = [];
-  private readonly segmentedExecution: boolean;
-  private readonly completedTransactions: CompletedExecutionTransaction[];
-  private readonly segmentEnd: number;
-
+  private readonly kernel: TransactionPlanner;
   constructor(input: {
-    taskId: string;
-    target: string;
-    executionId: string;
-    releaseKind: ReleaseKind;
-    operator: string;
-    expectedPlan?: ReleaseExecutionPlan;
-    segmentedExecution?: boolean;
+    taskId: string; target: string; executionId: string; releaseKind: ReleaseKind;
+    operator: string; expectedPlan?: ReleaseExecutionPlan; segmentedExecution?: boolean;
     completedTransactions?: CompletedExecutionTransaction[];
   }) {
-    const body = normalizeBody({
-      version: 1,
-      taskId: input.taskId,
-      target: input.target,
-      executionId: input.executionId,
-      releaseKind: input.releaseKind,
-      operator: input.operator,
-      transactions: [],
-    }, false);
-    this.body = {
-      version: 1,
-      taskId: body.taskId,
-      target: body.target,
-      executionId: body.executionId,
-      releaseKind: body.releaseKind,
-      operator: body.operator,
-    };
-    if (input.expectedPlan) {
-      const expected = normalizeBody(input.expectedPlan, false);
+    const { transactions: _, ...body } = normalizeBody({ version: 1, ...input, transactions: [] }, false);
+    this.body = body;
+    const expected = input.expectedPlan ? normalizeBody(input.expectedPlan, false) : undefined;
+    if (expected) {
       for (const key of ["taskId", "target", "executionId", "releaseKind", "operator"] as const) {
-        if (expected[key] !== this.body[key]) {
-          throw new Error(`locked execution plan ${key} does not match the runtime`);
-        }
+        if (expected[key] !== body[key]) throw new Error(`locked execution plan ${key} does not match the runtime`);
       }
-      this.expected = expected;
     }
-    this.segmentedExecution = input.segmentedExecution === true;
-    this.completedTransactions = input.completedTransactions ?? [];
-    if (this.segmentedExecution && !this.expected) {
-      throw new Error("segmented execution requires a locked execution plan");
-    }
-    if (!this.segmentedExecution && this.completedTransactions.length > 0) {
-      throw new Error("completed transactions require segmented execution");
-    }
-    if (this.expected) {
-      if (this.completedTransactions.length > this.expected.transactions.length) {
-        throw new Error("completed transactions exceed the execution plan");
-      }
-      for (const [index, completed] of this.completedTransactions.entries()) {
-        if (
-          completed.transactionId !== this.expected.transactions[index]?.transactionId
-          || typeof completed.transactionHash !== "string"
-          || !/^0x[0-9a-fA-F]{64}$/.test(completed.transactionHash)
-        ) {
-          throw new Error("completed transactions must form a contiguous plan prefix");
-        }
-      }
-    }
-    const expectedTransactions = this.expected?.transactions ?? [];
-    let segmentEnd = this.completedTransactions.length;
-    if (this.segmentedExecution && segmentEnd < expectedTransactions.length) {
-      if (expectedTransactions[segmentEnd].route === "operator") {
-        while (
-          segmentEnd < expectedTransactions.length
-          && expectedTransactions[segmentEnd].route === "operator"
-        ) segmentEnd += 1;
-      }
-      while (
-        segmentEnd < expectedTransactions.length
-        && expectedTransactions[segmentEnd].route === "external"
-      ) segmentEnd += 1;
-    } else if (!this.segmentedExecution) {
-      segmentEnd = Number.MAX_SAFE_INTEGER;
-    }
-    this.segmentEnd = segmentEnd;
+    this.kernel = new TransactionPlanner({ operator: body.operator, allowExternal: body.releaseKind !== "development",
+      expectedTransactions: expected?.transactions, segmentedExecution: input.segmentedExecution,
+      completedTransactions: input.completedTransactions });
   }
-
-  add(input: ReleaseExecutionTransactionInput): PlannedExecutionTransaction {
-    const index = this.transactions.length;
-    const stepId = safeId(input.stepId, "planned transaction stepId");
-    const executor = address(input.executor, "planned transaction executor");
-    const transaction = normalizeTransaction({
-      transactionId: `tx-${String(index + 1).padStart(4, "0")}-${stepId}`,
-      stepId,
-      transactionIndex: index,
-      route: executor === this.body.operator ? "operator" : "external",
-      executor,
-      to: input.to,
-      value: input.value,
-      data: input.data,
-      operation: input.operation,
-      ...(input.scheme === undefined ? {} : { scheme: input.scheme }),
-      ...(input.factoryDeps === undefined ? {} : { factoryDeps: input.factoryDeps }),
-    }, index, false);
-    if (this.body.releaseKind === "development" && transaction.route === "external") {
-      throw new Error("development execution plans cannot contain external transactions");
-    }
-    const expected = this.expected?.transactions[index];
-    if (this.expected && (!expected || JSON.stringify(expected) !== JSON.stringify(transaction))) {
-      throw new Error(
-        `transaction ${transaction.transactionId} does not match locked execution plan`,
-      );
-    }
-    if (this.segmentedExecution && index >= this.segmentEnd) {
-      throw new ExecutionSegmentDeferred(transaction.transactionId);
-    }
-    this.transactions.push(transaction);
-    const completed = this.completedTransactions[index];
-    if (completed) {
-      return {
-        ...transaction,
-        executionAction: "replay",
-        transactionHash: completed.transactionHash.toLowerCase(),
-      };
-    }
-    return {
-      ...transaction,
-      executionAction: transaction.route === "external" ? "package" : "execute",
-    };
-  }
-
+  add(input: ReleaseExecutionTransactionInput): PlannedExecutionTransaction { return this.kernel.add(input); }
   complete(options: { allowPartial?: boolean } = {}): PlanBody {
-    if (
-      this.expected
-      && this.transactions.length !== this.expected.transactions.length
-      && options.allowPartial !== true
-    ) {
-      throw new Error("execution did not consume every locked transaction");
-    }
-    if (options.allowPartial === true && !this.segmentedExecution) {
-      throw new Error("partial execution plan completion requires segmented execution");
-    }
-    return normalizeBody({
-      ...this.body,
-      transactions: this.transactions,
-    }, false);
+    return normalizeBody({ ...this.body, transactions: this.kernel.complete(options) }, false);
   }
 }
 

package/runtime/workflow/lib/externalExecutionScanner.ts

@@ -790,7 +790,7 @@ export const reconcileExternalExecution = async (input: {
       orderedMatches.map((match) => [match.transactionId, match]),
     );
     for (const change of deployment.changes) {
-      if (change.proxyKind !== "uups") continue;
+      if (change.proxyKind !== "uups" && change.proxyKind !== "transparent") continue;
       if (
         !change.proxyAddress
         || !change.implementationAddress
@@ -846,6 +846,7 @@ export const reconcileExternalExecution = async (input: {
         target: input.network,
         manifestDir: target.openzeppelin.manifestDir,
         proxy: change.proxyAddress,
+        ...(change.proxyKind === 'transparent'?{proxyKind:'transparent' as const,proxyAdminAddress:change.proxyAdminAddress,proxyAdminOwner:change.proxyAdminOwner}:{}),
         implementation: change.implementationAddress,
         contract: change.actualContract,
         constructorArgs: change.constructorArgs,