solforge 0.1.6 → 0.2.0

package/sf.config.json

@@ -0,0 +1,38 @@
+{
+  "server": {
+    "rpcPort": 8899,
+    "wsPort": 8900,
+    "db": {
+      "mode": "ephemeral",
+      "path": ".solforge/db.db"
+    }
+  },
+  "svm": {
+    "initialLamports": "1000000000000000",
+    "faucetSOL": 1000
+  },
+  "clone": {
+    "endpoint": "https://api.mainnet-beta.solana.com",
+    "programs": [
+      "JARSq9S9RgyynuAwcdWh2yEG6MbhfntWq7zjXjAo87uQ"
+    ],
+    "tokens": [
+      "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      "XsDoVfqeBukxuZHWhdvWHBhgEHjGNst4MLodqsJHzoB",
+      "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"
+    ],
+    "programAccounts": []
+  },
+  "gui": {
+    "enabled": true,
+    "port": 42069
+  },
+  "bootstrap": {
+    "airdrops": [
+      {
+        "address": "JARSnsWXAxUAp6Ny3Td9H1i4wNpesqkcfL1wf82t5tKi",
+        "amountSol": 100
+      }
+    ]
+  }
+}

package/src/cli/bootstrap.ts

@@ -0,0 +1,67 @@
+import * as p from "@clack/prompts";
+import { defaultConfig, type SolforgeConfig } from "../config";
+
+export async function bootstrapEnvironment(
+	config: SolforgeConfig,
+	host: string,
+	rpcPort: number,
+) {
+	const url = `http://${host}:${rpcPort}`;
+	const endpoint = config.clone.endpoint || defaultConfig.clone.endpoint;
+
+	for (const mint of config.clone.tokens || []) {
+		await withSpinner(`Cloning token ${mint}`, async () => {
+			await callRpc(url, "solforgeAdminCloneTokenMint", [mint, { endpoint }]);
+			await callRpc(url, "solforgeAdoptMintAuthority", [mint]);
+		});
+	}
+
+	for (const programId of config.clone.programs || []) {
+		await withSpinner(`Cloning program ${programId}`, async () => {
+			await callRpc(url, "solforgeAdminCloneProgram", [
+				programId,
+				{ endpoint },
+			]);
+		});
+	}
+
+	for (const { address, amountSol } of config.bootstrap?.airdrops || []) {
+		await withSpinner(
+			`Airdropping ${amountSol} SOL to ${address}`,
+			async () => {
+				const lamports = Math.round(amountSol * 1_000_000_000);
+				await callRpc(url, "requestAirdrop", [address, lamports]);
+			},
+		);
+	}
+}
+
+async function withSpinner(task: string, action: () => Promise<void>) {
+	const spin = p.spinner();
+	spin.start(`${task}...`);
+	try {
+		await action();
+		spin.stop(`${task} done`);
+	} catch (error) {
+		spin.stop(`${task} failed`);
+		p.log.error(String(error));
+	}
+}
+
+async function callRpc(url: string, method: string, params: unknown[]) {
+	const res = await fetch(url, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({ jsonrpc: "2.0", id: Date.now(), method, params }),
+	});
+	if (!res.ok) throw new Error(`${method} HTTP ${res.status}`);
+	const json = await res.json();
+	if (json?.error) {
+		const message = json.error?.message || `${method} failed`;
+		const detail = json.error?.data
+			? `: ${JSON.stringify(json.error.data)}`
+			: "";
+		throw new Error(message + detail);
+	}
+	return json.result;
+}

package/src/cli/commands/airdrop.ts

@@ -0,0 +1,37 @@
+import * as p from "@clack/prompts";
+import { readConfig } from "../../config";
+import { parseFlags } from "../utils/args";
+
+export async function airdropCommand(args: string[]) {
+	const { flags } = parseFlags(args);
+	const to = String(flags["to"] || "");
+	const sol = Number(flags["sol"] || 0);
+	const cfg = await readConfig();
+	const url = `http://localhost:${cfg.server.rpcPort}`;
+	if (!to || !sol) {
+		p.log.error("Usage: solforge airdrop --to <pubkey> --sol <amount>");
+		return;
+	}
+	const lamports = BigInt(Math.floor(sol * 1_000_000_000));
+	const body = {
+		jsonrpc: "2.0",
+		id: 1,
+		method: "requestAirdrop",
+		params: [to, Number(lamports)],
+	};
+	const s = p.spinner();
+	s.start("Requesting airdrop...");
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body),
+		});
+		const json = await res.json();
+		s.stop("Airdrop requested");
+		console.log(JSON.stringify(json, null, 2));
+	} catch (e) {
+		s.stop("Airdrop failed");
+		p.log.error(String(e));
+	}
+}

package/src/cli/commands/config.ts

@@ -0,0 +1,39 @@
+import * as p from "@clack/prompts";
+import {
+	getConfigValue,
+	readConfig,
+	setConfigValue,
+	writeDefaultConfig,
+} from "../../config";
+import { parseFlags } from "../utils/args";
+
+export async function configCommand(sub: string | undefined, args: string[]) {
+	switch (sub) {
+		case "init": {
+			const { flags } = parseFlags(args);
+			const force = !!flags["force"];
+			await writeDefaultConfig({ force });
+			p.log.success("Wrote sf.config.json");
+			return;
+		}
+		case "get": {
+			const key = args[0];
+			const cfg = await readConfig();
+			console.log(getConfigValue(cfg, key));
+			return;
+		}
+		case "set": {
+			const [key, value] = args;
+			const cfg = await readConfig();
+			const updated = setConfigValue(cfg, key, value);
+			await Bun.write(
+				"sf.config.json",
+				JSON.stringify(updated, null, 2) + "\n",
+			);
+			p.log.success(`Updated ${key}`);
+			return;
+		}
+		default:
+			p.log.error("Usage: solforge config <init|get|set>");
+	}
+}

package/src/cli/commands/mint.ts

@@ -0,0 +1,187 @@
+import * as p from "@clack/prompts";
+import { readConfig } from "../../config";
+import { parseFlags } from "../utils/args";
+// No network fetch; decimals are read from LiteSVM via RPC getTokenSupply
+
+// Create/overwrite a token account (ATA) with a specified amount (base units)
+// Usage: solforge mint --mint <mint> --to <owner> --amount <amount>
+export async function mintCommand(args: string[]) {
+	const { flags } = parseFlags(args);
+	let mint = flags["mint"] as string | undefined;
+	let receiver = flags["to"] as string | undefined; // required: receiver address (ATA owner)
+	let amountBase = flags["amount"] as string | undefined; // optional direct base-units
+	let uiAmount = flags["ui-amount"] as string | undefined; // preferred UI units
+
+	const cfg = await readConfig();
+	const url = `http://localhost:${cfg.server.rpcPort}`;
+
+	// Get known mints from server for selection
+	let knownMints: string[] = [];
+	try {
+		const resList = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "solforgeListMints",
+				params: [],
+			}),
+		});
+		const j = await resList.json();
+		if (!j.error && Array.isArray(j.result)) knownMints = j.result;
+	} catch {}
+
+	if (!mint) {
+		if (knownMints.length > 0) {
+			const choice = (await p.select({
+				message: "Select mint",
+				options: knownMints.map((m) => ({ value: m, label: m })),
+			})) as string | symbol | null;
+			if (!choice || typeof choice !== "string") return;
+			mint = choice;
+		} else {
+			p.log.error("No known mints. Clone or create a token first.");
+			return;
+		}
+	}
+
+	// Receiver (ATA owner) is required
+	if (!receiver) {
+		receiver = (await p.text({
+			message: "Receiver public key (ATA owner)",
+			placeholder: "<receiver public key>",
+			validate: (v) =>
+				v && v.length >= 32 ? undefined : "Enter a valid public key",
+		})) as string;
+		if (!receiver) return;
+	}
+
+	// Amount selection (prefer UI units)
+	if (!amountBase && !uiAmount) {
+		uiAmount = (await p.text({
+			message: "Amount (UI units)",
+			placeholder: "1000",
+			validate: (v) =>
+				v && !Number.isNaN(Number(v)) ? undefined : "Enter a number",
+		})) as string;
+		if (!uiAmount) return;
+	}
+
+	// If UI amount provided, get decimals from LiteSVM via getTokenSupply
+	if (!amountBase && uiAmount) {
+		let decimals = 0;
+		try {
+			const res = await fetch(url, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					jsonrpc: "2.0",
+					id: 2,
+					method: "getTokenSupply",
+					params: [mint],
+				}),
+			});
+			const j = await res.json();
+			const d = j?.result?.value?.decimals ?? j?.result?.decimals;
+			if (typeof d === "number") decimals = d;
+		} catch {}
+		amountBase = toBaseUnits(uiAmount, decimals);
+	}
+
+	const s = p.spinner();
+	s.start("Minting via real transaction...");
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "solforgeMintTo",
+				params: [mint, receiver, amountBase],
+			}),
+		});
+		const json = await res.json();
+		if (json.error) {
+			const msg = String(json.error.message || "mint failed");
+			// Offer admin fallback when faucet is not mint authority
+			if (/no faucet authority|authority/i.test(msg)) {
+				const choice = (await p.select({
+					message: "Mint authority is not faucet. Choose action:",
+					options: [
+						{
+							value: "adopt",
+							label: "Adopt faucet as authority (local) and mint (real tx)",
+						},
+						{ value: "admin", label: "Admin set-balance (no real tx)" },
+						{ value: "cancel", label: "Cancel" },
+					],
+				})) as "adopt" | "admin" | "cancel" | symbol | null;
+				if (!choice || choice === "cancel") throw new Error(msg);
+				if (choice === "adopt") {
+					s.message("Adopting faucet as authority...");
+					const resAdopt = await fetch(url, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							jsonrpc: "2.0",
+							id: 2,
+							method: "solforgeAdoptMintAuthority",
+							params: [mint],
+						}),
+					});
+					const jA = await resAdopt.json();
+					if (jA.error)
+						throw new Error(jA.error.message || "adopt authority failed");
+					s.message("Minting via real transaction...");
+					const resRetry = await fetch(url, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							jsonrpc: "2.0",
+							id: 3,
+							method: "solforgeMintTo",
+							params: [mint, receiver, amountBase],
+						}),
+					});
+					const jR = await resRetry.json();
+					if (jR.error) throw new Error(jR.error.message || "mint failed");
+					s.stop("Minted");
+					console.log(JSON.stringify(jR.result, null, 2));
+					return;
+				}
+				if (choice === "admin") {
+					const res2 = await fetch(url, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							jsonrpc: "2.0",
+							id: 4,
+							method: "solforgeCreateTokenAccount",
+							params: [mint, receiver, amountBase],
+						}),
+					});
+					const json2 = await res2.json();
+					if (json2.error)
+						throw new Error(json2.error.message || "admin mint failed");
+					s.stop("Minted (admin)");
+					console.log(JSON.stringify(json2.result, null, 2));
+					return;
+				}
+			}
+			throw new Error(msg);
+		}
+		s.stop("Minted");
+		console.log(JSON.stringify(json.result, null, 2));
+	} catch (e) {
+		s.stop("Mint failed");
+		p.log.error(String(e));
+	}
+}
+
+function toBaseUnits(ui: string, decimals: number): string {
+	const [i, f = ""] = String(ui).split(".");
+	const frac = (f + "0".repeat(decimals)).slice(0, decimals);
+	return BigInt(i + (decimals ? frac : "")).toString();
+}

package/src/cli/commands/program-clone.ts

@@ -0,0 +1,124 @@
+import * as p from "@clack/prompts";
+import { readConfig, writeConfig } from "../../config";
+import { parseFlags } from "../utils/args";
+
+export async function programCloneCommand(args: string[]) {
+	const { flags, rest } = parseFlags(args);
+	const programId = (
+		(rest[0] as string) ||
+		(flags["program"] as string) ||
+		""
+	).trim();
+	const configPath = flags["config"] as string | undefined;
+	const cfg = await readConfig(configPath);
+	const endpoint = (flags["endpoint"] as string) || cfg.clone.endpoint;
+	const withAccounts = !!flags["with-accounts"];
+	const accountsLimit = flags["accounts-limit"]
+		? Number(flags["accounts-limit"])
+		: undefined;
+	if (!programId) {
+		p.log.error(
+			"Usage: solforge program clone <programId> [--endpoint URL] [--with-accounts] [--accounts-limit N]",
+		);
+		return;
+	}
+	const url = `http://localhost:${cfg.server.rpcPort}`;
+	const s = p.spinner();
+	s.start("Cloning program...");
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "solforgeAdminCloneProgram",
+				params: [programId, { endpoint, withAccounts, accountsLimit }],
+			}),
+		});
+		const json = await res.json();
+		if (json.error) {
+			const details = json.error.data
+				? `\nDetails: ${JSON.stringify(json.error.data)}`
+				: "";
+			throw new Error((json.error.message || "program clone failed") + details);
+		}
+		s.stop("Program cloned");
+		console.log(JSON.stringify(json.result, null, 2));
+		await recordProgramClone(configPath, programId);
+	} catch (e) {
+		s.stop("Clone failed");
+		p.log.error(String(e));
+	}
+}
+
+export async function programAccountsCloneCommand(args: string[]) {
+	const { flags, rest } = parseFlags(args);
+	const programId = (
+		(rest[0] as string) ||
+		(flags["program"] as string) ||
+		""
+	).trim();
+	const configPath = flags["config"] as string | undefined;
+	const cfg = await readConfig(configPath);
+	const endpoint = (flags["endpoint"] as string) || cfg.clone.endpoint;
+	const limit = flags["limit"] ? Number(flags["limit"]) : undefined;
+	const filters = flags["filters"]
+		? safeJson(flags["filters"] as string)
+		: undefined;
+	if (!programId) {
+		p.log.error(
+			"Usage: solforge program accounts clone <programId> [--endpoint URL] [--limit N] [--filters JSON]",
+		);
+		return;
+	}
+	const url = `http://localhost:${cfg.server.rpcPort}`;
+	const s = p.spinner();
+	s.start("Cloning program accounts...");
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "solforgeAdminCloneProgramAccounts",
+				params: [programId, { endpoint, limit, filters }],
+			}),
+		});
+		const json = await res.json();
+		if (json.error)
+			throw new Error(json.error.message || "program accounts clone failed");
+		s.stop("Program accounts cloned");
+		console.log(JSON.stringify(json.result, null, 2));
+	} catch (e) {
+		s.stop("Clone failed");
+		p.log.error(String(e));
+	}
+}
+
+function safeJson(s: string): any {
+	try {
+		return JSON.parse(s);
+	} catch {
+		return undefined;
+	}
+}
+
+async function recordProgramClone(
+	configPath: string | undefined,
+	programId: string,
+) {
+	try {
+		const cfg = await readConfig(configPath);
+		const next = new Set(cfg.clone.programs ?? []);
+		if (!next.has(programId)) {
+			next.add(programId);
+			cfg.clone.programs = Array.from(next);
+			await writeConfig(cfg, configPath ?? "sf.config.json");
+			p.log.info(`Added ${programId} to clone programs in config`);
+		}
+	} catch (error) {
+		console.warn(`[config] Failed to update clone programs: ${String(error)}`);
+	}
+}

package/src/cli/commands/program-load.ts

@@ -0,0 +1,64 @@
+import * as p from "@clack/prompts";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { readConfig } from "../../config";
+import { parseFlags } from "../utils/args";
+
+export async function programLoadCommand(args: string[]) {
+	const { flags, rest } = parseFlags(args);
+	const programId = (rest[0] as string) || (flags["program"] as string);
+	const fromFile = flags["file"] as string | undefined;
+	const endpoint = flags["endpoint"] as string | undefined;
+	if (!programId) {
+		p.log.error(
+			"Usage: solforge program load <programId> [--file PATH | --endpoint URL]",
+		);
+		return;
+	}
+	let base64: string | undefined;
+	try {
+		if (fromFile) {
+			const bytes = await Bun.file(fromFile).arrayBuffer();
+			base64 = Buffer.from(bytes).toString("base64");
+		} else if (endpoint) {
+			// Fetch ProgramData from endpoint
+			const conn = new Connection(endpoint, "confirmed");
+			const pid = new PublicKey(programId);
+			const info = await conn.getAccountInfo(pid, "confirmed");
+			if (!info) throw new Error("Program account not found on endpoint");
+			// Program account should be upgradeable; fetch ProgramData and extract bytes after header
+			// Heuristic: delegate parsing to server if unsure. Here, try raw first.
+			base64 = Buffer.from(info.data as Buffer).toString("base64");
+		} else {
+			p.log.error("Either --file or --endpoint must be provided");
+			return;
+		}
+	} catch (e) {
+		p.log.error(`Failed to read ELF: ${String(e)}`);
+		return;
+	}
+
+	const cfg = await readConfig();
+	const url = `http://localhost:${cfg.server.rpcPort}`;
+	const s = p.spinner();
+	s.start("Loading program into LiteSVM...");
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "solforgeLoadProgram",
+				params: [programId, base64],
+			}),
+		});
+		const json = await res.json();
+		if (json.error)
+			throw new Error(json.error.message || "program load failed");
+		s.stop("Program loaded");
+		console.log(JSON.stringify(json.result, null, 2));
+	} catch (e) {
+		s.stop("Load failed");
+		p.log.error(String(e));
+	}
+}

package/src/cli/commands/rpc-start.ts

@@ -0,0 +1,46 @@
+import * as p from "@clack/prompts";
+import { readConfig } from "../../config";
+import { startRpcServers } from "../../rpc/start";
+import { parseFlags } from "../utils/args";
+
+export async function rpcStartCommand(args: string[]) {
+	const { flags } = parseFlags(args);
+	const cfg = await readConfig(flags["config"] as string | undefined);
+	const rpcPort = Number(flags["port"] ?? cfg.server.rpcPort ?? 8899);
+	const wsPort = Number(flags["ws-port"] ?? cfg.server.wsPort ?? rpcPort + 1);
+	const host = (flags["host"] as string) || "127.0.0.1";
+	const dbMode =
+		(flags["db-mode"] as string) || cfg.server.db.mode || "ephemeral";
+	const dbPath =
+		(flags["db-path"] as string) || cfg.server.db.path || ".solforge/db.db";
+	const guiPort = Number(flags["gui-port"] ?? cfg.gui.port ?? 42069);
+	const guiEnabled =
+		flags["no-gui"] === true
+			? false
+			: flags["gui"] === true
+				? true
+				: cfg.gui.enabled !== false;
+
+	const s = p.spinner();
+	const guiMsg = guiEnabled ? `, GUI on ${guiPort}` : "";
+	s.start(`Starting RPC on ${host}:${rpcPort}, WS on ${wsPort}${guiMsg}...`);
+	try {
+		const started = startRpcServers({
+			rpcPort,
+			wsPort,
+			dbMode: dbMode as any,
+			dbPath,
+			host,
+			guiEnabled,
+			guiPort,
+		});
+		s.stop("RPC started");
+		console.log(`HTTP: http://${host}:${started.rpcPort}`);
+		console.log(`WS:   ws://${host}:${started.wsPort}`);
+		if (started.guiPort) console.log(`GUI:  http://${host}:${started.guiPort}`);
+	} catch (e) {
+		s.stop("Failed to start RPC");
+		p.log.error(String(e));
+		process.exitCode = 1;
+	}
+}

package/src/cli/commands/token-adopt-authority.ts

@@ -0,0 +1,37 @@
+import * as p from "@clack/prompts";
+import { readConfig } from "../../config";
+import { parseFlags } from "../utils/args";
+
+// Set the faucet as mint authority for an existing mint in LiteSVM (local-only)
+export async function tokenAdoptAuthorityCommand(args: string[]) {
+	const { flags, rest } = parseFlags(args);
+	const mint = (rest[0] as string) || (flags["mint"] as string);
+	if (!mint) {
+		p.log.error("Usage: solforge token adopt-authority <mint>");
+		return;
+	}
+	const cfg = await readConfig();
+	const url = `http://localhost:${cfg.server.rpcPort}`;
+	const s = p.spinner();
+	s.start("Adopting faucet as mint authority...");
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "solforgeAdoptMintAuthority",
+				params: [mint],
+			}),
+		});
+		const json = await res.json();
+		if (json.error)
+			throw new Error(json.error.message || "adopt authority failed");
+		s.stop("Authority updated");
+		console.log(JSON.stringify(json.result, null, 2));
+	} catch (e) {
+		s.stop("Failed");
+		p.log.error(String(e));
+	}
+}