solforge 0.1.6 → 0.2.0

package/src/cli/setup-wizard.ts

@@ -0,0 +1,256 @@
+import * as p from "@clack/prompts";
+import { defaultConfig, type SolforgeConfig } from "../config";
+import {
+	cancelSetup,
+	collectCustomEntries,
+	ensure,
+	validatePort,
+	validatePositiveNumber,
+	validatePubkey,
+} from "./setup-utils";
+
+const TOKEN_PRESETS = [
+	{
+		value: "usdc",
+		label: "USDC",
+		mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+	},
+	{
+		value: "usdt",
+		label: "USDT",
+		mint: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+	},
+];
+const PROGRAM_PRESETS = [
+	{
+		value: "jupiter",
+		label: "Jupiter",
+		programId: "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
+	},
+	{
+		value: "pump",
+		label: "Pump core",
+		programId: "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P",
+	},
+	{
+		value: "pump-amm",
+		label: "Pump AMM",
+		programId: "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA",
+	},
+	{
+		value: "pump-fees",
+		label: "Pump fees",
+		programId: "pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ",
+	},
+];
+export async function runSetupWizard(existing: SolforgeConfig = defaultConfig) {
+	const base: SolforgeConfig = JSON.parse(JSON.stringify(existing));
+
+	const rpcPort = Number(
+		ensure(
+			await p.text({
+				message: "RPC port",
+				initialValue: String(
+					base.server.rpcPort ?? defaultConfig.server.rpcPort,
+				),
+				validate: validatePort,
+			}),
+		),
+	);
+
+	const wsPort = Number(
+		ensure(
+			await p.text({
+				message: "WebSocket port",
+				initialValue: String(base.server.wsPort ?? rpcPort + 1),
+				validate: validatePort,
+			}),
+		),
+	);
+
+	const guiEnabledResp = await p.confirm({
+		message: "Enable GUI server?",
+		initialValue: base.gui?.enabled ?? defaultConfig.gui.enabled,
+	});
+	if (p.isCancel(guiEnabledResp)) cancelSetup();
+	const guiEnabled = guiEnabledResp !== false;
+
+	let guiPort = base.gui?.port ?? defaultConfig.gui.port;
+	if (guiEnabled) {
+		guiPort = Number(
+			ensure(
+				await p.text({
+					message: "GUI port",
+					initialValue: String(guiPort ?? defaultConfig.gui.port),
+					validate: validatePort,
+				}),
+			),
+		);
+	}
+
+	const endpoint = ensure(
+		await p.text({
+			message: "Source RPC endpoint for cloning",
+			initialValue: base.clone.endpoint || defaultConfig.clone.endpoint,
+			placeholder: defaultConfig.clone.endpoint,
+			validate: (value) => (value ? undefined : "Endpoint is required"),
+		}),
+	).trim();
+
+	const tokenSelection = ensure(
+		await p.multiselect({
+			message: "Which tokens should be cloned into LiteSVM?",
+			options: [
+				...TOKEN_PRESETS.map((token) => ({
+					value: token.value,
+					label: `${token.label} (${token.mint})`,
+				})),
+				{ value: "__custom__", label: "Add custom token mint" },
+			],
+			initialValues: TOKEN_PRESETS.filter((preset) =>
+				base.clone.tokens?.includes(preset.mint),
+			).map((preset) => preset.value),
+			required: false,
+		}),
+	) as string[];
+	let tokenSeed: string[] = [];
+	if ((base.clone.tokens?.length ?? 0) > 0) {
+		const keep = await p.confirm({
+			message: `Keep existing token list (${base.clone.tokens.length})?`,
+			initialValue: true,
+		});
+		if (p.isCancel(keep)) cancelSetup();
+		if (keep) tokenSeed = [...base.clone.tokens];
+	}
+
+	const tokens = await resolveTokens(tokenSelection, tokenSeed);
+
+	const programSelection = ensure(
+		await p.multiselect({
+			message: "Clone any on-chain programs?",
+			options: [
+				...PROGRAM_PRESETS.map((program) => ({
+					value: program.value,
+					label: `${program.label} (${program.programId})`,
+				})),
+				{ value: "__custom__", label: "Add custom program" },
+			],
+			initialValues: PROGRAM_PRESETS.filter((preset) =>
+				base.clone.programs?.includes(preset.programId),
+			).map((preset) => preset.value),
+			required: false,
+		}),
+	) as string[];
+	let programSeed: string[] = [];
+	if ((base.clone.programs?.length ?? 0) > 0) {
+		const keepPrograms = await p.confirm({
+			message: `Keep existing program list (${base.clone.programs.length})?`,
+			initialValue: true,
+		});
+		if (p.isCancel(keepPrograms)) cancelSetup();
+		if (keepPrograms) programSeed = [...base.clone.programs];
+	}
+
+	const programs = await resolvePrograms(programSelection, programSeed);
+
+	const airdrops = await collectAirdrops(base.bootstrap?.airdrops ?? []);
+
+	base.server.rpcPort = rpcPort;
+	base.server.wsPort = wsPort;
+	base.gui = { enabled: guiEnabled, port: guiPort ?? defaultConfig.gui.port };
+	base.clone.endpoint = endpoint;
+	base.clone.tokens = tokens;
+	base.clone.programs = programs;
+	base.bootstrap = { airdrops };
+
+	return base;
+}
+
+async function resolveTokens(selections: string[], existing: string[] = []) {
+	const set = new Set(existing);
+	for (const selection of selections) {
+		if (selection === "__custom__") {
+			(await collectCustomEntries("token mint address")).forEach((value) =>
+				set.add(value),
+			);
+			continue;
+		}
+		const preset = TOKEN_PRESETS.find((token) => token.value === selection);
+		if (!preset) continue;
+		const mint = ensure(
+			await p.text({
+				message: `Mint address for ${preset.label}`,
+				initialValue: preset.mint,
+				validate: validatePubkey,
+			}),
+		).trim();
+		set.add(mint);
+	}
+	return Array.from(set);
+}
+
+async function resolvePrograms(selections: string[], existing: string[] = []) {
+	const set = new Set(existing);
+	for (const selection of selections) {
+		if (selection === "__custom__") {
+			(await collectCustomEntries("program id")).forEach((value) =>
+				set.add(value),
+			);
+			continue;
+		}
+		const preset = PROGRAM_PRESETS.find(
+			(program) => program.value === selection,
+		);
+		if (!preset) continue;
+		const programId = ensure(
+			await p.text({
+				message: `Program ID for ${preset.label}`,
+				initialValue: preset.programId,
+				validate: validatePubkey,
+			}),
+		).trim();
+		set.add(programId);
+	}
+	return Array.from(set);
+}
+
+async function collectAirdrops(
+	existing: Array<{ address: string; amountSol: number }>,
+) {
+	const entries: Array<{ address: string; amountSol: number }> = [];
+	if (existing.length > 0) {
+		const keep = await p.confirm({
+			message: `Keep existing airdrop recipients (${existing.length})?`,
+			initialValue: true,
+		});
+		if (p.isCancel(keep)) cancelSetup();
+		if (keep) entries.push(...existing);
+	}
+
+	while (true) {
+		const address = await p.text({
+			message:
+				entries.length === 0
+					? "Airdrop recipient address (leave blank to skip)"
+					: "Add another airdrop recipient (leave blank to finish)",
+		});
+		if (p.isCancel(address)) cancelSetup();
+		const trimmed = typeof address === "string" ? address.trim() : "";
+		if (!trimmed) break;
+		const error = validatePubkey(trimmed);
+		if (error) {
+			p.log.error(error);
+			continue;
+		}
+		const amount = ensure(
+			await p.text({
+				message: `Amount of SOL to airdrop to ${trimmed}`,
+				initialValue: "100",
+				validate: validatePositiveNumber,
+			}),
+		);
+		entries.push({ address: trimmed, amountSol: Number(amount) });
+	}
+
+	return entries;
+}

package/src/cli/utils/args.ts

@@ -0,0 +1,15 @@
+export function parseFlags(args: string[]) {
+	const flags: Record<string, string | boolean> = {};
+	const rest: string[] = [];
+	for (let i = 0; i < args.length; i++) {
+		const a = args[i];
+		if (a.startsWith("--")) {
+			const [k, v] = a.slice(2).split("=");
+			if (typeof v === "string" && v.length > 0) flags[k] = v;
+			else if (i + 1 < args.length && !args[i + 1].startsWith("-"))
+				flags[k] = args[++i];
+			else flags[k] = true;
+		} else rest.push(a);
+	}
+	return { flags, rest };
+}

package/src/config/index.ts

@@ -0,0 +1,130 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export interface SolforgeConfig {
+	server: {
+		rpcPort: number;
+		wsPort: number;
+		db: { mode: "ephemeral" | "persistent"; path: string };
+	};
+	svm: { initialLamports: string; faucetSOL: number };
+	clone: {
+		endpoint: string;
+		programs: string[];
+		tokens: string[];
+		programAccounts: Array<{
+			programId: string;
+			limit?: number;
+			filters?: unknown[];
+		}>;
+	};
+	gui: { enabled: boolean; port: number };
+	bootstrap: {
+		airdrops: Array<{ address: string; amountSol: number }>;
+	};
+}
+
+export const defaultConfig: SolforgeConfig = {
+	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: [],
+		tokens: [],
+		programAccounts: [],
+	},
+	gui: { enabled: true, port: 42069 },
+	bootstrap: { airdrops: [] },
+};
+
+export async function readConfig(path?: string): Promise<SolforgeConfig> {
+	const p = path || "sf.config.json";
+	try {
+		const t = await Bun.file(p).text();
+		const json = JSON.parse(t);
+		return deepMerge(defaultConfig, json);
+	} catch {
+		return defaultConfig;
+	}
+}
+
+export async function writeDefaultConfig(opts: { force?: boolean } = {}) {
+	const p = "sf.config.json";
+	try {
+		if (!opts.force)
+			await Bun.file(p)
+				.text()
+				.then(() => {
+					throw new Error("exists");
+				});
+	} catch {}
+	const dir = dirname(p);
+	if (dir && dir !== ".") {
+		try {
+			mkdirSync(dir, { recursive: true });
+		} catch {}
+	}
+	writeFileSync(p, JSON.stringify(defaultConfig, null, 2) + "\n");
+}
+
+export async function writeConfig(
+	config: SolforgeConfig,
+	path = "sf.config.json",
+) {
+	const dir = dirname(path);
+	if (dir && dir !== ".") {
+		try {
+			mkdirSync(dir, { recursive: true });
+		} catch {}
+	}
+	await Bun.write(path, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function getConfigValue(cfg: any, path?: string) {
+	if (!path) return cfg;
+	return path.split(".").reduce((o, k) => (o ? o[k] : undefined), cfg);
+}
+
+export function setConfigValue<T extends Record<string, any>>(
+	cfg: T,
+	path: string,
+	value: any,
+): T {
+	const parts = path.split(".");
+	let node: any = cfg;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const k = parts[i];
+		if (!node[k] || typeof node[k] !== "object") node[k] = {};
+		node = node[k];
+	}
+	node[parts[parts.length - 1]] = coerceValue(value);
+	return cfg;
+}
+
+function coerceValue(v: any) {
+	if (v === "true") return true;
+	if (v === "false") return false;
+	if (v !== "" && !isNaN(Number(v))) return Number(v);
+	try {
+		return JSON.parse(v);
+	} catch {
+		return v;
+	}
+}
+
+function deepMerge<T>(a: T, b: Partial<T>): T {
+	if (Array.isArray(a) || Array.isArray(b)) return (b as any) ?? (a as any);
+	if (typeof a === "object" && typeof b === "object" && a && b) {
+		const out: any = { ...a };
+		for (const [k, v] of Object.entries(b)) {
+			const ak = (a as any)[k];
+			out[k] = deepMerge(ak, v as any);
+		}
+		return out;
+	}
+	return (b as any) ?? (a as any);
+}

package/src/db/index.ts

@@ -0,0 +1,83 @@
+import Database from "bun:sqlite";
+import { existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { dirname } from "node:path";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { migrate } from "drizzle-orm/bun-sqlite/migrator";
+import { bundledMigrations } from "../migrations-bundled";
+import * as schema from "./schema";
+
+// DB path is configurable; default to project-local hidden folder
+const DB_PATH = process.env.SOLFORGE_DB_PATH || ".solforge/db.db";
+
+// Ensure directory exists
+try {
+	mkdirSync(dirname(DB_PATH), { recursive: true });
+} catch {}
+
+// Ephemeral by default (on-disk SQLite, cleared on each start).
+// Set SOLFORGE_DB_MODE=persistent or SOLFORGE_DB_PERSIST=1 for persistent DB.
+const PERSIST =
+	process.env.SOLFORGE_DB_MODE === "persistent" ||
+	process.env.SOLFORGE_DB_PERSIST === "1";
+try {
+	mkdirSync(dirname(DB_PATH), { recursive: true });
+} catch {}
+if (!PERSIST && DB_PATH !== ":memory:") {
+	try {
+		if (existsSync(DB_PATH)) unlinkSync(DB_PATH);
+	} catch {}
+	try {
+		if (existsSync(DB_PATH + "-wal")) unlinkSync(DB_PATH + "-wal");
+	} catch {}
+	try {
+		if (existsSync(DB_PATH + "-shm")) unlinkSync(DB_PATH + "-shm");
+	} catch {}
+}
+
+// Create SQLite connection and apply performance PRAGMAs
+export const sqlite = new Database(DB_PATH);
+try {
+	// Use DELETE journal to avoid VNODE/WAL issues across environments
+	sqlite.exec("PRAGMA journal_mode=DELETE;");
+	sqlite.exec("PRAGMA synchronous=NORMAL;");
+	sqlite.exec("PRAGMA temp_store=MEMORY;");
+	sqlite.exec("PRAGMA busy_timeout=1000;");
+} catch {}
+
+// Drizzle database instance with typed schema
+export const db = drizzle(sqlite, { schema });
+
+export type { SQLiteDatabase } from "drizzle-orm/sqlite-core";
+export * as dbSchema from "./schema";
+
+// Run Drizzle migrations on app start (Bun + SQLite)
+const migrationsFolder = process.env.DRIZZLE_MIGRATIONS || "drizzle";
+try {
+	// Prefer folder-based migrations when available (dev/uncompiled)
+	if (existsSync(migrationsFolder)) {
+		await migrate(db, { migrationsFolder });
+		console.log("✅ Database migrations completed (folder)");
+	} else {
+		// Bundled mode: apply embedded SQL files if schema isn't present
+		const haveTx = sqlite
+			.query(
+				"SELECT name FROM sqlite_master WHERE type='table' AND name='transactions'",
+			)
+			.get() as { name?: string } | undefined;
+		if (!haveTx?.name) {
+			for (const m of bundledMigrations) {
+				try {
+					const sql = await Bun.file(m.path).text();
+					sqlite.exec(sql);
+					console.log(`✅ Applied bundled migration: ${m.name}`);
+				} catch (e) {
+					console.error(`❌ Failed bundled migration: ${m.name}`, e);
+					throw e;
+				}
+			}
+		}
+		console.log("✅ Database migrations completed (bundled)");
+	}
+} catch (error) {
+	console.error("❌ Database migration failed:", error);
+}

package/src/db/schema/accounts.ts

@@ -0,0 +1,23 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const accounts = sqliteTable(
+	"accounts",
+	{
+		address: text("address").primaryKey(),
+		lamports: integer("lamports").notNull(),
+		ownerProgram: text("owner_program").notNull(),
+		executable: integer("executable").notNull(), // 0 or 1
+		rentEpoch: integer("rent_epoch").notNull(),
+		dataLen: integer("data_len").notNull(),
+		// Optional raw bytes; disabled by default in runtime
+		dataBase64: text("data_base64"),
+		lastSlot: integer("last_slot").notNull(),
+	},
+	(t) => ({
+		ownerIdx: index("idx_accounts_owner").on(t.ownerProgram),
+		lastSlotIdx: index("idx_accounts_last_slot").on(t.lastSlot),
+	}),
+);
+
+export type AccountRow = typeof accounts.$inferSelect;
+export type NewAccountRow = typeof accounts.$inferInsert;

package/src/db/schema/address-signatures.ts

@@ -0,0 +1,31 @@
+import {
+	index,
+	integer,
+	primaryKey,
+	sqliteTable,
+	text,
+} from "drizzle-orm/sqlite-core";
+
+export const addressSignatures = sqliteTable(
+	"address_signatures",
+	{
+		address: text("address").notNull(),
+		signature: text("signature").notNull(),
+		slot: integer("slot").notNull(),
+		err: integer("err").notNull(), // 0 or 1
+		blockTime: integer("block_time"),
+	},
+	(t) => ({
+		pk: primaryKey({
+			columns: [t.address, t.signature],
+			name: "pk_address_signatures",
+		}),
+		addressSlotIdx: index("idx_address_signatures_addr_slot").on(
+			t.address,
+			t.slot,
+		),
+	}),
+);
+
+export type AddressSignatureRow = typeof addressSignatures.$inferSelect;
+export type NewAddressSignatureRow = typeof addressSignatures.$inferInsert;

package/src/db/schema/index.ts

@@ -0,0 +1,5 @@
+export * from "./accounts";
+export * from "./address-signatures";
+export * from "./meta-kv";
+export * from "./transactions";
+export * from "./tx-accounts";

package/src/db/schema/meta-kv.ts

@@ -0,0 +1,9 @@
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const metaKv = sqliteTable("meta_kv", {
+	key: text("key").primaryKey(),
+	value: text("value").notNull(),
+});
+
+export type MetaKvRow = typeof metaKv.$inferSelect;
+export type NewMetaKvRow = typeof metaKv.$inferInsert;

package/src/db/schema/transactions.ts

@@ -0,0 +1,29 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const transactions = sqliteTable(
+	"transactions",
+	{
+		signature: text("signature").primaryKey(),
+		slot: integer("slot").notNull(),
+		blockTime: integer("block_time"),
+		version: text("version").notNull(), // 0 | "legacy"
+		errJson: text("err_json"),
+		fee: integer("fee").notNull(),
+		rawBase64: text("raw_base64").notNull(),
+		preBalancesJson: text("pre_balances_json").notNull(),
+		postBalancesJson: text("post_balances_json").notNull(),
+		logsJson: text("logs_json").notNull(),
+		preTokenBalancesJson: text("pre_token_balances_json")
+			.default("[]")
+			.notNull(),
+		postTokenBalancesJson: text("post_token_balances_json")
+			.default("[]")
+			.notNull(),
+	},
+	(t) => ({
+		slotIdx: index("idx_transactions_slot").on(t.slot),
+	}),
+);
+
+export type TransactionRow = typeof transactions.$inferSelect;
+export type NewTransactionRow = typeof transactions.$inferInsert;

package/src/db/schema/tx-accounts.ts

@@ -0,0 +1,33 @@
+import {
+	index,
+	integer,
+	primaryKey,
+	sqliteTable,
+	text,
+} from "drizzle-orm/sqlite-core";
+
+export const txAccounts = sqliteTable(
+	"tx_accounts",
+	{
+		signature: text("signature").notNull(),
+		accountIndex: integer("account_index").notNull(),
+		address: text("address").notNull(),
+		signer: integer("signer").notNull(), // 0 or 1
+		writable: integer("writable").notNull(), // 0 or 1
+		programIdIndex: integer("program_id_index"),
+	},
+	(t) => ({
+		pk: primaryKey({
+			columns: [t.signature, t.accountIndex],
+			name: "pk_tx_accounts",
+		}),
+		addressIdx: index("idx_tx_accounts_address").on(t.address),
+		addressSigIdx: index("idx_tx_accounts_address_signature").on(
+			t.address,
+			t.signature,
+		),
+	}),
+);
+
+export type TxAccountRow = typeof txAccounts.$inferSelect;
+export type NewTxAccountRow = typeof txAccounts.$inferInsert;