solforge 0.1.6 → 0.1.7

package/README.md

@@ -318,7 +318,7 @@ Here's the complete schema:
     "faucetAccounts": ["YourWalletPublicKeyHere"],
     "port": 8899,
     "faucetPort": 9900,
-    "reset": true,
+    "reset": false,
     "logLevel": "info",
     "bindAddress": "127.0.0.1",
     "limitLedgerSize": 100000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solforge",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Solana localnet orchestration tool for cloning mainnet programs and tokens",
   "module": "index.ts",
   "type": "module",

package/src/commands/init.ts

@@ -22,11 +22,11 @@ const defaultConfig: Config = {
     faucetAccounts: [],
     port: 8899,
     faucetPort: 9900,
-    reset: true,
+    reset: false,
     logLevel: "info",
     bindAddress: "127.0.0.1",
     quiet: false,
-    rpc: "https://mainnet.helius-rpc.com/?api-key=3a3b84ef-2985-4543-9d67-535eb707b6ec",
+    rpc: "https://api.mainnet-beta.solana.com",
     limitLedgerSize: 100000,
   },
 };

package/src/commands/mint.ts

@@ -5,22 +5,12 @@ import { join } from "path";
 import { input, select } from "@inquirer/prompts";
 import { runCommand } from "../utils/shell";
 import { Keypair, PublicKey } from "@solana/web3.js";
-
-interface TokenConfig {
-  symbol: string;
-  mainnetMint: string;
-  mintAmount: number;
-}
-
-interface ClonedToken {
-  config: TokenConfig;
-  mintAuthorityPath: string;
-  modifiedAccountPath: string;
-  mintAuthority: {
-    publicKey: string;
-    secretKey: number[];
-  };
-}
+import {
+  loadClonedTokens,
+  findTokenBySymbol,
+  type ClonedToken,
+} from "../utils/token-loader.js";
+import type { TokenConfig } from "../types/config.js";
 
 export const mintCommand = new Command()
   .name("mint")
@@ -71,9 +61,7 @@ export const mintCommand = new Command()
       // Select token (or use provided symbol)
       let selectedToken: ClonedToken;
       if (options.symbol) {
-        const token = tokens.find(
-          (t) => t.config.symbol.toLowerCase() === options.symbol.toLowerCase()
-        );
+        const token = findTokenBySymbol(tokens, options.symbol);
         if (!token) {
           console.error(
             chalk.red(`❌ Token ${options.symbol} not found in cloned tokens`)
@@ -181,8 +169,6 @@ export const mintCommand = new Command()
   });
 
 async function loadAvailableTokens(workDir: string): Promise<ClonedToken[]> {
-  const tokens: ClonedToken[] = [];
-
   try {
     // Load token config from sf.config.json
     const configPath = "sf.config.json";
@@ -193,42 +179,8 @@ async function loadAvailableTokens(workDir: string): Promise<ClonedToken[]> {
     const config = JSON.parse(readFileSync(configPath, "utf8"));
     const tokenConfigs: TokenConfig[] = config.tokens || [];
 
-    // Load shared mint authority
-    const sharedMintAuthorityPath = join(workDir, "shared-mint-authority.json");
-    if (!existsSync(sharedMintAuthorityPath)) {
-      throw new Error("Shared mint authority not found");
-    }
-
-    const secretKeyArray = JSON.parse(
-      readFileSync(sharedMintAuthorityPath, "utf8")
-    );
-    const mintAuthorityKeypair = Keypair.fromSecretKey(
-      new Uint8Array(secretKeyArray)
-    );
-    const mintAuthority = {
-      publicKey: mintAuthorityKeypair.publicKey.toBase58(),
-      secretKey: Array.from(mintAuthorityKeypair.secretKey),
-    };
-
-    // Build cloned tokens list
-    for (const tokenConfig of tokenConfigs) {
-      const tokenDir = join(
-        workDir,
-        `token-${tokenConfig.symbol.toLowerCase()}`
-      );
-      const modifiedAccountPath = join(tokenDir, "modified.json");
-
-      if (existsSync(modifiedAccountPath)) {
-        tokens.push({
-          config: tokenConfig,
-          mintAuthorityPath: sharedMintAuthorityPath,
-          modifiedAccountPath,
-          mintAuthority,
-        });
-      }
-    }
-
-    return tokens;
+    // Use the shared token loader
+    return await loadClonedTokens(tokenConfigs, workDir);
   } catch (error) {
     throw new Error(`Failed to load tokens: ${error}`);
   }

package/src/commands/start.ts

@@ -6,11 +6,10 @@ import { join } from "path";
 import { runCommand, checkSolanaTools } from "../utils/shell.js";
 import { configManager } from "../config/manager.js";
 import { TokenCloner } from "../services/token-cloner.js";
-import { ProgramCloner } from "../services/program-cloner.js";
 import { processRegistry } from "../services/process-registry.js";
 import { portManager } from "../services/port-manager.js";
 
-import type { Config, TokenConfig, ProgramConfig } from "../types/config.js";
+import type { Config, TokenConfig } from "../types/config.js";
 import type { ClonedToken } from "../services/token-cloner.js";
 import type { RunningValidator } from "../services/process-registry.js";
 

package/src/services/api-server.ts

@@ -11,8 +11,12 @@ import { runCommand } from "../utils/shell.js";
 import { TokenCloner } from "./token-cloner.js";
 import { ProgramCloner } from "./program-cloner.js";
 import { mintTokenToWallet as mintTokenToWalletShared } from "../commands/mint.js";
+import {
+  loadClonedTokens,
+  findTokenByMint,
+  type ClonedToken,
+} from "../utils/token-loader.js";
 import type { Config } from "../types/config.js";
-import type { ClonedToken } from "./token-cloner.js";
 
 export interface APIServerConfig {
   port: number;
@@ -256,57 +260,10 @@ export class APIServer {
   }
 
   private async getClonedTokens(): Promise<ClonedToken[]> {
-    const clonedTokens: ClonedToken[] = [];
-
-    for (const tokenConfig of this.config.config.tokens) {
-      const tokenDir = join(
-        this.config.workDir,
-        `token-${tokenConfig.symbol.toLowerCase()}`
-      );
-      const modifiedAccountPath = join(tokenDir, "modified.json");
-      const sharedMintAuthorityPath = join(
-        this.config.workDir,
-        "shared-mint-authority.json"
-      );
-
-      if (
-        existsSync(modifiedAccountPath) &&
-        existsSync(sharedMintAuthorityPath)
-      ) {
-        try {
-          const mintAuthorityData = JSON.parse(
-            readFileSync(sharedMintAuthorityPath, "utf8")
-          );
-          let mintAuthority;
-
-          if (Array.isArray(mintAuthorityData)) {
-            const keypair = Keypair.fromSecretKey(
-              new Uint8Array(mintAuthorityData)
-            );
-            mintAuthority = {
-              publicKey: keypair.publicKey.toBase58(),
-              secretKey: Array.from(keypair.secretKey),
-            };
-          } else {
-            mintAuthority = mintAuthorityData;
-          }
-
-          clonedTokens.push({
-            config: tokenConfig,
-            mintAuthorityPath: sharedMintAuthorityPath,
-            modifiedAccountPath,
-            mintAuthority,
-          });
-        } catch (error) {
-          console.error(
-            `Failed to load cloned token ${tokenConfig.symbol}:`,
-            error
-          );
-        }
-      }
-    }
-
-    return clonedTokens;
+    return await loadClonedTokens(
+      this.config.config.tokens,
+      this.config.workDir
+    );
   }
 
   private async getClonedPrograms(): Promise<
@@ -341,14 +298,10 @@ export class APIServer {
     amount: number
   ): Promise<any> {
     const clonedTokens = await this.getClonedTokens();
-    const token = clonedTokens.find(
-      (t) => t.config.mainnetMint === mintAddress
-    );
+    const token = findTokenByMint(clonedTokens, mintAddress);
 
     if (!token) {
-      throw new Error(
-        `Token with mint address ${mintAddress} not found in cloned tokens`
-      );
+      throw new Error(`Token ${mintAddress} not found in cloned tokens`);
     }
 
     // Use the shared minting function from the mint command

package/src/utils/token-loader.ts

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { Keypair } from "@solana/web3.js";
+import type { TokenConfig } from "../types/config.js";
+
+export interface ClonedToken {
+  config: TokenConfig;
+  mintAuthorityPath: string;
+  modifiedAccountPath: string;
+  metadataAccountPath?: string;
+  mintAuthority: {
+    publicKey: string;
+    secretKey: number[];
+  };
+}
+
+/**
+ * Shared utility to load cloned tokens from the work directory.
+ * This ensures consistent token loading across CLI and API server.
+ */
+export async function loadClonedTokens(
+  tokenConfigs: TokenConfig[],
+  workDir: string = ".solforge"
+): Promise<ClonedToken[]> {
+  const clonedTokens: ClonedToken[] = [];
+
+  // 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 (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 [];
+    }
+  }
+
+  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");
+
+    // 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;
+      }
+
+      clonedTokens.push(clonedToken);
+    }
+  }
+
+  return clonedTokens;
+}
+
+/**
+ * Find a cloned token by its mint address
+ */
+export function findTokenByMint(
+  clonedTokens: ClonedToken[],
+  mintAddress: string
+): ClonedToken | undefined {
+  return clonedTokens.find((token) => token.config.mainnetMint === mintAddress);
+}
+
+/**
+ * Find a cloned token by its symbol
+ */
+export function findTokenBySymbol(
+  clonedTokens: ClonedToken[],
+  symbol: string
+): ClonedToken | undefined {
+  return clonedTokens.find(
+    (token) => token.config.symbol.toLowerCase() === symbol.toLowerCase()
+  );
+}