solforge 0.2.0 → 0.2.2

package/src/services/validator.ts

@@ -0,0 +1,295 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,115 @@
+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()
+  );
+}

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(bun run:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}