solforge 0.2.4 → 0.2.6

package/src/commands/mint.ts

@@ -1,288 +1,287 @@
-import { Command } from "commander";
-import chalk from "chalk";
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
 import { input, select } from "@inquirer/prompts";
+import { PublicKey } from "@solana/web3.js";
+import chalk from "chalk";
+import { Command } from "commander";
+import { existsSync, readFileSync } from "node:fs";
+import type { TokenConfig } from "../types/config.js";
 import { runCommand } from "../utils/shell";
-import { Keypair, PublicKey } from "@solana/web3.js";
 import {
-  loadClonedTokens,
-  findTokenBySymbol,
-  type ClonedToken,
+	type ClonedToken,
+	findTokenBySymbol,
+	loadClonedTokens,
 } from "../utils/token-loader.js";
-import type { TokenConfig } from "../types/config.js";
 
 export const mintCommand = new Command()
-  .name("mint")
-  .description("Interactively mint tokens to any wallet address")
-  .option("--rpc-url <url>", "RPC URL to use", "http://127.0.0.1:8899")
-  .option("--symbol <symbol>", "Token symbol to mint")
-  .option("--wallet <address>", "Wallet address to mint to")
-  .option("--amount <amount>", "Amount to mint")
-  .action(async (options) => {
-    try {
-      console.log(chalk.blue("🪙 Interactive Token Minting"));
-      console.log(chalk.gray("Mint tokens to any wallet address\n"));
+	.name("mint")
+	.description("Interactively mint tokens to any wallet address")
+	.option("--rpc-url <url>", "RPC URL to use", "http://127.0.0.1:8899")
+	.option("--symbol <symbol>", "Token symbol to mint")
+	.option("--wallet <address>", "Wallet address to mint to")
+	.option("--amount <amount>", "Amount to mint")
+	.action(async (options) => {
+		try {
+			console.log(chalk.blue("🪙 Interactive Token Minting"));
+			console.log(chalk.gray("Mint tokens to any wallet 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);
-      }
+			// 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
-      const tokens = await loadAvailableTokens(workDir);
+			// Load available tokens
+			const tokens = await loadAvailableTokens(workDir);
 
-      if (tokens.length === 0) {
-        console.error(
-          chalk.red(
-            "❌ No tokens found. Run 'solforge start' first to clone tokens."
-          )
-        );
-        process.exit(1);
-      }
+			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.config.symbol} (${
-              token.config.mainnetMint
-            })`
-          )
-        );
-      });
-      console.log();
+			// Display available tokens
+			console.log(chalk.cyan("📋 Available Tokens:"));
+			tokens.forEach((token, index) => {
+				console.log(
+					chalk.gray(
+						`  ${index + 1}. ${token.config.symbol} (${
+							token.config.mainnetMint
+						})`,
+					),
+				);
+			});
+			console.log();
 
-      // Select token (or use provided symbol)
-      let selectedToken: ClonedToken;
-      if (options.symbol) {
-        const token = findTokenBySymbol(tokens, options.symbol);
-        if (!token) {
-          console.error(
-            chalk.red(`❌ Token ${options.symbol} not found in cloned tokens`)
-          );
-          process.exit(1);
-        }
-        selectedToken = token;
-        console.log(
-          chalk.gray(`Selected token: ${selectedToken.config.symbol}`)
-        );
-      } else {
-        selectedToken = await select({
-          message: "Select a token to mint:",
-          choices: tokens.map((token) => ({
-            name: `${token.config.symbol} (${token.config.mainnetMint})`,
-            value: token,
-          })),
-        });
-      }
+			// Select token (or use provided symbol)
+			let selectedToken: ClonedToken;
+			if (options.symbol) {
+				const token = findTokenBySymbol(tokens, options.symbol);
+				if (!token) {
+					console.error(
+						chalk.red(`❌ Token ${options.symbol} not found in cloned tokens`),
+					);
+					process.exit(1);
+				}
+				selectedToken = token;
+				console.log(
+					chalk.gray(`Selected token: ${selectedToken.config.symbol}`),
+				);
+			} else {
+				selectedToken = await select({
+					message: "Select a token to mint:",
+					choices: tokens.map((token) => ({
+						name: `${token.config.symbol} (${token.config.mainnetMint})`,
+						value: token,
+					})),
+				});
+			}
 
-      // Get recipient address (or use provided wallet)
-      let recipientAddress: string;
-      if (options.wallet) {
-        recipientAddress = options.wallet;
-        // Validate wallet address
-        try {
-          new PublicKey(recipientAddress);
-        } catch {
-          console.error(chalk.red("❌ Invalid wallet address"));
-          process.exit(1);
-        }
-        console.log(chalk.gray(`Recipient wallet: ${recipientAddress}`));
-      } else {
-        recipientAddress = await input({
-          message: "Enter recipient wallet address:",
-          validate: (value: string) => {
-            if (!value.trim()) {
-              return "Please enter a valid address";
-            }
-            try {
-              new PublicKey(value.trim());
-              return true;
-            } catch {
-              return "Please enter a valid Solana address";
-            }
-          },
-        });
-      }
+			// Get recipient address (or use provided wallet)
+			let recipientAddress: string;
+			if (options.wallet) {
+				recipientAddress = options.wallet;
+				// Validate wallet address
+				try {
+					new PublicKey(recipientAddress);
+				} catch {
+					console.error(chalk.red("❌ Invalid wallet address"));
+					process.exit(1);
+				}
+				console.log(chalk.gray(`Recipient wallet: ${recipientAddress}`));
+			} else {
+				recipientAddress = await input({
+					message: "Enter recipient wallet address:",
+					validate: (value: string) => {
+						if (!value.trim()) {
+							return "Please enter a valid address";
+						}
+						try {
+							new PublicKey(value.trim());
+							return true;
+						} catch {
+							return "Please enter a valid Solana address";
+						}
+					},
+				});
+			}
 
-      // Get amount to mint (or use provided amount)
-      let amount: string;
-      if (options.amount) {
-        const num = parseFloat(options.amount);
-        if (isNaN(num) || num <= 0) {
-          console.error(chalk.red("❌ Invalid amount"));
-          process.exit(1);
-        }
-        amount = options.amount;
-        console.log(chalk.gray(`Amount to mint: ${amount}`));
-      } else {
-        amount = await input({
-          message: "Enter amount to mint:",
-          validate: (value: string) => {
-            const num = parseFloat(value);
-            if (isNaN(num) || num <= 0) {
-              return "Please enter a valid positive number";
-            }
-            return true;
-          },
-        });
-      }
+			// Get amount to mint (or use provided amount)
+			let amount: string;
+			if (options.amount) {
+				const num = parseFloat(options.amount);
+				if (Number.isNaN(num) || num <= 0) {
+					console.error(chalk.red("❌ Invalid amount"));
+					process.exit(1);
+				}
+				amount = options.amount;
+				console.log(chalk.gray(`Amount to mint: ${amount}`));
+			} else {
+				amount = await input({
+					message: "Enter amount to mint:",
+					validate: (value: string) => {
+						const num = parseFloat(value);
+						if (Number.isNaN(num) || num <= 0) {
+							return "Please enter a valid positive number";
+						}
+						return true;
+					},
+				});
+			}
 
-      // Confirm minting if interactive
-      if (!options.symbol || !options.wallet || !options.amount) {
-        const confirm = await input({
-          message: `Confirm minting ${amount} ${selectedToken.config.symbol} to ${recipientAddress}? (y/N):`,
-          default: "N",
-        });
+			// Confirm minting if interactive
+			if (!options.symbol || !options.wallet || !options.amount) {
+				const confirm = await input({
+					message: `Confirm minting ${amount} ${selectedToken.config.symbol} to ${recipientAddress}? (y/N):`,
+					default: "N",
+				});
 
-        if (confirm.toLowerCase() !== "y" && confirm.toLowerCase() !== "yes") {
-          console.log(chalk.yellow("Minting cancelled."));
-          process.exit(0);
-        }
-      }
+				if (confirm.toLowerCase() !== "y" && confirm.toLowerCase() !== "yes") {
+					console.log(chalk.yellow("Minting cancelled."));
+					process.exit(0);
+				}
+			}
 
-      console.log(chalk.blue("🚀 Starting mint..."));
+			console.log(chalk.blue("🚀 Starting mint..."));
 
-      // Execute mint
-      await mintTokenToWallet(
-        selectedToken,
-        recipientAddress,
-        parseFloat(amount),
-        options.rpcUrl
-      );
+			// Execute mint
+			await mintTokenToWallet(
+				selectedToken,
+				recipientAddress,
+				parseFloat(amount),
+				options.rpcUrl,
+			);
 
-      console.log(
-        chalk.green(
-          `✅ Successfully minted ${amount} ${selectedToken.config.symbol} to ${recipientAddress}`
-        )
-      );
-    } catch (error) {
-      console.error(chalk.red(`❌ Mint failed: ${error}`));
-      process.exit(1);
-    }
-  });
+			console.log(
+				chalk.green(
+					`✅ Successfully minted ${amount} ${selectedToken.config.symbol} to ${recipientAddress}`,
+				),
+			);
+		} catch (error) {
+			console.error(chalk.red(`❌ Mint failed: ${error}`));
+			process.exit(1);
+		}
+	});
 
 async function loadAvailableTokens(workDir: string): Promise<ClonedToken[]> {
-  try {
-    // 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");
-    }
+	try {
+		// 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 || [];
+		const config = JSON.parse(readFileSync(configPath, "utf8"));
+		const tokenConfigs: TokenConfig[] = config.tokens || [];
 
-    // Use the shared token loader
-    return await loadClonedTokens(tokenConfigs, workDir);
-  } catch (error) {
-    throw new Error(`Failed to load tokens: ${error}`);
-  }
+		// Use the shared token loader
+		return await loadClonedTokens(tokenConfigs, workDir);
+	} catch (error) {
+		throw new Error(`Failed to load tokens: ${error}`);
+	}
 }
 
 export async function mintTokenToWallet(
-  token: ClonedToken,
-  walletAddress: string,
-  amount: number,
-  rpcUrl: string
+	token: ClonedToken,
+	walletAddress: string,
+	amount: number,
+	rpcUrl: string,
 ): Promise<void> {
-  // Check if associated token account already exists (same pattern as token-cloner.ts)
-  console.log(chalk.gray(`🔍 Checking for existing token account...`));
+	// Check if associated token account already exists (same pattern as token-cloner.ts)
+	console.log(chalk.gray(`🔍 Checking for existing token account...`));
 
-  const checkAccountsResult = await runCommand(
-    "spl-token",
-    ["accounts", "--owner", walletAddress, "--url", rpcUrl, "--output", "json"],
-    { silent: true }
-  );
+	const checkAccountsResult = await runCommand(
+		"spl-token",
+		["accounts", "--owner", walletAddress, "--url", rpcUrl, "--output", "json"],
+		{ silent: true },
+	);
 
-  let tokenAccountAddress = "";
+	let tokenAccountAddress = "";
 
-  if (checkAccountsResult.success && checkAccountsResult.stdout) {
-    try {
-      const accountsData = JSON.parse(checkAccountsResult.stdout);
+	if (checkAccountsResult.success && checkAccountsResult.stdout) {
+		try {
+			const accountsData = JSON.parse(checkAccountsResult.stdout);
 
-      // Look for existing token account for this mint
-      for (const account of accountsData.accounts || []) {
-        if (account.mint === token.config.mainnetMint) {
-          tokenAccountAddress = account.address;
-          console.log(
-            chalk.gray(
-              `ℹ️  Found existing token account: ${tokenAccountAddress}`
-            )
-          );
-          break;
-        }
-      }
-    } catch (error) {
-      // No existing accounts found or parsing error, will create new account
-    }
-  }
+			// Look for existing token account for this mint
+			for (const account of accountsData.accounts || []) {
+				if (account.mint === token.config.mainnetMint) {
+					tokenAccountAddress = account.address;
+					console.log(
+						chalk.gray(
+							`ℹ️  Found existing token account: ${tokenAccountAddress}`,
+						),
+					);
+					break;
+				}
+			}
+		} catch (_error) {
+			// No existing accounts found or parsing error, will create new account
+		}
+	}
 
-  if (!tokenAccountAddress) {
-    // Account doesn't exist, create it (same pattern as token-cloner.ts)
-    console.log(chalk.gray(`🔧 Creating token account...`));
+	if (!tokenAccountAddress) {
+		// Account doesn't exist, create it (same pattern as token-cloner.ts)
+		console.log(chalk.gray(`🔧 Creating token account...`));
 
-    const createAccountResult = await runCommand(
-      "spl-token",
-      [
-        "create-account",
-        token.config.mainnetMint,
-        "--owner",
-        walletAddress,
-        "--fee-payer",
-        token.mintAuthorityPath,
-        "--url",
-        rpcUrl,
-      ],
-      { silent: false }
-    );
+		const createAccountResult = await runCommand(
+			"spl-token",
+			[
+				"create-account",
+				token.config.mainnetMint,
+				"--owner",
+				walletAddress,
+				"--fee-payer",
+				token.mintAuthorityPath,
+				"--url",
+				rpcUrl,
+			],
+			{ silent: false },
+		);
 
-    if (!createAccountResult.success) {
-      throw new Error(
-        `Failed to create token account: ${createAccountResult.stderr}`
-      );
-    }
+		if (!createAccountResult.success) {
+			throw new Error(
+				`Failed to create token account: ${createAccountResult.stderr}`,
+			);
+		}
 
-    // Extract token account address from create-account output
-    const match = createAccountResult.stdout.match(/Creating account (\S+)/);
-    tokenAccountAddress = match?.[1] || "";
+		// Extract token account address from create-account output
+		const match = createAccountResult.stdout.match(/Creating account (\S+)/);
+		tokenAccountAddress = match?.[1] || "";
 
-    if (!tokenAccountAddress) {
-      throw new Error(
-        "Failed to determine token account address from create-account output"
-      );
-    }
+		if (!tokenAccountAddress) {
+			throw new Error(
+				"Failed to determine token account address from create-account output",
+			);
+		}
 
-    console.log(chalk.gray(`✅ Created token account: ${tokenAccountAddress}`));
-  }
+		console.log(chalk.gray(`✅ Created token account: ${tokenAccountAddress}`));
+	}
 
-  // Now mint to the token account (same pattern as token-cloner.ts)
-  console.log(chalk.gray(`💰 Minting ${amount} tokens...`));
+	// Now mint to the token account (same pattern as token-cloner.ts)
+	console.log(chalk.gray(`💰 Minting ${amount} tokens...`));
 
-  const result = await runCommand(
-    "spl-token",
-    [
-      "mint",
-      token.config.mainnetMint,
-      amount.toString(),
-      tokenAccountAddress,
-      "--mint-authority",
-      token.mintAuthorityPath,
-      "--fee-payer",
-      token.mintAuthorityPath,
-      "--url",
-      rpcUrl,
-    ],
-    { silent: false }
-  );
+	const result = await runCommand(
+		"spl-token",
+		[
+			"mint",
+			token.config.mainnetMint,
+			amount.toString(),
+			tokenAccountAddress,
+			"--mint-authority",
+			token.mintAuthorityPath,
+			"--fee-payer",
+			token.mintAuthorityPath,
+			"--url",
+			rpcUrl,
+		],
+		{ silent: false },
+	);
 
-  if (!result.success) {
-    throw new Error(`Failed to mint tokens: ${result.stderr}`);
-  }
+	if (!result.success) {
+		throw new Error(`Failed to mint tokens: ${result.stderr}`);
+	}
 }