solforge 0.2.12 → 0.2.13

package/src/config/manager.ts

@@ -1,157 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import type { Config, ValidationResult } from "../types/config.js";
-import { ConfigSchema } from "../types/config.js";
-
-export class ConfigManager {
-	private config: Config | null = null;
-	private configPath: string | null = null;
-
-	/**
-	 * Load configuration from a file path
-	 */
-	async load(configPath: string): Promise<Config> {
-		try {
-			const fullPath = resolve(configPath);
-
-			if (!existsSync(fullPath)) {
-				throw new Error(`Configuration file not found: ${fullPath}`);
-			}
-
-			const configContent = readFileSync(fullPath, "utf-8");
-			const rawConfig = JSON.parse(configContent);
-
-			// Validate and parse with Zod
-			const result = ConfigSchema.safeParse(rawConfig);
-
-			if (!result.success) {
-				const errors = result.error.issues.map((issue) => ({
-					path: issue.path.join("."),
-					message: issue.message,
-				}));
-				throw new Error(
-					`Configuration validation failed:\n${errors
-						.map((e) => `  - ${e.path}: ${e.message}`)
-						.join("\n")}`,
-				);
-			}
-
-			this.config = result.data;
-			this.configPath = fullPath;
-
-			return this.config;
-		} catch (error) {
-			if (error instanceof SyntaxError) {
-				throw new Error(`Invalid JSON in configuration file: ${error.message}`);
-			}
-			throw error;
-		}
-	}
-
-	/**
-	 * Save current configuration to file
-	 */
-	async save(configPath?: string): Promise<void> {
-		if (!this.config) {
-			throw new Error("No configuration loaded");
-		}
-
-		const targetPath = configPath || this.configPath;
-		if (!targetPath) {
-			throw new Error("No configuration path specified");
-		}
-
-		try {
-			const configContent = JSON.stringify(this.config, null, 2);
-			writeFileSync(targetPath, configContent, "utf-8");
-			this.configPath = targetPath;
-		} catch (error) {
-			throw new Error(
-				`Failed to save configuration: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
-			);
-		}
-	}
-
-	/**
-	 * Validate a configuration object
-	 */
-	validate(config: unknown): ValidationResult {
-		const result = ConfigSchema.safeParse(config);
-
-		if (result.success) {
-			return { valid: true, errors: [] };
-		}
-
-		const errors = result.error.issues.map((issue) => ({
-			path: issue.path.join("."),
-			message: issue.message,
-		}));
-
-		return { valid: false, errors };
-	}
-
-	/**
-	 * Create a default configuration
-	 */
-	createDefault(): Config {
-		const defaultConfig = ConfigSchema.parse({});
-		this.config = defaultConfig;
-		return defaultConfig;
-	}
-
-	/**
-	 * Get current configuration
-	 */
-	getConfig(): Config {
-		if (!this.config) {
-			throw new Error("No configuration loaded. Call load() first.");
-		}
-		return this.config;
-	}
-
-	/**
-	 * Update configuration
-	 */
-	updateConfig(updates: Partial<Config>): Config {
-		if (!this.config) {
-			throw new Error("No configuration loaded. Call load() first.");
-		}
-
-		const updated = { ...this.config, ...updates };
-		const result = ConfigSchema.safeParse(updated);
-
-		if (!result.success) {
-			const errors = result.error.issues.map((issue) => ({
-				path: issue.path.join("."),
-				message: issue.message,
-			}));
-			throw new Error(
-				`Configuration update validation failed:\n${errors
-					.map((e) => `  - ${e.path}: ${e.message}`)
-					.join("\n")}`,
-			);
-		}
-
-		this.config = result.data;
-		return this.config;
-	}
-
-	/**
-	 * Get configuration file path
-	 */
-	getConfigPath(): string | null {
-		return this.configPath;
-	}
-
-	/**
-	 * Check if configuration is loaded
-	 */
-	isLoaded(): boolean {
-		return this.config !== null;
-	}
-}
-
-// Singleton instance
-export const configManager = new ConfigManager();

package/src/db/index.ts

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

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

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

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

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

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

@@ -1,36 +0,0 @@
-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(),
-		// Additional rich metadata captured after execution
-		innerInstructionsJson: text("inner_instructions_json")
-			.default("[]")
-			.notNull(),
-		computeUnits: integer("compute_units"),
-		returnDataProgramId: text("return_data_program_id"),
-		returnDataBase64: text("return_data_base64"),
-	},
-	(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-account-states.ts

@@ -1,23 +0,0 @@
-import { index, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
-
-export const txAccountStates = sqliteTable(
-	"tx_account_states",
-	{
-		signature: text("signature").notNull(),
-		address: text("address").notNull(),
-		// JSON blobs capturing minimal account snapshot
-		// { lamports, ownerProgram, executable, rentEpoch, dataLen, dataBase64? }
-		preJson: text("pre_json"),
-		postJson: text("post_json"),
-	},
-	(t) => ({
-		pk: primaryKey({
-			columns: [t.signature, t.address],
-			name: "pk_tx_account_states",
-		}),
-		addrIdx: index("idx_tx_account_states_address").on(t.address),
-	}),
-);
-
-export type TxAccountStateRow = typeof txAccountStates.$inferSelect;
-export type NewTxAccountStateRow = typeof txAccountStates.$inferInsert;

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

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

package/src/db/tx-store.ts

@@ -1,264 +0,0 @@
-import { and, desc, eq, gt, inArray, lt } from "drizzle-orm";
-import { db } from "./index";
-import { accounts } from "./schema/accounts";
-import { addressSignatures } from "./schema/address-signatures";
-import { transactions } from "./schema/transactions";
-import { txAccounts } from "./schema/tx-accounts";
-import { txAccountStates } from "./schema/tx-account-states";
-
-export type InsertTxBundle = {
-	signature: string;
-	slot: number;
-	blockTime?: number;
-	version: 0 | "legacy";
-	fee: number;
-	err: unknown | null;
-	rawBase64: string;
-	preBalances: number[];
-	postBalances: number[];
-	logs: string[];
-	innerInstructions?: unknown[];
-	computeUnits?: number | bigint | null;
-	returnData?: { programId: string; dataBase64: string } | null;
-	accounts: Array<{
-		address: string;
-		index: number;
-		signer: boolean;
-		writable: boolean;
-		programIdIndex?: number;
-	}>;
-	preTokenBalances?: unknown[];
-	postTokenBalances?: unknown[];
-	accountStates?: Array<{
-		address: string;
-		pre?: Partial<AccountSnapshot> | null;
-		post?: Partial<AccountSnapshot> | null;
-	}>;
-};
-
-export type AccountSnapshot = {
-	address: string;
-	lamports: number;
-	ownerProgram: string;
-	executable: boolean;
-	rentEpoch: number;
-	dataLen: number;
-	dataBase64?: string | null;
-	lastSlot: number;
-};
-
-export class TxStore {
-	async insertTransactionBundle(bundle: InsertTxBundle): Promise<void> {
-		const errJson = bundle.err ? JSON.stringify(bundle.err) : null;
-		await db.transaction(async (tx) => {
-			await tx
-				.insert(transactions)
-				.values({
-					signature: bundle.signature,
-					slot: bundle.slot,
-					blockTime: bundle.blockTime ?? null,
-					version: String(bundle.version),
-					errJson,
-					fee: bundle.fee,
-					rawBase64: bundle.rawBase64,
-					preBalancesJson: JSON.stringify(bundle.preBalances ?? []),
-					postBalancesJson: JSON.stringify(bundle.postBalances ?? []),
-					logsJson: JSON.stringify(bundle.logs ?? []),
-					preTokenBalancesJson: JSON.stringify(bundle.preTokenBalances ?? []),
-					postTokenBalancesJson: JSON.stringify(bundle.postTokenBalances ?? []),
-					innerInstructionsJson: JSON.stringify(bundle.innerInstructions ?? []),
-					computeUnits:
-						bundle.computeUnits == null ? null : Number(bundle.computeUnits),
-					returnDataProgramId: bundle.returnData?.programId ?? null,
-					returnDataBase64: bundle.returnData?.dataBase64 ?? null,
-				})
-				.onConflictDoNothing();
-
-			if (Array.isArray(bundle.accounts) && bundle.accounts.length > 0) {
-				await tx
-					.insert(txAccounts)
-					.values(
-						bundle.accounts.map((a) => ({
-							signature: bundle.signature,
-							accountIndex: a.index,
-							address: a.address,
-							signer: a.signer ? 1 : 0,
-							writable: a.writable ? 1 : 0,
-							programIdIndex: a.programIdIndex ?? null,
-						})),
-					)
-					.onConflictDoNothing();
-
-				await tx
-					.insert(addressSignatures)
-					.values(
-						bundle.accounts.map((a) => ({
-							address: a.address,
-							signature: bundle.signature,
-							slot: bundle.slot,
-							err: errJson ? 1 : 0,
-							blockTime: bundle.blockTime ?? null,
-						})),
-					)
-					.onConflictDoNothing();
-			}
-
-			if (
-				Array.isArray(bundle.accountStates) &&
-				bundle.accountStates.length > 0
-			) {
-				await tx
-					.insert(txAccountStates)
-					.values(
-						bundle.accountStates.map((s) => ({
-							signature: bundle.signature,
-							address: s.address,
-							preJson: s.pre ? JSON.stringify(s.pre) : null,
-							postJson: s.post ? JSON.stringify(s.post) : null,
-						})),
-					)
-					.onConflictDoNothing();
-			}
-		});
-	}
-
-	async upsertAccounts(snapshots: AccountSnapshot[]): Promise<void> {
-		if (!Array.isArray(snapshots) || snapshots.length === 0) return;
-		// SQLite upsert via onConflictDoUpdate
-		for (const s of snapshots) {
-			await db
-				.insert(accounts)
-				.values({
-					address: s.address,
-					lamports: s.lamports,
-					ownerProgram: s.ownerProgram,
-					executable: s.executable ? 1 : 0,
-					rentEpoch: s.rentEpoch,
-					dataLen: s.dataLen,
-					dataBase64: s.dataBase64 ?? null,
-					lastSlot: s.lastSlot,
-				})
-				.onConflictDoUpdate({
-					target: accounts.address,
-					set: {
-						lamports: s.lamports,
-						ownerProgram: s.ownerProgram,
-						executable: s.executable ? 1 : 0,
-						rentEpoch: s.rentEpoch,
-						dataLen: s.dataLen,
-						dataBase64: s.dataBase64 ?? null,
-						lastSlot: s.lastSlot,
-					},
-				});
-		}
-	}
-
-	async getTransaction(signature: string) {
-		const rows = await db
-			.select()
-			.from(transactions)
-			.where(eq(transactions.signature, signature))
-			.limit(1);
-		return rows[0] || null;
-	}
-
-	async getStatuses(signatures: string[]) {
-		if (!Array.isArray(signatures) || signatures.length === 0)
-			return new Map<string, { slot: number; err: unknown | null }>();
-		const results = await db
-			.select({
-				signature: transactions.signature,
-				slot: transactions.slot,
-				errJson: transactions.errJson,
-			})
-			.from(transactions)
-			.where(inArraySafe(transactions.signature, signatures));
-		const map = new Map<string, { slot: number; err: unknown | null }>();
-		for (const r of results)
-			map.set(r.signature, {
-				slot: Number(r.slot),
-				err: r.errJson ? safeParse(r.errJson) : null,
-			});
-		return map;
-	}
-
-	async getSignaturesForAddress(
-		address: string,
-		opts: { before?: string; until?: string; limit?: number } = {},
-	) {
-		let beforeSlot: number | undefined;
-		let untilSlot: number | undefined;
-		if (opts.before) {
-			const row = await this.getTransaction(opts.before);
-			beforeSlot = row?.slot ? Number(row.slot) : undefined;
-		}
-		if (opts.until) {
-			const row = await this.getTransaction(opts.until);
-			untilSlot = row?.slot ? Number(row.slot) : undefined;
-		}
-		const limit = Math.min(Math.max(opts.limit ?? 1000, 1), 1000);
-
-		const whereClauses = [eq(addressSignatures.address, address)] as unknown[];
-		if (typeof beforeSlot === "number")
-			whereClauses.push(lt(addressSignatures.slot, beforeSlot));
-		if (typeof untilSlot === "number")
-			whereClauses.push(gt(addressSignatures.slot, untilSlot));
-
-		const rows = await db
-			.select({
-				signature: addressSignatures.signature,
-				slot: addressSignatures.slot,
-				blockTime: addressSignatures.blockTime,
-				err: addressSignatures.err,
-			})
-			.from(addressSignatures)
-			.where(and(...whereClauses))
-			.orderBy(desc(addressSignatures.slot))
-			.limit(limit);
-
-		return rows.map((r) => ({
-			signature: r.signature,
-			slot: Number(r.slot),
-			err: r.err ? {} : null,
-			memo: null as null,
-			blockTime: r.blockTime ? Number(r.blockTime) : null,
-			confirmationStatus: r.err ? "processed" : "confirmed",
-		}));
-	}
-
-	async getAccountsByOwner(ownerProgram: string, limit = 1000) {
-		const rows = await db
-			.select()
-			.from(accounts)
-			.where(eq(accounts.ownerProgram, ownerProgram))
-			.orderBy(desc(accounts.lastSlot))
-			.limit(Math.min(Math.max(limit, 1), 1000));
-		return rows;
-	}
-
-	async getBlockTimeForSlot(slot: number): Promise<number | null> {
-		const rows = await db
-			.select({ bt: transactions.blockTime })
-			.from(transactions)
-			.where(eq(transactions.slot, slot))
-			.limit(1);
-		const r = rows[0];
-		return r?.bt != null ? Number(r.bt) : null;
-	}
-}
-
-function safeParse<T = unknown>(s: string): T | null {
-	try {
-		return JSON.parse(s) as T;
-	} catch {
-		return null;
-	}
-}
-
-function inArraySafe<T>(col: unknown, arr: T[]) {
-	return arr.length > 0
-		? // biome-ignore lint/suspicious/noExplicitAny: Drizzle generic typing workaround
-			(inArray as unknown as (c: unknown, a: T[]) => any)(col, arr)
-		: // biome-ignore lint/suspicious/noExplicitAny: Force an always-false predicate without over-constraining types
-			eq(col as any, "__never__");
-}