solforge 0.2.5 → 0.2.6

package/server/methods/program/get-token-supply.ts

@@ -32,7 +32,8 @@ export const getTokenSupply: RpcMethodHandler = (id, params, context) => {
 				uiAmountString: ui.toString(),
 			},
 		});
-	} catch (e: any) {
-		return context.createErrorResponse(id, -32602, "Invalid params", e.message);
+	} catch (e: unknown) {
+		const message = e instanceof Error ? e.message : String(e);
+		return context.createErrorResponse(id, -32602, "Invalid params", message);
 	}
 };

package/server/methods/solforge/index.ts

@@ -46,12 +46,13 @@ export const solforgeGetStatus: RpcMethodHandler = async (
 				...formatLamports(faucetLamports),
 			},
 		});
-	} catch (error: any) {
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
 		return context.createErrorResponse(
 			id,
 			-32603,
 			"Status unavailable",
-			error?.message || String(error),
+			message,
 		);
 	}
 };
@@ -90,12 +91,13 @@ export const solforgeListPrograms: RpcMethodHandler = async (
 			.filter(Boolean);
 
 		return context.createSuccessResponse(id, detailed);
-	} catch (error: any) {
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
 		return context.createErrorResponse(
 			id,
 			-32603,
 			"List programs failed",
-			error?.message || String(error),
+			message,
 		);
 	}
 };
@@ -144,12 +146,13 @@ export const solforgeListTokensDetailed: RpcMethodHandler = async (
 			.filter(Boolean);
 
 		return context.createSuccessResponse(id, detailed);
-	} catch (error: any) {
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
 		return context.createErrorResponse(
 			id,
 			-32603,
 			"List tokens failed",
-			error?.message || String(error),
+			message,
 		);
 	}
 };

package/server/methods/transaction/get-parsed-transaction.ts

@@ -10,12 +10,8 @@ export const getParsedTransaction: RpcMethodHandler = async (
 	const cfg = { ...(config || {}), encoding: "jsonParsed" };
 	try {
 		return await getTransaction(id, [signature, cfg], context);
-	} catch (error: any) {
-		return context.createErrorResponse(
-			id,
-			-32603,
-			"Internal error",
-			error.message,
-		);
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
+		return context.createErrorResponse(id, -32603, "Internal error", message);
 	}
 };

package/server/methods/transaction/get-signature-statuses.ts

@@ -7,7 +7,7 @@ export const getSignatureStatuses: RpcMethodHandler = async (
 ) => {
 	const [signatures] = params;
 
-	let persisted: Map<string, { slot: number; err: any | null }> = new Map();
+	let persisted: Map<string, { slot: number; err: unknown | null }> = new Map();
 	try {
 		persisted = (await context.store?.getStatuses(signatures)) || new Map();
 	} catch {}
@@ -17,7 +17,7 @@ export const getSignatureStatuses: RpcMethodHandler = async (
 			// Prefer locally recorded transactions for reliability with CLI tooling
 			const rec = context.getRecordedTransaction(sig);
 			if (rec) {
-				const errVal: any = rec.err ?? null;
+				const errVal: unknown = rec.err ?? null;
 				const status = errVal ? { Err: errVal } : { Ok: null };
 				return {
 					slot: rec.slot,
@@ -29,7 +29,7 @@ export const getSignatureStatuses: RpcMethodHandler = async (
 			}
 			const db = persisted.get(sig);
 			if (db) {
-				const errVal: any = db.err ?? null;
+				const errVal: unknown = db.err ?? null;
 				const status = errVal ? { Err: errVal } : { Ok: null };
 				return {
 					slot: db.slot,
@@ -41,13 +41,20 @@ export const getSignatureStatuses: RpcMethodHandler = async (
 			}
 
 			const sigBytes = context.decodeBase58(sig);
-			const tx = (context.svm as any).getTransaction(sigBytes);
+			const txGetter = (
+				context.svm as unknown as {
+					getTransaction?: (sig: Uint8Array) => { err?: unknown } | undefined;
+				}
+			).getTransaction;
+			const tx =
+				typeof txGetter === "function" ? txGetter(sigBytes) : undefined;
 			if (!tx) return null;
 
-			let errVal: any = null;
+			let errVal: unknown = null;
 			try {
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-				errVal = "err" in tx ? (tx as any).err() : null;
+				const rawErr = (tx as { err?: unknown }).err;
+				errVal =
+					typeof rawErr === "function" ? (rawErr as () => unknown)() : rawErr;
 			} catch {
 				errVal = null;
 			}

package/server/methods/transaction/get-signatures-for-address.ts

@@ -31,15 +31,11 @@ export const getSignaturesForAddress: RpcMethodHandler = async (
 			// Graceful fallback: return empty list instead of error
 			return context.createSuccessResponse(id, []);
 		}
-	} catch (error: any) {
+	} catch (error: unknown) {
 		try {
 			console.error("[rpc] getSignaturesForAddress error", error);
 		} catch {}
-		return context.createErrorResponse(
-			id,
-			-32603,
-			"Internal error",
-			error.message,
-		);
+		const message = error instanceof Error ? error.message : String(error);
+		return context.createErrorResponse(id, -32603, "Internal error", message);
 	}
 };

package/server/methods/transaction/get-transaction.ts

@@ -8,14 +8,14 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 	try {
 		const rec = context.getRecordedTransaction(signature);
 		if (rec) {
-			const tx = rec.tx as any;
+			const tx = rec.tx;
 			if (encoding === "base64") {
 				const raw = Buffer.from(tx.serialize()).toString("base64");
 				// Top-level version is required by some clients
-				const isV0 =
-					typeof (tx.message as any)?.version === "number"
-						? (tx.message as any).version === 0
-						: true;
+				const isV0 = (() => {
+					const m = tx.message as unknown as { version?: number };
+					return typeof m?.version === "number" ? m.version === 0 : true;
+				})();
 				return context.createSuccessResponse(id, {
 					slot: rec.slot,
 					transaction: [raw, "base64"],
@@ -31,55 +31,86 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 							: [],
 						innerInstructions: [],
 						logMessages: rec.logs || [],
-						preTokenBalances: Array.isArray((rec as any).preTokenBalances)
-							? (rec as any).preTokenBalances
-							: [],
-						postTokenBalances: Array.isArray((rec as any).postTokenBalances)
-							? (rec as any).postTokenBalances
-							: [],
+						preTokenBalances: (() => {
+							const arr = (rec as unknown as { preTokenBalances?: unknown[] })
+								.preTokenBalances;
+							return Array.isArray(arr) ? arr : [];
+						})(),
+						postTokenBalances: (() => {
+							const arr = (rec as unknown as { postTokenBalances?: unknown[] })
+								.postTokenBalances;
+							return Array.isArray(arr) ? arr : [];
+						})(),
 						rewards: [],
 					},
 					blockTime: rec.blockTime,
 				});
 			}
 
-			const msg: any = tx.message as any;
-			const rawKeys1: any[] = Array.isArray(msg.staticAccountKeys)
+			const msg = tx.message as unknown as {
+				staticAccountKeys?: unknown[];
+				accountKeys?: unknown[];
+				compiledInstructions?: unknown[];
+				instructions?: unknown[];
+				header?: unknown;
+				recentBlockhash?: string;
+				version?: number;
+				addressTableLookups?: unknown[];
+				isAccountSigner?: (i: number) => boolean;
+				isAccountWritable?: (i: number) => boolean;
+			};
+			const rawKeys1: unknown[] = Array.isArray(msg.staticAccountKeys)
 				? msg.staticAccountKeys
 				: Array.isArray(msg.accountKeys)
 					? msg.accountKeys
 					: [];
-			const accountKeys = rawKeys1.map((k: any) => {
+			const accountKeys = rawKeys1.map((k) => {
 				try {
-					return typeof k === "string" ? k : k.toBase58();
+					return typeof k === "string"
+						? k
+						: (k as { toBase58: () => string }).toBase58();
 				} catch {
 					return String(k);
 				}
 			});
-			const compiled = Array.isArray(msg.compiledInstructions)
+			const compiled: unknown[] = Array.isArray(msg.compiledInstructions)
 				? msg.compiledInstructions
 				: Array.isArray(msg.instructions)
 					? msg.instructions
 					: [];
-			const instructions = compiled.map((ci: any) => {
+			const instructions = compiled.map((ci) => {
+				const c = ci as {
+					programIdIndex: number;
+					accountKeyIndexes?: number[];
+					accounts?: number[];
+					data: Uint8Array | number[];
+				};
 				const dataBytes: Uint8Array =
-					ci.data instanceof Uint8Array ? ci.data : Buffer.from(ci.data);
+					c.data instanceof Uint8Array ? c.data : Buffer.from(c.data);
 				return {
-					programIdIndex: ci.programIdIndex,
-					accounts: Array.from(ci.accountKeyIndexes || ci.accounts || []),
+					programIdIndex: c.programIdIndex,
+					accounts: Array.from(c.accountKeyIndexes || c.accounts || []),
 					data: context.encodeBase58(dataBytes),
 				};
 			});
-			const addressTableLookups = (msg.addressTableLookups || []).map(
-				(l: any) => ({
+			const addressTableLookups = (
+				Array.isArray(msg.addressTableLookups) ? msg.addressTableLookups : []
+			).map((l) => {
+				const a = l as {
+					accountKey?: { toBase58?: () => string } | string;
+					writableIndexes?: number[];
+					readonlyIndexes?: number[];
+				};
+				return {
 					accountKey:
-						typeof l.accountKey?.toBase58 === "function"
-							? l.accountKey.toBase58()
-							: String(l.accountKey),
-					writableIndexes: Array.from(l.writableIndexes || []),
-					readonlyIndexes: Array.from(l.readonlyIndexes || []),
-				}),
-			);
+						typeof (a.accountKey as { toBase58?: unknown })?.toBase58 ===
+						"function"
+							? (a.accountKey as { toBase58: () => string }).toBase58()
+							: String(a.accountKey),
+					writableIndexes: Array.from(a.writableIndexes || []),
+					readonlyIndexes: Array.from(a.readonlyIndexes || []),
+				};
+			});
 			const header = msg.header || {
 				numRequiredSignatures: tx.signatures.length,
 				numReadonlySignedAccounts: 0,
@@ -88,7 +119,7 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 			const recentBlockhash = msg.recentBlockhash || "";
 
 			const isV0 = typeof msg.version === "number" ? msg.version === 0 : true;
-			const result: any = {
+			const result = {
 				slot: rec.slot,
 				transaction: {
 					signatures: [signature],
@@ -110,12 +141,16 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 					postBalances: Array.isArray(rec.postBalances) ? rec.postBalances : [],
 					innerInstructions: [],
 					logMessages: rec.logs || [],
-					preTokenBalances: Array.isArray((rec as any).preTokenBalances)
-						? (rec as any).preTokenBalances
-						: [],
-					postTokenBalances: Array.isArray((rec as any).postTokenBalances)
-						? (rec as any).postTokenBalances
-						: [],
+					preTokenBalances: (() => {
+						const arr = (rec as unknown as { preTokenBalances?: unknown[] })
+							.preTokenBalances;
+						return Array.isArray(arr) ? arr : [];
+					})(),
+					postTokenBalances: (() => {
+						const arr = (rec as unknown as { postTokenBalances?: unknown[] })
+							.postTokenBalances;
+						return Array.isArray(arr) ? arr : [];
+					})(),
 					rewards: [],
 				},
 				blockTime: rec.blockTime,
@@ -134,12 +169,18 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 							? !!msg.isAccountWritable(i)
 							: i < (header?.numRequiredSignatures ?? 0),
 				}));
-				const parsedInstructions = compiled.map((ci: any) => {
-					const programId = accountKeys[ci.programIdIndex];
-					let parsed: any;
+				const parsedInstructions = compiled.map((ci) => {
+					const c = ci as {
+						programIdIndex: number;
+						accountKeyIndexes?: number[];
+						accounts?: number[];
+						data: Uint8Array | number[];
+					};
+					const programId = accountKeys[c.programIdIndex];
+					let parsed: unknown;
 					try {
 						const data: Uint8Array =
-							ci.data instanceof Uint8Array ? ci.data : Buffer.from(ci.data);
+							c.data instanceof Uint8Array ? c.data : Buffer.from(c.data);
 						if (programId === SYSTEM_PROGRAM_ID && data.length >= 12) {
 							const dv = new DataView(
 								data.buffer,
@@ -152,8 +193,9 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 								(ci.accountKeyIndexes?.length ?? 0) >= 2
 							) {
 								const lamports = Number(dv.getBigUint64(4, true));
-								const source = accountKeys[ci.accountKeyIndexes[0]];
-								const destination = accountKeys[ci.accountKeyIndexes[1]];
+								const source = accountKeys[c.accountKeyIndexes?.[0] as number];
+								const destination =
+									accountKeys[c.accountKeyIndexes?.[1] as number];
 								parsed = {
 									type: "transfer",
 									info: { source, destination, lamports },
@@ -164,16 +206,19 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 					if (parsed) return { program: "system", programId, parsed };
 					return {
 						programId,
-						accounts: (ci.accountKeyIndexes || []).map(
+						accounts: (c.accountKeyIndexes || []).map(
 							(ix: number) => accountKeys[ix],
 						),
 						data: context.encodeBase58(
-							ci.data instanceof Uint8Array ? ci.data : Buffer.from(ci.data),
+							c.data instanceof Uint8Array ? c.data : Buffer.from(c.data),
 						),
 					};
 				});
-				result.transaction.message.accountKeys = accountKeysParsed;
-				result.transaction.message.instructions = parsedInstructions;
+				(result.transaction.message as { accountKeys: unknown[] }).accountKeys =
+					accountKeysParsed;
+				(
+					result.transaction.message as { instructions: unknown[] }
+				).instructions = parsedInstructions as unknown[];
 			}
 
 			return context.createSuccessResponse(id, result);
@@ -213,15 +258,27 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 					// Build jsonParsed similar to in-memory path
 					const raw = Buffer.from(row.rawBase64, "base64");
 					const tx = VersionedTransaction.deserialize(raw);
-					const msg: any = tx.message as any;
-					const rawKeys2: any[] = Array.isArray(msg.staticAccountKeys)
+					const msg = tx.message as unknown as {
+						staticAccountKeys?: unknown[];
+						accountKeys?: unknown[];
+						compiledInstructions?: unknown[];
+						instructions?: unknown[];
+						header?: unknown;
+						recentBlockhash?: string;
+						addressTableLookups?: unknown[];
+						isAccountSigner?: (i: number) => boolean;
+						isAccountWritable?: (i: number) => boolean;
+					};
+					const rawKeys2: unknown[] = Array.isArray(msg.staticAccountKeys)
 						? msg.staticAccountKeys
 						: Array.isArray(msg.accountKeys)
 							? msg.accountKeys
 							: [];
-					const accountKeys = rawKeys2.map((k: any) => {
+					const accountKeys = rawKeys2.map((k) => {
 						try {
-							return typeof k === "string" ? k : k.toBase58();
+							return typeof k === "string"
+								? k
+								: (k as { toBase58: () => string }).toBase58();
 						} catch {
 							return String(k);
 						}
@@ -231,17 +288,23 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 						numReadonlySignedAccounts: 0,
 						numReadonlyUnsignedAccounts: 0,
 					};
-					const compiled = Array.isArray(msg.compiledInstructions)
+					const compiled: unknown[] = Array.isArray(msg.compiledInstructions)
 						? msg.compiledInstructions
 						: Array.isArray(msg.instructions)
 							? msg.instructions
 							: [];
-					const parsedInstructions = compiled.map((ci: any) => {
-						const programId = accountKeys[ci.programIdIndex];
-						let parsed: any;
+					const parsedInstructions = compiled.map((ci) => {
+						const c = ci as {
+							programIdIndex: number;
+							accountKeyIndexes?: number[];
+							accounts?: number[];
+							data: Uint8Array | number[];
+						};
+						const programId = accountKeys[c.programIdIndex];
+						let parsed: unknown;
 						try {
 							const data: Uint8Array =
-								ci.data instanceof Uint8Array ? ci.data : Buffer.from(ci.data);
+								c.data instanceof Uint8Array ? c.data : Buffer.from(c.data);
 							// Minimal system transfer parser
 							if (
 								programId === "11111111111111111111111111111111" &&
@@ -258,8 +321,8 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 									(ci.accountKeyIndexes?.length ?? 0) >= 2
 								) {
 									const lamports = Number(dv.getBigUint64(4, true));
-									const source = accountKeys[ci.accountKeyIndexes[0]];
-									const destination = accountKeys[ci.accountKeyIndexes[1]];
+									const source = accountKeys[c.accountKeyIndexes?.[0]];
+									const destination = accountKeys[c.accountKeyIndexes?.[1]];
 									parsed = {
 										type: "transfer",
 										info: { source, destination, lamports },
@@ -270,11 +333,11 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 						if (parsed) return { program: "system", programId, parsed };
 						return {
 							programId,
-							accounts: (ci.accountKeyIndexes || []).map(
+							accounts: (c.accountKeyIndexes || []).map(
 								(ix: number) => accountKeys[ix],
 							),
 							data: context.encodeBase58(
-								ci.data instanceof Uint8Array ? ci.data : Buffer.from(ci.data),
+								c.data instanceof Uint8Array ? c.data : Buffer.from(c.data),
 							),
 						};
 					});
@@ -291,7 +354,7 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 									: i < (header?.numRequiredSignatures ?? 0),
 						}),
 					);
-					const result: any = {
+					const result = {
 						slot: Number(row.slot),
 						transaction: {
 							signatures: [signature],
@@ -323,15 +386,25 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 				} else {
 					const raw = Buffer.from(row.rawBase64, "base64");
 					const tx = VersionedTransaction.deserialize(raw);
-					const msg: any = tx.message as any;
-					const rawKeys3: any[] = Array.isArray(msg.staticAccountKeys)
+					const msg = tx.message as unknown as {
+						staticAccountKeys?: unknown[];
+						accountKeys?: unknown[];
+						compiledInstructions?: unknown[];
+						instructions?: unknown[];
+						header?: unknown;
+						recentBlockhash?: string;
+						addressTableLookups?: unknown[];
+					};
+					const rawKeys3: unknown[] = Array.isArray(msg.staticAccountKeys)
 						? msg.staticAccountKeys
 						: Array.isArray(msg.accountKeys)
 							? msg.accountKeys
 							: [];
-					const accountKeys = rawKeys3.map((k: any) => {
+					const accountKeys = rawKeys3.map((k) => {
 						try {
-							return typeof k === "string" ? k : k.toBase58();
+							return typeof k === "string"
+								? k
+								: (k as { toBase58: () => string }).toBase58();
 						} catch {
 							return String(k);
 						}
@@ -341,19 +414,27 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 						numReadonlySignedAccounts: 0,
 						numReadonlyUnsignedAccounts: 0,
 					};
-					const compiled = Array.isArray(msg.compiledInstructions)
+					const compiled: unknown[] = Array.isArray(msg.compiledInstructions)
 						? msg.compiledInstructions
 						: Array.isArray(msg.instructions)
 							? msg.instructions
 							: [];
-					const instructions = compiled.map((ci: any) => ({
-						programIdIndex: ci.programIdIndex,
-						accounts: Array.from(ci.accountKeyIndexes || ci.accounts || []),
-						data: context.encodeBase58(
-							ci.data instanceof Uint8Array ? ci.data : Buffer.from(ci.data),
-						),
-					}));
-					const result: any = {
+					const instructions = compiled.map((ci) => {
+						const c = ci as {
+							programIdIndex: number;
+							accountKeyIndexes?: number[];
+							accounts?: number[];
+							data: Uint8Array | number[];
+						};
+						return {
+							programIdIndex: c.programIdIndex,
+							accounts: Array.from(c.accountKeyIndexes || c.accounts || []),
+							data: context.encodeBase58(
+								c.data instanceof Uint8Array ? c.data : Buffer.from(c.data),
+							),
+						};
+					});
+					const result = {
 						slot: Number(row.slot),
 						transaction: {
 							signatures: [signature],
@@ -388,7 +469,16 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 
 		// Fallback to LiteSVM history when no local record exists
 		const sigBytes = context.decodeBase58(signature);
-		const txh = (context.svm as any).getTransaction(sigBytes);
+		const getTx = (
+			context.svm as unknown as {
+				getTransaction?: (
+					sig: Uint8Array,
+				) =>
+					| { logs: () => string[]; err: () => unknown }
+					| { meta: () => { logs: () => string[] }; err: () => unknown };
+			}
+		).getTransaction;
+		const txh = typeof getTx === "function" ? getTx(sigBytes) : undefined;
 		if (!txh) return context.createSuccessResponse(id, null);
 
 		const isError = "err" in txh;
@@ -417,12 +507,8 @@ export const getTransaction: RpcMethodHandler = async (id, params, context) => {
 			},
 			blockTime: Math.floor(Date.now() / 1000),
 		});
-	} catch (error: any) {
-		return context.createErrorResponse(
-			id,
-			-32602,
-			"Invalid params",
-			error.message,
-		);
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
+		return context.createErrorResponse(id, -32602, "Invalid params", message);
 	}
 };

package/server/methods/transaction/send-transaction.ts

@@ -16,14 +16,17 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 		const tx = VersionedTransaction.deserialize(txData);
 
 		// Snapshot pre balances
-		const msg: any = tx.message as any;
-		const rawKeys: any[] = Array.isArray(msg.staticAccountKeys)
+		const msg = tx.message as unknown as {
+			staticAccountKeys?: unknown[];
+			accountKeys?: unknown[];
+		};
+		const rawKeys: unknown[] = Array.isArray(msg.staticAccountKeys)
 			? msg.staticAccountKeys
 			: Array.isArray(msg.accountKeys)
 				? msg.accountKeys
 				: [];
 		const staticKeys = rawKeys
-			.map((k: any) => {
+			.map((k) => {
 				try {
 					return typeof k === "string" ? new PublicKey(k) : (k as PublicKey);
 				} catch {
@@ -40,8 +43,11 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 		});
 
 		// Collect SPL token accounts from instructions for pre/post token balance snapshots
-		const msgAny: any = msg;
-		const compiled = Array.isArray(msgAny.compiledInstructions)
+		const msgAny = msg as unknown as {
+			compiledInstructions?: unknown[];
+			instructions?: unknown[];
+		};
+		const compiled: unknown[] = Array.isArray(msgAny.compiledInstructions)
 			? msgAny.compiledInstructions
 			: Array.isArray(msgAny.instructions)
 				? msgAny.instructions
@@ -67,7 +73,7 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 			} catch {}
 		}
 		// Pre token balances
-		const preTokenBalances: any[] = [];
+		const preTokenBalances: unknown[] = [];
 		const ataToInfo = new Map<
 			string,
 			{
@@ -127,8 +133,9 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 		const result = context.svm.sendTransaction(tx);
 
 		try {
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const maybeErr = (result as any).err?.();
+			const rawErr = (result as { err?: unknown }).err;
+			const maybeErr =
+				typeof rawErr === "function" ? (rawErr as () => unknown)() : rawErr;
 			if (maybeErr) {
 				return context.createErrorResponse(
 					id,
@@ -152,7 +159,7 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 			}
 		});
 		// Post token balances
-		const postTokenBalances: any[] = [];
+		const postTokenBalances: unknown[] = [];
 		for (const addr of tokenAccountSet) {
 			try {
 				const pk = new PublicKey(addr);
@@ -204,11 +211,16 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 		}
 		let logs: string[] = [];
 		try {
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const anyRes: any = result;
-			if (typeof anyRes?.logs === "function") logs = anyRes.logs();
-			else if (typeof anyRes?.meta === "function")
-				logs = anyRes.meta()?.logs?.() ?? [];
+			const sr = result as {
+				logs?: () => string[];
+				meta?: () => { logs?: () => string[] } | undefined;
+			};
+			if (typeof sr?.logs === "function") logs = sr.logs();
+			else if (typeof sr?.meta === "function") {
+				const m = sr.meta();
+				const lg = m?.logs;
+				if (typeof lg === "function") logs = lg();
+			}
 		} catch {}
 		context.recordTransaction(signature, tx, {
 			logs,
@@ -221,12 +233,13 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 		});
 
 		return context.createSuccessResponse(id, signature);
-	} catch (error: any) {
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
 		return context.createErrorResponse(
 			id,
 			-32003,
 			"Transaction failed",
-			error.message,
+			message,
 		);
 	}
 };