fix bun cli cleanup and relayer readiness fallback

Author: Eikix

test-suite/fhevm/scripts/bun/command-clean.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import type { CommandDeps } from "./command-contracts";
 import type { CleanOptions } from "./types";
 
@@ -182,6 +183,7 @@ function cleanupAllFhevmProjects(
 export function createCleanHandlers(deps: CommandDeps) {
   const {
     PROJECT,
+    COMPOSE_DIR,
     COLORS,
     runCommand,
     usageError,
@@ -191,13 +193,22 @@ export function createCleanHandlers(deps: CommandDeps) {
     purgeLocalBuildxCache,
   } = deps;
 
+  function cleanupTracingStack(): void {
+    const tracingCompose = path.resolve(COMPOSE_DIR, "tracing-docker-compose.yml");
+    runCommand(["docker", "compose", "-p", PROJECT, "-f", tracingCompose, "down", "-v"], {
+      check: false,
+      allowFailure: true,
+    });
+  }
+
   function clean(args: string[]): void {
     const options = parseCleanArgs(args, usageError);
     console.log(`${COLORS.lightBlue}[CLEAN]${COLORS.reset} ${COLORS.bold}Cleaning up FHEVM stack...${COLORS.reset}`);
     if (options.allFhevmProjects) {
       cleanupAllFhevmProjects(runCommand, logInfo, true);
     } else {
       cleanupKnownStack(true);
+      cleanupTracingStack();
     }
 
     if (options.purgeNetworks) {

test-suite/fhevm/scripts/bun/command-test.ts

@@ -7,6 +7,15 @@ type RelayerKeyUrls = {
   crsUrl: string;
 };
 
+function replaceRelayerHostWithIp(url: string, relayerHost: string): string {
+  return url.replace(/^https?:\/\/fhevm-relayer(?=[:/]|$)/, (prefix) => {
+    if (prefix.startsWith("https://")) {
+      return `https://${relayerHost}`;
+    }
+    return `http://${relayerHost}`;
+  });
+}
+
 function parseRelayerKeyUrls(payloadRaw: string): RelayerKeyUrls | undefined {
   const payload = payloadRaw.trim();
   if (!payload) {
@@ -157,20 +166,69 @@ export function createTestHandlers(deps: CommandDeps) {
       } else if (!testSuiteContainer || !isContainerRunningExact("fhevm-test-suite-e2e-debug")) {
         lastMessage = "fhevm-test-suite-e2e-debug container is not running";
       } else {
-        const keyurlResult = runCommand(
-          ["docker", "exec", testSuiteContainer, "curl", "-fsS", "http://fhevm-relayer:3000/v2/keyurl"],
+        const relayerIpInspect = runCommand(
+          ["docker", "inspect", "-f", "{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}", relayerContainer],
           { capture: true, check: false, allowFailure: true },
         );
+        const relayerIp = relayerIpInspect.status === 0 ? relayerIpInspect.stdout.trim() : "";
+        const relayerHosts = ["fhevm-relayer"];
+        if (relayerIp) {
+          relayerHosts.push(relayerIp);
+        }
 
-        if (keyurlResult.status !== 0) {
-          const details = [keyurlResult.stdout.trim(), keyurlResult.stderr.trim()].filter(Boolean).join(" ");
+        let keyurlResult:
+          | {
+              stdout: string;
+              stderr: string;
+              status: number;
+            }
+          | undefined;
+        let resolvedRelayerHost = relayerHosts[0];
+
+        for (const relayerHost of relayerHosts) {
+          const result = runCommand(
+            ["docker", "exec", testSuiteContainer, "curl", "-fsS", `http://${relayerHost}:3000/v2/keyurl`],
+            { capture: true, check: false, allowFailure: true },
+          );
+          if (result.status === 0) {
+            keyurlResult = result;
+            resolvedRelayerHost = relayerHost;
+            break;
+          }
+          keyurlResult = result;
+        }
+
+        if (!keyurlResult || keyurlResult.status !== 0) {
+          const details = keyurlResult
+            ? [keyurlResult.stdout.trim(), keyurlResult.stderr.trim()].filter(Boolean).join(" ")
+            : "failed to query relayer keyurl endpoint";
           lastMessage = details || "failed to query relayer keyurl endpoint";
         } else {
           const urls = parseRelayerKeyUrls(keyurlResult.stdout);
           if (!urls) {
             lastMessage = "relayer keyurl payload is missing required public key / CRS URLs";
           } else {
             const unreachable = [urls.publicKeyUrl, urls.crsUrl].filter((url) => {
+              const urlCandidates = [url];
+              if (resolvedRelayerHost !== "fhevm-relayer") {
+                const rewritten = replaceRelayerHostWithIp(url, resolvedRelayerHost);
+                if (rewritten !== url) {
+                  urlCandidates.push(rewritten);
+                }
+              }
+
+              const reachable = urlCandidates.some((candidateUrl) => {
+                const probe = runCommand(
+                  ["docker", "exec", testSuiteContainer, "curl", "-fsS", "--max-time", "5", "-o", "/dev/null", candidateUrl],
+                  { capture: true, check: false, allowFailure: true },
+                );
+                return probe.status === 0;
+              });
+
+              if (reachable) {
+                return false;
+              }
+
               const probe = runCommand(
                 ["docker", "exec", testSuiteContainer, "curl", "-fsS", "--max-time", "5", "-o", "/dev/null", url],
                 { capture: true, check: false, allowFailure: true },

test-suite/fhevm/scripts/tests/deploy-fhevm-stack.behavior.sh

@@ -105,13 +105,25 @@ case "${subcommand}" in
     shift || true
 
     if [[ "${1:-}" == "curl" ]]; then
+      if [[ "$*" == *"http://fhevm-relayer:3000/v2/keyurl"* && "${DOCKER_RELAYER_KEYURL_FAIL_HOSTNAME:-false}" == "true" ]]; then
+        echo "curl: (6) Could not resolve host: fhevm-relayer" >&2
+        exit 6
+      fi
+
       if [[ "$*" == *"http://fhevm-relayer:3000/v2/keyurl"* ]]; then
         cat <<'JSON'
 {"response":{"fheKeyInfo":[{"fhePublicKey":{"urls":["http://mock-fhevm/key"]}}],"crs":{"2048":{"urls":["http://mock-fhevm/crs"]}}}}
 JSON
         exit 0
       fi
 
+      if [[ -n "${DOCKER_RELAYER_IP:-}" && "$*" == *"http://${DOCKER_RELAYER_IP}:3000/v2/keyurl"* ]]; then
+        cat <<'JSON'
+{"response":{"fheKeyInfo":[{"fhePublicKey":{"urls":["http://mock-fhevm/key"]}}],"crs":{"2048":{"urls":["http://mock-fhevm/crs"]}}}}
+JSON
+        exit 0
+      fi
+
       if [[ "$*" == *"http://mock-fhevm/key"* || "$*" == *"http://mock-fhevm/crs"* ]]; then
         exit 0
       fi
@@ -235,7 +247,11 @@ JSON
       format="${2:-}"
       target="${3:-}"
       if [[ "${format}" == "{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}" ]]; then
-        echo "${DOCKER_MINIO_IP:-172.20.0.2}"
+        if [[ "${target}" == *"relayer"* ]]; then
+          echo "${DOCKER_RELAYER_IP:-172.20.0.9}"
+        else
+          echo "${DOCKER_MINIO_IP:-172.20.0.2}"
+        fi
         exit 0
       fi
     fi
@@ -945,6 +961,27 @@ test_telemetry_smoke_requires_jaeger() {
   cleanup_fixture
 }
 
+test_test_command_falls_back_to_relayer_ip_when_dns_alias_fails() {
+  setup_fixture
+
+  local output_file="${TEST_TMP_DIR}/test-relayer-ip-fallback.out"
+  export DOCKER_RELAYER_KEYURL_FAIL_HOSTNAME="true"
+  export DOCKER_RELAYER_IP="172.22.0.15"
+
+  if ! run_cli "${output_file}" test input-proof --no-hardhat-compile; then
+    echo "Test command should fall back to relayer container IP when hostname lookup fails" >&2
+    cat "${output_file}" >&2
+    return 1
+  fi
+
+  assert_contains "${COMMAND_LOG}" "http://fhevm-relayer:3000/v2/keyurl"
+  assert_contains "${COMMAND_LOG}" "http://172.22.0.15:3000/v2/keyurl"
+
+  unset DOCKER_RELAYER_KEYURL_FAIL_HOSTNAME
+  unset DOCKER_RELAYER_IP
+  cleanup_fixture
+}
+
 test_command_and_flag_matrix() {
   setup_fixture
 
@@ -1025,6 +1062,7 @@ main() {
   test_multicoprocessor_resume_forces_minio_reset
   test_clean_purge_invokes_prunes
   test_telemetry_smoke_requires_jaeger
+  test_test_command_falls_back_to_relayer_ip_when_dns_alias_fails
   test_command_and_flag_matrix
   test_usage_is_shown_for_cli_argument_errors