solforge 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solforge",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "module": "index.ts",
   "type": "module",
   "private": false,

package/scripts/postinstall.cjs

@@ -4,9 +4,9 @@
   - Skips if SOLFORGE_SKIP_DOWNLOAD=true
   - Falls back silently on errors (CLI will still work via Bun if installed)
 */
-const fs = require("fs");
-const path = require("path");
-const https = require("https");
+const fs = require("node:fs");
+const path = require("node:path");
+const https = require("node:https");
 
 function log(msg) {
 	console.log(`[solforge] ${msg}`);

package/server/lib/base58.ts

@@ -12,7 +12,7 @@ export function encodeBase58(bytes: Uint8Array): string {
 		encoded = ALPHABET[Number(remainder)] + encoded;
 	}
 	for (let i = 0; i < bytes.length && bytes[i] === 0; i++)
-		encoded = "1" + encoded;
+		encoded = `1${encoded}`;
 	return encoded || "1";
 }
 

package/server/lib/instruction-parser.ts

@@ -0,0 +1,242 @@
+import {
+  AddressLookupTableInstruction,
+  ComputeBudgetInstruction,
+  PublicKey,
+  StakeInstruction,
+  SystemInstruction,
+  SystemProgram,
+  TransactionInstruction,
+  VoteInstruction,
+} from "@solana/web3.js";
+import { decodeBase58 as _decodeBase58 } from "./base58";
+
+export type ParsedInstruction =
+  | { program: string; programId: string; parsed: { type: string; info: any } }
+  | { programId: string; accounts: string[]; data: string };
+
+function makeIx(
+  programId: string,
+  accountKeys: string[],
+  accounts: number[],
+  dataBase58: string,
+): TransactionInstruction {
+  const keys = accounts.map((i) => ({
+    pubkey: new PublicKey(accountKeys[i] || SystemProgram.programId),
+    isSigner: false,
+    isWritable: false,
+  }));
+  const data = Buffer.from(_decodeBase58(dataBase58));
+  return new TransactionInstruction({ programId: new PublicKey(programId), keys, data });
+}
+
+function ok(program: string, programId: string, type: string, info: any): ParsedInstruction {
+  return { program, programId, parsed: { type, info } };
+}
+
+export function parseInstruction(
+  programId: string,
+  accounts: number[],
+  dataBase58: string,
+  accountKeys: string[],
+): ParsedInstruction {
+  try {
+    const pid = new PublicKey(programId);
+    const ix = makeIx(programId, accountKeys, accounts, dataBase58);
+
+    // System Program
+    if (pid.equals(SystemProgram.programId)) {
+      const t = SystemInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "Create": {
+          const p = SystemInstruction.decodeCreateAccount(ix);
+          return ok("system", programId, "createAccount", {
+            fromPubkey: p.fromPubkey.toBase58(),
+            newAccountPubkey: p.newAccountPubkey.toBase58(),
+            lamports: Number(p.lamports),
+            space: Number(p.space),
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "Transfer": {
+          const p = SystemInstruction.decodeTransfer(ix);
+          return ok("system", programId, "transfer", {
+            source: p.fromPubkey.toBase58(),
+            destination: p.toPubkey.toBase58(),
+            lamports: Number(p.lamports),
+          });
+        }
+        case "TransferWithSeed": {
+          const p = SystemInstruction.decodeTransferWithSeed(ix);
+          return ok("system", programId, "transferWithSeed", {
+            fromPubkey: p.fromPubkey.toBase58(),
+            basePubkey: p.basePubkey.toBase58(),
+            toPubkey: p.toPubkey.toBase58(),
+            lamports: Number(p.lamports),
+            seed: p.seed,
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "Allocate": {
+          const p = SystemInstruction.decodeAllocate(ix);
+          return ok("system", programId, "allocate", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            space: Number(p.space),
+          });
+        }
+        case "AllocateWithSeed": {
+          const p = SystemInstruction.decodeAllocateWithSeed(ix);
+          return ok("system", programId, "allocateWithSeed", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            basePubkey: p.basePubkey.toBase58(),
+            seed: p.seed,
+            space: Number(p.space),
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "Assign": {
+          const p = SystemInstruction.decodeAssign(ix);
+          return ok("system", programId, "assign", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "AssignWithSeed": {
+          const p = SystemInstruction.decodeAssignWithSeed(ix);
+          return ok("system", programId, "assignWithSeed", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            basePubkey: p.basePubkey.toBase58(),
+            seed: p.seed,
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "InitializeNonceAccount":
+        case "AdvanceNonceAccount":
+        case "WithdrawNonceAccount":
+        case "AuthorizeNonceAccount":
+        case "CreateWithSeed":
+        case "UpgradeNonceAccount": {
+          // For brevity: rely on type only; details can be added if needed
+          return ok("system", programId, t, {});
+        }
+        default:
+          break;
+      }
+    }
+
+    // Compute Budget
+    try {
+      const t = ComputeBudgetInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "SetComputeUnitLimit": {
+          const p = ComputeBudgetInstruction.decodeSetComputeUnitLimit(ix);
+          return ok("computeBudget", programId, "setComputeUnitLimit", { units: Number(p.units) });
+        }
+        case "SetComputeUnitPrice": {
+          const p = ComputeBudgetInstruction.decodeSetComputeUnitPrice(ix);
+          return ok("computeBudget", programId, "setComputeUnitPrice", { microLamports: Number(p.microLamports) });
+        }
+        case "RequestHeapFrame": {
+          const p = ComputeBudgetInstruction.decodeRequestHeapFrame(ix);
+          return ok("computeBudget", programId, "requestHeapFrame", { bytes: Number(p.bytes) });
+        }
+        case "RequestUnits": {
+          const p = ComputeBudgetInstruction.decodeRequestUnits(ix);
+          return ok("computeBudget", programId, "requestUnits", { units: Number(p.units), additionalFee: Number(p.additionalFee) });
+        }
+      }
+    } catch {}
+
+    // Stake
+    try {
+      const t = StakeInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "Initialize":
+          return ok("stake", programId, "initialize", {});
+        case "Delegate": {
+          const p = StakeInstruction.decodeDelegate(ix);
+          return ok("stake", programId, "delegate", {
+            stakePubkey: p.stakePubkey.toBase58(),
+            votePubkey: p.votePubkey.toBase58(),
+            authorizedPubkey: p.authorizedPubkey.toBase58(),
+          });
+        }
+        case "Authorize": {
+          const p = StakeInstruction.decodeAuthorize(ix);
+          return ok("stake", programId, "authorize", {
+            stakePubkey: p.stakePubkey.toBase58(),
+            authorizedPubkey: p.authorizedPubkey.toBase58(),
+            newAuthorizedPubkey: p.newAuthorizedPubkey.toBase58(),
+            stakeAuthorizationType: p.stakeAuthorizationType.index,
+          });
+        }
+        case "AuthorizeWithSeed":
+          return ok("stake", programId, "authorizeWithSeed", {});
+        case "Split":
+          return ok("stake", programId, "split", {});
+        case "Withdraw":
+          return ok("stake", programId, "withdraw", {});
+        case "Deactivate":
+          return ok("stake", programId, "deactivate", {});
+        case "Merge":
+          return ok("stake", programId, "merge", {});
+      }
+    } catch {}
+
+    // Vote
+    try {
+      const t = VoteInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "InitializeAccount":
+          return ok("vote", programId, "initialize", {});
+        case "Authorize":
+          return ok("vote", programId, "authorize", {});
+        case "AuthorizeWithSeed":
+          return ok("vote", programId, "authorizeWithSeed", {});
+        case "Withdraw":
+          return ok("vote", programId, "withdraw", {});
+        default:
+          return ok("vote", programId, t, {});
+      }
+    } catch {}
+
+    // Address Lookup Table
+    try {
+      const t = AddressLookupTableInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "CreateLookupTable":
+        case "ExtendLookupTable":
+        case "CloseLookupTable":
+        case "FreezeLookupTable":
+        case "DeactivateLookupTable":
+          return ok("address-lookup-table", programId, t, {});
+      }
+    } catch {}
+
+    // Memo program: parse utf8 memo if possible
+    if (
+      programId === "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr" ||
+      programId === "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo"
+    ) {
+      try {
+        const bytes = _decodeBase58(dataBase58);
+        const memo = new TextDecoder().decode(bytes);
+        return ok("spl-memo", programId, "memo", { memo });
+      } catch {}
+      return ok("spl-memo", programId, "memo", {});
+    }
+
+    // Fallback: unknown program, return raw
+    return {
+      programId,
+      accounts: accounts.map((i) => accountKeys[i] || ""),
+      data: dataBase58,
+    };
+  } catch {
+    return {
+      programId,
+      accounts: accounts.map((i) => accountKeys[i] || ""),
+      data: dataBase58,
+    };
+  }
+}
+

package/server/methods/account/get-account-info.ts

@@ -79,12 +79,8 @@ export const getAccountInfo: RpcMethodHandler = async (id, params, context) => {
 			context: { slot: Number(context.slot) },
 			value: accountInfo,
 		});
-	} 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/account/get-balance.ts

@@ -16,12 +16,8 @@ export const getBalance: RpcMethodHandler = (id, params, context) => {
 			context: { slot: Number(context.slot) },
 			value: Number(balance || 0n),
 		});
-	} 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/account/get-multiple-accounts.ts

@@ -1,5 +1,6 @@
 import { PublicKey } from "@solana/web3.js";
 import type { RpcMethodHandler } from "../../types";
+import type { AccountSnapshot } from "../../../src/db/tx-store";
 
 /**
  * Implements the getMultipleAccounts RPC method
@@ -54,7 +55,7 @@ export const getMultipleAccounts: RpcMethodHandler = async (
 
 	// Opportunistic index update
 	try {
-		const snaps: any[] = [];
+		const snaps: AccountSnapshot[] = [];
 		for (const pubkeyStr of pubkeys) {
 			try {
 				const pubkey = new PublicKey(pubkeyStr);

package/server/methods/account/get-parsed-account-info.ts

@@ -10,12 +10,8 @@ export const getParsedAccountInfo: RpcMethodHandler = async (
 	const cfg = { ...(config || {}), encoding: "jsonParsed" };
 	try {
 		return await getAccountInfo(id, [pubkey, 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/account/parsers/index.ts

@@ -6,7 +6,7 @@ import { parseSystemAccount } from "./system";
 
 export type ParsedAccountData = {
 	program: string;
-	parsed: any; // match Solana RPC jsonParsed payloads
+	parsed: unknown; // match Solana RPC jsonParsed payloads
 	space: number;
 } | null;
 
@@ -32,7 +32,7 @@ export function parseAccountJson(
 	const dataBytes =
 		account.data instanceof Uint8Array
 			? account.data
-			: Buffer.from(account.data as any);
+			: Buffer.from(account.data as ReadonlyArray<number>);
 	const space = dataBytes.length;
 
 	// 1) System program

package/server/methods/account/parsers/loader-upgradeable.ts

@@ -12,7 +12,20 @@ export function parseUpgradeableLoader(
 	const bytes = data;
 	const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 	const space = bytes.length;
-	let parsed: any = null;
+	type UpgradeableParsed =
+		| { type: "program"; info: { programData: string } }
+		| {
+				type: "programData";
+				info: {
+					slot: number;
+					upgradeAuthority: string | null;
+					authority: string | null;
+					data: [string, "base64"];
+				};
+		  }
+		| { type: "buffer"; info: { authority: string | null } }
+		| null;
+	let parsed: UpgradeableParsed = null;
 	try {
 		if (bytes.length >= 4) {
 			const tag = dv.getUint32(0, true);

package/server/methods/account/parsers/spl-token.ts

@@ -51,10 +51,17 @@ export function parseSplTokenAccountOrMint(
 			try {
 				const mintAcc = context.svm.getAccount(dec.mint);
 				if (mintAcc) {
-					const mintOwner =
-						typeof (mintAcc as any).owner?.toBase58 === "function"
-							? ((mintAcc as any).owner as PublicKey)
-							: new PublicKey(mintAcc.owner);
+					const rawOwner = (mintAcc as { owner?: unknown }).owner;
+					const mintOwner = ((): PublicKey => {
+						if (
+							rawOwner &&
+							typeof (rawOwner as { toBase58?: unknown }).toBase58 ===
+								"function"
+						) {
+							return rawOwner as PublicKey;
+						}
+						return new PublicKey(String(rawOwner));
+					})();
 					const mintProg = mintOwner.equals(TOKEN_2022_PROGRAM_ID)
 						? TOKEN_2022_PROGRAM_ID
 						: TOKEN_PROGRAM_ID;
@@ -176,18 +183,18 @@ function buildAccountExtensions(account: {
 
 function buildMintExtensions(mint: {
 	tlvData: Buffer;
-}): Array<Record<string, any>> | undefined {
+}): Array<Record<string, unknown>> | undefined {
 	if (!mint.tlvData || mint.tlvData.length === 0) return undefined;
 	const types = getExtensionTypes(mint.tlvData);
 	if (!types.length) return undefined;
-	const out: Array<Record<string, any>> = [];
+	const out: Array<Record<string, unknown>> = [];
 	for (const ext of types) {
-		const entry: Record<string, any> = {
+		const entry: Record<string, unknown> = {
 			type: ExtensionType[ext] ?? String(ext),
 		};
 		try {
 			if (ext === ExtensionType.MetadataPointer) {
-				const state = getMetadataPointerState(mint as any);
+				const state = getMetadataPointerState(mint as { tlvData: Buffer });
 				if (state) {
 					entry.info = {
 						authority: state.authority ? state.authority.toBase58() : null,
@@ -222,9 +229,21 @@ function buildMintExtensions(mint: {
 	return out.length ? out : undefined;
 }
 
-function toAccountInfo(raw: any, owner: PublicKey): AccountInfo<Buffer> {
+function toAccountInfo(
+	raw: {
+		data?: Buffer | Uint8Array | number[];
+		lamports?: number | bigint;
+		executable?: boolean;
+		rentEpoch?: number | bigint;
+	},
+	owner: PublicKey,
+): AccountInfo<Buffer> {
 	const data =
-		raw.data instanceof Buffer ? raw.data : Buffer.from(raw.data ?? []);
+		raw.data instanceof Buffer
+			? raw.data
+			: raw.data instanceof Uint8Array
+				? Buffer.from(raw.data)
+				: Buffer.from((raw.data ?? []) as number[]);
 	return {
 		data,
 		executable: !!raw.executable,