solforge 0.2.0 → 0.2.2

package/src/index.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env bun
+
+// Suppress bigint-buffer warning
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+process.stderr.write = function(chunk: any, encoding?: any, callback?: any) {
+  if (typeof chunk === 'string' && chunk.includes('bigint: Failed to load bindings')) {
+    return true; // Suppress this specific warning
+  }
+  return originalStderrWrite(chunk, encoding, callback);
+};
+
+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 { mintCommand } from "./commands/mint.js";
+import { listCommand } from "./commands/list.js";
+import { stopCommand, killCommand } from "./commands/stop.js";
+import { addProgramCommand } from "./commands/add-program.js";
+import packageJson from "../package.json" with { type: "json" };
+
+const program = new Command();
+
+program
+  .name("solforge")
+  .description("Solana localnet orchestration tool")
+  .version(packageJson.version);
+
+// 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")
+  .option("--network", "Make API server accessible over network (binds to 0.0.0.0 instead of 127.0.0.1)")
+  .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, options.network || 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("api-server")
+  .description("Start API server standalone")
+  .option("-p, --port <port>", "Port for API server", "3000")
+  .option("--host <host>", "Host to bind to (default: 127.0.0.1, use 0.0.0.0 for network access)")
+  .option("--rpc-url <url>", "Validator RPC URL", "http://127.0.0.1:8899")
+  .option("--faucet-url <url>", "Validator faucet URL", "http://127.0.0.1:9900")
+  .option("--work-dir <dir>", "Work directory", "./.solforge")
+  .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);
+    }
+
+    // Import API server components
+    const { APIServer } = await import("./services/api-server.js");
+    const { configManager } = await import("./config/manager.js");
+
+    try {
+      await configManager.load(configPath);
+      const config = configManager.getConfig();
+
+      const apiServer = new APIServer({
+        port: parseInt(options.port),
+        host: options.host,
+        validatorRpcUrl: options.rpcUrl,
+        validatorFaucetUrl: options.faucetUrl,
+        config,
+        workDir: options.workDir,
+      });
+
+      const result = await apiServer.start();
+      if (result.success) {
+        console.log(chalk.green("✅ API Server started successfully!"));
+        
+        // Keep the process alive
+        process.on("SIGTERM", async () => {
+          console.log(chalk.yellow("📡 API Server received SIGTERM, shutting down..."));
+          await apiServer.stop();
+          process.exit(0);
+        });
+
+        process.on("SIGINT", async () => {
+          console.log(chalk.yellow("📡 API Server received SIGINT, shutting down..."));
+          await apiServer.stop();
+          process.exit(0);
+        });
+
+        // Keep process alive
+        setInterval(() => {}, 1000);
+      } else {
+        console.error(chalk.red(`❌ Failed to start API server: ${result.error}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `❌ API Server error: ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        )
+      );
+      process.exit(1);
+    }
+  });
+
+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(mintCommand);
+
+program
+  .command("reset")
+  .description("Reset localnet ledger")
+  .action(async () => {
+    console.log(chalk.blue("🔄 Resetting localnet..."));
+    // TODO: Implement reset
+  });
+
+program.parse();

package/src/services/api-server.ts

@@ -0,0 +1,485 @@
+import express from "express";
+import cors from "cors";
+import { Server } from "http";
+import { spawn, ChildProcess } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import { Connection, PublicKey, Keypair } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { runCommand } from "../utils/shell.js";
+import { TokenCloner } from "./token-cloner.js";
+import { ProgramCloner } from "./program-cloner.js";
+import { mintTokenToWallet as mintTokenToWalletShared } from "../commands/mint.js";
+import {
+  loadClonedTokens,
+  findTokenByMint,
+  type ClonedToken,
+} from "../utils/token-loader.js";
+import type { Config } from "../types/config.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 tokenCloner: TokenCloner;
+  private programCloner: ProgramCloner;
+  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, 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<any> {
+    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<any> {
+    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) {
+          // Skip failed token accounts
+          continue;
+        }
+      }
+
+      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<any> {
+    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 !== null && this.server.listening;
+  }
+}