solforge 0.2.12 → 0.2.13

package/src/services/api-server.ts

@@ -1,504 +0,0 @@
-import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
-import { Connection, PublicKey } from "@solana/web3.js";
-import chalk from "chalk";
-import cors from "cors";
-import express from "express";
-import { existsSync } from "node:fs";
-import type { Server } from "node:http";
-import { join } from "node:path";
-import { mintTokenToWallet as mintTokenToWalletShared } from "../commands/mint.js";
-import type { Config } from "../types/config.js";
-import { runCommand } from "../utils/shell.js";
-import {
-	type ClonedToken,
-	findTokenByMint,
-	loadClonedTokens,
-} from "../utils/token-loader.js";
-import { ProgramCloner } from "./program-cloner.js";
-import { TokenCloner } from "./token-cloner.js";
-
-export interface APIServerConfig {
-	port: number;
-	host?: string;
-	validatorRpcUrl: string;
-	validatorFaucetUrl: string;
-	config: Config;
-	workDir: string;
-}
-
-export class APIServer {
-	private app: express.Application;
-	private server: Server | null = null;
-	private config: APIServerConfig;
-	private connection: Connection;
-
-	constructor(config: APIServerConfig) {
-		this.config = config;
-		this.tokenCloner = new TokenCloner(config.workDir);
-		this.programCloner = new ProgramCloner(config.workDir);
-		this.connection = new Connection(config.validatorRpcUrl, "confirmed");
-
-		this.app = express();
-		this.setupMiddleware();
-		this.setupRoutes();
-	}
-
-	private setupMiddleware(): void {
-		this.app.use(cors());
-		this.app.use(express.json());
-
-		// Request logging
-		this.app.use((req, _res, next) => {
-			console.log(chalk.gray(`🌐 API: ${req.method} ${req.path}`));
-			next();
-		});
-	}
-
-	private setupRoutes(): void {
-		const router = express.Router();
-
-		// Health check
-		router.get("/health", (_req, res) => {
-			res.json({ status: "ok", timestamp: new Date().toISOString() });
-		});
-
-		// Get validator info
-		router.get("/validator/info", async (_req, res) => {
-			try {
-				const version = await this.connection.getVersion();
-				const blockHeight = await this.connection.getBlockHeight();
-				const slotLeader = await this.connection.getSlotLeader();
-
-				res.json({
-					version,
-					blockHeight,
-					slotLeader: slotLeader.toString(),
-					rpcUrl: this.config.validatorRpcUrl,
-					faucetUrl: this.config.validatorFaucetUrl,
-				});
-			} catch (error) {
-				res.status(500).json({
-					error: "Failed to fetch validator info",
-					details: error instanceof Error ? error.message : String(error),
-				});
-			}
-		});
-
-		// Get all cloned tokens
-		router.get("/tokens", async (_req, res) => {
-			try {
-				const clonedTokens = await this.getClonedTokens();
-				res.json({
-					tokens: clonedTokens.map((token) => ({
-						symbol: token.config.symbol,
-						mainnetMint: token.config.mainnetMint,
-						mintAuthority: token.mintAuthority.publicKey,
-						recipients: token.config.recipients,
-						cloneMetadata: token.config.cloneMetadata,
-					})),
-					count: clonedTokens.length,
-				});
-			} catch (error) {
-				res.status(500).json({
-					error: "Failed to fetch cloned tokens",
-					details: error instanceof Error ? error.message : String(error),
-				});
-			}
-		});
-
-		// Get all cloned programs
-		router.get("/programs", async (_req, res) => {
-			try {
-				const clonedPrograms = await this.getClonedPrograms();
-				res.json({
-					programs: clonedPrograms,
-					count: clonedPrograms.length,
-				});
-			} catch (error) {
-				res.status(500).json({
-					error: "Failed to fetch cloned programs",
-					details: error instanceof Error ? error.message : String(error),
-				});
-			}
-		});
-
-		// Mint tokens to a wallet
-		router.post("/tokens/:mintAddress/mint", async (req, res) => {
-			try {
-				const { mintAddress } = req.params;
-				const { walletAddress, amount } = req.body;
-
-				if (!walletAddress || !amount) {
-					return res.status(400).json({
-						error: "Missing required fields: walletAddress and amount",
-					});
-				}
-
-				// Validate mint address
-				try {
-					new PublicKey(mintAddress);
-				} catch {
-					return res.status(400).json({
-						error: "Invalid mint address",
-					});
-				}
-
-				// Validate wallet address
-				try {
-					new PublicKey(walletAddress);
-				} catch {
-					return res.status(400).json({
-						error: "Invalid wallet address",
-					});
-				}
-
-				// Validate amount
-				if (!Number.isInteger(amount) || amount <= 0) {
-					return res.status(400).json({
-						error: "Amount must be a positive integer",
-					});
-				}
-
-				const result = await this.mintTokenToWallet(
-					mintAddress,
-					walletAddress,
-					amount,
-				);
-				res.json(result);
-			} catch (error) {
-				res.status(500).json({
-					error: "Failed to mint tokens",
-					details: error instanceof Error ? error.message : String(error),
-				});
-			}
-		});
-
-		// Get account balances for a wallet
-		router.get("/wallet/:address/balances", async (req, res) => {
-			try {
-				const { address } = req.params;
-
-				// Validate wallet address
-				try {
-					new PublicKey(address);
-				} catch {
-					return res.status(400).json({
-						error: "Invalid wallet address",
-					});
-				}
-
-				const balances = await this.getWalletBalances(address);
-				res.json(balances);
-			} catch (error) {
-				res.status(500).json({
-					error: "Failed to fetch wallet balances",
-					details: error instanceof Error ? error.message : String(error),
-				});
-			}
-		});
-
-		// Airdrop SOL to a wallet
-		router.post("/airdrop", async (req, res) => {
-			try {
-				const { walletAddress, amount } = req.body;
-
-				if (!walletAddress || !amount) {
-					return res.status(400).json({
-						error: "Missing required fields: walletAddress and amount",
-					});
-				}
-
-				// Validate wallet address
-				try {
-					new PublicKey(walletAddress);
-				} catch {
-					return res.status(400).json({
-						error: "Invalid wallet address",
-					});
-				}
-
-				const result = await this.airdropSol(walletAddress, amount);
-				res.json(result);
-			} catch (error) {
-				res.status(500).json({
-					error: "Failed to airdrop SOL",
-					details: error instanceof Error ? error.message : String(error),
-				});
-			}
-		});
-
-		// Get recent transactions
-		router.get("/transactions/recent", async (req, res) => {
-			try {
-				const limit = Math.min(
-					parseInt(req.query.limit as string, 10) || 10,
-					100,
-				);
-				const signatures = await this.connection.getSignaturesForAddress(
-					new PublicKey("11111111111111111111111111111111"), // System program
-					{ limit },
-				);
-
-				res.json({
-					transactions: signatures,
-					count: signatures.length,
-				});
-			} catch (error) {
-				res.status(500).json({
-					error: "Failed to fetch recent transactions",
-					details: error instanceof Error ? error.message : String(error),
-				});
-			}
-		});
-
-		this.app.use("/api", router);
-
-		// 404 handler
-		this.app.use("*", (_req, res) => {
-			res.status(404).json({ error: "Endpoint not found" });
-		});
-	}
-
-	private async getClonedTokens(): Promise<ClonedToken[]> {
-		return await loadClonedTokens(
-			this.config.config.tokens,
-			this.config.workDir,
-		);
-	}
-
-	private async getClonedPrograms(): Promise<
-		Array<{ name?: string; programId: string; filePath?: string }>
-	> {
-		const clonedPrograms: Array<{
-			name?: string;
-			programId: string;
-			filePath?: string;
-		}> = [];
-
-		for (const programConfig of this.config.config.programs) {
-			const programsDir = join(this.config.workDir, "programs");
-			const fileName = programConfig.name
-				? `${programConfig.name.toLowerCase().replace(/\s+/g, "-")}.so`
-				: `${programConfig.mainnetProgramId}.so`;
-			const filePath = join(programsDir, fileName);
-
-			clonedPrograms.push({
-				name: programConfig.name,
-				programId: programConfig.mainnetProgramId,
-				filePath: existsSync(filePath) ? filePath : undefined,
-			});
-		}
-
-		return clonedPrograms;
-	}
-
-	private async mintTokenToWallet(
-		mintAddress: string,
-		walletAddress: string,
-		amount: number,
-	): Promise<{
-		success: true;
-		symbol: string;
-		amount: number;
-		walletAddress: string;
-		mintAddress: string;
-	}> {
-		const clonedTokens = await this.getClonedTokens();
-		const token = findTokenByMint(clonedTokens, mintAddress);
-
-		if (!token) {
-			throw new Error(`Token ${mintAddress} not found in cloned tokens`);
-		}
-
-		// Use the shared minting function from the mint command
-		await mintTokenToWalletShared(
-			token,
-			walletAddress,
-			amount,
-			this.config.validatorRpcUrl,
-		);
-
-		return {
-			success: true,
-			symbol: token.config.symbol,
-			amount,
-			walletAddress,
-			mintAddress: token.config.mainnetMint,
-		};
-	}
-
-	private async getWalletBalances(walletAddress: string): Promise<{
-		walletAddress: string;
-		solBalance: { lamports: number; sol: number };
-		tokenBalances: Array<{
-			mint: string;
-			symbol: string;
-			balance: string;
-			decimals: number;
-			uiAmount: number | null;
-		}>;
-		timestamp: string;
-	}> {
-		try {
-			const publicKey = new PublicKey(walletAddress);
-
-			// Get SOL balance
-			const solBalance = await this.connection.getBalance(publicKey);
-
-			// Get token accounts
-			const tokenAccounts = await this.connection.getTokenAccountsByOwner(
-				publicKey,
-				{
-					programId: TOKEN_PROGRAM_ID,
-				},
-			);
-
-			const tokenBalances = [];
-			const clonedTokens = await this.getClonedTokens();
-
-			for (const tokenAccount of tokenAccounts.value) {
-				try {
-					const accountInfo = await this.connection.getAccountInfo(
-						tokenAccount.pubkey,
-					);
-					if (accountInfo) {
-						// Parse token account data (simplified)
-						const data = accountInfo.data;
-						if (data.length >= 32) {
-							const mintBytes = data.slice(0, 32);
-							const mintAddress = new PublicKey(mintBytes).toBase58();
-
-							// Find matching cloned token
-							const clonedToken = clonedTokens.find(
-								(t) => t.config.mainnetMint === mintAddress,
-							);
-
-							if (clonedToken) {
-								// Get token balance
-								const balance = await this.connection.getTokenAccountBalance(
-									tokenAccount.pubkey,
-								);
-								tokenBalances.push({
-									mint: mintAddress,
-									symbol: clonedToken.config.symbol,
-									balance: balance.value.amount,
-									decimals: balance.value.decimals,
-									uiAmount: balance.value.uiAmount,
-								});
-							}
-						}
-					}
-				} catch (_error) {}
-			}
-
-			return {
-				walletAddress,
-				solBalance: {
-					lamports: solBalance,
-					sol: solBalance / 1e9,
-				},
-				tokenBalances,
-				timestamp: new Date().toISOString(),
-			};
-		} catch (error) {
-			throw new Error(
-				`Failed to get wallet balances: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
-			);
-		}
-	}
-
-	private async airdropSol(
-		walletAddress: string,
-		amount: number,
-	): Promise<{
-		success: true;
-		amount: number;
-		walletAddress: string;
-		signature: string;
-	}> {
-		const result = await runCommand(
-			"solana",
-			[
-				"airdrop",
-				amount.toString(),
-				walletAddress,
-				"--url",
-				this.config.validatorRpcUrl,
-			],
-			{ silent: false, debug: false },
-		);
-
-		if (!result.success) {
-			throw new Error(`Failed to airdrop SOL: ${result.stderr}`);
-		}
-
-		return {
-			success: true,
-			amount,
-			walletAddress,
-			signature:
-				result.stdout.match(/Signature: ([A-Za-z0-9]+)/)?.[1] || "unknown",
-		};
-	}
-
-	async start(): Promise<{ success: boolean; error?: string }> {
-		return new Promise((resolve) => {
-			try {
-				const host = this.config.host || "127.0.0.1";
-				this.server = this.app.listen(this.config.port, host, () => {
-					console.log(
-						chalk.green(
-							`🚀 API Server started on http://${host}:${this.config.port}`,
-						),
-					);
-					console.log(
-						chalk.gray(
-							`   📋 Endpoints available at http://${host}:${this.config.port}/api`,
-						),
-					);
-					resolve({ success: true });
-				});
-
-				this.server.on("error", (error) => {
-					console.error(
-						chalk.red(`❌ API Server failed to start: ${error.message}`),
-					);
-					resolve({ success: false, error: error.message });
-				});
-			} catch (error) {
-				resolve({
-					success: false,
-					error: error instanceof Error ? error.message : String(error),
-				});
-			}
-		});
-	}
-
-	async stop(): Promise<{ success: boolean; error?: string }> {
-		return new Promise((resolve) => {
-			if (!this.server) {
-				resolve({ success: true });
-				return;
-			}
-
-			this.server.close((error) => {
-				if (error) {
-					resolve({
-						success: false,
-						error: error instanceof Error ? error.message : String(error),
-					});
-				} else {
-					console.log(chalk.yellow("🛑 API Server stopped"));
-					resolve({ success: true });
-				}
-				this.server = null;
-			});
-		});
-	}
-
-	isRunning(): boolean {
-		return this.server?.listening;
-	}
-}

package/src/services/port-manager.ts

@@ -1,174 +0,0 @@
-import { processRegistry } from "./process-registry.js";
-
-export interface PortAllocation {
-	rpcPort: number;
-	faucetPort: number;
-}
-
-export class PortManager {
-	private readonly defaultRpcPort = 8899;
-	private readonly portRangeStart = 8000;
-	private readonly portRangeEnd = 9999;
-
-	/**
-	 * Get the next available port pair (RPC + Faucet)
-	 */
-	async getAvailablePorts(preferredRpcPort?: number): Promise<PortAllocation> {
-		const usedPorts = this.getUsedPorts();
-
-		// If preferred port is specified and available, use it
-		if (preferredRpcPort && !this.isPortUsed(preferredRpcPort, usedPorts)) {
-			const faucetPort = this.findAvailableFaucetPort(
-				preferredRpcPort,
-				usedPorts,
-			);
-			if (faucetPort) {
-				return { rpcPort: preferredRpcPort, faucetPort };
-			}
-		}
-
-		// Otherwise, find the next available ports
-		return this.findNextAvailablePorts(usedPorts);
-	}
-
-	/**
-	 * Check if a specific port is available
-	 */
-	async isPortAvailable(port: number): Promise<boolean> {
-		const usedPorts = this.getUsedPorts();
-		return (
-			!this.isPortUsed(port, usedPorts) &&
-			(await this.checkPortActuallyFree(port))
-		);
-	}
-
-	/**
-	 * Get all currently used ports from running validators
-	 */
-	private getUsedPorts(): Set<number> {
-		const validators = processRegistry.getRunning();
-		const usedPorts = new Set<number>();
-
-		validators.forEach((validator) => {
-			usedPorts.add(validator.rpcPort);
-			usedPorts.add(validator.faucetPort);
-		});
-
-		return usedPorts;
-	}
-
-	/**
-	 * Check if a port is in the used ports set
-	 */
-	private isPortUsed(port: number, usedPorts: Set<number>): boolean {
-		return usedPorts.has(port);
-	}
-
-	/**
-	 * Find an available faucet port for a given RPC port
-	 */
-	private findAvailableFaucetPort(
-		rpcPort: number,
-		usedPorts: Set<number>,
-	): number | null {
-		// Try default offset first (faucet = rpc + 1001)
-		let faucetPort = rpcPort + 1001;
-		if (
-			!this.isPortUsed(faucetPort, usedPorts) &&
-			this.isPortInRange(faucetPort)
-		) {
-			return faucetPort;
-		}
-
-		// Try other offsets
-		const offsets = [1000, 1002, 1003, 1004, 1005, 999, 998, 997];
-		for (const offset of offsets) {
-			faucetPort = rpcPort + offset;
-			if (
-				!this.isPortUsed(faucetPort, usedPorts) &&
-				this.isPortInRange(faucetPort)
-			) {
-				return faucetPort;
-			}
-		}
-
-		// Search in the entire range
-		for (let port = this.portRangeStart; port <= this.portRangeEnd; port++) {
-			if (!this.isPortUsed(port, usedPorts)) {
-				return port;
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * Find the next available port pair
-	 */
-	private findNextAvailablePorts(usedPorts: Set<number>): PortAllocation {
-		// Start from default ports if available
-		if (!this.isPortUsed(this.defaultRpcPort, usedPorts)) {
-			const faucetPort = this.findAvailableFaucetPort(
-				this.defaultRpcPort,
-				usedPorts,
-			);
-			if (faucetPort) {
-				return { rpcPort: this.defaultRpcPort, faucetPort };
-			}
-		}
-
-		// Search for available RPC port
-		for (
-			let rpcPort = this.portRangeStart;
-			rpcPort <= this.portRangeEnd;
-			rpcPort++
-		) {
-			if (!this.isPortUsed(rpcPort, usedPorts)) {
-				const faucetPort = this.findAvailableFaucetPort(rpcPort, usedPorts);
-				if (faucetPort) {
-					return { rpcPort, faucetPort };
-				}
-			}
-		}
-
-		throw new Error("No available port pairs found in the specified range");
-	}
-
-	/**
-	 * Check if port is within allowed range
-	 */
-	private isPortInRange(port: number): boolean {
-		return port >= this.portRangeStart && port <= this.portRangeEnd;
-	}
-
-	/**
-	 * Actually check if a port is free by attempting to bind to it
-	 */
-	private async checkPortActuallyFree(port: number): Promise<boolean> {
-		return new Promise((resolve) => {
-			const net = require("node:net");
-			const server = net.createServer();
-
-			server.once("listening", () => {
-				server.once("close", () => resolve(true));
-				server.close();
-			});
-
-			server.once("error", () => resolve(false));
-
-			server.listen(port);
-		});
-	}
-
-	/**
-	 * Get recommended ports for a configuration
-	 */
-	async getRecommendedPorts(config: {
-		localnet: { port: number; faucetPort: number };
-	}): Promise<PortAllocation> {
-		return this.getAvailablePorts(config.localnet.port);
-	}
-}
-
-// Singleton instance
-export const portManager = new PortManager();