solforge 0.1.7 → 0.2.0

package/src/services/validator.ts

@@ -1,295 +0,0 @@
-import { spawn, ChildProcess } from "child_process";
-import { existsSync } from "fs";
-import { join } from "path";
-import type {
-  ValidatorState,
-  ValidatorStatus,
-  LocalnetConfig,
-  OperationResult,
-} 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 = any> {
-  success: boolean;
-  data?: T;
-  error?: string;
-  details?: any;
-}
-
-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 { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { Keypair } from "@solana/web3.js";
-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()
-  );
-}