solforge 0.2.4 → 0.2.6

package/src/config/index.ts

@@ -68,7 +68,7 @@ export async function writeDefaultConfig(opts: { force?: boolean } = {}) {
 			mkdirSync(dir, { recursive: true });
 		} catch {}
 	}
-	writeFileSync(p, JSON.stringify(defaultConfig, null, 2) + "\n");
+	writeFileSync(p, `${JSON.stringify(defaultConfig, null, 2)}\n`);
 }
 
 export async function writeConfig(
@@ -81,50 +81,66 @@ export async function writeConfig(
 			mkdirSync(dir, { recursive: true });
 		} catch {}
 	}
-	await Bun.write(path, JSON.stringify(config, null, 2) + "\n");
+	await Bun.write(path, `${JSON.stringify(config, null, 2)}\n`);
 }
 
-export function getConfigValue(cfg: any, path?: string) {
+export function getConfigValue(
+	cfg: Record<string, unknown>,
+	path?: string,
+): unknown {
 	if (!path) return cfg;
-	return path.split(".").reduce((o, k) => (o ? o[k] : undefined), cfg);
+	let cur: unknown = cfg;
+	for (const k of path.split(".")) {
+		if (
+			cur &&
+			typeof cur === "object" &&
+			k in (cur as Record<string, unknown>)
+		) {
+			cur = (cur as Record<string, unknown>)[k];
+		} else {
+			return undefined;
+		}
+	}
+	return cur;
 }
 
-export function setConfigValue<T extends Record<string, any>>(
+export function setConfigValue<T extends Record<string, unknown>>(
 	cfg: T,
 	path: string,
-	value: any,
+	value: unknown,
 ): T {
 	const parts = path.split(".");
-	let node: any = cfg;
+	let node: Record<string, unknown> = 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 = node[k] as Record<string, unknown>;
 	}
 	node[parts[parts.length - 1]] = coerceValue(value);
 	return cfg;
 }
 
-function coerceValue(v: any) {
+function coerceValue(v: unknown): unknown {
 	if (v === "true") return true;
 	if (v === "false") return false;
-	if (v !== "" && !isNaN(Number(v))) return Number(v);
+	if (typeof v === "string" && v !== "" && !Number.isNaN(Number(v)))
+		return Number(v);
 	try {
-		return JSON.parse(v);
+		return typeof v === "string" ? JSON.parse(v) : 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 (Array.isArray(a) || Array.isArray(b)) return (b ?? a) as unknown as T;
 	if (typeof a === "object" && typeof b === "object" && a && b) {
-		const out: any = { ...a };
+		const out: Record<string, unknown> = { ...(a as Record<string, unknown>) };
 		for (const [k, v] of Object.entries(b)) {
-			const ak = (a as any)[k];
-			out[k] = deepMerge(ak, v as any);
+			const ak = (a as Record<string, unknown>)[k];
+			out[k] = deepMerge(ak as unknown, v as unknown) as unknown;
 		}
-		return out;
+		return out as unknown as T;
 	}
-	return (b as any) ?? (a as any);
+	return (b ?? a) as unknown as T;
 }

package/src/config/manager.ts

@@ -1,156 +1,156 @@
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join, resolve } from "path";
-import { ConfigSchema } from "../types/config.js";
+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: any): 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;
-  }
+	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

package/src/db/index.ts

@@ -27,10 +27,10 @@ if (!PERSIST && DB_PATH !== ":memory:") {
 		if (existsSync(DB_PATH)) unlinkSync(DB_PATH);
 	} catch {}
 	try {
-		if (existsSync(DB_PATH + "-wal")) unlinkSync(DB_PATH + "-wal");
+		if (existsSync(`${DB_PATH}-wal`)) unlinkSync(`${DB_PATH}-wal`);
 	} catch {}
 	try {
-		if (existsSync(DB_PATH + "-shm")) unlinkSync(DB_PATH + "-shm");
+		if (existsSync(`${DB_PATH}-shm`)) unlinkSync(`${DB_PATH}-shm`);
 	} catch {}
 }
 

package/src/db/tx-store.ts

@@ -23,8 +23,8 @@ export type InsertTxBundle = {
 		writable: boolean;
 		programIdIndex?: number;
 	}>;
-	preTokenBalances?: any[];
-	postTokenBalances?: any[];
+	preTokenBalances?: unknown[];
+	postTokenBalances?: unknown[];
 };
 
 export type AccountSnapshot = {
@@ -133,7 +133,7 @@ export class TxStore {
 
 	async getStatuses(signatures: string[]) {
 		if (!Array.isArray(signatures) || signatures.length === 0)
-			return new Map<string, { slot: number; err: any | null }>();
+			return new Map<string, { slot: number; err: unknown | null }>();
 		const results = await db
 			.select({
 				signature: transactions.signature,
@@ -142,7 +142,7 @@ export class TxStore {
 			})
 			.from(transactions)
 			.where(inArraySafe(transactions.signature, signatures));
-		const map = new Map<string, { slot: number; err: any | null }>();
+		const map = new Map<string, { slot: number; err: unknown | null }>();
 		for (const r of results)
 			map.set(r.signature, {
 				slot: Number(r.slot),
@@ -167,7 +167,7 @@ export class TxStore {
 		}
 		const limit = Math.min(Math.max(opts.limit ?? 1000, 1), 1000);
 
-		const whereClauses = [eq(addressSignatures.address, address)] as any[];
+		const whereClauses = [eq(addressSignatures.address, address)] as unknown[];
 		if (typeof beforeSlot === "number")
 			whereClauses.push(lt(addressSignatures.slot, beforeSlot));
 		if (typeof untilSlot === "number")
@@ -216,7 +216,7 @@ export class TxStore {
 	}
 }
 
-function safeParse<T = any>(s: string): T | null {
+function safeParse<T = unknown>(s: string): T | null {
 	try {
 		return JSON.parse(s) as T;
 	} catch {
@@ -224,6 +224,10 @@ function safeParse<T = any>(s: string): T | null {
 	}
 }
 
-function inArraySafe<T>(col: any, arr: T[]) {
-	return arr.length > 0 ? inArray(col, arr as any) : eq(col, "__never__");
+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__");
 }