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

package/dist/utils/downloadProverBinary.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadProverBinary = downloadProverBinary;
+exports.getProverVersion = getProverVersion;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const https_1 = tslib_1.__importDefault(require("https"));
+const http_1 = tslib_1.__importDefault(require("http"));
+const promises_1 = require("stream/promises");
+const PROVER_RELEASE_TAG = "2.0.6";
+const PROVER_BINARY_VERSION = "2.0.0"; // Version string the binary actually reports
+const GITHUB_RELEASES_BASE_URL = `https://github.com/Lightprotocol/light-protocol/releases/download/light-prover-v${PROVER_RELEASE_TAG}`;
+const MAX_REDIRECTS = 10;
+async function downloadProverBinary(binaryPath, binaryName, options = {}) {
+    const { maxRetries = 3, retryDelay = 2000 } = options;
+    const url = `${GITHUB_RELEASES_BASE_URL}/${binaryName}`;
+    console.log(`\nDownloading prover binary: ${binaryName}`);
+    console.log(`   From: ${url}`);
+    console.log(`   To: ${binaryPath}\n`);
+    const dir = path_1.default.dirname(binaryPath);
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            await downloadFile(url, binaryPath);
+            if (process.platform !== "win32") {
+                fs_1.default.chmodSync(binaryPath, 0o755);
+            }
+            console.log("\nProver binary downloaded.\n");
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            console.error(`\nDownload attempt ${attempt}/${maxRetries} failed: ${lastError.message}`);
+            if (attempt < maxRetries) {
+                console.log(`   Retrying in ${retryDelay / 1000}s...\n`);
+                await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            }
+        }
+    }
+    throw new Error(`Failed to download prover binary after ${maxRetries} attempts: ${lastError?.message}`);
+}
+async function downloadFile(url, outputPath, redirectDepth = 0) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith("https") ? https_1.default : http_1.default;
+        const request = protocol.get(url, (response) => {
+            if (response.statusCode === 301 ||
+                response.statusCode === 302 ||
+                response.statusCode === 307 ||
+                response.statusCode === 308) {
+                const redirectUrl = response.headers.location;
+                if (!redirectUrl) {
+                    return reject(new Error("Redirect without location header"));
+                }
+                if (redirectDepth >= MAX_REDIRECTS) {
+                    return reject(new Error(`Too many redirects: exceeded maximum of ${MAX_REDIRECTS} redirects`));
+                }
+                return downloadFile(redirectUrl, outputPath, redirectDepth + 1).then(resolve, reject);
+            }
+            if (response.statusCode !== 200) {
+                return reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+            }
+            const totalBytes = parseInt(response.headers["content-length"] || "0", 10);
+            let downloadedBytes = 0;
+            let lastProgress = 0;
+            const fileStream = fs_1.default.createWriteStream(outputPath);
+            response.on("data", (chunk) => {
+                downloadedBytes += chunk.length;
+                if (totalBytes > 0) {
+                    const progress = Math.floor((downloadedBytes / totalBytes) * 100);
+                    if (progress >= lastProgress + 5) {
+                        lastProgress = progress;
+                        const mb = (downloadedBytes / 1024 / 1024).toFixed(1);
+                        const totalMb = (totalBytes / 1024 / 1024).toFixed(1);
+                        process.stdout.write(`\r   Progress: ${progress}% (${mb}MB / ${totalMb}MB)`);
+                    }
+                }
+            });
+            (0, promises_1.pipeline)(response, fileStream)
+                .then(() => {
+                if (totalBytes > 0) {
+                    process.stdout.write("\r   Progress: 100% - Download complete\n");
+                }
+                resolve();
+            })
+                .catch((error) => {
+                fs_1.default.unlinkSync(outputPath);
+                reject(error);
+            });
+        });
+        request.on("error", (error) => {
+            if (fs_1.default.existsSync(outputPath)) {
+                fs_1.default.unlinkSync(outputPath);
+            }
+            reject(error);
+        });
+        request.setTimeout(60000, () => {
+            request.destroy();
+            reject(new Error("Download timeout"));
+        });
+    });
+}
+function getProverVersion() {
+    return PROVER_BINARY_VERSION;
+}

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, cloneNetwork, verbose, skipReset, }: {
     additionalPrograms?: {
         address: string;
         path: string;
@@ -24,10 +24,11 @@ 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;
+    cloneNetwork?: "devnet" | "mainnet";
+    verbose?: boolean;
+    skipReset?: boolean;
 }): Promise<void>;
 export declare function initTestEnvIfNeeded({ additionalPrograms, skipSystemAccounts, indexer, prover, geyserConfig, validatorArgs, }?: {
     additionalPrograms?: {
@@ -42,7 +43,7 @@ export declare function initTestEnvIfNeeded({ additionalPrograms, skipSystemAcco
 }): Promise<void>;
 export declare function programsDirPath(): string;
 export declare function programFilePath(programName: string): string;
-export declare function getSolanaArgs({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, downloadBinaries, }: {
+export declare function getSolanaArgs({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, downloadBinaries, cloneNetwork, verbose, skipReset, }: {
     additionalPrograms?: {
         address: string;
         path: string;
@@ -52,8 +53,11 @@ export declare function getSolanaArgs({ additionalPrograms, skipSystemAccounts,
     rpcPort?: number;
     gossipHost?: string;
     downloadBinaries?: boolean;
+    cloneNetwork?: "devnet" | "mainnet";
+    verbose?: boolean;
+    skipReset?: boolean;
 }): Promise<Array<string>>;
-export declare function startTestValidator({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, validatorArgs, geyserConfig, }: {
+export declare function startTestValidator({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, validatorArgs, geyserConfig, cloneNetwork, verbose, skipReset, }: {
     additionalPrograms?: {
         address: string;
         path: string;
@@ -64,6 +68,9 @@ export declare function startTestValidator({ additionalPrograms, skipSystemAccou
     gossipHost?: string;
     validatorArgs?: string;
     geyserConfig?: string;
+    cloneNetwork?: "devnet" | "mainnet";
+    verbose?: boolean;
+    skipReset?: boolean;
 }): Promise<void>;
 export declare function killTestValidator(): Promise<void>;
 export {};

package/dist/utils/initTestEnv.js

@@ -17,6 +17,7 @@ const psp_utils_1 = require("../psp-utils");
 const process_1 = require("./process");
 const processProverServer_1 = require("./processProverServer");
 const processPhotonIndexer_1 = require("./processPhotonIndexer");
+const web3_js_1 = require("@solana/web3.js");
 exports.SYSTEM_PROGRAMS = [
     {
         id: "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV",
@@ -44,6 +45,38 @@ exports.SYSTEM_PROGRAMS = [
         tag: constants_1.LIGHT_REGISTRY_TAG,
     },
 ];
+// Programs to clone from devnet/mainnet (the three core Light programs)
+const PROGRAMS_TO_CLONE = [
+    "Lighton6oQpVkeewmo2mcPTQQp7kYHr4fWpAgJyEmDX", // Light Registry
+    "SySTEM1eSU2p4BGQfQpimFEWWSC1XDFeun3Nqzz3rT7", // Light System Program
+    "compr6CUsB5m2jS4Y3831ztGSTnDpnKJTKS95d64XVq", // Account Compression
+];
+// Known Light Registry accounts to clone (excludes forester/epoch accounts)
+// These are the core config accounts needed for protocol operation
+const REGISTRY_ACCOUNTS_TO_CLONE = [
+    "CuEtcKkkbTn6qy2qxqDswq5U2ADsqoipYDAYfRvxPjcp", // governance_authority_pda (ProtocolConfigPda)
+    "8gH9tmziWsS8Wc4fnoN5ax3jsSumNYoRDuSBvmH2GMH8", // config_counter_pda
+    "35hkDgaAKwMCaxRz2ocSZ6NaUrtKkyNqU6c4RV3tYJRh", // registered_program_pda
+    "DumMsyvkaGJG4QnQ1BhTgvoRMXsgGxfpKDUCr22Xqu4w", // registered_registry_program_pda
+    "24rt4RgeyjUCWGS2eF7L7gyNMuz6JWdqYpAvb1KRoHxs", // group_pda
+];
+/**
+ * Fetches account public keys owned by a program from a given cluster.
+ * For Light Registry, returns known config accounts (skips forester/epoch accounts).
+ */
+async function getProgramOwnedAccounts(programId, rpcUrl) {
+    const isRegistry = programId === "Lighton6oQpVkeewmo2mcPTQQp7kYHr4fWpAgJyEmDX";
+    if (isRegistry) {
+        // Return known registry accounts instead of fetching all (too slow due to 88k+ forester accounts)
+        return REGISTRY_ACCOUNTS_TO_CLONE;
+    }
+    else {
+        // For other programs, fetch all accounts
+        const connection = new web3_js_1.Connection(rpcUrl);
+        const accounts = await connection.getProgramAccounts(new web3_js_1.PublicKey(programId), { dataSlice: { offset: 0, length: 0 } });
+        return accounts.map((acc) => acc.pubkey.toBase58());
+    }
+}
 async function stopTestEnv(options) {
     const processesToKill = [
         { name: "photon", condition: options.indexer, killFunction: processPhotonIndexer_1.killIndexer },
@@ -70,7 +103,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, cloneNetwork, verbose, skipReset, }) {
     // We cannot await this promise directly because it will hang the process
     startTestValidator({
         additionalPrograms,
@@ -80,6 +113,9 @@ async function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer = t
         gossipHost,
         validatorArgs,
         geyserConfig,
+        cloneNetwork,
+        verbose,
+        skipReset,
     });
     await (0, process_1.waitForServers)([{ port: rpcPort, path: "/health" }]);
     await (0, process_1.confirmServerStability)(`http://127.0.0.1:${rpcPort}/health`);
@@ -95,7 +131,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);
@@ -154,26 +190,31 @@ function programFilePath(programName) {
     }
     return path_1.default.resolve(__dirname, path_1.default.join(constants_1.BASE_PATH, programName));
 }
-async function getSolanaArgs({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, downloadBinaries = true, }) {
-    // TODO: adjust program tags
-    const programs = [...exports.SYSTEM_PROGRAMS];
-    if (additionalPrograms)
-        additionalPrograms.forEach((program) => {
-            programs.push({ id: program.address, path: program.path });
-        });
+async function getSolanaArgs({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, downloadBinaries = true, cloneNetwork, verbose = false, skipReset = false, }) {
     const dirPath = programsDirPath();
     const solanaArgs = [
-        "--reset",
         `--limit-ledger-size=${limitLedgerSize}`,
         `--rpc-port=${rpcPort}`,
         `--gossip-host=${gossipHost}`,
         "--quiet",
     ];
-    for (const program of programs) {
-        if (program.path) {
-            solanaArgs.push("--bpf-program", program.id, program.path);
+    if (!skipReset) {
+        solanaArgs.unshift("--reset");
+    }
+    // Add cluster URL if cloning from a network
+    if (cloneNetwork) {
+        const clusterUrl = cloneNetwork === "devnet" ? "devnet" : "mainnet-beta";
+        solanaArgs.push("--url", clusterUrl);
+    }
+    // Process system programs
+    for (const program of exports.SYSTEM_PROGRAMS) {
+        const shouldClone = cloneNetwork && PROGRAMS_TO_CLONE.includes(program.id);
+        if (shouldClone) {
+            // Clone program from network
+            solanaArgs.push("--clone-upgradeable-program", program.id);
         }
         else {
+            // Load program from local binary
             const localFilePath = programFilePath(program.name);
             if (program.name === "spl_noop.so" || downloadBinaries) {
                 await (0, psp_utils_1.downloadBinIfNotExists)({
@@ -188,14 +229,39 @@ async function getSolanaArgs({ additionalPrograms, skipSystemAccounts, limitLedg
             solanaArgs.push("--bpf-program", program.id, localFilePath);
         }
     }
-    if (!skipSystemAccounts) {
+    // Clone all accounts owned by the programs being cloned
+    if (cloneNetwork) {
+        const rpcUrl = cloneNetwork === "devnet"
+            ? "https://api.devnet.solana.com"
+            : "https://api.mainnet-beta.solana.com";
+        for (const programId of PROGRAMS_TO_CLONE) {
+            if (verbose) {
+                console.log(`Fetching accounts owned by ${programId}...`);
+            }
+            const accounts = await getProgramOwnedAccounts(programId, rpcUrl);
+            if (verbose) {
+                console.log(`Found ${accounts.length} accounts`);
+            }
+            for (const account of accounts) {
+                solanaArgs.push("--maybe-clone", account);
+            }
+        }
+    }
+    // Add additional user-provided programs (always loaded locally)
+    if (additionalPrograms) {
+        for (const program of additionalPrograms) {
+            solanaArgs.push("--bpf-program", program.address, program.path);
+        }
+    }
+    // Load local system accounts only if not cloning from network
+    if (!skipSystemAccounts && !cloneNetwork) {
         const accountsRelPath = "../../accounts";
         const accountsPath = path_1.default.resolve(__dirname, accountsRelPath);
         solanaArgs.push("--account-dir", accountsPath);
     }
     return solanaArgs;
 }
-async function startTestValidator({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, validatorArgs, geyserConfig, }) {
+async function startTestValidator({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, validatorArgs, geyserConfig, cloneNetwork, verbose, skipReset, }) {
     const command = "solana-test-validator";
     const solanaArgs = await getSolanaArgs({
         additionalPrograms,
@@ -203,6 +269,9 @@ async function startTestValidator({ additionalPrograms, skipSystemAccounts, limi
         limitLedgerSize,
         rpcPort,
         gossipHost,
+        cloneNetwork,
+        verbose,
+        skipReset,
     });
     await killTestValidator();
     await new Promise((r) => setTimeout(r, 1000));

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 });
@@ -181,6 +179,10 @@ function spawnBinary(command, args = []) {
             stdio: ["ignore", out, err],
             shell: false,
             detached: true,
+            env: {
+                ...process.env,
+                RUST_LOG: process.env.RUST_LOG || "debug",
+            },
         });
         spawnedProcess.on("close", async (code) => {
             console.log(`${binaryName} process exited with code ${code}`);
@@ -213,7 +215,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/processPhotonIndexer.js

@@ -23,13 +23,13 @@ async function isExpectedPhotonVersion(requiredVersion) {
 }
 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"`;
+        return `\nPhoton indexer ${constants_1.PHOTON_VERSION} (commit ${constants_1.PHOTON_GIT_COMMIT}) not found. Please install it by running: "cargo install --git ${constants_1.PHOTON_GIT_REPO} --rev ${constants_1.PHOTON_GIT_COMMIT} --locked --force"`;
     }
     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"`;
+        return `\nPhoton indexer ${constants_1.PHOTON_VERSION} not found. Please install it by running: "cargo install --git ${constants_1.PHOTON_GIT_REPO} --locked --force"`;
     }
     else {
-        return `\nLatest Photon indexer not found. Please install it by running: "cargo install photon-indexer --version ${constants_1.PHOTON_VERSION} --locked"`;
+        return `\nPhoton indexer ${constants_1.PHOTON_VERSION} not found. Please install it by running: "cargo install photon-indexer --version ${constants_1.PHOTON_VERSION} --locked --force"`;
     }
 }
 async function startIndexer(rpcUrl, indexerPort, checkPhotonVersion = true, photonDatabaseUrl) {

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,84 @@
 "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 os_1 = tslib_1.__importDefault(require("os"));
+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 KEYS_DIR = "proving-keys/";
+const downloadProverBinary_1 = require("./downloadProverBinary");
+const LIGHT_CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".config", "light");
+const PROVER_BIN_DIR = path_1.default.join(LIGHT_CONFIG_DIR, "bin");
+const KEYS_DIR = path_1.default.join(LIGHT_CONFIG_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 output = (0, child_process_1.execSync)(`"${binaryPath}" version`, {
+            encoding: "utf-8",
+            timeout: 5000,
+        }).trim();
+        // Extract version number (handles "v2.0.6", "light-prover v2.0.6", "2.0.6", etc.)
+        const match = output.match(/(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    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 args = ["start"];
-    args.push("--keys-dir", keysDir);
+    args.push("--keys-dir", KEYS_DIR);
     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,25 +87,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");
-    binaryName = path_1.default.join(binDir, binaryName);
-    return binaryName;
+    const binaryName = getProverNameByArch();
+    return path_1.default.join(PROVER_BIN_DIR, binaryName);
 }
 async function healthCheck(port, retries = 3, timeout = 3000) {
     const fetch = (await Promise.resolve().then(() => tslib_1.__importStar(require("node-fetch")))).default;

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;