@lightprotocol/zk-compression-cli 0.3.0

package/dist/utils/processPhotonIndexer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startIndexer = void 0;
+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"));
+async function startIndexer(checkPhotonVersion = true, photonDatabaseUrl) {
+    await killIndexer();
+    const resolvedOrNull = which_1.default.sync("photon", { nothrow: true });
+    if (resolvedOrNull === null ||
+        (checkPhotonVersion && !(await isExpectedPhotonVersion(constants_1.PHOTON_VERSION)))) {
+        const message = `Photon indexer not found. Please install it by running "cargo install photon-indexer --version ${constants_1.PHOTON_VERSION}"`;
+        console.log(message);
+        throw new Error(message);
+    }
+    else {
+        console.log("Starting indexer...");
+        let args = [];
+        if (photonDatabaseUrl) {
+            args = ["--db-url", photonDatabaseUrl];
+        }
+        (0, process_1.spawnBinary)(constants_1.INDEXER_PROCESS_NAME, args);
+        await (0, process_1.waitForServers)([{ port: 8784, path: "/getIndexerHealth" }]);
+        console.log("Indexer started successfully!");
+    }
+}
+exports.startIndexer = startIndexer;
+async function killIndexer() {
+    await (0, process_1.killProcess)(constants_1.INDEXER_PROCESS_NAME);
+}
+const execAsync = util.promisify(node_child_process_1.exec);
+async function isExpectedPhotonVersion(requiredVersion) {
+    try {
+        const { stdout } = await execAsync("photon --version");
+        const version = stdout.trim();
+        return version.includes(requiredVersion);
+    }
+    catch (error) {
+        console.error("Error checking Photon version:", error);
+        return false;
+    }
+}

package/dist/utils/processProverServer.d.ts

@@ -0,0 +1,3 @@
+export declare function killProver(): Promise<void>;
+export declare function startProver(proveCompressedAccounts: boolean, proveNewAddresses: boolean): Promise<void>;
+export declare function getProverNameByArch(): string;

package/dist/utils/processProverServer.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProverNameByArch = exports.startProver = exports.killProver = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const process_1 = require("./process");
+const constants_1 = require("./constants");
+const KEYS_DIR = "proving-keys/";
+async function killProver() {
+    await (0, process_1.killProcess)(getProverNameByArch());
+    // Temporary fix for the case when prover is instantiated via prover.sh:
+    await (0, process_1.killProcess)(constants_1.LIGHT_PROVER_PROCESS_NAME);
+}
+exports.killProver = killProver;
+async function startProver(proveCompressedAccounts, proveNewAddresses) {
+    if (!proveCompressedAccounts && !proveNewAddresses) {
+        console.log("No flags provided. Please provide at least one flag to start the prover.");
+        process.exit(1);
+    }
+    console.log("Kill existing prover process...");
+    await killProver();
+    await (0, process_1.killProcessByPort)("3001");
+    const keysDir = path_1.default.join(__dirname, "../..", "bin", KEYS_DIR);
+    const args = ["start"];
+    args.push(`--inclusion=${proveCompressedAccounts ? "true" : "false"}`);
+    args.push(`--non-inclusion=${proveNewAddresses ? "true" : "false"}`);
+    args.push("--keys-dir", keysDir);
+    console.log("Starting prover...");
+    (0, process_1.spawnBinary)(getProverNameByArch(), args);
+    await (0, process_1.waitForServers)([{ port: 3001, path: "/" }]);
+    console.log("Prover started successfully!");
+}
+exports.startProver = startProver;
+function getProverNameByArch() {
+    const platform = process.platform;
+    const arch = process.arch;
+    if (!platform || !arch) {
+        throw new Error("Unsupported platform or architecture");
+    }
+    let binaryName = `prover-${platform}-${arch}`;
+    if (platform.toString() === "windows") {
+        binaryName += ".exe";
+    }
+    // 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;
+}
+exports.getProverNameByArch = getProverNameByArch;

package/dist/utils/standardFlags.d.ts

@@ -0,0 +1,8 @@
+export declare const standardFlags: {
+    skipFetchBalance: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    localTestRpc: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare const confirmOptionsFlags: {
+    spendable: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    finalized: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};

package/dist/utils/standardFlags.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirmOptionsFlags = exports.standardFlags = void 0;
+const core_1 = require("@oclif/core");
+exports.standardFlags = {
+    skipFetchBalance: core_1.Flags.boolean({
+        char: "b",
+        description: "Skip fetching the most recent balance prior to the operation",
+        required: false,
+        default: false,
+        parse: async () => true,
+    }),
+    localTestRpc: core_1.Flags.boolean({
+        description: "Using a local test rpc",
+        aliases: ["lr"],
+        required: false,
+        default: true,
+        parse: async () => true,
+    }),
+};
+exports.confirmOptionsFlags = {
+    spendable: core_1.Flags.boolean({
+        char: "s",
+        description: "Fetch the most recent balance prior to the operation",
+        required: false,
+        default: false,
+        parse: async () => true,
+    }),
+    finalized: core_1.Flags.boolean({
+        char: "f",
+        description: "Fetch the most recent balance prior to the operation",
+        required: false,
+        default: false,
+        parse: async () => true,
+    }),
+};

package/dist/utils/utils.d.ts

@@ -0,0 +1,26 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Keypair } from "@solana/web3.js";
+export declare const defaultSolanaWalletKeypair: () => Keypair;
+export declare const setAnchorProvider: () => Promise<anchor.AnchorProvider>;
+export declare function getPayer(): Promise<anchor.web3.Keypair>;
+export declare function generateSolanaTransactionURL(transactionType: "tx" | "address", transactionHash: string, cluster: string): string;
+type Config = {
+    solanaRpcUrl: string;
+};
+export declare const getSolanaRpcUrl: () => string;
+export declare const getConfig: (filePath?: string) => Config;
+export declare function ensureDirectoryExists(dirPath: string): void;
+export declare const setConfig: (config: Partial<Config>, filePath?: string) => void;
+export declare class CustomLoader {
+    message: string;
+    logInterval: any;
+    logTimer: number | null;
+    startTime: number;
+    constructor(message: string, logInterval?: number);
+    start(): void;
+    stop(terminateCurve?: boolean): void;
+    logElapsedTime(): void;
+}
+export declare function isValidURL(url: string): boolean;
+export declare function isValidBase58SecretKey(secretKey: string): boolean;
+export {};

package/dist/utils/utils.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidBase58SecretKey = exports.isValidURL = exports.CustomLoader = exports.setConfig = exports.ensureDirectoryExists = exports.getConfig = exports.getSolanaRpcUrl = exports.generateSolanaTransactionURL = exports.getPayer = exports.setAnchorProvider = exports.defaultSolanaWalletKeypair = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const anchor = tslib_1.__importStar(require("@coral-xyz/anchor"));
+const solana = tslib_1.__importStar(require("@solana/web3.js"));
+const web3_js_1 = require("@solana/web3.js");
+const stateless_js_1 = require("@lightprotocol/stateless.js");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const constants_1 = require("./constants");
+const helpers_1 = require("@solana-developers/helpers");
+const cli_spinners_1 = tslib_1.__importDefault(require("cli-spinners"));
+require("dotenv").config();
+const defaultSolanaWalletKeypair = () => {
+    const walletPath = process.env.HOME + "/.config/solana/id.json";
+    if (fs.existsSync(walletPath)) {
+        return web3_js_1.Keypair.fromSecretKey(new Uint8Array(JSON.parse(fs.readFileSync(walletPath, "utf-8"))));
+    }
+    else {
+        throw new Error("Wallet file not found");
+    }
+};
+exports.defaultSolanaWalletKeypair = defaultSolanaWalletKeypair;
+const setAnchorProvider = async () => {
+    process.env.ANCHOR_WALLET = getWalletPath();
+    process.env.ANCHOR_PROVIDER_URL = (0, exports.getSolanaRpcUrl)();
+    const connection = new solana.Connection((0, exports.getSolanaRpcUrl)(), "confirmed");
+    const payer = await getPayer();
+    const anchorProvider = new anchor.AnchorProvider(connection, new anchor.Wallet(payer), stateless_js_1.confirmConfig);
+    anchor.setProvider(anchorProvider);
+    return anchorProvider;
+};
+exports.setAnchorProvider = setAnchorProvider;
+function getWalletPath() {
+    return process.env.HOME + "/.config/solana/id.json";
+}
+async function getPayer() {
+    return await (0, helpers_1.getKeypairFromFile)(getWalletPath());
+}
+exports.getPayer = getPayer;
+function generateSolanaTransactionURL(transactionType, transactionHash, cluster) {
+    return `https://explorer.solana.com/${transactionType}/${transactionHash}?cluster=${cluster}`;
+}
+exports.generateSolanaTransactionURL = generateSolanaTransactionURL;
+const getSolanaRpcUrl = () => {
+    const config = (0, exports.getConfig)();
+    return config.solanaRpcUrl;
+};
+exports.getSolanaRpcUrl = getSolanaRpcUrl;
+function getConfigPath() {
+    // Check for the environment variable
+    const envConfigPath = process.env.LIGHT_PROTOCOL_CONFIG;
+    if (envConfigPath) {
+        console.log(`reading config from custom path ${envConfigPath}`);
+        if (!(0, fs_1.existsSync)(envConfigPath)) {
+            throw new Error(`Config file not found at ${envConfigPath}, this path is configured with the environment variable LIGHT_PROTOCOL_CONFIG, the default path is ${process.env.HOME + constants_1.CONFIG_PATH + constants_1.CONFIG_FILE_NAME}, to use the default path, remove the environment variable LIGHT_PROTOCOL_CONFIG`);
+        }
+        return envConfigPath;
+    }
+    // Default path
+    return process.env.HOME + constants_1.CONFIG_PATH + constants_1.CONFIG_FILE_NAME;
+}
+const getConfig = (filePath) => {
+    if (!filePath)
+        filePath = getConfigPath();
+    let configData;
+    try {
+        configData = fs.readFileSync(filePath, "utf-8");
+    }
+    catch (error) {
+        // Ensure the directory structure exists
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        ensureDirectoryExists(process.env.HOME + constants_1.CONFIG_PATH);
+        if (!fs.existsSync(filePath)) {
+            const data = {
+                ...constants_1.DEFAULT_CONFIG,
+                secretKey: bytes_1.bs58.encode(solana.Keypair.generate().secretKey),
+            };
+            fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+            console.log("created config file in", filePath);
+            configData = fs.readFileSync(filePath, "utf-8");
+        }
+    }
+    return JSON.parse(configData);
+};
+exports.getConfig = getConfig;
+function ensureDirectoryExists(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+exports.ensureDirectoryExists = ensureDirectoryExists;
+const setConfig = (config, filePath) => {
+    if (!filePath)
+        filePath = getConfigPath();
+    try {
+        const existingConfig = (0, exports.getConfig)();
+        const updatedConfig = { ...existingConfig, ...config };
+        fs.writeFileSync(filePath, JSON.stringify(updatedConfig, null, 2));
+    }
+    catch (error) {
+        throw new Error("Failed to update configuration file");
+    }
+};
+exports.setConfig = setConfig;
+class CustomLoader {
+    constructor(message, logInterval = 1000) {
+        this.message = message;
+        this.logInterval = logInterval;
+        this.logTimer = null;
+        this.startTime = Date.now();
+    }
+    start() {
+        this.startTime = Date.now();
+        process.stdout.write(`\n${cli_spinners_1.default.dots.frames[Math.floor(Math.random() * 10)]} ${this.message}\n`);
+        this.logInterval = setInterval(() => { }, this.logInterval);
+    }
+    stop(terminateCurve = true) {
+        clearInterval(this.logInterval);
+        if (terminateCurve)
+            globalThis.curve_bn128.terminate();
+        this.logElapsedTime();
+    }
+    logElapsedTime() {
+        const elapsedTime = ((Date.now() - this.startTime) / 1000).toFixed(2);
+        process.stdout.write(`\nElapsed time: ${elapsedTime}s\n`);
+    }
+}
+exports.CustomLoader = CustomLoader;
+function isValidURL(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.isValidURL = isValidURL;
+function isValidBase58SecretKey(secretKey) {
+    const base58Regex = /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/;
+    return base58Regex.test(secretKey);
+}
+exports.isValidBase58SecretKey = isValidBase58SecretKey;