solforge 0.2.12 → 0.2.14

package/src/services/token-cloner.ts

@@ -1,811 +0,0 @@
-import { Keypair, PublicKey } from "@solana/web3.js";
-import chalk from "chalk";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { TokenConfig } from "../types/config.js";
-import { runCommand } from "../utils/shell.js";
-
-// Metaplex Token Metadata Program ID
-const METADATA_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
-
-export interface ClonedToken {
-	config: TokenConfig;
-	mintAuthorityPath: string;
-	modifiedAccountPath: string;
-	metadataAccountPath?: string; // Path to cloned metadata account
-	mintAuthority: {
-		publicKey: string;
-		secretKey: number[];
-	};
-}
-
-export class TokenCloner {
-	private workDir: string;
-
-	constructor(workDir: string = ".solforge") {
-		this.workDir = workDir;
-		// Ensure work directory exists
-		if (!existsSync(this.workDir)) {
-			mkdirSync(this.workDir, { recursive: true });
-		}
-	}
-
-	/**
-	 * Clone tokens by fetching account data, modifying mint authority, and preparing for validator
-	 */
-	async cloneTokens(
-		tokens: TokenConfig[],
-		rpcUrl: string = "https://api.mainnet-beta.solana.com",
-		debug: boolean = false,
-	): Promise<ClonedToken[]> {
-		const clonedTokens: ClonedToken[] = [];
-
-		// Generate one shared mint authority for all tokens
-		const sharedMintAuthorityPath = join(
-			this.workDir,
-			"shared-mint-authority.json",
-		);
-		let sharedMintAuthority: { publicKey: string; secretKey: number[] };
-
-		if (existsSync(sharedMintAuthorityPath)) {
-			// Use existing shared mint authority
-			console.log(chalk.gray(`🔑 Using existing shared mint authority...`));
-			const fileContent = JSON.parse(
-				readFileSync(sharedMintAuthorityPath, "utf8"),
-			);
-
-			// Handle both old format {publicKey, secretKey} and new format [secretKey array]
-			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),
-				};
-
-				// Verify consistency with metadata if it exists
-				const metadataPath = join(
-					this.workDir,
-					"shared-mint-authority-meta.json",
-				);
-				if (existsSync(metadataPath)) {
-					const metadata = JSON.parse(readFileSync(metadataPath, "utf8"));
-					if (metadata.publicKey !== sharedMintAuthority.publicKey) {
-						console.log(chalk.yellow(`⚠️  Public key mismatch detected!`));
-						console.log(chalk.gray(`  Expected: ${metadata.publicKey}`));
-						console.log(chalk.gray(`  Got: ${sharedMintAuthority.publicKey}`));
-						console.log(
-							chalk.gray(
-								`  Using the original saved public key for consistency`,
-							),
-						);
-						sharedMintAuthority.publicKey = metadata.publicKey;
-					}
-				}
-			} else {
-				// Old format: file contains {publicKey, secretKey}
-				sharedMintAuthority = fileContent;
-			}
-		} else {
-			// Generate new shared mint authority
-			console.log(
-				chalk.gray(`🔑 Generating shared mint authority for all tokens...`),
-			);
-			const keypair = Keypair.generate();
-			sharedMintAuthority = {
-				publicKey: keypair.publicKey.toBase58(),
-				secretKey: Array.from(keypair.secretKey),
-			};
-
-			// Ensure work directory exists
-			if (!existsSync(this.workDir)) {
-				mkdirSync(this.workDir, { recursive: true });
-			}
-
-			// Save shared mint authority in the format expected by spl-token (just the secret key array)
-			// But also save a metadata file for verification
-			writeFileSync(
-				sharedMintAuthorityPath,
-				JSON.stringify(sharedMintAuthority.secretKey),
-			);
-
-			// Save metadata for debugging and verification
-			const metadataPath = join(
-				this.workDir,
-				"shared-mint-authority-meta.json",
-			);
-			writeFileSync(
-				metadataPath,
-				JSON.stringify(
-					{
-						publicKey: sharedMintAuthority.publicKey,
-						savedAt: new Date().toISOString(),
-					},
-					null,
-					2,
-				),
-			);
-		}
-
-		console.log(
-			chalk.gray(
-				`  📋 Shared mint authority: ${sharedMintAuthority.publicKey}`,
-			),
-		);
-
-		for (const token of tokens) {
-			console.log(
-				chalk.cyan(`🪙 Cloning ${token.symbol} (${token.mainnetMint})...`),
-			);
-
-			try {
-				const cloned = await this.cloneToken(
-					token,
-					rpcUrl,
-					debug,
-					sharedMintAuthority,
-					sharedMintAuthorityPath,
-				);
-				clonedTokens.push(cloned);
-				console.log(chalk.green(`  ✅ ${token.symbol} cloned successfully`));
-			} catch (error) {
-				console.error(chalk.red(`  ❌ Failed to clone ${token.symbol}:`));
-				console.error(
-					chalk.red(
-						`     ${error instanceof Error ? error.message : String(error)}`,
-					),
-				);
-				throw error; // Stop on first failure
-			}
-		}
-
-		return clonedTokens;
-	}
-
-	/**
-	 * Clone a single token
-	 */
-	private async cloneToken(
-		token: TokenConfig,
-		rpcUrl: string,
-		debug: boolean = false,
-		sharedMintAuthority: { publicKey: string; secretKey: number[] },
-		sharedMintAuthorityPath: string,
-	): Promise<ClonedToken> {
-		const tokenDir = join(this.workDir, `token-${token.symbol.toLowerCase()}`);
-		if (!existsSync(tokenDir)) {
-			mkdirSync(tokenDir, { recursive: true });
-		}
-
-		const originalAccountPath = join(tokenDir, "original.json");
-		const modifiedAccountPath = join(tokenDir, "modified.json");
-		const metadataAccountPath = join(tokenDir, "metadata.json");
-
-		// Step 1: Fetch original account data from mainnet
-		console.log(chalk.gray(`  📥 Fetching account data from mainnet...`));
-		if (debug) {
-			console.log(chalk.gray(`  🔗 Using RPC: ${rpcUrl}`));
-		}
-
-		const fetchResult = await runCommand(
-			"solana",
-			[
-				"account",
-				token.mainnetMint,
-				"--output",
-				"json-compact",
-				"--output-file",
-				originalAccountPath,
-				"--url",
-				rpcUrl,
-			],
-			{ silent: !debug, debug },
-		);
-
-		if (!fetchResult.success) {
-			console.error(
-				chalk.red(`  ❌ Failed to fetch account data for ${token.symbol}`),
-			);
-			throw new Error(
-				`Failed to fetch account: ${fetchResult.stderr || fetchResult.stdout}`,
-			);
-		}
-
-		// Step 2: Clone metadata if requested
-		let hasMetadata = false;
-		if (token.cloneMetadata !== false) {
-			// Default to true
-			try {
-				hasMetadata = await this.cloneTokenMetadata(
-					token,
-					rpcUrl,
-					metadataAccountPath,
-					debug,
-				);
-				if (hasMetadata) {
-					console.log(chalk.gray(`  📋 Token metadata cloned successfully`));
-				}
-			} catch (error) {
-				console.log(
-					chalk.yellow(
-						`  ⚠️  Failed to clone metadata: ${
-							error instanceof Error ? error.message : String(error)
-						}`,
-					),
-				);
-				// Don't fail the entire token cloning if metadata fails
-			}
-		}
-
-		// Step 3: Modify mint authority
-		console.log(chalk.gray(`  🔧 Modifying mint authority...`));
-		await this.modifyMintAuthority(
-			originalAccountPath,
-			modifiedAccountPath,
-			sharedMintAuthority,
-		);
-
-		const result: ClonedToken = {
-			config: token,
-			mintAuthorityPath: sharedMintAuthorityPath,
-			modifiedAccountPath,
-			mintAuthority: sharedMintAuthority,
-		};
-
-		// Add metadata path if we successfully cloned metadata
-		if (hasMetadata) {
-			result.metadataAccountPath = metadataAccountPath;
-		}
-
-		return result;
-	}
-
-	/**
-	 * Clone token metadata from Metaplex Token Metadata program
-	 */
-	private async cloneTokenMetadata(
-		token: TokenConfig,
-		rpcUrl: string,
-		metadataAccountPath: string,
-		debug: boolean = false,
-	): Promise<boolean> {
-		try {
-			// Derive metadata account address
-			const metadataAddress = await this.deriveMetadataAddress(
-				token.mainnetMint,
-			);
-
-			if (debug) {
-				console.log(chalk.gray(`  🔍 Metadata PDA: ${metadataAddress}`));
-			}
-
-			// Fetch metadata account data
-			const fetchResult = await runCommand(
-				"solana",
-				[
-					"account",
-					metadataAddress,
-					"--output",
-					"json-compact",
-					"--output-file",
-					metadataAccountPath,
-					"--url",
-					rpcUrl,
-				],
-				{ silent: !debug, debug },
-			);
-
-			if (!fetchResult.success) {
-				if (debug) {
-					console.log(
-						chalk.gray(`  ℹ️  No metadata account found for ${token.symbol}`),
-					);
-				}
-				return false;
-			}
-
-			return true;
-		} catch (error) {
-			throw new Error(
-				`Failed to clone metadata: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
-			);
-		}
-	}
-
-	/**
-	 * Derive the metadata account address for a given mint
-	 * PDA: ["metadata", metadata_program_id, mint_address]
-	 */
-	private async deriveMetadataAddress(mintAddress: string): Promise<string> {
-		try {
-			// Use web3.js to derive the actual PDA
-			const metadataProgram = new PublicKey(METADATA_PROGRAM_ID);
-			const mint = new PublicKey(mintAddress);
-
-			const [metadataAddress] = PublicKey.findProgramAddressSync(
-				[Buffer.from("metadata"), metadataProgram.toBuffer(), mint.toBuffer()],
-				metadataProgram,
-			);
-
-			return metadataAddress.toBase58();
-		} catch (error) {
-			throw new Error(
-				`Failed to derive metadata PDA: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
-			);
-		}
-	}
-
-	/**
-	 * Modify the mint account data to use a new mint authority
-	 */
-	private async modifyMintAuthority(
-		originalPath: string,
-		modifiedPath: string,
-		mintAuthority: { publicKey: string; secretKey: number[] },
-	): Promise<void> {
-		// Read original account data
-		const originalData = JSON.parse(readFileSync(originalPath, "utf8"));
-
-		// Decode the base64 account data
-		const accountData = Buffer.from(originalData.account.data[0], "base64");
-
-		// Convert to mutable array for modification
-		const dataArray = new Uint8Array(accountData);
-
-		// Check if mint authority is set to None (fixed supply)
-		const mintAuthorityOption = dataArray[0];
-		const hasFixedSupply = mintAuthorityOption === 0;
-
-		if (hasFixedSupply) {
-			console.log(
-				chalk.yellow(`  ⚠️  Token has fixed supply, making it mintable...`),
-			);
-
-			// Set mint_authority_option to Some (1)
-			dataArray[0] = 1;
-
-			// Set the mint authority (bytes 4-35)
-			const keypair = Keypair.fromSecretKey(
-				new Uint8Array(mintAuthority.secretKey),
-			);
-			const newAuthorityBytes = keypair.publicKey.toBuffer();
-
-			for (let i = 0; i < 32; i++) {
-				const byte = newAuthorityBytes[i];
-				if (byte !== undefined) {
-					dataArray[4 + i] = byte;
-				}
-			}
-		} else {
-			console.log(chalk.gray(`  🔄 Updating existing mint authority...`));
-
-			// Create mint authority public key from the keypair
-			const keypair = Keypair.fromSecretKey(
-				new Uint8Array(mintAuthority.secretKey),
-			);
-			const newAuthorityBytes = keypair.publicKey.toBuffer();
-
-			// Replace mint authority (starts at byte 4, 32 bytes long)
-			for (let i = 0; i < 32; i++) {
-				const byte = newAuthorityBytes[i];
-				if (byte !== undefined) {
-					dataArray[4 + i] = byte;
-				}
-			}
-		}
-
-		// Convert back to base64
-		const modifiedData = Buffer.from(dataArray).toString("base64");
-
-		// Create modified account data
-		const modifiedAccountData = {
-			...originalData,
-			account: {
-				...originalData.account,
-				data: [modifiedData, "base64"],
-			},
-		};
-
-		// Handle rentEpoch properly (needs to be a number, not string)
-		let jsonString = JSON.stringify(modifiedAccountData, null, 2);
-		jsonString = jsonString.replace(
-			/"rentEpoch":\s*\d+/g,
-			'"rentEpoch": 18446744073709551615',
-		);
-
-		// Save modified account
-		writeFileSync(modifiedPath, jsonString);
-	}
-
-	/**
-	 * Get validator arguments for cloned tokens
-	 */
-	getValidatorArgs(clonedTokens: ClonedToken[]): string[] {
-		const args: string[] = [];
-
-		for (const token of clonedTokens) {
-			// Add the modified mint account
-			args.push(
-				"--account",
-				token.config.mainnetMint,
-				token.modifiedAccountPath,
-			);
-
-			// Add metadata account if it exists
-			if (token.metadataAccountPath && existsSync(token.metadataAccountPath)) {
-				try {
-					// Derive metadata address for this token
-					const metadataAddress = this.deriveMetadataAddressSync(
-						token.config.mainnetMint,
-					);
-					args.push("--account", metadataAddress, token.metadataAccountPath);
-					console.log(
-						chalk.gray(
-							`  📋 Adding metadata account for ${token.config.symbol}`,
-						),
-					);
-				} catch (error) {
-					console.log(
-						chalk.yellow(
-							`⚠️  Failed to add metadata account for ${token.config.symbol}: ${
-								error instanceof Error ? error.message : String(error)
-							}`,
-						),
-					);
-				}
-			}
-		}
-
-		return args;
-	}
-
-	/**
-	 * Synchronous version of deriveMetadataAddress for use in getValidatorArgs
-	 */
-	private deriveMetadataAddressSync(mintAddress: string): string {
-		try {
-			// Use web3.js to derive the actual PDA
-			const metadataProgram = new PublicKey(METADATA_PROGRAM_ID);
-			const mint = new PublicKey(mintAddress);
-
-			const [metadataAddress] = PublicKey.findProgramAddressSync(
-				[Buffer.from("metadata"), metadataProgram.toBuffer(), mint.toBuffer()],
-				metadataProgram,
-			);
-
-			return metadataAddress.toBase58();
-		} catch (error) {
-			throw new Error(
-				`Failed to derive metadata PDA: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
-			);
-		}
-	}
-
-	/**
-	 * Mint initial tokens to mint authority, then to recipients after validator is running
-	 */
-	async mintTokensToRecipients(
-		clonedTokens: ClonedToken[],
-		rpcUrl: string,
-		debug: boolean = false,
-	): Promise<void> {
-		for (const token of clonedTokens) {
-			console.log(chalk.cyan(`💰 Processing ${token.config.symbol}...`));
-
-			// First, mint the default amount to the mint authority
-			try {
-				await this.mintToMintAuthority(token, rpcUrl, debug);
-				console.log(
-					chalk.green(
-						`  ✅ Minted ${token.config.mintAmount} ${token.config.symbol} to mint authority`,
-					),
-				);
-			} catch (error) {
-				console.error(chalk.red(`  ❌ Failed to mint to mint authority:`));
-				console.error(
-					chalk.red(
-						`     ${error instanceof Error ? error.message : String(error)}`,
-					),
-				);
-				continue; // Skip recipients if mint authority minting failed
-			}
-
-			// Then mint to recipients if any are configured
-			if (token.config.recipients.length > 0) {
-				console.log(
-					chalk.gray(
-						`  🔄 Minting to ${token.config.recipients.length} recipients...`,
-					),
-				);
-
-				for (const recipient of token.config.recipients) {
-					try {
-						await this.mintToRecipient(
-							token,
-							recipient.wallet,
-							recipient.amount,
-							rpcUrl,
-						);
-						console.log(
-							chalk.green(
-								`  ✅ Minted ${recipient.amount} ${
-									token.config.symbol
-								} to ${recipient.wallet.slice(0, 8)}...`,
-							),
-						);
-					} catch (error) {
-						console.error(
-							chalk.red(
-								`  ❌ Failed to mint to ${recipient.wallet.slice(0, 8)}...:`,
-							),
-						);
-						console.error(
-							chalk.red(
-								`     ${error instanceof Error ? error.message : String(error)}`,
-							),
-						);
-					}
-				}
-			}
-		}
-	}
-
-	/**
-	 * Mint initial tokens to the mint authority account
-	 */
-	private async mintToMintAuthority(
-		token: ClonedToken,
-		rpcUrl: string,
-		debug: boolean = false,
-	): Promise<void> {
-		console.log(
-			chalk.gray(
-				`  🔄 Minting ${token.config.mintAmount} tokens to mint authority...`,
-			),
-		);
-
-		// Check if associated token account already exists
-		if (debug) {
-			console.log(
-				chalk.gray(`  🔍 Checking if token account already exists...`),
-			);
-		}
-
-		const checkAccountsResult = await runCommand(
-			"spl-token",
-			[
-				"accounts",
-				"--owner",
-				token.mintAuthority.publicKey,
-				"--url",
-				rpcUrl,
-				"--output",
-				"json",
-			],
-			{ silent: true },
-		);
-
-		let tokenAccountAddress = "";
-
-		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;
-						break;
-					}
-				}
-
-				if (tokenAccountAddress) {
-					if (debug) {
-						console.log(
-							chalk.gray(
-								`  ℹ️  Token account already exists: ${tokenAccountAddress}`,
-							),
-						);
-					}
-				}
-			} catch (_error) {
-				if (debug) {
-					console.log(
-						chalk.gray(`  ℹ️  No existing accounts found or parsing error`),
-					);
-				}
-			}
-		}
-
-		if (!tokenAccountAddress) {
-			// Account doesn't exist, create it
-			if (debug) {
-				console.log(
-					chalk.gray(`  🔧 Creating token account for mint authority...`),
-				);
-			}
-
-			const createAccountResult = await runCommand(
-				"spl-token",
-				[
-					"create-account",
-					token.config.mainnetMint,
-					"--owner",
-					token.mintAuthority.publicKey,
-					"--fee-payer",
-					token.mintAuthorityPath,
-					"--url",
-					rpcUrl,
-				],
-				{ silent: !debug, debug },
-			);
-
-			if (!createAccountResult.success) {
-				console.error(chalk.red(`  ❌ Failed to create token account:`));
-				console.error(
-					chalk.red(
-						`     Command: spl-token create-account ${token.config.mainnetMint} --owner ${token.mintAuthority.publicKey} --fee-payer ${token.mintAuthorityPath} --url ${rpcUrl}`,
-					),
-				);
-				console.error(
-					chalk.red(`     Exit code: ${createAccountResult.exitCode}`),
-				);
-				console.error(chalk.red(`     Stderr: ${createAccountResult.stderr}`));
-				if (createAccountResult.stdout) {
-					console.error(
-						chalk.red(`     Stdout: ${createAccountResult.stdout}`),
-					);
-				}
-				throw new Error(
-					`Failed to create token account: ${createAccountResult.stderr}`,
-				);
-			} else {
-				if (debug) {
-					console.log(chalk.gray(`  ✅ Token account created successfully`));
-				}
-				// 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");
-		}
-
-		if (debug) {
-			console.log(chalk.gray(`  📍 Token account: ${tokenAccountAddress}`));
-		}
-
-		// Mint tokens to the specific token account
-		const mintResult = await runCommand(
-			"spl-token",
-			[
-				"mint",
-				token.config.mainnetMint,
-				token.config.mintAmount.toString(),
-				tokenAccountAddress,
-				"--mint-authority",
-				token.mintAuthorityPath,
-				"--fee-payer",
-				token.mintAuthorityPath,
-				"--url",
-				rpcUrl,
-			],
-			{ silent: !debug, debug },
-		);
-
-		if (!mintResult.success) {
-			throw new Error(`Failed to mint tokens: ${mintResult.stderr}`);
-		}
-	}
-
-	/**
-	 * Mint tokens to a specific recipient
-	 */
-	private async mintToRecipient(
-		token: ClonedToken,
-		recipientAddress: string,
-		amount: number,
-		rpcUrl: string,
-	): Promise<void> {
-		console.log(
-			chalk.gray(`  🔄 Minting ${amount} tokens to ${recipientAddress}...`),
-		);
-
-		// Check if associated token account already exists
-		const checkAccountsResult = await runCommand(
-			"spl-token",
-			[
-				"accounts",
-				"--owner",
-				recipientAddress,
-				"--url",
-				rpcUrl,
-				"--output",
-				"json",
-			],
-			{ silent: true },
-		);
-
-		let tokenAccountAddress = "";
-
-		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;
-						break;
-					}
-				}
-			} catch (_error) {
-				// No existing accounts found or parsing error, will create new account
-			}
-		}
-
-		if (!tokenAccountAddress) {
-			// Account doesn't exist, create it
-			const createAccountResult = await runCommand(
-				"spl-token",
-				[
-					"create-account",
-					token.config.mainnetMint,
-					"--owner",
-					recipientAddress,
-					"--fee-payer",
-					token.mintAuthorityPath,
-					"--url",
-					rpcUrl,
-				],
-				{ silent: true },
-			);
-
-			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] || "";
-		}
-
-		if (!tokenAccountAddress) {
-			throw new Error("Failed to determine token account address");
-		}
-
-		// Mint tokens to the specific token account
-		const mintResult = await runCommand(
-			"spl-token",
-			[
-				"mint",
-				token.config.mainnetMint,
-				amount.toString(),
-				tokenAccountAddress,
-				"--mint-authority",
-				token.mintAuthorityPath,
-				"--fee-payer",
-				token.mintAuthorityPath,
-				"--url",
-				rpcUrl,
-			],
-			{ silent: true },
-		);
-
-		if (!mintResult.success) {
-			throw new Error(`Failed to mint tokens: ${mintResult.stderr}`);
-		}
-	}
-}