solforge 0.2.12 → 0.2.14

package/server/ws-server.ts

@@ -1,178 +0,0 @@
-import type { Server } from "bun";
-import type { LiteSVMRpcServer } from "./rpc-server";
-
-type Sub = { id: number; type: "signature"; signature: string };
-
-export function createLiteSVMWebSocketServer(
-	rpcServer: LiteSVMRpcServer,
-	port: number = 8900,
-	host?: string,
-) {
-	let nextSubId = 1;
-	const subs = new Map<number, Sub>();
-
-	const sockets = new Set<WebSocket>();
-	const pendingChecks = new Map<string, number>();
-
-	const sendSignatureNotification = (
-		sig: string,
-		slot: number,
-		err: unknown,
-	) => {
-		const payload = {
-			jsonrpc: "2.0",
-			method: "signatureNotification",
-			params: {
-				result: { context: { slot }, value: { err } },
-			},
-		} as const;
-		for (const [id, sub] of subs.entries()) {
-			if (sub.type === "signature" && sub.signature === sig) {
-				try {
-					for (const s of sockets) {
-						s.send(
-							JSON.stringify({
-								...payload,
-								params: { ...payload.params, subscription: id },
-							}),
-						);
-					}
-				} catch {}
-				subs.delete(id);
-			}
-		}
-	};
-
-	const scheduleSignatureCheck = (sig: string) => {
-		if (pendingChecks.has(sig)) return;
-		pendingChecks.set(sig, 0);
-		const tick = () => {
-			const tries = (pendingChecks.get(sig) ?? 0) + 1;
-			pendingChecks.set(sig, tries);
-			const status = rpcServer.getSignatureStatus(sig);
-			if (status) {
-				pendingChecks.delete(sig);
-				sendSignatureNotification(sig, status.slot, status.err);
-				return;
-			}
-			if (tries < 60) {
-				setTimeout(tick, 25);
-			} else {
-				pendingChecks.delete(sig);
-			}
-		};
-		setTimeout(tick, 10);
-	};
-
-	const notifySignature = (sig: string) => {
-		scheduleSignatureCheck(sig);
-	};
-
-	const unsubscribe = rpcServer.onSignatureRecorded(notifySignature);
-
-	const server: Server = Bun.serve({
-		port,
-		hostname: host || process.env.RPC_HOST || "127.0.0.1",
-		fetch(req, srv) {
-			if (srv.upgrade(req)) return undefined as unknown as Response;
-			return new Response("Not a websocket", { status: 400 });
-		},
-		websocket: {
-			open(ws) {
-				sockets.add(ws);
-			},
-			close(ws) {
-				sockets.delete(ws);
-			},
-			message(ws, data) {
-				try {
-					const msg = JSON.parse(
-						typeof data === "string"
-							? data
-							: Buffer.from(data as ArrayBuffer).toString("utf8"),
-					);
-					const {
-						id,
-						method,
-						params = [],
-					} = msg as { id: number; method: string; params?: unknown[] };
-					if (method === "signatureSubscribe") {
-						const [signature] = params;
-						const subId = nextSubId++;
-						subs.set(subId, { id: subId, type: "signature", signature });
-						// Respond with subscription id
-						ws.send(JSON.stringify({ jsonrpc: "2.0", id, result: subId }));
-						// If already have a status, notify immediately
-						const status = rpcServer.getSignatureStatus(signature);
-						if (status) {
-							ws.send(
-								JSON.stringify({
-									jsonrpc: "2.0",
-									method: "signatureNotification",
-									params: {
-										result: {
-											context: { slot: status.slot },
-											value: { err: status.err },
-										},
-										subscription: subId,
-									},
-								}),
-							);
-							subs.delete(subId);
-						}
-						return;
-					}
-					if (method === "signatureUnsubscribe") {
-						const [subId] = params;
-						subs.delete(subId);
-						ws.send(JSON.stringify({ jsonrpc: "2.0", id, result: true }));
-						return;
-					}
-					// Stub other subs to succeed without notifications
-					if (
-						method === "logsSubscribe" ||
-						method === "slotSubscribe" ||
-						method === "programSubscribe" ||
-						method === "blockSubscribe"
-					) {
-						const subId = nextSubId++;
-						ws.send(JSON.stringify({ jsonrpc: "2.0", id, result: subId }));
-						return;
-					}
-					if (method === "ping") {
-						ws.send(JSON.stringify({ jsonrpc: "2.0", id, result: null }));
-						return;
-					}
-					// Method not found (ws)
-					ws.send(
-						JSON.stringify({
-							jsonrpc: "2.0",
-							id,
-							error: { code: -32601, message: `Method not found: ${method}` },
-						}),
-					);
-				} catch (_e) {
-					try {
-						ws.send(
-							JSON.stringify({
-								jsonrpc: "2.0",
-								id: null,
-								error: { code: -32700, message: "Parse error" },
-							}),
-						);
-					} catch {}
-				}
-			},
-		},
-	});
-
-	const hostname = (host || process.env.RPC_HOST || "127.0.0.1").toString();
-	console.log(`📣 LiteSVM RPC PubSub running on ws://${hostname}:${port}`);
-	return {
-		wsServer: server,
-		stop: () => {
-			unsubscribe();
-			server.stop(true);
-		},
-	};
-}

package/src/api-server-entry.ts

@@ -1,109 +0,0 @@
-#!/usr/bin/env node
-
-import chalk from "chalk";
-import { configManager } from "./config/manager.js";
-import { APIServer } from "./services/api-server.js";
-
-async function main() {
-	try {
-		// Parse command line arguments
-		const args = process.argv.slice(2);
-		const portIndex = args.indexOf("--port");
-		const hostIndex = args.indexOf("--host");
-		const configIndex = args.indexOf("--config");
-		const rpcIndex = args.indexOf("--rpc-url");
-		const faucetIndex = args.indexOf("--faucet-url");
-		const workDirIndex = args.indexOf("--work-dir");
-
-		if (
-			portIndex === -1 ||
-			configIndex === -1 ||
-			rpcIndex === -1 ||
-			faucetIndex === -1 ||
-			workDirIndex === -1 ||
-			!args[portIndex + 1] ||
-			!args[configIndex + 1] ||
-			!args[rpcIndex + 1] ||
-			!args[faucetIndex + 1] ||
-			!args[workDirIndex + 1]
-		) {
-			console.error(
-				"Usage: api-server-entry --port <port> --config <config-path> --rpc-url <url> --faucet-url <url> --work-dir <dir> [--host <host>]",
-			);
-			process.exit(1);
-		}
-
-		const port = parseInt(String(args[portIndex + 1]), 10);
-		const host =
-			hostIndex !== -1 && args[hostIndex + 1] ? args[hostIndex + 1] : undefined;
-		const configPath = String(args[configIndex + 1]);
-		const rpcUrl = String(args[rpcIndex + 1]);
-		const faucetUrl = String(args[faucetIndex + 1]);
-		const workDir = String(args[workDirIndex + 1]);
-
-		// Load configuration
-		await configManager.load(configPath);
-		const config = configManager.getConfig();
-
-		// Create and start API server
-		const apiServer = new APIServer({
-			port,
-			host,
-			validatorRpcUrl: rpcUrl,
-			validatorFaucetUrl: faucetUrl,
-			config,
-			workDir,
-		});
-
-		const result = await apiServer.start();
-
-		if (result.success) {
-			console.log(chalk.green(`🚀 API Server started on port ${port}`));
-
-			// Keep the process alive
-			process.on("SIGTERM", async () => {
-				console.log(
-					chalk.yellow("📡 API Server received SIGTERM, shutting down..."),
-				);
-				await apiServer.stop();
-				process.exit(0);
-			});
-
-			process.on("SIGINT", async () => {
-				console.log(
-					chalk.yellow("📡 API Server received SIGINT, shutting down..."),
-				);
-				await apiServer.stop();
-				process.exit(0);
-			});
-
-			// Keep process alive
-			setInterval(() => {}, 1000);
-		} else {
-			console.error(
-				chalk.red(`❌ Failed to start API server: ${result.error}`),
-			);
-			process.exit(1);
-		}
-	} catch (error) {
-		console.error(
-			chalk.red(
-				`❌ API Server error: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
-			),
-		);
-		process.exit(1);
-	}
-}
-
-main().catch((error) => {
-	console.error(
-		chalk.red(
-			`❌ Fatal error: ${
-				error instanceof Error ? error.message : String(error)
-			}`,
-		),
-	);
-	process.exit(1);
-});

package/src/cli/bootstrap.ts

@@ -1,67 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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();
-}