solforge 0.2.4 → 0.2.5

package/src/services/token-cloner.ts

@@ -1,809 +1,811 @@
-import { writeFileSync, readFileSync, existsSync, mkdirSync } from "fs";
-import { resolve, join } from "path";
 import { Keypair, PublicKey } from "@solana/web3.js";
 import chalk from "chalk";
-import { runCommand } from "../utils/shell.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, resolve } from "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[];
-  };
+	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}`);
-    }
-  }
+	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}`);
+		}
+	}
 }