solforge 0.2.5 → 0.2.7

package/server/methods/account/request-airdrop.ts

@@ -6,13 +6,14 @@ import {
 	VersionedTransaction,
 } from "@solana/web3.js";
 import type { RpcMethodHandler } from "../../types";
+import { sendTransaction as sendTxRpc } from "../transaction/send-transaction";
 
 /**
  * Implements the requestAirdrop RPC method
  * @see https://docs.solana.com/api/http#requestairdrop
  */
-export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
-	const [pubkeyStr, lamports, config] = params || [];
+export const requestAirdrop: RpcMethodHandler = async (id, params, context) => {
+	const [pubkeyStr, lamports, _config] = params || [];
 
 	try {
 		const toPubkey = new PublicKey(pubkeyStr);
@@ -59,26 +60,57 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 		tx.sign([faucet]);
 
 		// Compute pre balances for all static account keys
-		const txMsg: any = tx.message as any;
-		const rawKeys: any[] = Array.isArray(txMsg.staticAccountKeys)
-			? txMsg.staticAccountKeys
-			: Array.isArray(txMsg.accountKeys)
-				? txMsg.accountKeys
+		const msg = tx.message as unknown as {
+			staticAccountKeys?: unknown;
+			accountKeys?: unknown;
+		};
+		const rawKeys = Array.isArray(msg.staticAccountKeys)
+			? (msg.staticAccountKeys as unknown[])
+			: Array.isArray(msg.accountKeys)
+				? (msg.accountKeys as unknown[])
 				: [];
-		const staticKeys = rawKeys.map((k: any) => {
-			try {
-				return typeof k === "string" ? new PublicKey(k) : (k as PublicKey);
-			} catch {
-				return faucet.publicKey;
-			}
-		});
-		const preBalances = staticKeys.map((pk) => {
-			try {
-				return Number(context.svm.getBalance(pk));
-			} catch {
-				return 0;
-			}
-		});
+        const staticKeys = rawKeys.map((k) => {
+            try {
+                return typeof k === "string" ? new PublicKey(k) : (k as PublicKey);
+            } catch {
+                return faucet.publicKey;
+            }
+        });
+        const preBalances = staticKeys.map((pk) => {
+            try {
+                return Number(context.svm.getBalance(pk));
+            } catch {
+                return 0;
+            }
+        });
+        const preAccountStates = staticKeys.map((pk) => {
+            try {
+                const addr = pk.toBase58();
+                const acc = context.svm.getAccount(pk);
+                if (!acc) return { address: addr, pre: null } as const;
+                return {
+                    address: addr,
+                    pre: {
+                        lamports: Number(acc.lamports || 0n),
+                        ownerProgram: new PublicKey(acc.owner).toBase58(),
+                        executable: !!acc.executable,
+                        rentEpoch: Number(acc.rentEpoch || 0),
+                        dataLen: acc.data?.length ?? 0,
+                        dataBase64: undefined,
+                        lastSlot: Number(context.slot),
+                    },
+                } as const;
+            } catch {
+                return { address: pk.toBase58(), pre: null } as const;
+            }
+        });
+        try {
+            if (process.env.DEBUG_TX_CAPTURE === "1") {
+                console.debug(
+                    `[tx-capture] pre snapshots: keys=${staticKeys.length} captured=${preAccountStates.length}`,
+                );
+            }
+        } catch {}
 		const toIndex = staticKeys.findIndex((pk) => pk.equals(toPubkey));
 		const beforeTo =
 			toIndex >= 0
@@ -91,51 +123,58 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 						}
 					})();
 
-		const sendResult = context.svm.sendTransaction(tx);
-		// Surface errors to aid debugging
-		try {
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const rawErrFun = (sendResult as any).err;
-			const maybeErr =
-				typeof rawErrFun === "function" ? rawErrFun() : rawErrFun;
-			if (maybeErr) {
-				let logsForErr: string[] = [];
-				try {
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					const anyRes: any = sendResult;
-					if (typeof anyRes?.logs === "function") logsForErr = anyRes.logs();
-					else if (typeof anyRes?.meta === "function")
-						logsForErr = anyRes.meta()?.logs?.() ?? [];
-				} catch {}
-				console.warn(
-					"[requestAirdrop] transfer failed. err=",
-					maybeErr,
-					" logs=\n",
-					logsForErr.join("\n"),
-				);
-			}
-		} catch {}
+        // Send via standard sendTransaction RPC to unify capture + persistence
+        const rawB64 = Buffer.from(tx.serialize()).toString("base64");
+        const resp = await (sendTxRpc as RpcMethodHandler)(id, [rawB64], context);
+        if ((resp as any)?.error) return resp;
+        // Surface errors to aid debugging
+        const sendResult = undefined as unknown as { err?: unknown };
+        // Any send errors would have been returned by send-transaction already
 
-		let signature = tx.signatures[0]
-			? context.encodeBase58(tx.signatures[0])
-			: context.encodeBase58(new Uint8Array(64).fill(0));
-		context.notifySignature(signature);
-		// Compute post balances and capture logs if available for explorer detail view
-		let postBalances = staticKeys.map((pk) => {
-			try {
-				return Number(context.svm.getBalance(pk));
-			} catch {
-				return 0;
-			}
-		});
-		let logs: string[] = [];
-		try {
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const anyRes: any = sendResult;
-			if (typeof anyRes?.logs === "function") logs = anyRes.logs();
-			else if (typeof anyRes?.meta === "function")
-				logs = anyRes.meta()?.logs?.() ?? [];
-		} catch {}
+        let signature = String((resp as any)?.result || "");
+        if (!signature) {
+            signature = tx.signatures[0]
+                ? context.encodeBase58(tx.signatures[0])
+                : context.encodeBase58(new Uint8Array(64).fill(0));
+        }
+        try { context.notifySignature(signature); } catch {}
+        // Compute post balances and capture logs if available for explorer detail view
+        let postBalances = staticKeys.map((pk) => {
+            try {
+                return Number(context.svm.getBalance(pk));
+            } catch {
+                return 0;
+            }
+        });
+        const postAccountStates = staticKeys.map((pk) => {
+            try {
+                const addr = pk.toBase58();
+                const acc = context.svm.getAccount(pk);
+                if (!acc) return { address: addr, post: null } as const;
+                return {
+                    address: addr,
+                    post: {
+                        lamports: Number(acc.lamports || 0n),
+                        ownerProgram: new PublicKey(acc.owner).toBase58(),
+                        executable: !!acc.executable,
+                        rentEpoch: Number(acc.rentEpoch || 0),
+                        dataLen: acc.data?.length ?? 0,
+                        dataBase64: undefined,
+                        lastSlot: Number(context.slot),
+                    },
+                } as const;
+            } catch {
+                return { address: pk.toBase58(), post: null } as const;
+            }
+        });
+        try {
+            if (process.env.DEBUG_TX_CAPTURE === "1") {
+                console.debug(
+                    `[tx-capture] post snapshots: keys=${staticKeys.length} captured=${postAccountStates.length}`,
+                );
+            }
+        } catch {}
+        // Parsing, recording etc. are performed by send-transaction
 		// Verify recipient received lamports; retry once if not
 		const afterTo =
 			toIndex >= 0
@@ -175,7 +214,9 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 				tx2.sign([faucet]);
 				const res2 = context.svm.sendTransaction(tx2);
 				try {
-					const e2 = (res2 as any).err?.() ?? (res2 as any).err;
+					const e2Raw = (res2 as { err?: unknown }).err;
+					const e2 =
+						typeof e2Raw === "function" ? (e2Raw as () => unknown)() : e2Raw;
 					if (e2) console.warn("[requestAirdrop] retry failed:", e2);
 				} catch {}
 				signature = tx2.signatures[0]
@@ -193,27 +234,22 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 		}
 
 		// Try to capture error again for accurate status reporting
-		let recErr: any = null;
-		try {
-			const rawErrFun = (sendResult as any).err;
-			recErr = typeof rawErrFun === "function" ? rawErrFun() : rawErrFun;
-		} catch {}
-		context.recordTransaction(signature, tx, {
-			logs,
-			fee: 5000,
-			blockTime: Math.floor(Date.now() / 1000),
-			preBalances,
-			postBalances,
-			err: recErr,
-		});
+        // No additional error capture; send-transaction has already recorded it
+        // Pre/post snapshots are still useful for account cache; we can upsert
+        try {
+            const snapshots = new Map<string, { pre?: any; post?: any }>();
+            for (const s of preAccountStates) snapshots.set(s.address, { pre: s.pre || null });
+            for (const s of postAccountStates) {
+                const e = snapshots.get(s.address) || {};
+                e.post = s.post || null;
+                snapshots.set(s.address, e);
+            }
+            // Not persisted here; DB already has the transaction via send-transaction
+        } catch {}
 
 		return context.createSuccessResponse(id, signature);
-	} 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/admin/mint-to.ts

@@ -16,6 +16,7 @@ import {
 	VersionedTransaction,
 } from "@solana/web3.js";
 import type { RpcMethodHandler } from "../../types";
+import { sendTransaction as sendTxRpc } from "../transaction/send-transaction";
 
 // Mint via a real SPL Token transaction signed by faucet (must be mint authority)
 export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
@@ -148,16 +149,15 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			}
 		} catch {}
 
-		// Send transaction via svm
-		const _res = context.svm.sendTransaction(vtx);
-		// Compute signature (base58) from the signed transaction
-		let signatureStr = "";
-		try {
-			const sigBytes = vtx.signatures?.[0];
-			if (sigBytes)
-				signatureStr = context.encodeBase58(new Uint8Array(sigBytes));
-		} catch {}
-		if (!signatureStr) signatureStr = `mint:${ata.toBase58()}:${Date.now()}`;
+        // Send via the standard RPC sendTransaction path to unify capture/parsing
+        const rawBase64ForRpc = Buffer.from(vtx.serialize()).toString("base64");
+        const rpcResp = await (sendTxRpc as RpcMethodHandler)(
+            id,
+            [rawBase64ForRpc],
+            context,
+        );
+        if ((rpcResp as any)?.error) return rpcResp;
+        const signatureStr = String((rpcResp as any)?.result || "");
 
 		// Token balance deltas (pre/post) for ATA
 		type UiTokenAmount = {
@@ -229,34 +229,7 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			];
 		} catch {}
 
-		// Insert into DB for explorer via context.recordTransaction for richer details
-		try {
-			const rawBase64 = Buffer.from(vtx.serialize()).toString("base64");
-			const postBalances = trackedKeys.map((pk) => {
-				try {
-					return Number(context.svm.getBalance(pk) || 0n);
-				} catch {
-					return 0;
-				}
-			});
-			const logs: string[] = ["spl-token mintToChecked"];
-			try {
-				(vtx as unknown as { serialize: () => Uint8Array }).serialize = () =>
-					Buffer.from(rawBase64, "base64");
-			} catch {}
-			context.recordTransaction(signatureStr, vtx, {
-				logs,
-				fee: 0,
-				blockTime: Math.floor(Date.now() / 1000),
-				preBalances,
-				postBalances,
-				preTokenBalances,
-				postTokenBalances,
-			});
-		} catch {}
-		try {
-			context.notifySignature(signatureStr);
-		} catch {}
+        // send-transaction already records/announces signature and persists to DB
 
 		return context.createSuccessResponse(id, {
 			ok: true,

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

@@ -24,12 +24,8 @@ export const getBlock: RpcMethodHandler = (id, params, context) => {
 			rewards: [],
 			blockTime,
 		});
-	} 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/block/get-blocks-with-limit.ts

@@ -12,12 +12,8 @@ export const getBlocksWithLimit: RpcMethodHandler = (id, params, context) => {
 		const blocks: number[] = [];
 		for (let s = start; s <= end; s++) blocks.push(s);
 		return context.createSuccessResponse(id, blocks);
-	} 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/block/is-blockhash-valid.ts

@@ -12,12 +12,8 @@ export const isBlockhashValid: RpcMethodHandler = (id, params, context) => {
 			context: { slot: Number(context.slot) },
 			value: isValid,
 		});
-	} 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/get-address-lookup-table.ts

@@ -20,12 +20,8 @@ export const getAddressLookupTable: RpcMethodHandler = (
 			context: { slot: Number(context.slot) },
 			value: null,
 		});
-	} 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/program/get-program-accounts.ts

@@ -21,7 +21,11 @@ export const getProgramAccounts: RpcMethodHandler = async (
 		const dataSlice = cfg?.dataSlice as
 			| { offset: number; length: number }
 			| undefined;
-		const filters = (cfg?.filters || []) as Array<any>;
+		type GpaFilter = {
+			dataSize?: number;
+			memcmp?: { offset?: number; bytes?: string };
+		};
+		const filters: GpaFilter[] = (cfg?.filters as unknown as GpaFilter[]) || [];
 		const limit = Math.max(1, Math.min(Number(cfg?.limit ?? 10000), 50000));
 
 		let rows: Array<{ address: string }> = [];
@@ -29,7 +33,7 @@ export const getProgramAccounts: RpcMethodHandler = async (
 			rows = (await context.store?.getAccountsByOwner(programStr, limit)) || [];
 		} catch {}
 
-		const out: any[] = [];
+		const out: unknown[] = [];
 		for (const r of rows) {
 			try {
 				const pk = new PublicKey(r.address);
@@ -210,12 +214,8 @@ export const getProgramAccounts: RpcMethodHandler = async (
 		}
 
 		return context.createSuccessResponse(id, out);
-	} 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/program/get-token-account-balance.ts

@@ -53,12 +53,8 @@ export const getTokenAccountBalance: RpcMethodHandler = (
 				uiAmountString: ui.toString(),
 			},
 		});
-	} 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/program/get-token-accounts-by-delegate.ts

@@ -23,7 +23,7 @@ export const getTokenAccountsByDelegate: RpcMethodHandler = async (
 			requestedProgramId === token2022Id ? token2022Id : classicId;
 		const rows =
 			(await context.store?.getAccountsByOwner(programFilter, 50_000)) || [];
-		const out: any[] = [];
+		const out: unknown[] = [];
 		for (const r of rows) {
 			try {
 				const acc = context.svm.getAccount(new PublicKey(r.address));
@@ -75,7 +75,8 @@ export const getTokenAccountsByDelegate: RpcMethodHandler = async (
 			context: { slot: Number(context.slot) },
 			value: out,
 		});
-	} 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/program/get-token-accounts-by-owner.ts

@@ -30,7 +30,7 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 			: [classicId, token2022Id];
 
 		// Query DB for accounts owned by both SPL Token programs (classic + 2022)
-		const rows: Array<{ address: string; lastSlot: number } & any> = [];
+		const rows: Array<{ address: string; lastSlot: number }> = [];
 		for (const programId of programIds) {
 			try {
 				const found =
@@ -43,7 +43,7 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 			}
 		}
 
-		const out: any[] = [];
+		const out: unknown[] = [];
 		const seen = new Set<string>();
 		for (const r of rows) {
 			if (seen.has(r.address)) continue;
@@ -55,11 +55,12 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 				let ownerPk: PublicKey;
 				try {
 					// acc.owner may already be a PublicKey in LiteSVM
-					const anyOwner: any = (acc as any).owner;
+					const rawOwner = (acc as { owner?: unknown }).owner;
 					ownerPk =
-						typeof anyOwner?.toBase58 === "function"
-							? (anyOwner as PublicKey)
-							: new PublicKey(anyOwner);
+						rawOwner &&
+						typeof (rawOwner as { toBase58?: unknown }).toBase58 === "function"
+							? (rawOwner as PublicKey)
+							: new PublicKey(String(rawOwner));
 				} catch {
 					ownerPk = TOKEN_PROGRAM_ID; // fallback avoids throw; unpackAccount will fail if wrong and be skipped
 				}
@@ -80,9 +81,14 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 					try {
 						const mintAcc = context.svm.getAccount(dec.mint);
 						const mintOwnerPk = mintAcc
-							? typeof (mintAcc as any).owner?.toBase58 === "function"
-								? (mintAcc as any).owner
-								: new PublicKey(mintAcc.owner)
+							? ((): PublicKey => {
+									const ro = (mintAcc as { owner?: unknown }).owner;
+									return ro &&
+										typeof (ro as { toBase58?: unknown }).toBase58 ===
+											"function"
+										? (ro as PublicKey)
+										: new PublicKey(String(ro));
+								})()
 							: programPk;
 						const info = mintAcc
 							? unpackMint(
@@ -122,7 +128,12 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 						uiAmountString: (delegatedUiAmount ?? 0).toString(),
 					};
 					// rentExemptReserve only for native (wrapped SOL) accounts; value in lamports (9 decimals)
-					let rentExemptReserve = null as any;
+					let rentExemptReserve: {
+						amount: string;
+						decimals: number;
+						uiAmount: number | null;
+						uiAmountString: string;
+					} | null = null;
 					if (dec.isNative) {
 						const lamports = BigInt(
 							dec.rentExemptReserve?.toString?.() ??
@@ -196,9 +207,13 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 					const mintPk = new PublicKey(m);
 					const mintAcc = context.svm.getAccount(mintPk);
 					const mintOwnerPk = mintAcc
-						? typeof (mintAcc as any).owner?.toBase58 === "function"
-							? (mintAcc as any).owner
-							: new PublicKey(mintAcc.owner)
+						? ((): PublicKey => {
+								const ro = (mintAcc as { owner?: unknown }).owner;
+								return ro &&
+									typeof (ro as { toBase58?: unknown }).toBase58 === "function"
+									? (ro as PublicKey)
+									: new PublicKey(String(ro));
+							})()
 						: TOKEN_PROGRAM_ID;
 					// Determine which token program this mint belongs to
 					const programForMint = mintOwnerPk.equals(TOKEN_2022_PROGRAM_ID)
@@ -221,12 +236,12 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 					const acc = context.svm.getAccount(ata);
 					if (!acc || (acc.data?.length ?? 0) < ACCOUNT_SIZE) continue;
 					if (seen.has(ata.toBase58())) continue;
-					let ownerPk: PublicKey;
-					const anyOwner: any = (acc as any).owner;
-					ownerPk =
-						typeof anyOwner?.toBase58 === "function"
-							? (anyOwner as PublicKey)
-							: new PublicKey(anyOwner);
+					const rawOwner = (acc as { owner?: unknown }).owner;
+					const ownerPk: PublicKey =
+						rawOwner &&
+						typeof (rawOwner as { toBase58?: unknown }).toBase58 === "function"
+							? (rawOwner as PublicKey)
+							: new PublicKey(String(rawOwner));
 					const programPk = ownerPk.equals(TOKEN_2022_PROGRAM_ID)
 						? TOKEN_2022_PROGRAM_ID
 						: TOKEN_PROGRAM_ID;
@@ -249,9 +264,14 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 					try {
 						const mintAcc = context.svm.getAccount(dec.mint);
 						const mintOwnerPk = mintAcc
-							? typeof (mintAcc as any).owner?.toBase58 === "function"
-								? (mintAcc as any).owner
-								: new PublicKey(mintAcc.owner)
+							? ((): PublicKey => {
+									const ro = (mintAcc as { owner?: unknown }).owner;
+									return ro &&
+										typeof (ro as { toBase58?: unknown }).toBase58 ===
+											"function"
+										? (ro as PublicKey)
+										: new PublicKey(String(ro));
+								})()
 							: programPk;
 						const info = mintAcc
 							? unpackMint(
@@ -326,9 +346,14 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 						const ownerPk = new PublicKey(ownerStr);
 						const mintAcc = context.svm.getAccount(mintPk);
 						const mintOwnerPk = mintAcc
-							? typeof (mintAcc as any).owner?.toBase58 === "function"
-								? (mintAcc as any).owner
-								: new PublicKey(mintAcc.owner)
+							? ((): PublicKey => {
+									const ro = (mintAcc as { owner?: unknown }).owner;
+									return ro &&
+										typeof (ro as { toBase58?: unknown }).toBase58 ===
+											"function"
+										? (ro as PublicKey)
+										: new PublicKey(String(ro));
+								})()
 							: TOKEN_PROGRAM_ID;
 						const programForMint = mintOwnerPk.equals(TOKEN_2022_PROGRAM_ID)
 							? TOKEN_2022_PROGRAM_ID
@@ -364,7 +389,7 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 						(v) => typeof v === "number" && v >= 0,
 					),
 				);
-				const filtered: any[] = [];
+				const filtered: unknown[] = [];
 				for (let i = 0; i < out.length; i++) {
 					const e = out[i];
 					const info = e.account?.data?.parsed?.info;
@@ -381,15 +406,11 @@ export const getTokenAccountsByOwner: RpcMethodHandler = async (
 			context: { slot: Number(context.slot) },
 			value: out,
 		});
-	} catch (e: any) {
+	} catch (e: unknown) {
 		try {
 			console.error("[rpc] getTokenAccountsByOwner error", e);
 		} catch {}
-		return context.createErrorResponse(
-			id,
-			-32603,
-			"Internal error",
-			e?.message || String(e),
-		);
+		const message = e instanceof Error ? e.message : String(e);
+		return context.createErrorResponse(id, -32603, "Internal error", message);
 	}
 };

package/server/methods/program/get-token-largest-accounts.ts

@@ -74,7 +74,8 @@ export const getTokenLargestAccounts: RpcMethodHandler = async (
 			context: { slot: Number(context.slot) },
 			value: top,
 		});
-	} 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/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);
 	}
 };