@lightprotocol/zk-compression-cli 0.24.0 → 0.26.0

package/dist/utils/initTestEnv.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYSTEM_PROGRAMS = void 0;
 exports.stopTestEnv = stopTestEnv;
 exports.initTestEnv = initTestEnv;
 exports.initTestEnvIfNeeded = initTestEnvIfNeeded;
@@ -16,6 +17,33 @@ const psp_utils_1 = require("../psp-utils");
 const process_1 = require("./process");
 const processProverServer_1 = require("./processProverServer");
 const processPhotonIndexer_1 = require("./processPhotonIndexer");
+exports.SYSTEM_PROGRAMS = [
+    {
+        id: "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV",
+        name: "spl_noop.so",
+        tag: constants_1.SPL_NOOP_PROGRAM_TAG,
+    },
+    {
+        id: "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7",
+        name: "light_system_program_pinocchio.so",
+        tag: constants_1.LIGHT_SYSTEM_PROGRAM_TAG,
+    },
+    {
+        id: "cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m",
+        name: "light_compressed_token.so",
+        tag: constants_1.LIGHT_COMPRESSED_TOKEN_TAG,
+    },
+    {
+        id: "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq",
+        name: "account_compression.so",
+        tag: constants_1.LIGHT_ACCOUNT_COMPRESSION_TAG,
+    },
+    {
+        id: "Lighton6oQpVkeewmo2mcPTQQp7kYHr4fWpAgJyEmDX",
+        name: "light_registry.so",
+        tag: constants_1.LIGHT_REGISTRY_TAG,
+    },
+];
 async function stopTestEnv(options) {
     const processesToKill = [
         { name: "photon", condition: options.indexer, killFunction: processPhotonIndexer_1.killIndexer },
@@ -65,7 +93,15 @@ async function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer = t
         const config = (0, utils_1.getConfig)();
         config.proverUrl = `http://127.0.0.1:${proverPort}`;
         (0, utils_1.setConfig)(config);
-        await (0, processProverServer_1.startProver)(proverPort, proverRunMode, circuits);
+        try {
+            // TODO: check if using redisUrl is better here.
+            await (0, processProverServer_1.startProver)(proverPort, proverRunMode, circuits);
+        }
+        catch (error) {
+            console.error("Failed to start prover:", error);
+            // Prover logs will be automatically displayed by spawnBinary in process.ts
+            throw error;
+        }
     }
 }
 async function initTestEnvIfNeeded({ additionalPrograms, skipSystemAccounts, indexer = false, prover = false, geyserConfig, validatorArgs, } = {}) {
@@ -120,33 +156,7 @@ function programFilePath(programName) {
 }
 async function getSolanaArgs({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, downloadBinaries = true, }) {
     // TODO: adjust program tags
-    const programs = [
-        {
-            id: "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV",
-            name: "spl_noop.so",
-            tag: constants_1.SPL_NOOP_PROGRAM_TAG,
-        },
-        {
-            id: "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7",
-            name: "light_system_program.so",
-            tag: constants_1.LIGHT_SYSTEM_PROGRAM_TAG,
-        },
-        {
-            id: "cTokenmWW8bLPjZEBAUgYy3zKxQZW6VKi7bqNFEVv3m",
-            name: "light_compressed_token.so",
-            tag: constants_1.LIGHT_COMPRESSED_TOKEN_TAG,
-        },
-        {
-            id: "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq",
-            name: "account_compression.so",
-            tag: constants_1.LIGHT_ACCOUNT_COMPRESSION_TAG,
-        },
-        {
-            id: "Lighton6oQpVkeewmo2mcPTQQp7kYHr4fWpAgJyEmDX",
-            name: "light_registry.so",
-            tag: constants_1.LIGHT_REGISTRY_TAG,
-        },
-    ];
+    const programs = [...exports.SYSTEM_PROGRAMS];
     if (additionalPrograms)
         additionalPrograms.forEach((program) => {
             programs.push({ id: program.address, path: program.path });

package/dist/utils/process.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Logs the contents of prover log files in test-ledger dir.
+ */
+export declare function logProverFileContents(): Promise<void>;
 export declare function killProcess(processName: string): Promise<void>;
 export declare function killProcessByPort(port: number): Promise<void>;
 /**

package/dist/utils/process.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.logProverFileContents = logProverFileContents;
 exports.killProcess = killProcess;
 exports.killProcessByPort = killProcessByPort;
 exports.executeCommand = executeCommand;
@@ -16,6 +17,41 @@ const node_child_process_1 = require("node:child_process");
 const util_1 = require("util");
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const waitOn = require("wait-on");
+const readdir = (0, util_1.promisify)(fs_1.default.readdir);
+const readFile = (0, util_1.promisify)(fs_1.default.readFile);
+/**
+ * Logs the contents of prover log files in test-ledger dir.
+ */
+async function logProverFileContents() {
+    const testLedgerDir = path_1.default.join(__dirname, "../..", "test-ledger");
+    try {
+        if (!fs_1.default.existsSync(testLedgerDir)) {
+            console.log("test-ledger directory does not exist");
+            return;
+        }
+        const files = await readdir(testLedgerDir);
+        const proverFiles = files.filter((file) => file.includes("prover"));
+        if (proverFiles.length === 0) {
+            console.log("No prover log files found in test-ledger directory");
+            return;
+        }
+        for (const file of proverFiles) {
+            const filePath = path_1.default.join(testLedgerDir, file);
+            console.log(`\n========== Contents of ${file} ==========`);
+            try {
+                const contents = await readFile(filePath, "utf8");
+                console.log(contents);
+                console.log(`========== End of ${file} ==========\n`);
+            }
+            catch (error) {
+                console.error(`Error reading ${file}:`, error);
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error accessing test-ledger directory:", error);
+    }
+}
 async function killProcess(processName) {
     const processList = await (0, find_process_1.default)("name", processName);
     const targetProcesses = processList.filter((proc) => proc.name.includes(processName) || proc.cmd.includes(processName));
@@ -27,7 +63,6 @@ async function killProcess(processName) {
             console.error(`Failed to kill process ${proc.pid}: ${error}`);
         }
     }
-    // Double-check if processes are still running
     const remainingProcesses = await (0, find_process_1.default)("name", processName);
     if (remainingProcesses.length > 0) {
         console.warn(`Warning: ${remainingProcesses.length} processes still running after kill attempt`);
@@ -145,8 +180,12 @@ function spawnBinary(command, args = []) {
             shell: false,
             detached: true,
         });
-        spawnedProcess.on("close", (code) => {
+        spawnedProcess.on("close", async (code) => {
             console.log(`${binaryName} process exited with code ${code}`);
+            if (code !== 0 && binaryName.includes("prover")) {
+                console.error(`Prover process failed with exit code ${code}`);
+                await logProverFileContents();
+            }
         });
         return spawnedProcess;
     }

package/dist/utils/processPhotonIndexer.d.ts

@@ -1,2 +1,2 @@
-export declare function startIndexer(rpcUrl: string, indexerPort: number, checkPhotonVersion?: boolean, photonDatabaseUrl?: string): Promise<void>;
+export declare function startIndexer(rpcUrl: string, indexerPort: number, checkPhotonVersion?: boolean, photonDatabaseUrl?: string): Promise<undefined>;
 export declare function killIndexer(): Promise<void>;

package/dist/utils/processPhotonIndexer.js

@@ -8,27 +8,48 @@ const process_1 = require("./process");
 const constants_1 = require("./constants");
 const node_child_process_1 = require("node:child_process");
 const util = tslib_1.__importStar(require("node:util"));
+const node_process_1 = require("node:process");
+const execAsync = util.promisify(node_child_process_1.exec);
+async function isExpectedPhotonVersion(requiredVersion) {
+    try {
+        const { stdout } = await execAsync("photon --version");
+        const version = stdout.trim();
+        return version.includes(requiredVersion);
+    }
+    catch (error) {
+        console.error("Error checking Photon version:", error);
+        return false;
+    }
+}
+function getPhotonInstallMessage() {
+    if (constants_1.USE_PHOTON_FROM_GIT && constants_1.PHOTON_GIT_COMMIT) {
+        return `\nLatest Photon indexer not found. Please install it by running: "cargo install --git ${constants_1.PHOTON_GIT_REPO} --rev ${constants_1.PHOTON_GIT_COMMIT} --locked"`;
+    }
+    else if (constants_1.USE_PHOTON_FROM_GIT) {
+        return `\nLatest Photon indexer not found. Please install it by running: "cargo install --git ${constants_1.PHOTON_GIT_REPO} --locked"`;
+    }
+    else {
+        return `\nLatest Photon indexer not found. Please install it by running: "cargo install photon-indexer --version ${constants_1.PHOTON_VERSION} --locked"`;
+    }
+}
 async function startIndexer(rpcUrl, indexerPort, checkPhotonVersion = true, photonDatabaseUrl) {
     await killIndexer();
     const resolvedOrNull = which_1.default.sync("photon", { nothrow: true });
     if (resolvedOrNull === null ||
         (checkPhotonVersion && !(await isExpectedPhotonVersion(constants_1.PHOTON_VERSION)))) {
-        const message = `Photon indexer not found. Please install it by running "cargo install photon-indexer --version ${constants_1.PHOTON_VERSION} --locked"`;
-        console.log(message);
-        throw new Error(message);
+        console.log(getPhotonInstallMessage());
+        return (0, node_process_1.exit)(1);
     }
     else {
         console.log("Starting indexer...");
-        let args = [];
+        const args = [
+            "--port",
+            indexerPort.toString(),
+            "--rpc-url",
+            rpcUrl,
+        ];
         if (photonDatabaseUrl) {
-            args = [
-                "--db-url",
-                photonDatabaseUrl,
-                "--port",
-                indexerPort.toString(),
-                "--rpc-url",
-                rpcUrl,
-            ];
+            args.push("--db-url", photonDatabaseUrl);
         }
         (0, process_1.spawnBinary)(constants_1.INDEXER_PROCESS_NAME, args);
         await (0, process_1.waitForServers)([{ port: indexerPort, path: "/getIndexerHealth" }]);
@@ -38,15 +59,3 @@ async function startIndexer(rpcUrl, indexerPort, checkPhotonVersion = true, phot
 async function killIndexer() {
     await (0, process_1.killProcess)(constants_1.INDEXER_PROCESS_NAME);
 }
-const execAsync = util.promisify(node_child_process_1.exec);
-async function isExpectedPhotonVersion(requiredVersion) {
-    try {
-        const { stdout } = await execAsync("photon --version");
-        const version = stdout.trim();
-        return version.includes(requiredVersion);
-    }
-    catch (error) {
-        console.error("Error checking Photon version:", error);
-        return false;
-    }
-}

package/dist/utils/processProverServer.d.ts

@@ -1,4 +1,6 @@
 export declare function killProver(): Promise<void>;
-export declare function startProver(proverPort: number, runMode: string | undefined, circuits?: string[] | undefined): Promise<void>;
+export declare function isProverRunningWithFlags(runMode?: string, circuits?: string[], proverPort?: number, redisUrl?: string): Promise<boolean>;
+export declare function startProver(proverPort: number, runMode: string | undefined, circuits?: string[] | undefined, force?: boolean, redisUrl?: string): Promise<void>;
 export declare function getProverNameByArch(): string;
 export declare function getProverPathByArch(): string;
+export declare function healthCheck(port: number, retries?: number, timeout?: number): Promise<boolean>;

package/dist/utils/processProverServer.js

@@ -1,19 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.killProver = killProver;
+exports.isProverRunningWithFlags = isProverRunningWithFlags;
 exports.startProver = startProver;
 exports.getProverNameByArch = getProverNameByArch;
 exports.getProverPathByArch = getProverPathByArch;
+exports.healthCheck = healthCheck;
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
 const process_1 = require("./process");
 const constants_1 = require("./constants");
+const find_process_1 = tslib_1.__importDefault(require("find-process"));
 const KEYS_DIR = "proving-keys/";
 async function killProver() {
     await (0, process_1.killProcess)(getProverNameByArch());
     await (0, process_1.killProcess)(constants_1.LIGHT_PROVER_PROCESS_NAME);
 }
-async function startProver(proverPort, runMode, circuits = []) {
+async function isProverRunningWithFlags(runMode, circuits, proverPort, redisUrl) {
+    // Use find-process to get prover processes by name pattern
+    const proverProcesses = await (0, find_process_1.default)("name", "prover-");
+    const expectedArgs = [];
+    if (runMode) {
+        expectedArgs.push("--run-mode", runMode);
+    }
+    if (Array.isArray(circuits)) {
+        for (const c of circuits) {
+            expectedArgs.push("--circuit", c);
+        }
+    }
+    if (proverPort) {
+        expectedArgs.push("--prover-address", `0.0.0.0:${proverPort}`);
+    }
+    if (redisUrl) {
+        expectedArgs.push("--redis-url", redisUrl);
+    }
+    let found = false;
+    for (const proc of proverProcesses) {
+        if (proc.cmd &&
+            (proc.cmd.includes("prover-") || proc.name.startsWith("prover-"))) {
+            console.log("\n[Prover Process Detected]");
+            console.log(`  PID: ${proc.pid}`);
+            console.log(`  Command: ${proc.cmd}`);
+            let matches = true;
+            for (const arg of expectedArgs) {
+                if (!proc.cmd.includes(arg)) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                found = true;
+                console.log("\x1b[32m✔ Prover is already running with the same configuration.\x1b[0m");
+                console.log("  To restart the prover, stop the process above or use the --force flag.\n");
+                break;
+            }
+            else {
+                const missing = proc.cmd
+                    ? expectedArgs.filter((arg) => !proc.cmd.includes(arg))
+                    : [];
+                if (missing.length > 0) {
+                    console.log(`  (Not a match for current request. Missing args: ${missing.join(", ")})`);
+                }
+            }
+        }
+    }
+    if (!found) {
+        console.log("\x1b[33mNo running prover found with the requested configuration.\x1b[0m");
+    }
+    return found;
+}
+async function startProver(proverPort, runMode, circuits = [], force = false, redisUrl) {
+    if (!force &&
+        (await isProverRunningWithFlags(runMode, circuits, proverPort))) {
+        return;
+    }
     console.log("Kill existing prover process...");
     await killProver();
     await (0, process_1.killProcessByPort)(proverPort);
@@ -34,10 +94,13 @@ async function startProver(proverPort, runMode, circuits = []) {
         console.log(`Starting prover with circuits: ${circuits.join(", ")}...`);
     }
     if ((!circuits || circuits.length === 0) && runMode == null) {
-        runMode = "rpc";
+        runMode = "local-rpc";
         args.push("--run-mode", runMode);
         console.log(`Starting prover with fallback ${runMode} mode...`);
     }
+    if (redisUrl) {
+        args.push("--redis-url", redisUrl);
+    }
     (0, process_1.spawnBinary)(getProverPathByArch(), args);
     await (0, process_1.waitForServers)([{ port: proverPort, path: "/" }]);
     console.log(`Prover started successfully!`);
@@ -61,3 +124,21 @@ function getProverPathByArch() {
     binaryName = path_1.default.join(binDir, binaryName);
     return binaryName;
 }
+async function healthCheck(port, retries = 3, timeout = 3000) {
+    const fetch = (await Promise.resolve().then(() => tslib_1.__importStar(require("node-fetch")))).default;
+    for (let i = 0; i < retries; i++) {
+        try {
+            const res = await fetch(`http://localhost:${port}/health`);
+            if (res.ok) {
+                console.log("Health check passed!");
+                return true;
+            }
+        }
+        catch (e) {
+            console.error("Health check error:", e);
+        }
+        await new Promise((r) => setTimeout(r, timeout));
+    }
+    console.log("Health check failed after all attempts.");
+    return false;
+}