solforge 0.1.0

package/src/commands/transfer.ts

@@ -0,0 +1,259 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { input, select } from "@inquirer/prompts";
+import { runCommand } from "../utils/shell";
+import { Keypair } from "@solana/web3.js";
+
+interface TokenBalance {
+  mint: string;
+  symbol: string;
+  address: string;
+  balance: string;
+  decimals: number;
+}
+
+interface TokenConfig {
+  symbol: string;
+  mainnetMint: string;
+  mintAmount: number;
+}
+
+export const transferCommand = new Command()
+  .name("transfer")
+  .description(
+    "Interactively transfer tokens from mint authority to any address"
+  )
+  .option("--rpc-url <url>", "RPC URL to use", "http://127.0.0.1:8899")
+  .action(async (options) => {
+    try {
+      console.log(chalk.blue("🔄 Interactive Token Transfer"));
+      console.log(
+        chalk.gray("Send tokens from mint authority to any address\n")
+      );
+
+      // Check if solforge data exists
+      const workDir = ".solforge";
+      if (!existsSync(workDir)) {
+        console.error(
+          chalk.red("❌ No solforge data found. Run 'solforge start' first.")
+        );
+        process.exit(1);
+      }
+
+      // Load available tokens and their balances
+      const tokens = await loadAvailableTokens(workDir, options.rpcUrl);
+
+      if (tokens.length === 0) {
+        console.error(
+          chalk.red(
+            "❌ No tokens found. Run 'solforge start' first to clone tokens."
+          )
+        );
+        process.exit(1);
+      }
+
+      // Display available tokens
+      console.log(chalk.cyan("📋 Available Tokens:"));
+      tokens.forEach((token, index) => {
+        console.log(
+          chalk.gray(
+            `  ${index + 1}. ${token.symbol} (${token.mint}) - Balance: ${
+              token.balance
+            }`
+          )
+        );
+      });
+      console.log();
+
+      // Select token
+      const selectedToken = await select({
+        message: "Select a token to transfer:",
+        choices: tokens.map((token, index) => ({
+          name: `${token.symbol} - Balance: ${token.balance}`,
+          value: token,
+        })),
+      });
+
+      // Get recipient address
+      const recipientAddress = await input({
+        message: "Enter recipient address (wallet address or PDA):",
+        validate: (value: string) => {
+          if (!value.trim()) {
+            return "Please enter a valid address";
+          }
+          // Basic length check for Solana addresses
+          if (value.trim().length < 32 || value.trim().length > 44) {
+            return "Please enter a valid Solana address (32-44 characters)";
+          }
+          return true;
+        },
+      });
+
+      // Get amount to transfer
+      const maxAmount = parseFloat(selectedToken.balance);
+      const amount = await input({
+        message: `Enter amount to transfer (max: ${selectedToken.balance}):`,
+        validate: (value: string) => {
+          const num = parseFloat(value);
+          if (isNaN(num) || num <= 0) {
+            return "Please enter a valid positive number";
+          }
+          if (num > maxAmount) {
+            return `Amount cannot exceed available balance: ${selectedToken.balance}`;
+          }
+          return true;
+        },
+      });
+
+      // Use amount as-is (spl-token expects UI amount, not base units)
+      const transferAmount = amount;
+
+      // Confirm transfer
+      const confirm = await input({
+        message: `Confirm transfer of ${amount} ${selectedToken.symbol} to ${recipientAddress}? (y/N):`,
+        default: "N",
+      });
+
+      if (confirm.toLowerCase() !== "y" && confirm.toLowerCase() !== "yes") {
+        console.log(chalk.yellow("Transfer cancelled."));
+        process.exit(0);
+      }
+
+      console.log(chalk.blue("🚀 Starting transfer..."));
+
+      // Execute transfer
+      await executeTransfer(
+        selectedToken,
+        recipientAddress,
+        transferAmount.toString(),
+        options.rpcUrl,
+        workDir
+      );
+
+      console.log(
+        chalk.green(
+          `✅ Successfully transferred ${amount} ${selectedToken.symbol} to ${recipientAddress}`
+        )
+      );
+    } catch (error) {
+      console.error(chalk.red(`❌ Transfer failed: ${error}`));
+      process.exit(1);
+    }
+  });
+
+async function loadAvailableTokens(
+  workDir: string,
+  rpcUrl: string
+): Promise<TokenBalance[]> {
+  const tokens: TokenBalance[] = [];
+
+  try {
+    // Load shared mint authority secret key and generate keypair
+    const sharedMintAuthorityPath = join(workDir, "shared-mint-authority.json");
+    if (!existsSync(sharedMintAuthorityPath)) {
+      throw new Error("Shared mint authority not found");
+    }
+
+    const secretKeyArray = JSON.parse(
+      readFileSync(sharedMintAuthorityPath, "utf8")
+    );
+    const mintAuthorityKeypair = Keypair.fromSecretKey(
+      new Uint8Array(secretKeyArray)
+    );
+    const mintAuthorityAddress = mintAuthorityKeypair.publicKey.toBase58();
+
+    // Load token config from sf.config.json
+    const configPath = "sf.config.json";
+    if (!existsSync(configPath)) {
+      throw new Error("sf.config.json not found in current directory");
+    }
+
+    const config = JSON.parse(readFileSync(configPath, "utf8"));
+    const tokenConfigs: TokenConfig[] = config.tokens || [];
+
+    // Get token account balances
+    const accountsResult = await runCommand(
+      "spl-token",
+      [
+        "accounts",
+        "--owner",
+        mintAuthorityAddress,
+        "--url",
+        rpcUrl,
+        "--output",
+        "json",
+      ],
+      { silent: true }
+    );
+
+    if (!accountsResult.success) {
+      throw new Error(
+        `Failed to fetch token accounts: ${accountsResult.stderr}`
+      );
+    }
+
+    const accountsData = JSON.parse(accountsResult.stdout);
+
+    // Match accounts with token config
+    for (const account of accountsData.accounts || []) {
+      const tokenInfo = tokenConfigs.find(
+        (token: TokenConfig) => token.mainnetMint === account.mint
+      );
+      if (tokenInfo) {
+        tokens.push({
+          mint: account.mint,
+          symbol: tokenInfo.symbol,
+          address: account.address,
+          balance: account.tokenAmount.uiAmountString,
+          decimals: account.tokenAmount.decimals,
+        });
+      }
+    }
+
+    return tokens;
+  } catch (error) {
+    throw new Error(`Failed to load tokens: ${error}`);
+  }
+}
+
+async function executeTransfer(
+  token: TokenBalance,
+  recipientAddress: string,
+  amount: string,
+  rpcUrl: string,
+  workDir: string
+): Promise<void> {
+  // Load mint authority keypair path
+  const sharedMintAuthorityPath = join(workDir, "shared-mint-authority.json");
+
+  // Transfer tokens directly to wallet address
+  // The --fund-recipient flag will automatically create the associated token account if needed
+  console.log(chalk.gray("💸 Transferring tokens..."));
+
+  const transferResult = await runCommand(
+    "spl-token",
+    [
+      "transfer",
+      token.mint,
+      amount,
+      recipientAddress,
+      "--from",
+      token.address,
+      "--owner",
+      sharedMintAuthorityPath,
+      "--fee-payer",
+      sharedMintAuthorityPath,
+      "--fund-recipient",
+      "--allow-unfunded-recipient",
+      "--url",
+      rpcUrl,
+    ],
+    { silent: false }
+  );
+
+  if (!transferResult.success) {
+    throw new Error(`Transfer failed: ${transferResult.stderr}`);
+  }
+}

package/src/config/manager.ts

@@ -0,0 +1,157 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join, resolve } from "path";
+import { ConfigSchema } from "../types/config.js";
+import type { Config, ValidationResult } from "../types/config.js";
+
+export class ConfigManager {
+  private config: Config | null = null;
+  private configPath: string | null = null;
+
+  /**
+   * Load configuration from a file path
+   */
+  async load(configPath: string): Promise<Config> {
+    try {
+      const fullPath = resolve(configPath);
+
+      if (!existsSync(fullPath)) {
+        throw new Error(`Configuration file not found: ${fullPath}`);
+      }
+
+      const configContent = readFileSync(fullPath, "utf-8");
+      const rawConfig = JSON.parse(configContent);
+
+      // Validate and parse with Zod
+      const result = ConfigSchema.safeParse(rawConfig);
+
+      if (!result.success) {
+        const errors = result.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message,
+        }));
+        throw new Error(
+          `Configuration validation failed:\n${errors
+            .map((e) => `  - ${e.path}: ${e.message}`)
+            .join("\n")}`
+        );
+      }
+
+      this.config = result.data;
+      this.configPath = fullPath;
+
+      return this.config;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`Invalid JSON in configuration file: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Save current configuration to file
+   */
+  async save(configPath?: string): Promise<void> {
+    if (!this.config) {
+      throw new Error("No configuration loaded");
+    }
+
+    const targetPath = configPath || this.configPath;
+    if (!targetPath) {
+      throw new Error("No configuration path specified");
+    }
+
+    try {
+      const configContent = JSON.stringify(this.config, null, 2);
+      writeFileSync(targetPath, configContent, "utf-8");
+      this.configPath = targetPath;
+    } catch (error) {
+      throw new Error(
+        `Failed to save configuration: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
+  /**
+   * Validate a configuration object
+   */
+  validate(config: any): ValidationResult {
+    const result = ConfigSchema.safeParse(config);
+
+    if (result.success) {
+      return { valid: true, errors: [] };
+    }
+
+    const errors = result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message,
+    }));
+
+    return { valid: false, errors };
+  }
+
+  /**
+   * Create a default configuration
+   */
+  createDefault(): Config {
+    const defaultConfig = ConfigSchema.parse({});
+    this.config = defaultConfig;
+    return defaultConfig;
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): Config {
+    if (!this.config) {
+      throw new Error("No configuration loaded. Call load() first.");
+    }
+    return this.config;
+  }
+
+  /**
+   * Update configuration
+   */
+  updateConfig(updates: Partial<Config>): Config {
+    if (!this.config) {
+      throw new Error("No configuration loaded. Call load() first.");
+    }
+
+    const updated = { ...this.config, ...updates };
+    const result = ConfigSchema.safeParse(updated);
+
+    if (!result.success) {
+      const errors = result.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        message: issue.message,
+      }));
+      throw new Error(
+        `Configuration update validation failed:\n${errors
+          .map((e) => `  - ${e.path}: ${e.message}`)
+          .join("\n")}`
+      );
+    }
+
+    this.config = result.data;
+    return this.config;
+  }
+
+  /**
+   * Get configuration file path
+   */
+  getConfigPath(): string | null {
+    return this.configPath;
+  }
+
+  /**
+   * Check if configuration is loaded
+   */
+  isLoaded(): boolean {
+    return this.config !== null;
+  }
+}
+
+// Singleton instance
+export const configManager = new ConfigManager();

package/src/index.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import chalk from "chalk";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { initCommand } from "./commands/init.js";
+import { statusCommand } from "./commands/status.js";
+import { startCommand } from "./commands/start.js";
+import { transferCommand } from "./commands/transfer.js";
+import { listCommand } from "./commands/list.js";
+import { stopCommand, killCommand } from "./commands/stop.js";
+import { addProgramCommand } from "./commands/add-program.js";
+
+const program = new Command();
+
+program
+  .name("solforge")
+  .description("Solana localnet orchestration tool")
+  .version("0.1.0");
+
+// Check for sf.config.json in current directory
+function findConfig(): string | null {
+  const configPath = resolve(process.cwd(), "sf.config.json");
+  return existsSync(configPath) ? configPath : null;
+}
+
+program
+  .command("init")
+  .description("Initialize a new sf.config.json in current directory")
+  .action(async () => {
+    console.log(chalk.blue("🚀 Initializing SolForge configuration..."));
+    await initCommand();
+  });
+
+program
+  .command("start")
+  .description("Start localnet with current sf.config.json")
+  .option("--debug", "Enable debug logging to see commands and detailed output")
+  .action(async (options) => {
+    const configPath = findConfig();
+    if (!configPath) {
+      console.error(
+        chalk.red("❌ No sf.config.json found in current directory")
+      );
+      console.log(chalk.yellow("💡 Run `solforge init` to create one"));
+      process.exit(1);
+    }
+
+    await startCommand(options.debug || false);
+  });
+
+program
+  .command("list")
+  .description("List all running validators")
+  .action(async () => {
+    await listCommand();
+  });
+
+program
+  .command("stop")
+  .description("Stop running validator(s)")
+  .argument("[validator-id]", "ID of validator to stop")
+  .option("--all", "Stop all running validators")
+  .option("--kill", "Force kill the validator (SIGKILL instead of SIGTERM)")
+  .action(async (validatorId, options) => {
+    await stopCommand(validatorId, options);
+  });
+
+program
+  .command("kill")
+  .description("Force kill running validator(s)")
+  .argument("[validator-id]", "ID of validator to kill")
+  .option("--all", "Kill all running validators")
+  .action(async (validatorId, options) => {
+    await killCommand(validatorId, options);
+  });
+
+program
+  .command("add-program")
+  .description("Add a program to sf.config.json")
+
+  .option("--program-id <address>", "Mainnet program ID to clone and deploy")
+  .option("--name <name>", "Friendly name for the program")
+  .option("--no-interactive", "Run in non-interactive mode")
+  .action(async (options) => {
+    await addProgramCommand(options);
+  });
+
+program
+  .command("status")
+  .description("Show localnet status")
+  .action(async () => {
+    await statusCommand();
+  });
+
+program.addCommand(transferCommand);
+
+program
+  .command("reset")
+  .description("Reset localnet ledger")
+  .action(async () => {
+    console.log(chalk.blue("🔄 Resetting localnet..."));
+    // TODO: Implement reset
+  });
+
+program.parse();

package/src/services/port-manager.ts

@@ -0,0 +1,177 @@
+import { processRegistry } from "./process-registry.js";
+
+export interface PortAllocation {
+  rpcPort: number;
+  faucetPort: number;
+}
+
+export class PortManager {
+  private readonly defaultRpcPort = 8899;
+  private readonly defaultFaucetPort = 9900;
+  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("net");
+      const server = net.createServer();
+
+      server.listen(port, (err: any) => {
+        if (err) {
+          resolve(false);
+        } else {
+          server.once("close", () => resolve(true));
+          server.close();
+        }
+      });
+
+      server.on("error", () => resolve(false));
+    });
+  }
+
+  /**
+   * 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();