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

package/dist/utils/downloadProverBinary.js

@@ -0,0 +1,107 @@
+"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 proverVersion_generated_1 = require("./proverVersion.generated");
+const GITHUB_RELEASES_BASE_URL = `https://github.com/Lightprotocol/light-protocol/releases/download/light-prover-v${proverVersion_generated_1.PROVER_VERSION}`;
+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 proverVersion_generated_1.PROVER_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,14 +113,21 @@ 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`);
+    await (0, process_1.confirmRpcReadiness)(`http://127.0.0.1:${rpcPort}`);
     if (indexer) {
         const config = (0, utils_1.getConfig)();
         config.indexerUrl = `http://127.0.0.1:${indexerPort}`;
         (0, utils_1.setConfig)(config);
-        await (0, processPhotonIndexer_1.startIndexer)(`http://127.0.0.1:${rpcPort}`, indexerPort, checkPhotonVersion, photonDatabaseUrl);
+        const proverUrlForIndexer = prover
+            ? `http://127.0.0.1:${proverPort}`
+            : undefined;
+        await (0, processPhotonIndexer_1.startIndexer)(`http://127.0.0.1:${rpcPort}`, indexerPort, checkPhotonVersion, photonDatabaseUrl, proverUrlForIndexer);
     }
     if (prover) {
         const config = (0, utils_1.getConfig)();
@@ -95,7 +135,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 +194,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 +233,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 +273,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.d.ts

@@ -33,3 +33,13 @@ export declare function waitForServers(servers: {
     path: string;
 }[]): Promise<void>;
 export declare function confirmServerStability(url: string, attempts?: number): Promise<void>;
+/**
+ * Confirms that the Solana RPC is fully ready to process requests.
+ * This goes beyond HTTP availability and verifies the RPC can handle actual Solana requests.
+ *
+ * @param rpcUrl - The RPC endpoint URL
+ * @param maxAttempts - Maximum number of attempts (default: 30)
+ * @param delayMs - Delay between attempts in milliseconds (default: 500ms)
+ * @throws Error if RPC doesn't become ready within maxAttempts
+ */
+export declare function confirmRpcReadiness(rpcUrl: string, maxAttempts?: number, delayMs?: number): Promise<void>;

package/dist/utils/process.js

@@ -8,6 +8,7 @@ exports.execute = execute;
 exports.spawnBinary = spawnBinary;
 exports.waitForServers = waitForServers;
 exports.confirmServerStability = confirmServerStability;
+exports.confirmRpcReadiness = confirmRpcReadiness;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
 const path_1 = tslib_1.__importDefault(require("path"));
@@ -16,14 +17,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 +168,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 +180,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 +216,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!`);
         });
@@ -240,3 +243,50 @@ async function confirmServerStability(url, attempts = 20) {
         throw error;
     }
 }
+/**
+ * Confirms that the Solana RPC is fully ready to process requests.
+ * This goes beyond HTTP availability and verifies the RPC can handle actual Solana requests.
+ *
+ * @param rpcUrl - The RPC endpoint URL
+ * @param maxAttempts - Maximum number of attempts (default: 30)
+ * @param delayMs - Delay between attempts in milliseconds (default: 500ms)
+ * @throws Error if RPC doesn't become ready within maxAttempts
+ */
+async function confirmRpcReadiness(rpcUrl, maxAttempts = 30, delayMs = 500) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const response = await axios_1.default.post(rpcUrl, {
+                jsonrpc: "2.0",
+                id: 1,
+                method: "getHealth",
+                params: [],
+            }, {
+                headers: { "Content-Type": "application/json" },
+                timeout: 3000,
+            });
+            if (response.data?.result === "ok") {
+                console.log(`RPC is ready after ${attempt} attempt${attempt > 1 ? "s" : ""}.`);
+                return;
+            }
+            // Response received but not "ok"
+            lastError = new Error(`RPC returned unexpected result: ${JSON.stringify(response.data)}`);
+        }
+        catch (error) {
+            lastError = error;
+            // Log connection errors only on later attempts to reduce noise
+            if (attempt > 5 && attempt % 5 === 0) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.log(`RPC not ready yet (attempt ${attempt}/${maxAttempts}): ${errorMsg}`);
+            }
+        }
+        // Don't sleep after the last attempt
+        if (attempt < maxAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    // If we get here, all attempts failed
+    const errorMsg = lastError instanceof Error ? lastError.message : String(lastError);
+    const totalTime = Math.round((maxAttempts * delayMs) / 1000);
+    throw new Error(`RPC failed to become ready after ${maxAttempts} attempts (~${totalTime}s). Last error: ${errorMsg}`);
+}

package/dist/utils/processPhotonIndexer.d.ts

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

package/dist/utils/processPhotonIndexer.js

@@ -23,16 +23,16 @@ 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) {
+async function startIndexer(rpcUrl, indexerPort, checkPhotonVersion = true, photonDatabaseUrl, proverUrl) {
     await killIndexer();
     const resolvedOrNull = which_1.default.sync("photon", { nothrow: true });
     if (resolvedOrNull === null ||
@@ -51,6 +51,9 @@ async function startIndexer(rpcUrl, indexerPort, checkPhotonVersion = true, phot
         if (photonDatabaseUrl) {
             args.push("--db-url", photonDatabaseUrl);
         }
+        if (proverUrl) {
+            args.push("--prover-url", proverUrl);
+        }
         (0, process_1.spawnBinary)(constants_1.INDEXER_PROCESS_NAME, args);
         await (0, process_1.waitForServers)([{ port: indexerPort, path: "/getIndexerHealth" }]);
         console.log("Indexer started successfully!");

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>;