solforge 0.2.4 → 0.2.6

package/src/types/config.ts

@@ -2,61 +2,61 @@ 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
+	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
+	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"),
+	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({}),
+	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
@@ -67,44 +67,44 @@ export type Config = z.infer<typeof ConfigSchema>;
 
 // Validator status types
 export type ValidatorStatus =
-  | "stopped"
-  | "starting"
-  | "running"
-  | "stopping"
-  | "error";
+	| "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;
+	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 OperationResult<T = unknown> {
+	success: boolean;
+	data?: T;
+	error?: string;
+	details?: unknown;
 }
 
 export interface CloneResult {
-  type: "program" | "token";
-  id: string;
-  name?: string;
-  success: boolean;
-  error?: string;
+	type: "program" | "token";
+	id: string;
+	name?: string;
+	success: boolean;
+	error?: string;
 }
 
 export interface ValidationResult {
-  valid: boolean;
-  errors: Array<{
-    path: string;
-    message: string;
-  }>;
+	valid: boolean;
+	errors: Array<{
+		path: string;
+		message: string;
+	}>;
 }

package/src/utils/shell.ts

@@ -2,109 +2,109 @@ import { $ } from "bun";
 import chalk from "chalk";
 
 export interface CommandResult {
-  success: boolean;
-  stdout: string;
-  stderr: string;
-  exitCode: number;
+	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;
-  } = {}
+	command: string,
+	args: string[] = [],
+	options: {
+		silent?: boolean;
+		jsonOutput?: boolean;
+		debug?: boolean;
+	} = {},
 ): Promise<CommandResult> {
-  const { silent = false, jsonOutput = false, debug = false } = options;
+	const { silent = false, jsonOutput = false, debug = false } = options;
 
-  try {
-    if (!silent || debug) {
-      console.log(chalk.gray(`$ ${command} ${args.join(" ")}`));
-    }
+	try {
+		if (!silent || debug) {
+			console.log(chalk.gray(`$ ${command} ${args.join(" ")}`));
+		}
 
-    const result = await $`${command} ${args}`.quiet();
+		const result = await $`${command} ${args}`.quiet();
 
-    const stdout = result.stdout.toString();
-    const stderr = result.stderr.toString();
-    const exitCode = result.exitCode;
-    const success = exitCode === 0;
+		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 (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 (!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")
-        );
-      }
-    }
+		// 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);
+		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}`));
-    }
+		if (!silent) {
+			console.error(chalk.red(`Command execution failed: ${errorMessage}`));
+		}
 
-    return {
-      success: false,
-      stdout: "",
-      stderr: errorMessage,
-      exitCode: 1,
-    };
-  }
+		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;
+	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;
+	solana: boolean;
+	splToken: boolean;
 }> {
-  const [solana, splToken] = await Promise.all([
-    commandExists("solana"),
-    commandExists("spl-token"),
-  ]);
+	const [solana, splToken] = await Promise.all([
+		commandExists("solana"),
+		commandExists("spl-token"),
+	]);
 
-  return { solana, splToken };
+	return { solana, splToken };
 }

package/src/utils/token-loader.ts

@@ -1,17 +1,17 @@
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
 import { Keypair } from "@solana/web3.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import type { TokenConfig } from "../types/config.js";
 
 export interface ClonedToken {
-  config: TokenConfig;
-  mintAuthorityPath: string;
-  modifiedAccountPath: string;
-  metadataAccountPath?: string;
-  mintAuthority: {
-    publicKey: string;
-    secretKey: number[];
-  };
+	config: TokenConfig;
+	mintAuthorityPath: string;
+	modifiedAccountPath: string;
+	metadataAccountPath?: string;
+	mintAuthority: {
+		publicKey: string;
+		secretKey: number[];
+	};
 }
 
 /**
@@ -19,97 +19,97 @@ export interface ClonedToken {
  * This ensures consistent token loading across CLI and API server.
  */
 export async function loadClonedTokens(
-  tokenConfigs: TokenConfig[],
-  workDir: string = ".solforge"
+	tokenConfigs: TokenConfig[],
+	workDir: string = ".solforge",
 ): Promise<ClonedToken[]> {
-  const clonedTokens: ClonedToken[] = [];
+	const clonedTokens: ClonedToken[] = [];
 
-  // Load shared mint authority
-  const sharedMintAuthorityPath = join(workDir, "shared-mint-authority.json");
-  let sharedMintAuthority: { publicKey: string; secretKey: number[] } | null =
-    null;
+	// 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 (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),
-        };
+			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 [];
-    }
-  }
+				// 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 [];
-  }
+	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");
+	// 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,
-      };
+		// 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;
-      }
+			// Add metadata path if it exists
+			if (existsSync(metadataAccountPath)) {
+				clonedToken.metadataAccountPath = metadataAccountPath;
+			}
 
-      clonedTokens.push(clonedToken);
-    }
-  }
+			clonedTokens.push(clonedToken);
+		}
+	}
 
-  return clonedTokens;
+	return clonedTokens;
 }
 
 /**
  * Find a cloned token by its mint address
  */
 export function findTokenByMint(
-  clonedTokens: ClonedToken[],
-  mintAddress: string
+	clonedTokens: ClonedToken[],
+	mintAddress: string,
 ): ClonedToken | undefined {
-  return clonedTokens.find((token) => token.config.mainnetMint === mintAddress);
+	return clonedTokens.find((token) => token.config.mainnetMint === mintAddress);
 }
 
 /**
  * Find a cloned token by its symbol
  */
 export function findTokenBySymbol(
-  clonedTokens: ClonedToken[],
-  symbol: string
+	clonedTokens: ClonedToken[],
+	symbol: string,
 ): ClonedToken | undefined {
-  return clonedTokens.find(
-    (token) => token.config.symbol.toLowerCase() === symbol.toLowerCase()
-  );
+	return clonedTokens.find(
+		(token) => token.config.symbol.toLowerCase() === symbol.toLowerCase(),
+	);
 }