fix(test-suite): restore simple acl workflow compat

Author: Eikix

test-suite/fhevm/src/artifacts.test.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 
 import { describe, expect, test } from "bun:test";
 
-import { composeUp, resolvedComposeEnv, serviceNameList } from "./artifacts";
+import { composeUp, resolvedComposeEnv, rewriteRelayerConfig, serviceNameList } from "./artifacts";
 import { composePath, TEMPLATE_COMPOSE_DIR } from "./layout";
 import { stubState } from "./test-helpers";
 
@@ -125,4 +125,25 @@ describe("compose templates", () => {
       ],
     ]);
   });
+
+  test("legacy relayer config keeps top-level readiness retry", () => {
+    const config = rewriteRelayerConfig(
+      {
+        gateway: {
+          readiness_checker: {
+            host_acl_check: { retry: { max_attempts: 3, retry_interval_ms: 1000 } },
+            gw_ciphertext_check: { retry: { max_attempts: 15, retry_interval_ms: 2000 } },
+            public_decrypt: { capacity: 1 },
+            user_decrypt: { capacity: 1 },
+          },
+        },
+      },
+      stubState(),
+    ) as { gateway: { readiness_checker: Record<string, unknown> } };
+    expect(config.gateway.readiness_checker.retry).toEqual({
+      max_attempts: 15,
+      retry_interval_ms: 2000,
+    });
+    expect(config.gateway.readiness_checker.host_acl_check).toBeUndefined();
+  });
 });

test-suite/fhevm/src/artifacts.ts

@@ -5,6 +5,7 @@ import YAML from "yaml";
 
 import {
   compatPolicyForState,
+  requiresLegacyRelayerReadinessConfig,
   requiresMultichainAclAddress,
   type CompatPolicy,
 } from "./compat";
@@ -30,7 +31,6 @@ import {
 import type { BuiltImage, InstanceOverride, OverrideGroup, State } from "./types";
 import type { RunOptions, Runner } from "./utils";
 import {
-  copyFile,
   ensureDir,
   exists,
   mergeArgs,
@@ -351,6 +351,33 @@ const deriveWallet = async (runner: Runner, mnemonic: string, index: number) =>
   return { address, privateKey };
 };
 
+export const rewriteRelayerConfig = (config: Record<string, unknown>, state: Pick<State, "versions">) => {
+  if (!requiresLegacyRelayerReadinessConfig(state)) {
+    return config;
+  }
+  const gateway = config.gateway;
+  if (!gateway || typeof gateway !== "object") {
+    return config;
+  }
+  const readiness = (gateway as Record<string, unknown>).readiness_checker;
+  if (!readiness || typeof readiness !== "object") {
+    return config;
+  }
+  const current = readiness as Record<string, unknown>;
+  (gateway as Record<string, unknown>).readiness_checker = Object.fromEntries(
+    Object.entries({
+      retry:
+        current.retry ??
+        (current.gw_ciphertext_check as Record<string, unknown> | undefined)?.retry ??
+        (current.host_acl_check as Record<string, unknown> | undefined)?.retry,
+      public_decrypt: current.public_decrypt,
+      user_decrypt: current.user_decrypt,
+      delegated_user_decrypt: current.delegated_user_decrypt,
+    }).filter(([, value]) => value !== undefined),
+  );
+  return config;
+};
+
 const writeRuntimeEnvFiles = async (state: State, deps: Pick<ArtifactDeps, "runner">) => {
   await ensureDir(ENV_DIR);
   const compat = compatPolicyForState(state);
@@ -467,7 +494,11 @@ const writeRuntimeEnvFiles = async (state: State, deps: Pick<ArtifactDeps, "runn
     versionsEnvPath,
     state.versions.env,
   );
-  await copyFile(TEMPLATE_RELAYER_CONFIG, relayerConfigPath);
+  const relayerConfig = rewriteRelayerConfig(
+    YAML.parse(await fs.readFile(TEMPLATE_RELAYER_CONFIG, "utf8")) as Record<string, unknown>,
+    state,
+  );
+  await fs.writeFile(relayerConfigPath, YAML.stringify(relayerConfig));
 };
 
 const imageRefsForServices = async (component: string, services: string[]) => {

test-suite/fhevm/src/cli.test.ts

@@ -12,7 +12,7 @@ import {
 } from "./artifacts";
 import { REPO_ROOT, STATE_DIR, TEST_GREP, composePath, resolveServiceOverrides } from "./layout";
 import { main, overrideWarnings, probeBootstrap, resolveUpgradePlan } from "./runtime";
-import { compatPolicyForState } from "./compat";
+import { compatPolicyForState, requiresMultichainAclAddress } from "./compat";
 import { predictedCrsId, predictedKeyId } from "./utils";
 import { applyVersionEnvOverrides, createGitHubClient, resolveTarget } from "./versions";
 import {
@@ -359,6 +359,20 @@ describe("runtime invariants", () => {
     ]);
   });
 
+  test("full modern workspace protocol overrides disable multichain acl discovery requirements", () => {
+    expect(
+      requiresMultichainAclAddress(
+        stubState({
+          overrides: [
+            { group: "coprocessor" },
+            { group: "gateway-contracts" },
+            { group: "host-contracts" },
+          ],
+        }),
+      ),
+    ).toBe(false);
+  });
+
   test("probeBootstrap treats transient material fetch failures as retryable", async () => {
     const state = stubState({
       discovery: {

test-suite/fhevm/src/compat.ts

@@ -73,8 +73,16 @@ const versionLt = (version: string, target: CompatSemver) => {
   return false;
 };
 
-export const requiresMultichainAclAddress = (state: Pick<State, "versions">) =>
-  versionLt(state.versions.env.COPROCESSOR_TX_SENDER_VERSION ?? "", [0, 12, 0]);
+const usesModernWorkspaceProtocol = (state: Pick<State, "overrides">) =>
+  ["coprocessor", "gateway-contracts", "host-contracts"].every((group) =>
+    state.overrides.some((override) => override.group === group),
+  );
+
+export const requiresMultichainAclAddress = (state: Pick<State, "versions" | "overrides">) =>
+  !usesModernWorkspaceProtocol(state) && versionLt(state.versions.env.COPROCESSOR_TX_SENDER_VERSION ?? "", [0, 12, 0]);
+
+export const requiresLegacyRelayerReadinessConfig = (state: Pick<State, "versions">) =>
+  versionLt(state.versions.env.RELAYER_VERSION ?? "", [0, 10, 0]);
 
 export const compatPolicyForState = (state: State): CompatPolicy => {
   const policy: CompatPolicy = { coprocessorArgs: {}, connectorEnv: {} };

test-suite/fhevm/src/runtime.ts

@@ -508,7 +508,7 @@ const discoverContracts = async (deps: RuntimeDeps): Promise<Pick<Discovery, "ga
   };
 };
 
-const validateDiscovery = (state: Pick<State, "target" | "versions" | "discovery">) => {
+const validateDiscovery = (state: Pick<State, "target" | "versions" | "discovery" | "overrides">) => {
   const discovery = state.discovery;
   if (!discovery) {
     throw new Error("Missing discovery state");