fix(deployer): ship the proof-server compose file

testkit-js boots the `auto` container from `<proofServer.path>/<fileName>`
and defaults that path to `process.cwd()`, so every `auto` deploy failed
with `open <cwd>/proof-server.yml: no such file`. The package now ships
that compose file and points testkit at it. A compose file in the cwd
still wins, as the override for a different image.

The tag is pinned so `auto` cannot move under a deploy. The healthcheck
is disabled because the image is distroless: every probe form fails, and
testkit waits on listening ports anyway.

Author: 0xisk

packages/deployer/CHANGELOG.md

@@ -13,3 +13,4 @@ and this package adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Initial package. `Deployer` and `runDeploy` build and submit a Compact deploy transaction from a `compact.toml` profile, resolving the artifact, constructor args, initial private state, and contract signing key, then record the result in `<deployments_dir>/<network>.json` (#86)
 - Wallet support: seed-file / `MN_DEPLOYER_SEED` / keystore / prefunded-local seed resolution, a per-seed on-disk sync cache under `.states/`, and a `proof_server = "auto"` mode that boots a testkit-js proof-server container for the run (#86)
 - Supported deploy stack is `@midnight-ntwrk/compact-runtime` 0.16.0 and `@midnight-ntwrk/ledger-v8` 8.1.2; artifacts must be compiled with `compact compile +0.31.1`. See the README's "Supported stack" section (#86)
+- A packaged `proof-server.yml`, pinning `midnightntwrk/proof-server:8.0.3`, is what `proof_server = "auto"` boots. `auto` no longer depends on a compose file in the working directory, though one there still wins (#165)

packages/deployer/README.md

@@ -190,6 +190,8 @@ signing_key_file = "./deploy/Vault.signingkey"
 
 `proof_server`: a URL pins the server; `"auto"` spawns a `testcontainers`-managed proof-server container for the duration of the deploy; omitting it falls back to the env var `PROOF_SERVER_PORT` then to `http://127.0.0.1:6300`.
 
+`"auto"` needs Docker and boots the `proof-server.yml` shipped in this package, which pins `midnightntwrk/proof-server:8.0.3` and publishes port 6300 on a free host port. To boot a different image, put your own `proof-server.yml` in the directory you run `compact-deploy` from; a compose file there wins over the packaged one.
+
 ## Keystore format
 
 `compact-deploy` reads/writes a JSON keystore with the Ethereum V3 shape (scrypt + AES-128-CTR) but with `version: "midnight-1"` so other tooling does not silently mis-read it as an Ethereum key. The encrypted secret is a 32-byte Midnight wallet seed (hex).

packages/deployer/package.json

@@ -84,6 +84,7 @@
   },
   "files": [
     "dist",
+    "proof-server.yml",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"

packages/deployer/proof-server.yml

@@ -0,0 +1,16 @@
+# Compose file backing `proof_server = "auto"`. Ships in the package.
+#
+# The service name, `container_name` and `TESTCONTAINERS_UID` are testkit's
+# contract, not free choice: it looks the container up as `proof-server_<uid>`
+# and reads the port back via `getMappedPort(6300)`.
+services:
+  proof-server:
+    # Pinned to a release, not `:latest`, so `auto` cannot move under a deploy.
+    image: 'midnightntwrk/proof-server:8.0.3'
+    container_name: 'proof-server_$TESTCONTAINERS_UID'
+    command: ['midnight-proof-server -v']
+    # Host port 0: Docker picks a free one, so concurrent deploys cannot collide.
+    ports:
+      - '0:6300'
+    environment:
+      RUST_BACKTRACE: 'full'

packages/deployer/src/providers/proof-server.test.ts

@@ -1,14 +1,35 @@
+import { existsSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import type { Logger } from 'pino';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { NetworkConfig } from '../config/schema.ts';
 import { ConfigError } from '../errors.ts';
 
+/**
+ * Stand-in for testkit's container config. Kept global and mutable like the
+ * real one, so a start observes whatever the last write left behind.
+ */
+let containersConfig = {
+  proofServer: {
+    path: process.cwd(),
+    fileName: 'proof-server.yml',
+    container: { name: 'proof-server', port: 6300, waitStrategy: {} },
+  },
+};
+
+/** Directories `DynamicProofServerContainer.start` was pointed at, in order. */
+const composeDirs: string[] = [];
+
 vi.mock('@midnight-ntwrk/testkit-js', () => ({
   DynamicProofServerContainer: {
-    start: vi.fn(async () => ({
-      getUrl: () => 'http://dynamic-container:6300',
-      stop: vi.fn(async () => undefined),
-    })),
+    start: vi.fn(async () => {
+      composeDirs.push(containersConfig.proofServer.path);
+      return {
+        getUrl: () => 'http://dynamic-container:6300',
+        stop: vi.fn(async () => undefined),
+      };
+    }),
   },
   StaticProofServerContainer: vi.fn(function StaticProofServerContainer(
     this: { getUrl: () => string; stop: () => Promise<void> },
@@ -17,6 +38,10 @@ vi.mock('@midnight-ntwrk/testkit-js', () => ({
     this.getUrl = () => `http://127.0.0.1:${port}`;
     this.stop = vi.fn(async () => undefined);
   }),
+  getContainersConfiguration: vi.fn(() => containersConfig),
+  setContainersConfiguration: vi.fn((next: typeof containersConfig) => {
+    containersConfig = next;
+  }),
 }));
 
 const { DynamicProofServerContainer, StaticProofServerContainer } =
@@ -205,3 +230,54 @@ describe('ProofServer — disposal', () => {
     expect(logger.warn).toHaveBeenCalled();
   });
 });
+
+describe('ProofServer.start — the "auto" compose file', () => {
+  const FILE_NAME = 'proof-server.yml';
+
+  const emptyDir = (): string => mkdtempSync(join(tmpdir(), 'compose-'));
+
+  const dirWithComposeFile = (): string => {
+    const dir = emptyDir();
+    writeFileSync(join(dir, FILE_NAME), 'services: {}\n');
+    return dir;
+  };
+
+  /** Starts `auto` from `cwd`; answers with the directory testkit booted from. */
+  const composeDirFrom = async (cwd: string): Promise<string> => {
+    vi.spyOn(process, 'cwd').mockReturnValue(cwd);
+    composeDirs.length = 0;
+    await ProofServer.start({
+      network: { ...baseNetwork, proof_server: 'auto' },
+      logger: makeLogger(),
+    });
+    expect(composeDirs).toHaveLength(1);
+    return composeDirs[0];
+  };
+
+  afterEach(() => {
+    vi.mocked(process.cwd).mockRestore();
+  });
+
+  // Also guards `files` in package.json: dropping the yaml there would break
+  // `auto` for npm installs only, never in CI, which runs from the worktree.
+  it('should boot from the packaged file when the cwd has no compose file', async () => {
+    const dir = await composeDirFrom(emptyDir());
+
+    expect(existsSync(join(dir, FILE_NAME))).toBe(true);
+  });
+
+  it('should prefer a compose file in the cwd over the packaged one', async () => {
+    const cwd = dirWithComposeFile();
+
+    expect(await composeDirFrom(cwd)).toBe(cwd);
+  });
+
+  it('should re-resolve per start rather than reuse the last path', async () => {
+    const overriding = dirWithComposeFile();
+    expect(await composeDirFrom(overriding)).toBe(overriding);
+
+    const packaged = await composeDirFrom(emptyDir());
+    expect(packaged).not.toBe(overriding);
+    expect(existsSync(join(packaged, FILE_NAME))).toBe(true);
+  });
+});

packages/deployer/src/providers/proof-server.ts

@@ -1,6 +1,11 @@
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import {
   DynamicProofServerContainer,
+  getContainersConfiguration,
   StaticProofServerContainer,
+  setContainersConfiguration,
 } from '@midnight-ntwrk/testkit-js';
 import type { Logger } from 'pino';
 import type { NetworkConfig } from '../config/schema.ts';
@@ -13,6 +18,35 @@ export interface ProofServerOptions {
   logger: Logger;
 }
 
+/** Holds the packaged `proof-server.yml`. Two levels up from `providers/` in
+ *  both `src/` and the built `dist/`. */
+const PACKAGE_ROOT = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  '..',
+  '..',
+);
+
+/**
+ * Point testkit at a compose file it can read.
+ *
+ * testkit boots the `auto` container from `<proofServer.path>/<fileName>` and
+ * defaults that path to `process.cwd()`. A compose file in the cwd still wins,
+ * as the escape hatch for a different image; otherwise the packaged one. The
+ * choice is remade on every start because testkit's config is global.
+ */
+function useComposeFile(logger: Logger): void {
+  const current = getContainersConfiguration();
+  const { fileName } = current.proofServer;
+  const cwd = process.cwd();
+  const path = existsSync(resolve(cwd, fileName)) ? cwd : PACKAGE_ROOT;
+
+  logger.debug(`Proof-server compose file: ${resolve(path, fileName)}`);
+  setContainersConfiguration({
+    ...current,
+    proofServer: { ...current.proofServer, path },
+  });
+}
+
 /**
  * Proof-server handle with a resolved URL + lifecycle. Always acquired via
  * {@link ProofServer.start}; {@link dispose} is a no-op for static URLs
@@ -50,6 +84,7 @@ export class ProofServer {
 
     if (explicit === 'auto') {
       logger.info('Starting proof-server container (auto)…');
+      useComposeFile(logger);
       const container = await DynamicProofServerContainer.start(
         logger,
         undefined,