@lightprotocol/zk-compression-cli 0.3.0

package/dist/psp-utils/download.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadBinIfNotExists = exports.downloadFile = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const fs = tslib_1.__importStar(require("fs"));
+const util_1 = require("util");
+const cli_progress_1 = tslib_1.__importDefault(require("cli-progress"));
+const path = tslib_1.__importStar(require("path"));
+const tar = tslib_1.__importStar(require("tar"));
+const zlib = tslib_1.__importStar(require("zlib"));
+const stateless_js_1 = require("@lightprotocol/stateless.js");
+const fileExists = (0, util_1.promisify)(fs.exists);
+async function latestRelease(owner, repo) {
+    const github = "https://api.github.com";
+    console.log(`🔍 Checking the latest release of ${github}/repos/${owner}/${repo}/releases/latest`);
+    const response = await axios_1.default.get(`${github}/repos/${owner}/${repo}/releases/latest`);
+    const tag_name = response.data.tag_name;
+    console.log(`📦 The newest release of ${repo} is ${tag_name}`);
+    return response.data.tag_name;
+}
+/**
+ * Makes the given file executable.
+ * @param filePath - The path to the file to make executable.
+ */
+function makeExecutable(filePath) {
+    fs.chmodSync(filePath, "755");
+}
+/**
+ * Makes all files without extensions in the given directory executable.
+ * @param dirPath - The path to the directory to make files executable.
+ * @returns {Promise<void>}
+ */
+async function makeExecutableInDir(dirPath) {
+    const files = fs.readdirSync(dirPath);
+    for (const file of files) {
+        const filePath = path.join(dirPath, file);
+        const stat = fs.statSync(filePath);
+        const extname = path.extname(filePath);
+        if (stat.isDirectory()) {
+            await makeExecutableInDir(filePath);
+        }
+        else if (!filePath.startsWith(".") &&
+            (extname === "" || extname === ".sh")) {
+            fs.chmodSync(filePath, "755");
+        }
+    }
+}
+/**
+ * Decompresses the given downloaded data stream to the given local file path.
+ * @param decompressor - The decompressor to use.
+ * @param data - The data stream to decompress.
+ * @param localFilePath - The local file path to decompress the data to. If
+ * provided, that only file will be decompressed from the archive. If not
+ * provided, all files will be decompressed to `dirPath`.
+ * @param dirPath - The directory path to decompress the data to.
+ * @returns {Promise<void>}
+ */
+function handleTarFile({ decompressor, data, localFilePath, dirPath, }) {
+    const parser = new tar.Parse();
+    data.pipe(decompressor).pipe(parser);
+    parser.on("entry", (entry) => {
+        const baseName = path.parse(entry.path).base;
+        const outputFilePath = localFilePath
+            ? localFilePath
+            : path.join(dirPath, entry.path);
+        if (baseName.startsWith("._")) {
+            // Ignore AppleDouble files.
+            entry.resume();
+        }
+        else if (!localFilePath ||
+            entry.path === path.parse(localFilePath).base) {
+            // Unpack the file if it's the one we want, or if we want all files.
+            // Create directory if it does not exist.
+            const dir = path.dirname(outputFilePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Check if entry is a file before attempting to create a write stream for it
+            if (entry.type === "file") {
+                entry.pipe(fs.createWriteStream(outputFilePath));
+            }
+            else if (entry.type === "File") {
+                entry.pipe(fs.createWriteStream(outputFilePath));
+            }
+            else {
+                entry.resume();
+            }
+        }
+        else {
+            entry.resume();
+        }
+    });
+    return new Promise((resolve, _reject) => {
+        parser.on("end", () => {
+            // Make the file executable after it has been written.
+            if (localFilePath) {
+                makeExecutable(localFilePath);
+            }
+            else {
+                makeExecutableInDir(dirPath);
+            }
+            resolve();
+        });
+    });
+}
+/**
+ * Downloads a file from the given URL to the given local file path.
+ * @param localFilePath - The local file path to download the file to. If
+ * provided and the download file is an archive, only the file with the same
+ * name as `localFilePath` will be extracted from the archive. If not provided,
+ * all files will be extracted to `dirPath`.
+ * @param dirPath - The path to the directory where the file(s) will be created.
+ * @param url - The URL to download the file from.
+ * @returns {Promise<void>}
+ */
+async function downloadFile({ localFilePath, dirPath, url, }) {
+    console.log(`📥 Downloading ${url}...`);
+    let retries = 3;
+    while (retries > 0) {
+        try {
+            const { data, headers } = await (0, axios_1.default)({
+                url,
+                method: "GET",
+                responseType: "stream",
+            });
+            const totalLength = headers["content-length"];
+            const progressBar = new cli_progress_1.default.SingleBar({}, cli_progress_1.default.Presets.shades_classic);
+            progressBar.start(totalLength, 0);
+            data.on("data", (chunk) => {
+                progressBar.increment(chunk.length);
+            });
+            data.on("end", () => {
+                progressBar.stop();
+            });
+            // If the file is a tar.gz file, decompress it while it's being written.
+            if (url.endsWith(".tar.gz")) {
+                console.log(`📦 Extracting ${url}...`);
+                const decompressor = zlib.createGunzip();
+                await handleTarFile({
+                    decompressor,
+                    data,
+                    localFilePath,
+                    dirPath,
+                });
+            }
+            else {
+                if (!localFilePath)
+                    throw new Error("localFilePath is undefined");
+                const writeStream = fs.createWriteStream(localFilePath);
+                data.pipe(writeStream);
+                return new Promise((resolve, reject) => {
+                    writeStream.on("finish", () => {
+                        makeExecutable(localFilePath);
+                        resolve();
+                    });
+                    writeStream.on("error", reject);
+                });
+            }
+            break;
+        }
+        catch (error) {
+            retries--;
+            console.error(`Failed to download ${url}. Retries left: ${retries}`);
+            if (retries <= 0) {
+                throw new Error(`Failed to download ${url} after multiple attempts.`);
+            }
+            await (0, stateless_js_1.sleep)(1000);
+        }
+    }
+}
+exports.downloadFile = downloadFile;
+/**
+ * Download a binary from the given release artifact of the GitHub repository,
+ * if it was not already downloaded.
+ * @param localFilePath - The path to the local file (which either already
+ * exists or will be created).
+ * @param dirPath - The path to the directory where the file(s) will be created.
+ * @param owner - The owner of the GitHub repository.
+ * @param repoName - The name of the GitHub repository.
+ * @param remoteFileName - The name of the file in the GitHub release artifact.
+ * @returns {Promise<void>}
+ */
+async function downloadBinIfNotExists({ localFilePath, dirPath, owner, repoName, remoteFileName, tag, }) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    // Check if file exists
+    if (await fileExists(localFilePath)) {
+        return;
+    }
+    if (!tag)
+        tag = await latestRelease(owner, repoName);
+    const url = `https://github.com/${owner}/${repoName}/releases/download/${tag}/${remoteFileName}`;
+    await downloadFile({
+        localFilePath,
+        dirPath,
+        url,
+    });
+    // Wait for a second to make sure the file is written
+    await (0, stateless_js_1.sleep)(1000);
+}
+exports.downloadBinIfNotExists = downloadBinIfNotExists;

package/dist/psp-utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./download";

package/dist/psp-utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./download"), exports);

package/dist/utils/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const SPL_NOOP_PROGRAM_TAG = "spl-noop-v0.2.0";
+export declare const LIGHT_MERKLE_TREE_PROGRAM_TAG = "light-merkle-tree-program-v0.3.1";
+export declare const CONFIG_PATH = "/.config/light/";
+export declare const CONFIG_FILE_NAME = "config.json";
+export declare const DEFAULT_CONFIG: {
+    solanaRpcUrl: string;
+};
+export declare const CARGO_GENERATE_TAG = "v0.18.4";
+export declare const SOLANA_VALIDATOR_PROCESS_NAME = "solana-test-validator";
+export declare const LIGHT_PROVER_PROCESS_NAME = "light-prover";
+export declare const INDEXER_PROCESS_NAME = "photon";
+export declare const PHOTON_VERSION = "0.18.0";
+export declare const LIGHT_PROTOCOL_PROGRAMS_DIR_ENV = "LIGHT_PROTOCOL_PROGRAMS_DIR";
+export declare const BASE_PATH = "../../bin/";

package/dist/utils/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_PATH = exports.LIGHT_PROTOCOL_PROGRAMS_DIR_ENV = exports.PHOTON_VERSION = exports.INDEXER_PROCESS_NAME = exports.LIGHT_PROVER_PROCESS_NAME = exports.SOLANA_VALIDATOR_PROCESS_NAME = exports.CARGO_GENERATE_TAG = exports.DEFAULT_CONFIG = exports.CONFIG_FILE_NAME = exports.CONFIG_PATH = exports.LIGHT_MERKLE_TREE_PROGRAM_TAG = exports.SPL_NOOP_PROGRAM_TAG = void 0;
+exports.SPL_NOOP_PROGRAM_TAG = "spl-noop-v0.2.0";
+exports.LIGHT_MERKLE_TREE_PROGRAM_TAG = "light-merkle-tree-program-v0.3.1";
+exports.CONFIG_PATH = "/.config/light/";
+exports.CONFIG_FILE_NAME = "config.json";
+exports.DEFAULT_CONFIG = {
+    solanaRpcUrl: "http://127.0.0.1:8899",
+};
+// TODO: investigate why latest cargo-generate fails
+// Fixed version because 11/11/23 release (v0.18.5) fails
+exports.CARGO_GENERATE_TAG = "v0.18.4";
+exports.SOLANA_VALIDATOR_PROCESS_NAME = "solana-test-validator";
+exports.LIGHT_PROVER_PROCESS_NAME = "light-prover";
+exports.INDEXER_PROCESS_NAME = "photon";
+exports.PHOTON_VERSION = "0.18.0";
+exports.LIGHT_PROTOCOL_PROGRAMS_DIR_ENV = "LIGHT_PROTOCOL_PROGRAMS_DIR";
+exports.BASE_PATH = "../../bin/";

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./utils";
+export * from "./initTestEnv";
+export * from "./processPhotonIndexer";
+export * from "./processProverServer";
+export * from "./constants";

package/dist/utils/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./initTestEnv"), exports);
+tslib_1.__exportStar(require("./processPhotonIndexer"), exports);
+tslib_1.__exportStar(require("./processProverServer"), exports);
+tslib_1.__exportStar(require("./constants"), exports);

package/dist/utils/initTestEnv.d.ts

@@ -0,0 +1,38 @@
+export declare function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer, prover, proveCompressedAccounts, proveNewAddresses, checkPhotonVersion, photonDatabaseUrl, }: {
+    additionalPrograms?: {
+        address: string;
+        path: string;
+    }[];
+    skipSystemAccounts?: boolean;
+    indexer: boolean;
+    prover: boolean;
+    proveCompressedAccounts?: boolean;
+    proveNewAddresses?: boolean;
+    checkPhotonVersion?: boolean;
+    photonDatabaseUrl?: string;
+}): Promise<void>;
+export declare function initTestEnvIfNeeded({ additionalPrograms, skipSystemAccounts, indexer, prover, }?: {
+    additionalPrograms?: {
+        address: string;
+        path: string;
+    }[];
+    skipSystemAccounts?: boolean;
+    indexer?: boolean;
+    prover?: boolean;
+}): Promise<void>;
+export declare function getSolanaArgs({ additionalPrograms, skipSystemAccounts, downloadBinaries, }: {
+    additionalPrograms?: {
+        address: string;
+        path: string;
+    }[];
+    skipSystemAccounts?: boolean;
+    downloadBinaries?: boolean;
+}): Promise<Array<string>>;
+export declare function startTestValidator({ additionalPrograms, skipSystemAccounts, }: {
+    additionalPrograms?: {
+        address: string;
+        path: string;
+    }[];
+    skipSystemAccounts?: boolean;
+}): Promise<void>;
+export declare function killTestValidator(): Promise<void>;

package/dist/utils/initTestEnv.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killTestValidator = exports.startTestValidator = exports.getSolanaArgs = exports.initTestEnvIfNeeded = exports.initTestEnv = void 0;
+const tslib_1 = require("tslib");
+const stateless_js_1 = require("@lightprotocol/stateless.js");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+const path_1 = tslib_1.__importDefault(require("path"));
+const psp_utils_1 = require("../psp-utils");
+const process_1 = require("./process");
+const processProverServer_1 = require("./processProverServer");
+const processPhotonIndexer_1 = require("./processPhotonIndexer");
+async function initTestEnv({ additionalPrograms, skipSystemAccounts, indexer = true, prover = true, proveCompressedAccounts = true, proveNewAddresses = false, checkPhotonVersion = true, photonDatabaseUrl, }) {
+    console.log("Performing setup tasks...\n");
+    const initAccounts = async () => {
+        const anchorProvider = await (0, utils_1.setAnchorProvider)();
+        const payer = await (0, utils_1.getPayer)();
+        await (0, stateless_js_1.airdropSol)({
+            connection: anchorProvider.connection,
+            lamports: 100e9,
+            recipientPublicKey: payer.publicKey,
+        });
+    };
+    // We cannot await this promise directly because it will hang the process
+    startTestValidator({ additionalPrograms, skipSystemAccounts });
+    await (0, process_1.waitForServers)([{ port: 8899, path: "/health" }]);
+    await (0, process_1.confirmServerStability)("http://127.0.0.1:8899/health");
+    await initAccounts();
+    if (indexer) {
+        await (0, processPhotonIndexer_1.startIndexer)(checkPhotonVersion, photonDatabaseUrl);
+    }
+    if (prover) {
+        await (0, processProverServer_1.startProver)(proveCompressedAccounts, proveNewAddresses);
+    }
+}
+exports.initTestEnv = initTestEnv;
+async function initTestEnvIfNeeded({ additionalPrograms, skipSystemAccounts, indexer = false, prover = false, } = {}) {
+    try {
+        const anchorProvider = await (0, utils_1.setAnchorProvider)();
+        // this request will fail if there is no local test validator running
+        const payer = await (0, utils_1.getPayer)();
+        await anchorProvider.connection.getBalance(payer.publicKey);
+    }
+    catch (error) {
+        // launch local test validator and initialize test environment
+        await initTestEnv({
+            additionalPrograms,
+            skipSystemAccounts,
+            indexer,
+            prover,
+        });
+    }
+}
+exports.initTestEnvIfNeeded = initTestEnvIfNeeded;
+/*
+ * Determines a path to which Light Protocol programs should be downloaded.
+ *
+ * If the `LIGHT_PROTOCOL_PROGRAMS_DIR` environment variable is set, the path
+ * provided in it is used.
+ *
+ * Otherwise, the `bin` directory in the CLI internals is used.
+ *
+ * @returns {string} Directory path for Light Protocol programs.
+ */
+function programsDirPath() {
+    return (process.env[constants_1.LIGHT_PROTOCOL_PROGRAMS_DIR_ENV] ||
+        path_1.default.resolve(__dirname, constants_1.BASE_PATH));
+}
+/*
+ * Determines a patch to which the given program should be downloaded.
+ *
+ * If the `LIGHT_PROTOCOL_PROGRAMS_DIR` environment variable is set, the path
+ * provided in it is used as a parent
+ *
+ * Otherwise, the `bin` directory in the CLI internals is used.
+ *
+ * @returns {string} Path for the given program.
+ */
+function programFilePath(programName) {
+    const programsDir = process.env[constants_1.LIGHT_PROTOCOL_PROGRAMS_DIR_ENV];
+    if (programsDir) {
+        return path_1.default.join(programsDir, programName);
+    }
+    return path_1.default.resolve(__dirname, path_1.default.join(constants_1.BASE_PATH, programName));
+}
+async function getSolanaArgs({ additionalPrograms, skipSystemAccounts, downloadBinaries = true, }) {
+    const LIMIT_LEDGER_SIZE = "500000000";
+    // TODO: adjust program tags
+    const programs = [
+        {
+            id: "noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV",
+            name: "spl_noop.so",
+            tag: constants_1.SPL_NOOP_PROGRAM_TAG,
+        },
+        {
+            id: "6UqiSPd2mRCTTwkzhcs1M6DGYsqHWd5jiPueX3LwDMXQ",
+            name: "light_system_program.so",
+            tag: constants_1.LIGHT_MERKLE_TREE_PROGRAM_TAG,
+        },
+        {
+            id: "9sixVEthz2kMSKfeApZXHwuboT6DZuT6crAYJTciUCqE",
+            name: "light_compressed_token.so",
+            tag: constants_1.LIGHT_MERKLE_TREE_PROGRAM_TAG,
+        },
+        {
+            id: "5QPEJ5zDsVou9FQS3KCauKswM3VwBEBu4dpL9xTqkWwN",
+            name: "account_compression.so",
+            tag: constants_1.LIGHT_MERKLE_TREE_PROGRAM_TAG,
+        },
+        {
+            id: "5WzvRtu7LABotw1SUEpguJiKU27LRGsiCnF5FH6VV7yP",
+            name: "light_registry.so",
+            tag: constants_1.LIGHT_MERKLE_TREE_PROGRAM_TAG,
+        },
+    ];
+    if (additionalPrograms)
+        additionalPrograms.forEach((program) => {
+            programs.push({ id: program.address, path: program.path });
+        });
+    const dirPath = programsDirPath();
+    const solanaArgs = [
+        "--reset",
+        `--limit-ledger-size=${LIMIT_LEDGER_SIZE}`,
+        "--quiet",
+    ];
+    for (const program of programs) {
+        if (program.path) {
+            solanaArgs.push("--bpf-program", program.id, program.path);
+        }
+        else {
+            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,
+                });
+            }
+            solanaArgs.push("--bpf-program", program.id, localFilePath);
+        }
+    }
+    if (!skipSystemAccounts) {
+        const accountsRelPath = "../../accounts";
+        const accountsPath = path_1.default.resolve(__dirname, accountsRelPath);
+        solanaArgs.push("--account-dir", accountsPath);
+    }
+    return solanaArgs;
+}
+exports.getSolanaArgs = getSolanaArgs;
+async function startTestValidator({ additionalPrograms, skipSystemAccounts, }) {
+    const command = "solana-test-validator";
+    const solanaArgs = await getSolanaArgs({
+        additionalPrograms,
+        skipSystemAccounts,
+    });
+    await killTestValidator();
+    await new Promise((r) => setTimeout(r, 1000));
+    console.log("Starting test validator...", command);
+    await (0, process_1.executeCommand)({
+        command,
+        args: [...solanaArgs],
+    });
+}
+exports.startTestValidator = startTestValidator;
+async function killTestValidator() {
+    await (0, process_1.killProcess)("solana-test-validator");
+}
+exports.killTestValidator = killTestValidator;

package/dist/utils/process.d.ts

@@ -0,0 +1,30 @@
+export declare function killProcess(processName: string): Promise<void>;
+export declare function killProcessByPort(port: string): Promise<void>;
+/**
+ * Executes a command and logs the output to the console.
+ * @param command - Path to the command to be executed.
+ * @param args - Arguments to be passed to the command.
+ * @param additionalPath - Additional path to be added to the PATH environment
+ * variable.
+ */
+export declare function executeCommand({ command, args, additionalPath, logFile, }: {
+    command: string;
+    args: string[];
+    additionalPath?: string;
+    logFile?: boolean;
+}): Promise<string>;
+/**
+ * Executes a shell command and returns a promise that resolves to the output of the shell command, or an error.
+ *
+ * @param command A shell command to execute
+ * @returns Promise that resolves to string output of shell command
+ * @throws {Error} If shell command execution fails
+ * @example const output = await execute("ls -alh");
+ */
+export declare function execute(command: string): Promise<string>;
+export declare function spawnBinary(command: string, args?: string[]): void;
+export declare function waitForServers(servers: {
+    port: number;
+    path: string;
+}[]): Promise<void>;
+export declare function confirmServerStability(url: string, attempts?: number): Promise<void>;

package/dist/utils/process.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirmServerStability = exports.waitForServers = exports.spawnBinary = exports.execute = exports.executeCommand = exports.killProcessByPort = exports.killProcess = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+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");
+async function killProcess(processName) {
+    const processList = await (0, find_process_1.default)("name", processName);
+    const targetProcesses = processList.filter((proc) => proc.cmd.split(" ")[0] === processName);
+    targetProcesses.forEach((proc) => {
+        process.kill(proc.pid);
+    });
+}
+exports.killProcess = killProcess;
+async function killProcessByPort(port) {
+    await execute("lsof -t -i:3001 | while read line; do kill -9 $line; done");
+}
+exports.killProcessByPort = killProcessByPort;
+/**
+ * Executes a command and logs the output to the console.
+ * @param command - Path to the command to be executed.
+ * @param args - Arguments to be passed to the command.
+ * @param additionalPath - Additional path to be added to the PATH environment
+ * variable.
+ */
+async function executeCommand({ command, args, additionalPath, logFile = true, }) {
+    return new Promise((resolve, reject) => {
+        const commandBase = path_1.default.basename(command);
+        let stdoutData = "";
+        const childPathEnv = additionalPath
+            ? process.env.PATH + path_1.default.delimiter + additionalPath
+            : process.env.PATH;
+        const options = {
+            env: childPathEnv ? { ...process.env, PATH: childPathEnv } : process.env,
+            detached: true,
+        };
+        if (logFile) {
+            const folderName = "test-ledger";
+            const file = `./${folderName}/${commandBase}.log`;
+            if (!fs_1.default.existsSync(folderName)) {
+                fs_1.default.mkdirSync(folderName);
+            }
+            const logStream = fs_1.default.createWriteStream(file, {
+                flags: "a",
+            });
+            process.stdout.pipe(logStream);
+            process.stderr.pipe(logStream);
+        }
+        console.log(`Executing command ${commandBase} ${args}...`);
+        let childProcess;
+        try {
+            childProcess = (0, child_process_1.spawn)(command, args, options);
+        }
+        catch (e) {
+            throw new Error(`Failed to execute command ${commandBase}: ${e}`);
+        }
+        childProcess.stdout.on("data", (data) => {
+            stdoutData += data.toString();
+            process.stdout.write(data);
+        });
+        childProcess.stderr.on("data", (data) => {
+            process.stderr.write(data);
+        });
+        childProcess.on("close", (code) => {
+            if (code !== 0) {
+                console.log(`${commandBase} exited with code ${code}`);
+                reject(new Error(`${commandBase} exited with code ${code}`));
+            }
+            else {
+                console.log(`${commandBase} finished successfully!`);
+                resolve(stdoutData);
+            }
+        });
+    });
+}
+exports.executeCommand = executeCommand;
+const exec = (0, util_1.promisify)(node_child_process_1.exec);
+/**
+ * Executes a shell command and returns a promise that resolves to the output of the shell command, or an error.
+ *
+ * @param command A shell command to execute
+ * @returns Promise that resolves to string output of shell command
+ * @throws {Error} If shell command execution fails
+ * @example const output = await execute("ls -alh");
+ */
+async function execute(command) {
+    try {
+        const { stdout } = await exec(command);
+        return stdout;
+    }
+    catch (err) {
+        console.log("Error in `execute`: ", err);
+        throw err;
+    }
+}
+exports.execute = execute;
+function spawnBinary(command, args = []) {
+    const logDir = "test-ledger";
+    const binaryName = path_1.default.basename(command);
+    const dir = path_1.default.join(__dirname, logDir);
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir);
+    }
+    const out = fs_1.default.openSync(`${logDir}/${binaryName}.log`, "a");
+    const err = fs_1.default.openSync(`${logDir}/${binaryName}.log`, "a");
+    const spawnedProcess = (0, child_process_1.spawn)(command, args, {
+        stdio: ["ignore", out, err],
+        shell: false,
+        detached: true,
+    });
+    spawnedProcess.on("close", (code) => {
+        console.log(`${binaryName} process exited with code ${code}`);
+    });
+}
+exports.spawnBinary = spawnBinary;
+async function waitForServers(servers) {
+    const opts = {
+        resources: servers.map(({ port, path }) => `http-get://127.0.0.1:${port}${path}`),
+        delay: 1000,
+        timeout: 15000,
+        interval: 300,
+        simultaneous: 2,
+        validateStatus: function (status) {
+            return ((status >= 200 && status < 300) || status === 404 || status === 405);
+        },
+    };
+    try {
+        await waitOn(opts);
+        servers.forEach((server) => {
+            console.log(`${server.port} is up!`);
+        });
+    }
+    catch (err) {
+        console.error("Error waiting for server to start:", err);
+        throw err;
+    }
+}
+exports.waitForServers = waitForServers;
+// Solana test validator can be unreliable when starting up.
+async function confirmServerStability(url, attempts = 20) {
+    try {
+        for (let i = 0; i < attempts; i++) {
+            const response = await axios_1.default.get(url);
+            if (response.status !== 200) {
+                throw new Error("Server failed stability check");
+            }
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        console.log("Server has passed stability checks.");
+    }
+    catch (error) {
+        console.error("Server stability check failed:", error);
+        throw error;
+    }
+}
+exports.confirmServerStability = confirmServerStability;

package/dist/utils/processPhotonIndexer.d.ts

@@ -0,0 +1 @@
+export declare function startIndexer(checkPhotonVersion?: boolean, photonDatabaseUrl?: string): Promise<void>;