solforge 0.2.11 → 0.2.13

package/src/services/validator.ts

@@ -1,293 +0,0 @@
-import { type ChildProcess, spawn } from "node:child_process";
-import type {
-	LocalnetConfig,
-	OperationResult,
-	ValidatorState,
-	ValidatorStatus,
-} from "../types/config.js";
-
-export class ValidatorService {
-	private process: ChildProcess | null = null;
-	private state: ValidatorState;
-	private config: LocalnetConfig;
-
-	constructor(config: LocalnetConfig) {
-		this.config = config;
-		this.state = {
-			status: "stopped",
-			port: config.port,
-			faucetPort: config.faucetPort,
-			rpcUrl: `http://${config.bindAddress}:${config.port}`,
-			wsUrl: `ws://${config.bindAddress}:${config.port}`,
-			logs: [],
-		};
-	}
-
-	/**
-	 * Start the validator with the given configuration
-	 */
-	async start(
-		programs: string[] = [],
-		tokens: string[] = [],
-	): Promise<OperationResult<ValidatorState>> {
-		if (this.state.status === "running") {
-			return {
-				success: false,
-				error: "Validator is already running",
-				data: this.state,
-			};
-		}
-
-		try {
-			this.updateStatus("starting");
-
-			const args = this.buildValidatorArgs(programs, tokens);
-
-			this.process = spawn("solana-test-validator", args, {
-				stdio: ["pipe", "pipe", "pipe"],
-				detached: false,
-			});
-
-			this.state.pid = this.process.pid;
-			this.state.startTime = new Date();
-
-			// Handle process events
-			this.setupProcessHandlers();
-
-			// Wait for validator to be ready
-			await this.waitForReady();
-
-			this.updateStatus("running");
-
-			return {
-				success: true,
-				data: this.state,
-			};
-		} catch (error) {
-			this.updateStatus("error");
-			this.state.error = error instanceof Error ? error.message : String(error);
-
-			return {
-				success: false,
-				error: this.state.error,
-				data: this.state,
-			};
-		}
-	}
-
-	/**
-	 * Stop the validator
-	 */
-	async stop(): Promise<OperationResult<ValidatorState>> {
-		if (this.state.status === "stopped") {
-			return {
-				success: true,
-				data: this.state,
-			};
-		}
-
-		try {
-			this.updateStatus("stopping");
-
-			if (this.process) {
-				this.process.kill("SIGTERM");
-
-				// Wait for graceful shutdown
-				await new Promise<void>((resolve) => {
-					const timeout = setTimeout(() => {
-						if (this.process) {
-							this.process.kill("SIGKILL");
-						}
-						resolve();
-					}, 5000);
-
-					this.process?.on("exit", () => {
-						clearTimeout(timeout);
-						resolve();
-					});
-				});
-			}
-
-			this.cleanup();
-			this.updateStatus("stopped");
-
-			return {
-				success: true,
-				data: this.state,
-			};
-		} catch (error) {
-			return {
-				success: false,
-				error: error instanceof Error ? error.message : String(error),
-				data: this.state,
-			};
-		}
-	}
-
-	/**
-	 * Get current validator state
-	 */
-	getState(): ValidatorState {
-		return { ...this.state };
-	}
-
-	/**
-	 * Check if validator is running
-	 */
-	isRunning(): boolean {
-		return this.state.status === "running";
-	}
-
-	/**
-	 * Get recent logs
-	 */
-	getLogs(count = 100): string[] {
-		return this.state.logs.slice(-count);
-	}
-
-	/**
-	 * Build validator arguments based on configuration
-	 */
-	private buildValidatorArgs(
-		programs: string[] = [],
-		tokens: string[] = [],
-	): string[] {
-		const args: string[] = [];
-
-		// Basic configuration
-		args.push("--rpc-port", this.config.port.toString());
-		args.push("--faucet-port", this.config.faucetPort.toString());
-		args.push("--bind-address", this.config.bindAddress);
-
-		if (this.config.reset) {
-			args.push("--reset");
-		}
-
-		if (this.config.quiet) {
-			args.push("--quiet");
-		}
-
-		if (this.config.ledgerPath) {
-			args.push("--ledger", this.config.ledgerPath);
-		}
-
-		// Set log level
-		args.push("--log");
-
-		// Clone programs
-		for (const programId of programs) {
-			args.push("--clone", programId);
-		}
-
-		// Clone tokens (these would be mint addresses)
-		for (const tokenMint of tokens) {
-			args.push("--clone", tokenMint);
-		}
-
-		// Always specify mainnet as the source for cloning
-		if (programs.length > 0 || tokens.length > 0) {
-			args.push("--url", "https://api.mainnet-beta.solana.com");
-		}
-
-		return args;
-	}
-
-	/**
-	 * Setup process event handlers
-	 */
-	private setupProcessHandlers(): void {
-		if (!this.process) return;
-
-		this.process.stdout?.on("data", (data: Buffer) => {
-			const log = data.toString().trim();
-			this.addLog(`[STDOUT] ${log}`);
-		});
-
-		this.process.stderr?.on("data", (data: Buffer) => {
-			const log = data.toString().trim();
-			this.addLog(`[STDERR] ${log}`);
-		});
-
-		this.process.on("error", (error) => {
-			this.addLog(`[ERROR] ${error.message}`);
-			this.updateStatus("error");
-			this.state.error = error.message;
-		});
-
-		this.process.on("exit", (code, signal) => {
-			this.addLog(`[EXIT] Process exited with code ${code}, signal ${signal}`);
-			this.cleanup();
-
-			if (this.state.status !== "stopping") {
-				this.updateStatus(code === 0 ? "stopped" : "error");
-				if (code !== 0) {
-					this.state.error = `Process exited with code ${code}`;
-				}
-			}
-		});
-	}
-
-	/**
-	 * Wait for validator to be ready
-	 */
-	private async waitForReady(timeout = 30000): Promise<void> {
-		const startTime = Date.now();
-
-		while (Date.now() - startTime < timeout) {
-			try {
-				// Try to connect to the RPC endpoint
-				const response = await fetch(this.state.rpcUrl, {
-					method: "POST",
-					headers: { "Content-Type": "application/json" },
-					body: JSON.stringify({
-						jsonrpc: "2.0",
-						id: 1,
-						method: "getHealth",
-					}),
-				});
-
-				if (response.ok) {
-					return; // Validator is ready
-				}
-			} catch (_error) {
-				// Continue waiting
-			}
-
-			await new Promise((resolve) => setTimeout(resolve, 1000));
-		}
-
-		throw new Error("Validator failed to start within timeout period");
-	}
-
-	/**
-	 * Update validator status
-	 */
-	private updateStatus(status: ValidatorStatus): void {
-		this.state.status = status;
-		this.addLog(`[STATUS] Validator status changed to: ${status}`);
-	}
-
-	/**
-	 * Add log entry
-	 */
-	private addLog(message: string): void {
-		const timestamp = new Date().toISOString();
-		const logEntry = `[${timestamp}] ${message}`;
-		this.state.logs.push(logEntry);
-
-		// Keep only last 1000 log entries
-		if (this.state.logs.length > 1000) {
-			this.state.logs = this.state.logs.slice(-1000);
-		}
-	}
-
-	/**
-	 * Clean up process references
-	 */
-	private cleanup(): void {
-		this.process = null;
-		this.state.pid = undefined;
-		this.state.startTime = undefined;
-		this.state.error = undefined;
-	}
-}

package/src/types/config.ts

@@ -1,110 +0,0 @@
-import { z } from "zod";
-
-// Token configuration schema
-export const TokenConfigSchema = z.object({
-	symbol: z.string().min(1, "Token symbol is required"),
-	mainnetMint: z.string().min(1, "Mainnet mint address is required"),
-	mintAuthority: z.string().optional(), // Path to keypair file
-	mintAmount: z
-		.number()
-		.positive("Mint amount must be positive")
-		.default(1000000), // Amount to mint to mint authority
-	recipients: z
-		.array(
-			z.object({
-				wallet: z.string().min(1, "Wallet address is required"),
-				amount: z.number().positive("Amount must be positive"),
-			}),
-		)
-		.default([]),
-	cloneMetadata: z.boolean().default(true), // Whether to clone token metadata
-});
-
-// Program configuration schema
-export const ProgramConfigSchema = z.object({
-	name: z.string().optional(),
-	mainnetProgramId: z.string().min(1, "Program ID is required"),
-	deployPath: z.string().optional(), // Optional path to local .so file
-	upgradeable: z.boolean().default(false),
-	cluster: z
-		.enum(["mainnet-beta", "devnet", "testnet"])
-		.default("mainnet-beta"),
-	dependencies: z.array(z.string()).default([]), // Other program IDs this program depends on
-});
-
-// Localnet configuration schema
-export const LocalnetConfigSchema = z.object({
-	airdropAmount: z.number().positive().default(100),
-	faucetAccounts: z.array(z.string()).default([]),
-	logLevel: z.enum(["trace", "debug", "info", "warn", "error"]).default("info"),
-	port: z.number().int().min(1000).max(65535).default(8899),
-	faucetPort: z.number().int().min(1000).max(65535).default(9900),
-	reset: z.boolean().default(false),
-	quiet: z.boolean().default(false),
-	ledgerPath: z.string().optional(),
-	bindAddress: z.string().default("127.0.0.1"),
-	limitLedgerSize: z.number().int().positive().default(100000),
-	rpc: z
-		.string()
-		.url("RPC must be a valid URL")
-		.default("https://api.mainnet-beta.solana.com"),
-});
-
-// Complete configuration schema
-export const ConfigSchema = z.object({
-	name: z.string().default("solforge-localnet"),
-	description: z.string().optional(),
-	tokens: z.array(TokenConfigSchema).default([]),
-	programs: z.array(ProgramConfigSchema).default([]),
-	localnet: LocalnetConfigSchema.default({}),
-});
-
-// Inferred TypeScript types
-export type TokenConfig = z.infer<typeof TokenConfigSchema>;
-export type ProgramConfig = z.infer<typeof ProgramConfigSchema>;
-export type LocalnetConfig = z.infer<typeof LocalnetConfigSchema>;
-export type Config = z.infer<typeof ConfigSchema>;
-
-// Validator status types
-export type ValidatorStatus =
-	| "stopped"
-	| "starting"
-	| "running"
-	| "stopping"
-	| "error";
-
-export interface ValidatorState {
-	status: ValidatorStatus;
-	pid?: number;
-	port: number;
-	faucetPort: number;
-	rpcUrl: string;
-	wsUrl: string;
-	startTime?: Date;
-	logs: string[];
-	error?: string;
-}
-
-// Operation result types
-export interface OperationResult<T = unknown> {
-	success: boolean;
-	data?: T;
-	error?: string;
-	details?: unknown;
-}
-
-export interface CloneResult {
-	type: "program" | "token";
-	id: string;
-	name?: string;
-	success: boolean;
-	error?: string;
-}
-
-export interface ValidationResult {
-	valid: boolean;
-	errors: Array<{
-		path: string;
-		message: string;
-	}>;
-}

package/src/utils/shell.ts

@@ -1,110 +0,0 @@
-import { $ } from "bun";
-import chalk from "chalk";
-
-export interface CommandResult {
-	success: boolean;
-	stdout: string;
-	stderr: string;
-	exitCode: number;
-}
-
-/**
- * Execute a shell command and return the result
- */
-export async function runCommand(
-	command: string,
-	args: string[] = [],
-	options: {
-		silent?: boolean;
-		jsonOutput?: boolean;
-		debug?: boolean;
-	} = {},
-): Promise<CommandResult> {
-	const { silent = false, jsonOutput = false, debug = false } = options;
-
-	try {
-		if (!silent || debug) {
-			console.log(chalk.gray(`$ ${command} ${args.join(" ")}`));
-		}
-
-		const result = await $`${command} ${args}`.quiet();
-
-		const stdout = result.stdout.toString();
-		const stderr = result.stderr.toString();
-		const exitCode = result.exitCode;
-		const success = exitCode === 0;
-
-		if (debug) {
-			console.log(chalk.gray(`Exit code: ${exitCode}`));
-			if (stdout) {
-				console.log(chalk.gray(`Stdout: ${stdout}`));
-			}
-			if (stderr) {
-				console.log(chalk.gray(`Stderr: ${stderr}`));
-			}
-		}
-
-		if (!silent && !success) {
-			console.error(chalk.red(`Command failed with exit code ${exitCode}`));
-			if (stderr) {
-				console.error(chalk.red(`Error: ${stderr}`));
-			}
-		}
-
-		// If JSON output is expected, try to parse it
-		let parsedOutput = stdout;
-		if (jsonOutput && success && stdout.trim()) {
-			try {
-				parsedOutput = JSON.parse(stdout);
-			} catch (_e) {
-				// If JSON parsing fails, keep original stdout
-				console.warn(
-					chalk.yellow("Warning: Expected JSON output but got invalid JSON"),
-				);
-			}
-		}
-
-		return {
-			success,
-			stdout: parsedOutput,
-			stderr,
-			exitCode,
-		};
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-
-		if (!silent) {
-			console.error(chalk.red(`Command execution failed: ${errorMessage}`));
-		}
-
-		return {
-			success: false,
-			stdout: "",
-			stderr: errorMessage,
-			exitCode: 1,
-		};
-	}
-}
-
-/**
- * Check if a command exists in PATH
- */
-export async function commandExists(command: string): Promise<boolean> {
-	const result = await runCommand("which", [command], { silent: true });
-	return result.success;
-}
-
-/**
- * Check if solana CLI tools are available
- */
-export async function checkSolanaTools(): Promise<{
-	solana: boolean;
-	splToken: boolean;
-}> {
-	const [solana, splToken] = await Promise.all([
-		commandExists("solana"),
-		commandExists("spl-token"),
-	]);
-
-	return { solana, splToken };
-}

package/src/utils/token-loader.ts

@@ -1,115 +0,0 @@
-import { Keypair } from "@solana/web3.js";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { TokenConfig } from "../types/config.js";
-
-export interface ClonedToken {
-	config: TokenConfig;
-	mintAuthorityPath: string;
-	modifiedAccountPath: string;
-	metadataAccountPath?: string;
-	mintAuthority: {
-		publicKey: string;
-		secretKey: number[];
-	};
-}
-
-/**
- * Shared utility to load cloned tokens from the work directory.
- * This ensures consistent token loading across CLI and API server.
- */
-export async function loadClonedTokens(
-	tokenConfigs: TokenConfig[],
-	workDir: string = ".solforge",
-): Promise<ClonedToken[]> {
-	const clonedTokens: ClonedToken[] = [];
-
-	// Load shared mint authority
-	const sharedMintAuthorityPath = join(workDir, "shared-mint-authority.json");
-	let sharedMintAuthority: { publicKey: string; secretKey: number[] } | null =
-		null;
-
-	if (existsSync(sharedMintAuthorityPath)) {
-		try {
-			const fileContent = JSON.parse(
-				readFileSync(sharedMintAuthorityPath, "utf8"),
-			);
-
-			if (Array.isArray(fileContent)) {
-				// New format: file contains just the secret key array
-				const keypair = Keypair.fromSecretKey(new Uint8Array(fileContent));
-				sharedMintAuthority = {
-					publicKey: keypair.publicKey.toBase58(),
-					secretKey: Array.from(keypair.secretKey),
-				};
-
-				// Check metadata for consistency
-				const metadataPath = join(workDir, "shared-mint-authority-meta.json");
-				if (existsSync(metadataPath)) {
-					const metadata = JSON.parse(readFileSync(metadataPath, "utf8"));
-					if (metadata.publicKey !== sharedMintAuthority.publicKey) {
-						sharedMintAuthority.publicKey = metadata.publicKey;
-					}
-				}
-			} else {
-				// Old format: file contains {publicKey, secretKey}
-				sharedMintAuthority = fileContent;
-			}
-		} catch (error) {
-			console.error("Failed to load shared mint authority:", error);
-			return [];
-		}
-	}
-
-	if (!sharedMintAuthority) {
-		return [];
-	}
-
-	// Load each token that has been cloned
-	for (const tokenConfig of tokenConfigs) {
-		const tokenDir = join(workDir, `token-${tokenConfig.symbol.toLowerCase()}`);
-		const modifiedAccountPath = join(tokenDir, "modified.json");
-		const metadataAccountPath = join(tokenDir, "metadata.json");
-
-		// Check if this token has already been cloned
-		if (existsSync(modifiedAccountPath)) {
-			const clonedToken: ClonedToken = {
-				config: tokenConfig,
-				mintAuthorityPath: sharedMintAuthorityPath,
-				modifiedAccountPath,
-				mintAuthority: sharedMintAuthority,
-			};
-
-			// Add metadata path if it exists
-			if (existsSync(metadataAccountPath)) {
-				clonedToken.metadataAccountPath = metadataAccountPath;
-			}
-
-			clonedTokens.push(clonedToken);
-		}
-	}
-
-	return clonedTokens;
-}
-
-/**
- * Find a cloned token by its mint address
- */
-export function findTokenByMint(
-	clonedTokens: ClonedToken[],
-	mintAddress: string,
-): ClonedToken | undefined {
-	return clonedTokens.find((token) => token.config.mainnetMint === mintAddress);
-}
-
-/**
- * Find a cloned token by its symbol
- */
-export function findTokenBySymbol(
-	clonedTokens: ClonedToken[],
-	symbol: string,
-): ClonedToken | undefined {
-	return clonedTokens.find(
-		(token) => token.config.symbol.toLowerCase() === symbol.toLowerCase(),
-	);
-}