[codex] cover verifier report test gaps

package.json

@@ -4,7 +4,7 @@
   "private": true,
   "packageManager": "pnpm@10.30.0",
   "engines": {
-    "node": ">=20 <26"
+    "node": ">=20 <27"
   },
   "scripts": {
     "sync:abis": "tsx scripts/sync-abis.ts",
@@ -22,15 +22,17 @@
     "coverage:check": "tsx scripts/check-wrapper-coverage.ts && tsx scripts/check-http-api-coverage.ts",
     "codegen": "pnpm run sync:abis && pnpm run sync:method-policy && pnpm run build:manifest && pnpm run sync:event-projections && pnpm run build:typechain && pnpm run build:abi-registry && pnpm run build:rpc-registry && pnpm run seed:api-surface && pnpm run build:http-api && pnpm run build:wrappers && pnpm run coverage:check",
     "build": "pnpm run codegen && pnpm -r build",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage.enabled true --coverage.reporter=text --maxWorkers 1",
+    "test": "vitest run --maxWorkers 1",
+    "test:coverage": "tsx scripts/run-test-coverage.ts",
     "test:contract:api:base-sepolia": "API_LAYER_RUN_CONTRACT_INTEGRATION=1 vitest run packages/api/src/app.contract-integration.test.ts --maxWorkers 1",
     "baseline:show": "tsx scripts/show-validated-baseline.ts",
     "baseline:verify": "tsx scripts/verify-validated-baseline.ts",
     "setup:base-sepolia": "tsx scripts/base-sepolia-operator-setup.ts",
     "test:contract:base-sepolia": "tsx scripts/run-base-sepolia-contract-proof.ts",
+    "test:contract:admin-reads:base-sepolia": "API_LAYER_RUN_CONTRACT_INTEGRATION=1 vitest run packages/api/src/app.contract-integration.test.ts -t \"proves admin, emergency, and multisig control-plane reads through HTTP on Base Sepolia\" --maxWorkers 1",
+    "verify:layer1:live:base-sepolia": "tsx scripts/verify-layer1-live.ts --output verify-live-output.json",
     "verify:marketplace:purchase:base-sepolia": "tsx scripts/verify-marketplace-purchase-live.ts --output verify-marketplace-purchase-output.json",
-    "verify:governance:base-sepolia": "tsx scripts/verify-governance-workflows.ts",
+    "verify:governance:base-sepolia": "tsx scripts/verify-governance-workflows.ts --output verify-governance-output.json",
     "debug:tx": "tsx scripts/debug-tx.ts",
     "debug:simulate": "tsx scripts/debug-simulate.ts",
     "debug:trace": "tsx scripts/debug-trace.ts",
@@ -46,7 +48,9 @@
     "@types/express": "^5.0.3",
     "@types/node": "^24.3.0",
     "@types/pg": "^8.15.5",
+    "@vitest/coverage-istanbul": "3.2.4",
     "@vitest/coverage-v8": "^3.2.4",
+    "c8": "^11.0.0",
     "dotenv": "^16.4.7",
     "ethers": "^6.15.0",
     "tsx": "^4.20.5",

packages/api/src/app.behavior.test.ts

@@ -0,0 +1,257 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { HttpError } from "./shared/errors.js";
+
+const mocks = vi.hoisted(() => {
+  const providerStatus = {
+    primary: "cbdp",
+    secondary: "alchemy",
+    active: "cbdp",
+    failoverActive: false,
+  };
+
+  const createApiExecutionContext = vi.fn(() => ({
+    providerRouter: {
+      getStatus: vi.fn(() => providerStatus),
+    },
+  }));
+
+  return {
+    providerStatus,
+    createApiExecutionContext,
+    getTransactionRequest: vi.fn(),
+    getTransactionStatus: vi.fn(),
+    mountDomainModules: vi.fn(),
+    createWorkflowRouter: vi.fn(() => (_request: unknown, _response: unknown, next: () => void) => next()),
+  };
+});
+
+vi.mock("./modules/index.js", () => ({
+  mountDomainModules: mocks.mountDomainModules,
+}));
+
+vi.mock("./shared/execution-context.js", () => ({
+  createApiExecutionContext: mocks.createApiExecutionContext,
+  getTransactionRequest: mocks.getTransactionRequest,
+  getTransactionStatus: mocks.getTransactionStatus,
+}));
+
+vi.mock("./workflows/index.js", () => ({
+  createWorkflowRouter: mocks.createWorkflowRouter,
+}));
+
+import { createApiServer } from "./app.js";
+
+const originalEnv = { ...process.env };
+
+async function startServer(options: Parameters<typeof createApiServer>[0] = {}) {
+  const server = createApiServer(options).listen();
+  await new Promise<void>((resolve) => {
+    if (server.listening) {
+      resolve();
+      return;
+    }
+    server.once("listening", () => resolve());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 8787;
+  return {
+    server,
+    port,
+  };
+}
+
+async function closeServer(server: Awaited<ReturnType<typeof startServer>>["server"]) {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+async function jsonCall(port: number, path: string) {
+  const response = await fetch(`http://127.0.0.1:${port}${path}`, { signal: AbortSignal.timeout(2_500) });
+  return {
+    status: response.status,
+    payload: await response.json(),
+  };
+}
+
+describe("createApiServer coverage branches", () => {
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  it("returns the configured system health chain id and provider status", async () => {
+    process.env.API_LAYER_CHAIN_ID = "31337";
+    process.env.CHAIN_ID = "84532";
+
+    const { server, port } = await startServer({ port: 0, quiet: true });
+
+    try {
+      const health = await jsonCall(port, "/v1/system/health");
+      const providerStatus = await jsonCall(port, "/v1/system/provider-status");
+
+      expect(health).toEqual({
+        status: 200,
+        payload: { ok: true, chainId: 31337 },
+      });
+      expect(providerStatus).toEqual({
+        status: 200,
+        payload: mocks.providerStatus,
+      });
+      expect(mocks.mountDomainModules).toHaveBeenCalledOnce();
+      expect(mocks.createWorkflowRouter).toHaveBeenCalledOnce();
+    } finally {
+      await closeServer(server);
+    }
+  });
+
+  it("returns transaction request payloads on success", async () => {
+    mocks.getTransactionRequest.mockResolvedValue({
+      id: "req-123",
+      status: "queued",
+    });
+
+    const { server, port } = await startServer({ port: 0, quiet: true });
+
+    try {
+      const result = await jsonCall(port, "/v1/transactions/requests/req-123");
+
+      expect(result).toEqual({
+        status: 200,
+        payload: {
+          id: "req-123",
+          status: "queued",
+        },
+      });
+      expect(mocks.getTransactionRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          providerRouter: expect.any(Object),
+        }),
+        "req-123",
+      );
+    } finally {
+      await closeServer(server);
+    }
+  });
+
+  it("omits diagnostics when a transaction request error does not include them", async () => {
+    mocks.getTransactionRequest.mockRejectedValue(new Error("boom"));
+
+    const { server, port } = await startServer({ port: 0, quiet: true });
+
+    try {
+      const result = await jsonCall(port, "/v1/transactions/requests/req-404");
+
+      expect(result).toEqual({
+        status: 500,
+        payload: {
+          error: "boom",
+        },
+      });
+    } finally {
+      await closeServer(server);
+    }
+  });
+
+  it("includes diagnostics when transaction status lookup fails with them", async () => {
+    mocks.getTransactionStatus.mockRejectedValue(
+      new HttpError(429, "rate limit exceeded", { retryAfterMs: 500 }),
+    );
+
+    const { server, port } = await startServer({ port: 0, quiet: true });
+
+    try {
+      const result = await jsonCall(port, "/v1/transactions/0xabc");
+
+      expect(result).toEqual({
+        status: 429,
+        payload: {
+          error: "rate limit exceeded",
+          diagnostics: { retryAfterMs: 500 },
+        },
+      });
+    } finally {
+      await closeServer(server);
+    }
+  });
+
+  it("uses the environment port and logs startup when quiet mode is disabled", async () => {
+    process.env.API_LAYER_PORT = "0";
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    const { server, port } = await startServer();
+
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 25));
+      expect(logSpy).toHaveBeenCalledWith(`USpeaks API listening on ${port}`);
+    } finally {
+      await closeServer(server);
+      logSpy.mockRestore();
+    }
+  });
+
+  it("prefers the explicit listen port and falls back to CHAIN_ID when API_LAYER_CHAIN_ID is unset", async () => {
+    process.env.CHAIN_ID = "84531";
+
+    const { server, port } = await startServer({ port: 0, quiet: true });
+
+    try {
+      const health = await jsonCall(port, "/v1/system/health");
+
+      expect(health).toEqual({
+        status: 200,
+        payload: { ok: true, chainId: 84531 },
+      });
+    } finally {
+      await closeServer(server);
+    }
+  });
+
+  it("falls back to the default Base Sepolia chain id when chain env vars are unset", async () => {
+    delete process.env.API_LAYER_CHAIN_ID;
+    delete process.env.CHAIN_ID;
+
+    const { server, port } = await startServer({ port: 0, quiet: true });
+
+    try {
+      const health = await jsonCall(port, "/v1/system/health");
+
+      expect(health).toEqual({
+        status: 200,
+        payload: { ok: true, chainId: 84532 },
+      });
+    } finally {
+      await closeServer(server);
+    }
+  });
+
+  it("uses default server options and the hardcoded port fallback when none are provided", () => {
+    delete process.env.API_LAYER_PORT;
+
+    const apiServer = createApiServer();
+    const fakeServer = {
+      address: vi.fn().mockReturnValue({ port: 8787 }),
+    };
+    const listenSpy = vi.spyOn(apiServer.app, "listen").mockImplementation(((port: number) => {
+      expect(port).toBe(8787);
+      return fakeServer as never;
+    }) as never);
+
+    const server = apiServer.listen();
+
+    expect(server).toBe(fakeServer);
+    expect(listenSpy).toHaveBeenCalledOnce();
+    listenSpy.mockRestore();
+  });
+});