@lightprotocol/zk-compression-cli 0.27.1-alpha.9 → 0.28.0-beta.10

package/dist/utils/initTestEnv.js

@@ -7,17 +7,22 @@ exports.initTestEnvIfNeeded = initTestEnvIfNeeded;
 exports.programsDirPath = programsDirPath;
 exports.programFilePath = programFilePath;
 exports.getSolanaArgs = getSolanaArgs;
+exports.getSurfpoolArgs = getSurfpoolArgs;
 exports.startTestValidator = startTestValidator;
 exports.killTestValidator = killTestValidator;
 const tslib_1 = require("tslib");
 const utils_1 = require("./utils");
 const constants_1 = require("./constants");
+const fs_1 = tslib_1.__importDefault(require("fs"));
 const path_1 = tslib_1.__importDefault(require("path"));
+const os_1 = tslib_1.__importDefault(require("os"));
 const psp_utils_1 = require("../psp-utils");
 const process_1 = require("./process");
 const processProverServer_1 = require("./processProverServer");
 const processPhotonIndexer_1 = require("./processPhotonIndexer");
+const processForester_1 = require("./processForester");
 const web3_js_1 = require("@solana/web3.js");
+const child_process_1 = require("child_process");
 exports.SYSTEM_PROGRAMS = [
     {
         id: "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV",
@@ -79,6 +84,7 @@ async function getProgramOwnedAccounts(programId, rpcUrl) {
 }
 async function stopTestEnv(options) {
     const processesToKill = [
+        { name: "forester", condition: options.forester ?? false, killFunction: processForester_1.killForester },
         { name: "photon", condition: options.indexer, killFunction: processPhotonIndexer_1.killIndexer },
         { name: "prover", condition: options.prover, killFunction: processProverServer_1.killProver },
         {
@@ -103,23 +109,62 @@ 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, geyserConfig, validatorArgs, cloneNetwork, verbose, skipReset, }) {
-    // We cannot await this promise directly because it will hang the process
-    startTestValidator({
-        additionalPrograms,
-        skipSystemAccounts,
-        limitLedgerSize,
-        rpcPort,
-        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}`);
+async function initTestEnv({ additionalPrograms, upgradeablePrograms, skipSystemAccounts, indexer = true, prover = true, forester = false, rpcPort = 8899, indexerPort = 8784, proverPort = 3001, foresterPort = 8080, gossipHost = "127.0.0.1", checkPhotonVersion = true, photonDatabaseUrl, limitLedgerSize, geyserConfig, validatorArgs, cloneNetwork, verbose, skipReset, useSurfpool, lightPdaPrograms, additionalAccountDirs, }) {
+    if (useSurfpool) {
+        // For surfpool we can await startTestValidator because spawnBinary returns
+        // immediately (surfpool starts in ~30ms). For solana-test-validator we must
+        // NOT await because the validator is a long-running process.
+        await startTestValidator({
+            additionalPrograms,
+            upgradeablePrograms,
+            skipSystemAccounts,
+            limitLedgerSize,
+            rpcPort,
+            gossipHost,
+            validatorArgs,
+            geyserConfig,
+            cloneNetwork,
+            verbose,
+            skipReset,
+            useSurfpool,
+            additionalAccountDirs,
+        });
+        // Surfpool only supports JSON-RPC POST, not GET /health.
+        await (0, process_1.confirmRpcReadiness)(`http://127.0.0.1:${rpcPort}`);
+    }
+    else {
+        // We cannot await this promise directly because it will hang the process
+        startTestValidator({
+            additionalPrograms,
+            upgradeablePrograms,
+            skipSystemAccounts,
+            limitLedgerSize,
+            rpcPort,
+            gossipHost,
+            validatorArgs,
+            geyserConfig,
+            cloneNetwork,
+            verbose,
+            skipReset,
+            useSurfpool,
+            additionalAccountDirs,
+        });
+        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 (prover) {
+        const config = (0, utils_1.getConfig)();
+        config.proverUrl = `http://127.0.0.1:${proverPort}`;
+        (0, utils_1.setConfig)(config);
+        try {
+            await (0, processProverServer_1.startProver)(proverPort);
+        }
+        catch (error) {
+            console.error("Failed to start prover:", error);
+            throw error;
+        }
+    }
     if (indexer) {
         const config = (0, utils_1.getConfig)();
         config.indexerUrl = `http://127.0.0.1:${indexerPort}`;
@@ -127,19 +172,54 @@ async function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer = t
         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);
+        // Surfpool's first available block may not be slot 0.
+        // Query the RPC so Photon starts from the correct slot.
+        let startSlot;
+        if (useSurfpool) {
+            const conn = new web3_js_1.Connection(`http://127.0.0.1:${rpcPort}`);
+            startSlot = await conn.getFirstAvailableBlock();
+        }
+        await (0, processPhotonIndexer_1.startIndexer)(`http://127.0.0.1:${rpcPort}`, indexerPort, checkPhotonVersion, photonDatabaseUrl, proverUrlForIndexer, startSlot);
     }
-    if (prover) {
-        const config = (0, utils_1.getConfig)();
-        config.proverUrl = `http://127.0.0.1:${proverPort}`;
-        (0, utils_1.setConfig)(config);
+    if (forester) {
+        if (!indexer || !prover) {
+            throw new Error("Forester requires both indexer and prover to be running");
+        }
         try {
-            // TODO: check if using redisUrl is better here.
-            await (0, processProverServer_1.startProver)(proverPort);
+            const payer = (0, processForester_1.getPayerForForester)();
+            await (0, processForester_1.startForester)({
+                rpcUrl: `http://127.0.0.1:${rpcPort}`,
+                wsRpcUrl: `ws://127.0.0.1:${rpcPort + 1}`,
+                indexerUrl: `http://127.0.0.1:${indexerPort}`,
+                proverUrl: `http://127.0.0.1:${proverPort}`,
+                payer,
+                foresterPort,
+                lightPdaPrograms,
+            });
         }
         catch (error) {
-            console.error("Failed to start prover:", error);
-            // Prover logs will be automatically displayed by spawnBinary in process.ts
+            console.error("Failed to start forester:", error);
+            throw error;
+        }
+    }
+    if (forester) {
+        if (!indexer || !prover) {
+            throw new Error("Forester requires both indexer and prover to be running");
+        }
+        try {
+            const payer = (0, processForester_1.getPayerForForester)();
+            await (0, processForester_1.startForester)({
+                rpcUrl: `http://127.0.0.1:${rpcPort}`,
+                wsRpcUrl: `ws://127.0.0.1:${rpcPort + 1}`,
+                indexerUrl: `http://127.0.0.1:${indexerPort}`,
+                proverUrl: `http://127.0.0.1:${proverPort}`,
+                payer,
+                foresterPort,
+                lightPdaPrograms,
+            });
+        }
+        catch (error) {
+            console.error("Failed to start forester:", error);
             throw error;
         }
     }
@@ -194,12 +274,12 @@ 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, cloneNetwork, verbose = false, skipReset = false, }) {
+async function getSolanaArgs({ additionalPrograms, upgradeablePrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, downloadBinaries = true, cloneNetwork, verbose = false, skipReset = false, }) {
     const dirPath = programsDirPath();
     const solanaArgs = [
         `--limit-ledger-size=${limitLedgerSize}`,
         `--rpc-port=${rpcPort}`,
-        `--gossip-host=${gossipHost}`,
+        `--bind-address=${gossipHost}`,
         "--quiet",
     ];
     if (!skipReset) {
@@ -257,6 +337,12 @@ async function getSolanaArgs({ additionalPrograms, skipSystemAccounts, limitLedg
             solanaArgs.push("--bpf-program", program.address, program.path);
         }
     }
+    // Add upgradeable programs (with upgrade authority)
+    if (upgradeablePrograms) {
+        for (const program of upgradeablePrograms) {
+            solanaArgs.push("--upgradeable-program", program.address, program.path, program.upgradeAuthority);
+        }
+    }
     // Load local system accounts only if not cloning from network
     if (!skipSystemAccounts && !cloneNetwork) {
         const accountsRelPath = "../../accounts";
@@ -265,34 +351,172 @@ async function getSolanaArgs({ additionalPrograms, skipSystemAccounts, limitLedg
     }
     return solanaArgs;
 }
-async function startTestValidator({ additionalPrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, validatorArgs, geyserConfig, cloneNetwork, verbose, skipReset, }) {
-    const command = "solana-test-validator";
-    const solanaArgs = await getSolanaArgs({
-        additionalPrograms,
-        skipSystemAccounts,
-        limitLedgerSize,
-        rpcPort,
-        gossipHost,
-        cloneNetwork,
-        verbose,
-        skipReset,
-    });
-    await killTestValidator();
-    await new Promise((r) => setTimeout(r, 1000));
-    // Add geyser config if provided
-    if (geyserConfig) {
-        solanaArgs.push("--geyser-plugin-config", geyserConfig);
-    }
-    // Add custom validator args last
-    if (validatorArgs) {
-        solanaArgs.push(...validatorArgs.split(" "));
-    }
-    console.log("Starting test validator...");
-    await (0, process_1.executeCommand)({
-        command,
-        args: [...solanaArgs],
+async function getSurfpoolArgs({ additionalPrograms, upgradeablePrograms, skipSystemAccounts, rpcPort, gossipHost, downloadBinaries = true, additionalAccountDirs, }) {
+    const dirPath = programsDirPath();
+    const args = ["start", "--offline", "--no-tui", "--no-deploy", "--no-studio"];
+    args.push("--port", String(rpcPort));
+    args.push("--host", String(gossipHost));
+    // Load system programs
+    for (const program of exports.SYSTEM_PROGRAMS) {
+        const localFilePath = programFilePath(program.name);
+        if (program.name === "spl_noop.so" || downloadBinaries) {
+            await (0, psp_utils_1.downloadBinIfNotExists)({
+                localFilePath,
+                dirPath,
+                owner: "Lightprotocol",
+                repoName: "light-protocol",
+                remoteFileName: program.name,
+                tag: program.tag,
+            });
+        }
+        args.push("--bpf-program", program.id, localFilePath);
+    }
+    // Load additional programs
+    if (additionalPrograms) {
+        for (const program of additionalPrograms) {
+            args.push("--bpf-program", program.address, program.path);
+        }
+    }
+    // Load upgradeable programs with full BPF upgradeable loader account layout
+    if (upgradeablePrograms) {
+        for (const program of upgradeablePrograms) {
+            args.push("--upgradeable-program", program.address, program.path, program.upgradeAuthority);
+        }
+    }
+    // Load system accounts
+    if (!skipSystemAccounts) {
+        const accountsRelPath = "../../accounts";
+        const accountsPath = path_1.default.resolve(__dirname, accountsRelPath);
+        args.push("--account-dir", accountsPath);
+    }
+    // Load additional account directories
+    if (additionalAccountDirs) {
+        for (const accountDir of additionalAccountDirs) {
+            args.push("--account-dir", path_1.default.resolve(accountDir));
+        }
+    }
+    return args;
+}
+function getSurfpoolAssetName() {
+    const platform = process.platform; // "darwin" | "linux"
+    const arch = process.arch; // "arm64" | "x64"
+    return `surfpool-${platform}-${arch}.tar.gz`;
+}
+function getSurfpoolBinDir() {
+    return path_1.default.join(os_1.default.homedir(), ".config", "light", "bin");
+}
+function getSurfpoolBinaryPath() {
+    return path_1.default.join(getSurfpoolBinDir(), "surfpool");
+}
+function getInstalledSurfpoolVersion() {
+    const binaryPath = getSurfpoolBinaryPath();
+    if (!fs_1.default.existsSync(binaryPath)) {
+        return null;
+    }
+    try {
+        const output = (0, child_process_1.execSync)(`"${binaryPath}" --version`, {
+            encoding: "utf-8",
+            timeout: 5000,
+        }).trim();
+        const match = output.match(/(\d+\.\d+\.\d+)/);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function downloadSurfpoolBinary() {
+    const binPath = getSurfpoolBinaryPath();
+    const dirPath = getSurfpoolBinDir();
+    const assetName = getSurfpoolAssetName();
+    if (!fs_1.default.existsSync(dirPath)) {
+        fs_1.default.mkdirSync(dirPath, { recursive: true });
+    }
+    // Remove existing binary so downloadBinIfNotExists actually downloads
+    if (fs_1.default.existsSync(binPath)) {
+        fs_1.default.unlinkSync(binPath);
+    }
+    await (0, psp_utils_1.downloadBinIfNotExists)({
+        localFilePath: binPath,
+        dirPath,
+        owner: "Lightprotocol",
+        repoName: "surfpool",
+        remoteFileName: assetName,
+        tag: constants_1.SURFPOOL_RELEASE_TAG,
     });
 }
-async function killTestValidator() {
+async function ensureSurfpoolBinary() {
+    const binPath = getSurfpoolBinaryPath();
+    const installedVersion = getInstalledSurfpoolVersion();
+    if (installedVersion === constants_1.SURFPOOL_VERSION) {
+        return binPath;
+    }
+    if (installedVersion) {
+        console.log(`Surfpool version mismatch. Expected: ${constants_1.SURFPOOL_VERSION}, Found: ${installedVersion}. Downloading correct version...`);
+    }
+    else if (fs_1.default.existsSync(binPath)) {
+        console.log("Surfpool binary found but version could not be determined. Downloading latest version...");
+    }
+    await downloadSurfpoolBinary();
+    return binPath;
+}
+async function startTestValidator({ additionalPrograms, upgradeablePrograms, skipSystemAccounts, limitLedgerSize, rpcPort, gossipHost, validatorArgs, geyserConfig, cloneNetwork, verbose, skipReset, useSurfpool, additionalAccountDirs, }) {
+    if (useSurfpool) {
+        const command = await ensureSurfpoolBinary();
+        const surfpoolArgs = await getSurfpoolArgs({
+            additionalPrograms,
+            upgradeablePrograms,
+            skipSystemAccounts,
+            rpcPort,
+            gossipHost,
+            additionalAccountDirs,
+        });
+        await killTestValidator(rpcPort);
+        await new Promise((r) => setTimeout(r, 1000));
+        console.log("Starting surfpool...");
+        (0, process_1.spawnBinary)(command, surfpoolArgs, process.env);
+    }
+    else {
+        const command = "solana-test-validator";
+        const solanaArgs = await getSolanaArgs({
+            additionalPrograms,
+            upgradeablePrograms,
+            skipSystemAccounts,
+            limitLedgerSize,
+            rpcPort,
+            gossipHost,
+            cloneNetwork,
+            verbose,
+            skipReset,
+        });
+        await killTestValidator(rpcPort);
+        await new Promise((r) => setTimeout(r, 1000));
+        // Add geyser config if provided
+        if (geyserConfig) {
+            solanaArgs.push("--geyser-plugin-config", geyserConfig);
+        }
+        // Add custom validator args last
+        if (validatorArgs) {
+            solanaArgs.push(...validatorArgs.split(" "));
+        }
+        console.log("Starting test validator...");
+        // Use spawnBinary instead of executeCommand to properly detach the process.
+        // This ensures the validator survives when the CLI exits (executeCommand uses
+        // piped stdio which causes SIGPIPE when parent exits).
+        // Pass process.env directly to maintain same env behavior as before.
+        (0, process_1.spawnBinary)(command, solanaArgs, process.env);
+    }
+}
+async function killTestValidator(rpcPort = 8899) {
     await (0, process_1.killProcess)("solana-test-validator");
+    await (0, process_1.killProcess)("surfpool");
+    // Fallback: kill anything still listening on the RPC port.
+    // find-process name matching can miss processes depending on platform
+    // and how the binary path appears in the process table.
+    try {
+        await (0, process_1.killProcessByPort)(rpcPort);
+    }
+    catch {
+        // No process listening on the port, nothing to do.
+    }
 }

package/dist/utils/photonVersion.generated.d.ts

@@ -0,0 +1,3 @@
+export declare const PHOTON_VERSION = "0.51.2";
+export declare const PHOTON_GIT_COMMIT = "7a649f9c45a138ef47b090445163abe84775145c";
+export declare const PHOTON_GIT_REPO = "https://github.com/lightprotocol/photon.git";

package/dist/utils/photonVersion.generated.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHOTON_GIT_REPO = exports.PHOTON_GIT_COMMIT = exports.PHOTON_VERSION = void 0;
+// Auto-generated from external/photon submodule - do not edit manually
+exports.PHOTON_VERSION = "0.51.2";
+exports.PHOTON_GIT_COMMIT = "7a649f9c45a138ef47b090445163abe84775145c";
+exports.PHOTON_GIT_REPO = "https://github.com/lightprotocol/photon.git";

package/dist/utils/process.d.ts

@@ -27,7 +27,7 @@ export declare function executeCommand({ command, args, additionalPath, logFile,
  * @example const output = await execute("ls -alh");
  */
 export declare function execute(command: string): Promise<string>;
-export declare function spawnBinary(command: string, args?: string[]): import("child_process").ChildProcess;
+export declare function spawnBinary(command: string, args?: string[], env?: NodeJS.ProcessEnv): import("child_process").ChildProcess;
 export declare function waitForServers(servers: {
     port: number;
     path: string;

package/dist/utils/process.js

@@ -55,19 +55,17 @@ async function logProverFileContents() {
 }
 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));
+    const targetProcesses = processList.filter((proc) => proc.pid !== process.pid &&
+        proc.pid !== process.ppid &&
+        (proc.name.includes(processName) || proc.cmd.includes(processName)));
     for (const proc of targetProcesses) {
         try {
             process.kill(proc.pid, "SIGKILL");
         }
         catch (error) {
-            console.error(`Failed to kill process ${proc.pid}: ${error}`);
+            // Process may have already exited between find and kill.
         }
     }
-    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`);
-    }
 }
 async function killProcessByPort(port) {
     if (port < 0) {
@@ -165,7 +163,7 @@ async function execute(command) {
         throw err;
     }
 }
-function spawnBinary(command, args = []) {
+function spawnBinary(command, args = [], env) {
     const logDir = "test-ledger";
     const binaryName = path_1.default.basename(command);
     const dir = path_1.default.join(process.cwd(), logDir);
@@ -180,16 +178,33 @@ function spawnBinary(command, args = []) {
             stdio: ["ignore", out, err],
             shell: false,
             detached: true,
-            env: {
+            env: env ?? {
                 ...process.env,
                 RUST_LOG: process.env.RUST_LOG || "debug",
             },
         });
+        // Close parent's copy of the file descriptors so the child owns them
+        // exclusively and node's event loop isn't held open.
+        fs_1.default.closeSync(out);
+        fs_1.default.closeSync(err);
+        // Allow node to exit without waiting for the detached child.
+        spawnedProcess.unref();
         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();
+            if (code !== 0) {
+                console.error(`${binaryName} process failed with exit code ${code}`);
+                try {
+                    const contents = fs_1.default.readFileSync(logPath, "utf8");
+                    console.error(`--- ${binaryName}.log ---`);
+                    console.error(contents);
+                    console.error(`--- End of ${binaryName}.log ---`);
+                }
+                catch {
+                    // log file may not exist yet
+                }
+                if (binaryName.includes("prover")) {
+                    await logProverFileContents();
+                }
             }
         });
         return spawnedProcess;

package/dist/utils/processForester.d.ts

@@ -0,0 +1,23 @@
+export interface ForesterConfig {
+    rpcUrl: string;
+    wsRpcUrl: string;
+    indexerUrl: string;
+    proverUrl: string;
+    payer: string;
+    foresterPort: number;
+    lightPdaPrograms?: string[];
+}
+/**
+ * Starts the forester service for auto-compression of compressible accounts.
+ *
+ * @param config - Forester configuration
+ */
+export declare function startForester(config: ForesterConfig): Promise<undefined>;
+export declare function killForester(): Promise<void>;
+/**
+ * Gets the payer keypair as a JSON array string for forester.
+ * Reads from ~/.config/solana/id.json or SOLANA_PAYER environment variable.
+ *
+ * @returns JSON array string of the keypair bytes
+ */
+export declare function getPayerForForester(): string;

package/dist/utils/processForester.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startForester = startForester;
+exports.killForester = killForester;
+exports.getPayerForForester = getPayerForForester;
+const tslib_1 = require("tslib");
+const which_1 = tslib_1.__importDefault(require("which"));
+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 fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const execAsync = util.promisify(node_child_process_1.exec);
+async function isForesterInstalled() {
+    try {
+        const resolvedOrNull = which_1.default.sync("forester", { nothrow: true });
+        return resolvedOrNull !== null;
+    }
+    catch (error) {
+        return false;
+    }
+}
+function getForesterInstallMessage() {
+    return `\nForester not found. Please install it by running: "cargo install --git https://github.com/Lightprotocol/light-protocol forester --locked --force"`;
+}
+/**
+ * Starts the forester service for auto-compression of compressible accounts.
+ *
+ * @param config - Forester configuration
+ */
+async function startForester(config) {
+    await killForester();
+    if (!(await isForesterInstalled())) {
+        console.log(getForesterInstallMessage());
+        return (0, node_process_1.exit)(1);
+    }
+    console.log("Starting forester...");
+    const args = [
+        "start",
+        "--rpc-url",
+        config.rpcUrl,
+        "--ws-rpc-url",
+        config.wsRpcUrl,
+        "--indexer-url",
+        config.indexerUrl,
+        "--prover-url",
+        config.proverUrl,
+        "--payer",
+        config.payer,
+        "--api-server-port",
+        config.foresterPort.toString(),
+        "--enable-compressible",
+    ];
+    // Add light PDA programs if specified
+    if (config.lightPdaPrograms && config.lightPdaPrograms.length > 0) {
+        for (const program of config.lightPdaPrograms) {
+            args.push("--light-pda-program", program);
+        }
+    }
+    (0, process_1.spawnBinary)(constants_1.FORESTER_PROCESS_NAME, args);
+    await (0, process_1.waitForServers)([{ port: config.foresterPort, path: "/health" }]);
+    console.log("Forester started successfully!");
+}
+async function killForester() {
+    await (0, process_1.killProcess)(constants_1.FORESTER_PROCESS_NAME);
+}
+/**
+ * Gets the payer keypair as a JSON array string for forester.
+ * Reads from ~/.config/solana/id.json or SOLANA_PAYER environment variable.
+ *
+ * @returns JSON array string of the keypair bytes
+ */
+function getPayerForForester() {
+    // Check for SOLANA_PAYER environment variable first
+    if (process.env.SOLANA_PAYER) {
+        return process.env.SOLANA_PAYER;
+    }
+    // Default to standard Solana keypair location
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    const keypairPath = path.join(homeDir, ".config", "solana", "id.json");
+    if (fs.existsSync(keypairPath)) {
+        const keypairData = fs.readFileSync(keypairPath, "utf-8");
+        return keypairData.trim();
+    }
+    throw new Error("No payer keypair found. Set SOLANA_PAYER environment variable or create ~/.config/solana/id.json");
+}

package/dist/utils/processPhotonIndexer.d.ts

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

package/dist/utils/processPhotonIndexer.js

@@ -6,6 +6,7 @@ const tslib_1 = require("tslib");
 const which_1 = tslib_1.__importDefault(require("which"));
 const process_1 = require("./process");
 const constants_1 = require("./constants");
+const photonVersion_generated_1 = require("./photonVersion.generated");
 const node_child_process_1 = require("node:child_process");
 const util = tslib_1.__importStar(require("node:util"));
 const node_process_1 = require("node:process");
@@ -22,21 +23,13 @@ async function isExpectedPhotonVersion(requiredVersion) {
     }
 }
 function getPhotonInstallMessage() {
-    if (constants_1.USE_PHOTON_FROM_GIT && constants_1.PHOTON_GIT_COMMIT) {
-        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 `\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 `\nPhoton indexer ${constants_1.PHOTON_VERSION} not found. Please install it by running: "cargo install photon-indexer --version ${constants_1.PHOTON_VERSION} --locked --force"`;
-    }
+    return `\nPhoton indexer ${photonVersion_generated_1.PHOTON_VERSION} (commit ${photonVersion_generated_1.PHOTON_GIT_COMMIT}) not found. Please install it by running: "cargo install --git ${photonVersion_generated_1.PHOTON_GIT_REPO} --rev ${photonVersion_generated_1.PHOTON_GIT_COMMIT} --locked --force"`;
 }
-async function startIndexer(rpcUrl, indexerPort, checkPhotonVersion = true, photonDatabaseUrl, proverUrl) {
+async function startIndexer(rpcUrl, indexerPort, checkPhotonVersion = true, photonDatabaseUrl, proverUrl, startSlot) {
     await killIndexer();
     const resolvedOrNull = which_1.default.sync("photon", { nothrow: true });
     if (resolvedOrNull === null ||
-        (checkPhotonVersion && !(await isExpectedPhotonVersion(constants_1.PHOTON_VERSION)))) {
+        (checkPhotonVersion && !(await isExpectedPhotonVersion(photonVersion_generated_1.PHOTON_VERSION)))) {
         console.log(getPhotonInstallMessage());
         return (0, node_process_1.exit)(1);
     }
@@ -54,6 +47,9 @@ async function startIndexer(rpcUrl, indexerPort, checkPhotonVersion = true, phot
         if (proverUrl) {
             args.push("--prover-url", proverUrl);
         }
+        if (startSlot !== undefined) {
+            args.push("--start-slot", startSlot.toString());
+        }
         (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.js

@@ -84,6 +84,7 @@ async function startProver(proverPort, redisUrl) {
     }
     (0, process_1.spawnBinary)(getProverPathByArch(), args);
     await (0, process_1.waitForServers)([{ port: proverPort, path: "/" }]);
+    await new Promise((r) => setTimeout(r, 5000));
     console.log(`Prover started successfully!`);
 }
 function getProverNameByArch() {