@lightprotocol/zk-compression-cli 0.27.1-alpha.1 → 0.27.1-alpha.2

package/dist/utils/initTestEnv.d.ts

@@ -9,7 +9,7 @@ export declare function stopTestEnv(options: {
     indexer: boolean;
     prover: boolean;
 }): Promise<void>;
-export declare function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer, prover, rpcPort, indexerPort, proverPort, gossipHost, checkPhotonVersion, photonDatabaseUrl, limitLedgerSize, proverRunMode, circuits, geyserConfig, validatorArgs, }: {
+export declare function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer, prover, rpcPort, indexerPort, proverPort, gossipHost, checkPhotonVersion, photonDatabaseUrl, limitLedgerSize, geyserConfig, validatorArgs, }: {
     additionalPrograms?: {
         address: string;
         path: string;
@@ -24,8 +24,6 @@ export declare function initTestEnv({ additionalPrograms, skipSystemAccounts, in
     checkPhotonVersion?: boolean;
     photonDatabaseUrl?: string;
     limitLedgerSize?: number;
-    proverRunMode?: "local-rpc" | "inclusion" | "non-inclusion" | "forester" | "forester-test" | "rpc" | "full" | "full-test";
-    circuits?: string[];
     validatorArgs?: string;
     geyserConfig?: string;
 }): Promise<void>;

package/dist/utils/initTestEnv.js

@@ -70,7 +70,7 @@ async function stopTestEnv(options) {
     await Promise.all(killPromises);
     console.log("All specified processes and validator stopped.");
 }
-async function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer = true, prover = true, rpcPort = 8899, indexerPort = 8784, proverPort = 3001, gossipHost = "127.0.0.1", checkPhotonVersion = true, photonDatabaseUrl, limitLedgerSize, proverRunMode, circuits, geyserConfig, validatorArgs, }) {
+async function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer = true, prover = true, rpcPort = 8899, indexerPort = 8784, proverPort = 3001, gossipHost = "127.0.0.1", checkPhotonVersion = true, photonDatabaseUrl, limitLedgerSize, geyserConfig, validatorArgs, }) {
     // We cannot await this promise directly because it will hang the process
     startTestValidator({
         additionalPrograms,
@@ -95,7 +95,7 @@ async function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer = t
         (0, utils_1.setConfig)(config);
         try {
             // TODO: check if using redisUrl is better here.
-            await (0, processProverServer_1.startProver)(proverPort, proverRunMode, circuits);
+            await (0, processProverServer_1.startProver)(proverPort);
         }
         catch (error) {
             console.error("Failed to start prover:", error);

package/dist/utils/process.js

@@ -16,14 +16,14 @@ const find_process_1 = tslib_1.__importDefault(require("find-process"));
 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 wait_on_1 = tslib_1.__importDefault(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");
+    const testLedgerDir = path_1.default.join(process.cwd(), "test-ledger");
     try {
         if (!fs_1.default.existsSync(testLedgerDir)) {
             console.log("test-ledger directory does not exist");
@@ -167,9 +167,7 @@ async function execute(command) {
 function spawnBinary(command, args = []) {
     const logDir = "test-ledger";
     const binaryName = path_1.default.basename(command);
-    console.log("command", command);
-    console.log("args", args);
-    const dir = path_1.default.join(__dirname, "../..", logDir);
+    const dir = path_1.default.join(process.cwd(), logDir);
     try {
         if (!fs_1.default.existsSync(dir)) {
             fs_1.default.mkdirSync(dir, { recursive: true });
@@ -213,7 +211,7 @@ async function waitForServers(servers) {
         },
     };
     try {
-        await waitOn(opts);
+        await (0, wait_on_1.default)(opts);
         servers.forEach((server) => {
             console.log(`${server.port} is up!`);
         });

package/dist/utils/processProverServer.d.ts

@@ -1,6 +1,5 @@
 export declare function killProver(): 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 startProver(proverPort: number, 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,103 +1,80 @@
 "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 fs_1 = tslib_1.__importDefault(require("fs"));
+const child_process_1 = require("child_process");
 const process_1 = require("./process");
 const constants_1 = require("./constants");
-const find_process_1 = tslib_1.__importDefault(require("find-process"));
+const downloadProverBinary_1 = require("./downloadProverBinary");
 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 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);
+/**
+ * Gets the version of the installed prover binary
+ * Returns null if the binary doesn't exist or version command fails
+ */
+function getInstalledProverVersion() {
+    const binaryPath = getProverPathByArch();
+    if (!fs_1.default.existsSync(binaryPath)) {
+        return null;
+    }
+    try {
+        const version = (0, child_process_1.execSync)(`"${binaryPath}" version`, {
+            encoding: "utf-8",
+            timeout: 5000,
+        }).trim();
+        return version;
+    }
+    catch (error) {
+        return null;
     }
-    if (Array.isArray(circuits)) {
-        for (const c of circuits) {
-            expectedArgs.push("--circuit", c);
-        }
+}
+/**
+ * Ensures the prover binary exists with the correct version, downloading it if necessary
+ */
+async function ensureProverBinary() {
+    const binaryPath = getProverPathByArch();
+    const binaryName = getProverNameByArch();
+    const expectedVersion = (0, downloadProverBinary_1.getProverVersion)();
+    const installedVersion = getInstalledProverVersion();
+    if (installedVersion === expectedVersion) {
+        return;
     }
-    if (proverPort) {
-        expectedArgs.push("--prover-address", `0.0.0.0:${proverPort}`);
+    if (installedVersion) {
+        console.log(`Prover binary version mismatch. Expected: ${expectedVersion}, Found: ${installedVersion}`);
+        console.log("Downloading correct version...");
     }
-    if (redisUrl) {
-        expectedArgs.push("--redis-url", redisUrl);
+    else if (fs_1.default.existsSync(binaryPath)) {
+        console.log("Prover binary found but version could not be determined. Downloading latest version...");
     }
-    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(", ")})`);
-                }
-            }
-        }
+    else {
+        console.log("Prover binary not found. Downloading...");
     }
-    if (!found) {
-        console.log("\x1b[33mNo running prover found with the requested configuration.\x1b[0m");
+    try {
+        await (0, downloadProverBinary_1.downloadProverBinary)(binaryPath, binaryName);
     }
-    return found;
-}
-async function startProver(proverPort, runMode, circuits = [], force = false, redisUrl) {
-    if (!force &&
-        (await isProverRunningWithFlags(runMode, circuits, proverPort))) {
-        return;
+    catch (error) {
+        throw new Error(`Failed to download prover binary: ${error instanceof Error ? error.message : String(error)}\n` +
+            `Please download manually from: https://github.com/Lightprotocol/light-protocol/releases`);
     }
-    console.log("Kill existing prover process...");
+}
+async function startProver(proverPort, redisUrl) {
+    await ensureProverBinary();
     await killProver();
     await (0, process_1.killProcessByPort)(proverPort);
-    const keysDir = path_1.default.join(__dirname, "../..", "bin", KEYS_DIR);
+    const keysDir = path_1.default.join(path_1.default.resolve(__dirname, constants_1.BASE_PATH), KEYS_DIR);
     const args = ["start"];
     args.push("--keys-dir", keysDir);
     args.push("--prover-address", `0.0.0.0:${proverPort}`);
-    if (runMode != null) {
-        args.push("--run-mode", runMode);
-    }
-    for (const circuit of circuits) {
-        args.push("--circuit", circuit);
-    }
-    if (runMode != null) {
-        console.log(`Starting prover in ${runMode} mode...`);
-    }
-    else if (circuits && circuits.length > 0) {
-        console.log(`Starting prover with circuits: ${circuits.join(", ")}...`);
-    }
-    if ((!circuits || circuits.length === 0) && runMode == null) {
-        runMode = "local-rpc";
-        args.push("--run-mode", runMode);
-        console.log(`Starting prover with fallback ${runMode} mode...`);
-    }
+    args.push("--auto-download", "true");
     if (redisUrl) {
         args.push("--redis-url", redisUrl);
     }
@@ -106,23 +83,28 @@ async function startProver(proverPort, runMode, circuits = [], force = false, re
     console.log(`Prover started successfully!`);
 }
 function getProverNameByArch() {
-    const platform = process.platform;
-    const arch = process.arch;
-    if (!platform || !arch) {
+    const nodePlatform = process.platform;
+    const nodeArch = process.arch;
+    if (!nodePlatform || !nodeArch) {
         throw new Error("Unsupported platform or architecture");
     }
-    let binaryName = `prover-${platform}-${arch}`;
-    if (platform.toString() === "windows") {
-        throw new Error("Windows OS support is not included in this NPM release. Please reach out to team@lightprotocol.com to get the Windows binary.");
-        //@ts-ignore
+    let goPlatform = nodePlatform;
+    let goArch = nodeArch;
+    if (nodeArch === "x64") {
+        goArch = "amd64";
+    }
+    if (nodePlatform === "win32") {
+        goPlatform = "windows";
+    }
+    let binaryName = `prover-${goPlatform}-${goArch}`;
+    if (goPlatform === "windows") {
         binaryName += ".exe";
     }
     return binaryName;
 }
 function getProverPathByArch() {
     let binaryName = getProverNameByArch();
-    // We need to provide the full path to the binary because it's not in the PATH.
-    const binDir = path_1.default.join(__dirname, "../..", "bin");
+    const binDir = path_1.default.resolve(__dirname, constants_1.BASE_PATH);
     binaryName = path_1.default.join(binDir, binaryName);
     return binaryName;
 }

package/dist/utils/utils.d.ts

@@ -1,6 +1,10 @@
 import * as anchor from "@coral-xyz/anchor";
 import { Keypair } from "@solana/web3.js";
 import { Rpc } from "@lightprotocol/stateless.js";
+/**
+ * Get a Keypair from a secret key file (compatible with Solana CLI)
+ */
+export declare function getKeypairFromFile(filepath?: string): Promise<Keypair>;
 export declare const defaultSolanaWalletKeypair: () => Keypair;
 export declare const setAnchorProvider: () => Promise<anchor.AnchorProvider>;
 export declare function rpc(): Rpc;

package/dist/utils/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomLoader = exports.setConfig = exports.getConfig = exports.getProverUrl = exports.getIndexerUrl = exports.getSolanaRpcUrl = exports.setAnchorProvider = exports.defaultSolanaWalletKeypair = void 0;
+exports.getKeypairFromFile = getKeypairFromFile;
 exports.rpc = rpc;
 exports.getPayer = getPayer;
 exports.generateSolanaTransactionURL = generateSolanaTransactionURL;
@@ -17,9 +18,45 @@ const web3_js_1 = require("@solana/web3.js");
 const stateless_js_1 = require("@lightprotocol/stateless.js");
 const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
 const constants_1 = require("./constants");
-const helpers_1 = require("@solana-developers/helpers");
 const cli_spinners_1 = tslib_1.__importDefault(require("cli-spinners"));
-require("dotenv").config();
+const dotenv_1 = tslib_1.__importDefault(require("dotenv"));
+dotenv_1.default.config();
+/**
+ * Get a Keypair from a secret key file (compatible with Solana CLI)
+ */
+async function getKeypairFromFile(filepath) {
+    // Default value from Solana CLI
+    const DEFAULT_FILEPATH = "~/.config/solana/id.json";
+    if (!filepath) {
+        filepath = DEFAULT_FILEPATH;
+    }
+    if (filepath[0] === "~") {
+        const home = process.env.HOME || null;
+        if (home) {
+            filepath = path.join(home, filepath.slice(1));
+        }
+    }
+    let fileContents;
+    try {
+        fileContents = fs.readFileSync(filepath, "utf8");
+    }
+    catch {
+        throw new Error(`Could not read keypair from file at '${filepath}'`);
+    }
+    // Parse contents of file
+    let parsedFileContents;
+    try {
+        parsedFileContents = Uint8Array.from(JSON.parse(fileContents));
+    }
+    catch (error_) {
+        const error = error_;
+        if (!error.message.includes("Unexpected token")) {
+            throw error;
+        }
+        throw new Error(`Invalid secret key file at '${filepath}'!`);
+    }
+    return web3_js_1.Keypair.fromSecretKey(parsedFileContents);
+}
 const defaultSolanaWalletKeypair = () => {
     const walletPath = process.env.HOME + "/.config/solana/id.json";
     if (fs.existsSync(walletPath)) {
@@ -52,7 +89,7 @@ function getWalletPath() {
     return process.env.HOME + "/.config/solana/id.json";
 }
 async function getPayer() {
-    return await (0, helpers_1.getKeypairFromFile)(getWalletPath());
+    return await getKeypairFromFile(getWalletPath());
 }
 function generateSolanaTransactionURL(transactionType, transactionHash, cluster) {
     return `https://explorer.solana.com/${transactionType}/${transactionHash}?cluster=${cluster}`;
@@ -131,6 +168,10 @@ const setConfig = (config, filePath) => {
 };
 exports.setConfig = setConfig;
 class CustomLoader {
+    message;
+    logInterval;
+    logTimer;
+    startTime;
     constructor(message, logInterval = 1000) {
         this.message = message;
         this.logInterval = logInterval;