solforge 0.2.12 → 0.2.14

package/server/lib/parsers/spl-token.ts

@@ -1,340 +0,0 @@
-import type { PublicKey, TransactionInstruction } from "@solana/web3.js";
-import {
-    decodeMintToCheckedInstruction,
-    decodeTransferInstruction,
-    decodeTransferCheckedInstruction,
-    decodeInitializeAccount3Instruction,
-    decodeInitializeImmutableOwnerInstruction,
-    decodeTransferCheckedInstructionUnchecked,
-    decodeTransferInstructionUnchecked,
-    decodeInitializeAccount3InstructionUnchecked,
-    decodeInitializeImmutableOwnerInstructionUnchecked,
-} from "@solana/spl-token";
-import { u8 } from "@solana/buffer-layout";
-import { PublicKey as PK } from "@solana/web3.js";
-import {
-    TOKEN_PROGRAM_ID as TOKEN_PROGRAM_V1,
-    TOKEN_2022_PROGRAM_ID as TOKEN_PROGRAM_2022,
-    getAssociatedTokenAddressSync,
-} from "@solana/spl-token";
-
-// Keep shape compatible with instruction-parser
-export type ParsedInstruction =
-	| {
-			program: string;
-			programId: string;
-			parsed: { type: string; info: unknown };
-	  }
-	| { programId: string; accounts: string[]; data: string };
-
-function ok(programId: string, type: string, info: unknown): ParsedInstruction {
-    // Use a single label for both SPL v1 and Token-2022 for compatibility with UIs
-    return { program: "spl-token", programId, parsed: { type, info } };
-}
-
-function asBase58(pk: PublicKey | undefined): string | undefined {
-	try {
-		return pk ? pk.toBase58() : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-export function tryParseSplToken(
-    ix: TransactionInstruction,
-    programIdStr: string,
-    _accountKeys: string[],
-    dataBase58: string,
-    tokenBalanceHints?: Array<{ mint: string; decimals: number }>,
-): ParsedInstruction | null {
-	try {
-		// Accept both SPL Token and Token-2022 program ids
-		// We pass the actual program id to decoders for strict match
-		const programPk = new PK(programIdStr);
-		// Don't early-return on program id; allow both programs
-
-		// MintToChecked
-		try {
-			const m = decodeMintToCheckedInstruction(ix, programPk);
-			const amount = m.data.amount;
-			const decimals = m.data.decimals;
-			const amtStr =
-				typeof amount === "bigint" ? amount.toString() : String(amount);
-			const base = BigInt(10) ** BigInt(decimals);
-			const whole = BigInt(amtStr) / base;
-			const frac = BigInt(amtStr) % base;
-			const fracStr = frac
-				.toString()
-				.padStart(decimals, "0")
-				.replace(/0+$/, "");
-			const uiStr = fracStr.length ? `${whole}.${fracStr}` : `${whole}`;
-			return ok(programIdStr, "mintToChecked", {
-				account: asBase58(m.keys.destination.pubkey),
-				mint: asBase58(m.keys.mint.pubkey),
-				mintAuthority: asBase58(m.keys.authority.pubkey),
-				tokenAmount: {
-					amount: amtStr,
-					decimals,
-					uiAmount: Number(uiStr),
-					uiAmountString: uiStr,
-				},
-			});
-		} catch {}
-
-		// Transfer / TransferChecked (strict)
-		try {
-			const t = decodeTransferInstruction(ix, programPk);
-			const amt = t.data.amount;
-			return ok(programIdStr, "transfer", {
-				amount: typeof amt === "bigint" ? amt.toString() : String(amt),
-				source: asBase58(t.keys.source.pubkey),
-				destination: asBase58(t.keys.destination.pubkey),
-				authority: asBase58(t.keys.owner.pubkey),
-			});
-		} catch {}
-
-		try {
-			const t = decodeTransferCheckedInstruction(ix, programPk);
-			const amt = t.data.amount;
-			const decimals = t.data.decimals;
-			return ok(programIdStr, "transferChecked", {
-				tokenAmount: {
-					amount: typeof amt === "bigint" ? amt.toString() : String(amt),
-					decimals,
-				},
-				source: asBase58(t.keys.source.pubkey),
-				destination: asBase58(t.keys.destination.pubkey),
-				authority: asBase58(t.keys.owner.pubkey),
-				mint: asBase58(t.keys.mint.pubkey),
-			});
-		} catch {}
-
-		// InitializeAccount3 (strict)
-		try {
-			const a = decodeInitializeAccount3Instruction(ix, programPk);
-			return ok(programIdStr, "initializeAccount3", {
-				account: asBase58(a.keys.account.pubkey),
-				mint: asBase58(a.keys.mint.pubkey),
-				owner: asBase58(a.data.owner),
-			});
-		} catch {}
-
-		// InitializeImmutableOwner
-		try {
-			const im = decodeInitializeImmutableOwnerInstruction(ix, programPk);
-			return ok(programIdStr, "initializeImmutableOwner", {
-				account: asBase58(im.keys.account.pubkey),
-			});
-		} catch {}
-
-		// GetAccountDataSize: decode extension types (u16 little-endian sequence)
-		try {
-			const bytes = Buffer.from(bs58decode(dataBase58));
-			const t = u8().decode(bytes);
-			// 21 corresponds to TokenInstruction.GetAccountDataSize
-			if (t === 21) {
-				const mint = asBase58(ix.keys[0]?.pubkey);
-				const extCodes: number[] = [];
-				for (let i = 1; i + 1 < bytes.length; i += 2) {
-					const code = bytes[i] | (bytes[i + 1] << 8);
-					extCodes.push(code);
-				}
-				const extMap: Record<number, string> = {
-					7: "immutableOwner",
-					8: "memoTransfer",
-					9: "nonTransferable",
-					12: "permanentDelegate",
-					14: "transferHook",
-					15: "transferHookAccount",
-					18: "metadataPointer",
-					19: "tokenMetadata",
-					20: "groupPointer",
-					21: "tokenGroup",
-					22: "groupMemberPointer",
-					23: "tokenGroupMember",
-					25: "scaledUiAmountConfig",
-					26: "pausableConfig",
-					27: "pausableAccount",
-				};
-				const extensionTypes = extCodes.map((c) => extMap[c] || String(c));
-				return ok(programIdStr, "getAccountDataSize", { mint, extensionTypes });
-			}
-		} catch {}
-
-		// Unchecked fallbacks: decode data fields even if keys/validation missing
-		try {
-			const raw = bs58decode(dataBase58);
-			const op = raw[0];
-			// Transfer
-			if (op === 3) {
-				const t = decodeTransferInstructionUnchecked(ix);
-				const amt = t.data.amount;
-				return ok(programIdStr, "transfer", {
-					amount: typeof amt === "bigint" ? amt.toString() : String(amt),
-					source: asBase58(t.keys.source?.pubkey),
-					destination: asBase58(t.keys.destination?.pubkey),
-					authority: asBase58(t.keys.owner?.pubkey),
-				});
-			}
-			// TransferChecked
-            if (op === 12) {
-                const t = decodeTransferCheckedInstructionUnchecked(ix);
-                const amt = t.data.amount;
-                const decimals = t.data.decimals;
-                const hintMint = (() => {
-                    try {
-                        const dec = Number(decimals);
-                        const candidates = (tokenBalanceHints || []).filter(
-                            (h) => Number(h.decimals) === dec,
-                        );
-                        if (candidates.length === 1) return candidates[0].mint;
-                        // Prefer non-zero decimals over 0 (filters out native 4uQe mint in many cases)
-                        const nonZero = candidates.filter((c) => c.decimals > 0);
-                        if (nonZero.length === 1) return nonZero[0].mint;
-                        // Fall back to first candidate if multiple
-                        return candidates[0]?.mint;
-                    } catch {
-                        return undefined;
-                    }
-                })();
-                return ok(programIdStr, "transferChecked", {
-                    tokenAmount: {
-                        amount: typeof amt === "bigint" ? amt.toString() : String(amt),
-                        decimals,
-                    },
-                    source: asBase58(t.keys.source?.pubkey),
-                    destination: asBase58(t.keys.destination?.pubkey),
-                    authority: asBase58(t.keys.owner?.pubkey),
-                    mint: asBase58(t.keys.mint?.pubkey) || hintMint,
-                });
-            }
-			// InitializeAccount3
-            if (op === 18) {
-                const a = decodeInitializeAccount3InstructionUnchecked(ix);
-                const hintMint = (() => {
-                    try {
-                        // Prefer single non-zero-decimals mint in this tx
-                        const nonZero = (tokenBalanceHints || []).filter(
-                            (h) => h.decimals > 0,
-                        );
-                        if (nonZero.length === 1) return nonZero[0].mint;
-                        // Fall back to first available mint
-                        return (tokenBalanceHints || [])[0]?.mint;
-                    } catch {
-                        return undefined;
-                    }
-                })();
-                const ownerStr = asBase58(a.data.owner);
-                const mintStr = asBase58(a.keys.mint?.pubkey) || hintMint;
-                let accountStr = asBase58(a.keys.account?.pubkey);
-                try {
-                    if (!accountStr && ownerStr && mintStr) {
-                        const ownerPk = new PK(ownerStr);
-                        const mintPk = new PK(mintStr);
-                        const programId =
-                            programIdStr === TOKEN_PROGRAM_2022.toBase58()
-                                ? TOKEN_PROGRAM_2022
-                                : TOKEN_PROGRAM_V1;
-                        const ata = getAssociatedTokenAddressSync(
-                            mintPk,
-                            ownerPk,
-                            true,
-                            programId,
-                        );
-                        accountStr = ata.toBase58();
-                    }
-                } catch {}
-                return ok(programIdStr, "initializeAccount3", {
-                    account: accountStr,
-                    mint: mintStr,
-                    owner: ownerStr,
-                });
-            }
-			// InitializeImmutableOwner
-			if (op === 22) {
-				const im = decodeInitializeImmutableOwnerInstructionUnchecked(ix);
-				return ok(programIdStr, "initializeImmutableOwner", {
-					account: asBase58(im.keys.account?.pubkey),
-				});
-			}
-		} catch {}
-
-		// Fallback: classify by TokenInstruction opcode (first byte) when nothing else matched
-		try {
-			const raw = bs58decode(dataBase58);
-			if (raw.length > 0) {
-				const op = raw[0];
-				const map: Record<number, string> = {
-					0: "initializeMint",
-					1: "initializeAccount",
-					2: "initializeMultisig",
-					3: "transfer",
-					4: "approve",
-					5: "revoke",
-					6: "setAuthority",
-					7: "mintTo",
-					8: "burn",
-					9: "closeAccount",
-					10: "freezeAccount",
-					11: "thawAccount",
-					12: "transferChecked",
-					13: "approveChecked",
-					14: "mintToChecked",
-					15: "burnChecked",
-					16: "initializeAccount2",
-					17: "syncNative",
-					18: "initializeAccount3",
-					19: "initializeMultisig2",
-					20: "initializeMint2",
-					21: "getAccountDataSize",
-					22: "initializeImmutableOwner",
-					23: "amountToUiAmount",
-					24: "uiAmountToAmount",
-					25: "initializeMintCloseAuthority",
-					26: "transferFeeExtension",
-					27: "confidentialTransferExtension",
-					28: "defaultAccountStateExtension",
-					29: "reallocate",
-					30: "memoTransferExtension",
-					31: "createNativeMint",
-					32: "initializeNonTransferableMint",
-					33: "interestBearingMintExtension",
-					34: "cpiGuardExtension",
-					35: "initializePermanentDelegate",
-					36: "transferHookExtension",
-					39: "metadataPointerExtension",
-					40: "groupPointerExtension",
-					41: "groupMemberPointerExtension",
-					43: "scaledUiAmountExtension",
-					44: "pausableExtension",
-				};
-				const type = map[op];
-				if (type) return ok(programIdStr, type, {});
-			}
-		} catch {}
-
-		// Unknown SPL token instruction (unrecognized opcode)
-		return null;
-	} catch {
-		return null;
-	}
-}
-
-// Local base58 decode to avoid importing from sibling file
-const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-const BASE = BigInt(ALPHABET.length);
-function bs58decode(str: string): Uint8Array {
-	let num = 0n;
-	for (const char of str) {
-		const index = ALPHABET.indexOf(char);
-		if (index === -1) throw new Error("Invalid base58 character");
-		num = num * BASE + BigInt(index);
-	}
-	const bytes: number[] = [];
-	while (num > 0n) {
-		bytes.unshift(Number(num % 256n));
-		num = num / 256n;
-	}
-	for (let i = 0; i < str.length && str[i] === "1"; i++) bytes.unshift(0);
-	return new Uint8Array(bytes.length > 0 ? bytes : [0]);
-}

package/server/lib/spl-token.ts

@@ -1,57 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-
-export const TOKEN_PROGRAM_ID = new PublicKey(
-	"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
-);
-
-// Minimal SPL Token v1 layouts
-export type DecodedMint = {
-	supply: bigint;
-	decimals: number;
-	isInitialized: boolean;
-};
-
-export type DecodedTokenAccount = {
-	mint: string;
-	owner: string;
-	amount: bigint;
-	state: number;
-	delegatedAmount: bigint;
-};
-
-export function decodeMint(data: Uint8Array): DecodedMint | null {
-	if (!data || data.length < 82) return null;
-	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-	// supply at offset 36? Common layout: 4 (opt) + 32 (auth) + 8 (supply) + 1 (dec) + 1 (init)
-	const supply = view.getBigUint64(36, true);
-	const decimals = view.getUint8(44);
-	const isInitialized = view.getUint8(45) !== 0;
-	return { supply, decimals, isInitialized };
-}
-
-export function decodeTokenAccount(
-	data: Uint8Array,
-): DecodedTokenAccount | null {
-	if (!data || data.length < 165) return null;
-	const mint = new PublicKey(data.slice(0, 32)).toBase58();
-	const owner = new PublicKey(data.slice(32, 64)).toBase58();
-	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-	const amount = view.getBigUint64(64, true);
-	const state = data[108];
-	const delegatedAmount = view.getBigUint64(124, true);
-	return { mint, owner, amount, state, delegatedAmount };
-}
-
-export function formatUiAmount(amount: bigint, decimals: number) {
-	const base = BigInt(10) ** BigInt(decimals);
-	const whole = amount / base;
-	const frac = amount % base;
-	const fracStr = frac.toString().padStart(decimals, "0").replace(/0+$/, "");
-	const ui = fracStr.length > 0 ? `${whole}.${fracStr}` : `${whole}`;
-	return {
-		amount: amount.toString(),
-		decimals,
-		uiAmount: Number(ui),
-		uiAmountString: ui,
-	};
-}

package/server/methods/TEMPLATE.md

@@ -1,117 +0,0 @@
-# RPC Method Template
-
-Use this template when adding new RPC methods to SolForge.
-
-## File Template
-
-```typescript
-import { PublicKey } from "@solana/web3.js"; // Only if needed
-import type { RpcMethodHandler } from "../types"; // Adjust path based on location
-
-/**
- * Implements the methodName RPC method
- * @see https://docs.solana.com/api/http#methodname
- */
-export const methodName: RpcMethodHandler = (id, params, context) => {
-  // 1. Parse parameters
-  const [param1, param2, config] = params;
-  
-  // 2. Validate parameters (if needed)
-  if (!param1) {
-    return context.createErrorResponse(
-      id,
-      -32602,
-      "Missing required parameter: param1"
-    );
-  }
-  
-  try {
-    // 3. Execute the RPC logic
-    const result = context.svm.someOperation();
-    
-    // 4. Format and return the response
-    return context.createSuccessResponse(id, {
-      context: { 
-        slot: Number(context.slot),
-        apiVersion: "1.18.0" // If needed
-      },
-      value: result
-    });
-  } catch (error: any) {
-    // 5. Handle errors appropriately
-    return context.createErrorResponse(
-      id,
-      -32603, // Use appropriate error code
-      "Operation failed",
-      error.message
-    );
-  }
-};
-```
-
-## Common Patterns
-
-### Methods that modify state
-```typescript
-// After successful operation, increment slot/blockHeight
-if (success) {
-  // This is handled in the main server now
-  // Just return success response
-  return context.createSuccessResponse(id, signature);
-}
-```
-
-### Methods with optional config
-```typescript
-const [address, config] = params;
-const encoding = config?.encoding || "base64";
-const commitment = config?.commitment || "confirmed";
-```
-
-### Batch operations
-```typescript
-const results = addresses.map(addr => {
-  try {
-    // Process each item
-    return processItem(addr);
-  } catch {
-    // Return null for failed items
-    return null;
-  }
-});
-```
-
-## Error Codes Reference
-
-- `-32700`: Parse error (JSON parsing failed)
-- `-32600`: Invalid request (not a valid JSON-RPC request)
-- `-32601`: Method not found
-- `-32602`: Invalid params
-- `-32603`: Internal error
-- `-32000`: Generic server error
-- `-32001`: Resource not found
-- `-32002`: Resource unavailable
-- `-32003`: Transaction rejected
-- `-32004`: Method not supported
-- `-32005`: Limit exceeded
-
-## Checklist
-
-Before committing a new RPC method:
-
-- [ ] Method follows naming convention (camelCase)
-- [ ] File uses kebab-case naming
-- [ ] Proper TypeScript types used
-- [ ] Error handling implemented
-- [ ] Success case tested
-- [ ] Error cases tested
-- [ ] Added to methods/index.ts
-- [ ] Documentation updated in README.md
-- [ ] Follows SolForge patterns
-
-## Examples in Codebase
-
-- Simple query: See `get-balance.ts`
-- Complex response: See `get-account-info.ts`
-- Transaction handling: See `send-transaction.ts`
-- Batch operation: See `get-multiple-accounts.ts`

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

@@ -1,86 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import type { RpcMethodHandler } from "../../types";
-import { parseAccountJson } from "./parsers";
-
-/**
- * Implements the getAccountInfo RPC method
- * @see https://docs.solana.com/api/http#getaccountinfo
- */
-export const getAccountInfo: RpcMethodHandler = async (id, params, context) => {
-	const [pubkeyStr, config] = params;
-	const encoding = config?.encoding || "base64";
-
-	try {
-		const pubkey = new PublicKey(pubkeyStr);
-		const account = context.svm.getAccount(pubkey);
-
-		if (!account) {
-			return context.createSuccessResponse(id, {
-				context: { slot: Number(context.slot) },
-				value: null,
-			});
-		}
-
-		const owner = new PublicKey(account.owner).toBase58();
-		// Opportunistic index update
-		try {
-			await context.store?.upsertAccounts([
-				{
-					address: pubkey.toBase58(),
-					lamports: Number(account.lamports || 0n),
-					ownerProgram: owner,
-					executable: !!account.executable,
-					rentEpoch: Number(account.rentEpoch || 0),
-					dataLen: account.data?.length ?? 0,
-					dataBase64: undefined,
-					lastSlot: Number(context.slot),
-				},
-			]);
-		} catch {}
-
-		if (encoding === "jsonParsed") {
-			const parsed = parseAccountJson(
-				pubkey,
-				{
-					owner: new PublicKey(account.owner),
-					data: account.data ? new Uint8Array(account.data) : new Uint8Array(),
-					lamports: account.lamports,
-					executable: account.executable,
-					rentEpoch: account.rentEpoch,
-				},
-				context,
-			);
-
-			return context.createSuccessResponse(id, {
-				context: { slot: Number(context.slot) },
-				value: {
-					lamports: Number(account.lamports),
-					owner,
-					executable: account.executable,
-					rentEpoch: Number(account.rentEpoch || 0),
-					data: parsed || {
-						program: "unknown",
-						parsed: null,
-						space: account.data?.length ?? 0,
-					},
-				},
-			});
-		}
-
-		const accountInfo = {
-			lamports: Number(account.lamports),
-			owner,
-			data: [Buffer.from(account.data).toString("base64"), "base64"] as const,
-			executable: account.executable,
-			rentEpoch: Number(account.rentEpoch || 0),
-		};
-
-		return context.createSuccessResponse(id, {
-			context: { slot: Number(context.slot) },
-			value: accountInfo,
-		});
-	} 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

@@ -1,23 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import type { RpcMethodHandler } from "../../types";
-
-/**
- * Implements the getBalance RPC method
- * @see https://docs.solana.com/api/http#getbalance
- */
-export const getBalance: RpcMethodHandler = (id, params, context) => {
-	const [pubkeyStr] = params;
-
-	try {
-		const pubkey = new PublicKey(pubkeyStr);
-		const balance = context.svm.getBalance(pubkey);
-
-		return context.createSuccessResponse(id, {
-			context: { slot: Number(context.slot) },
-			value: Number(balance || 0n),
-		});
-	} 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,84 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import type { RpcMethodHandler } from "../../types";
-import type { AccountSnapshot } from "../../../src/db/tx-store";
-
-/**
- * Implements the getMultipleAccounts RPC method
- * @see https://docs.solana.com/api/http#getmultipleaccounts
- */
-export const getMultipleAccounts: RpcMethodHandler = async (
-	id,
-	params,
-	context,
-) => {
-	const [pubkeys, config] = params;
-	const encoding = config?.encoding || "base64";
-
-	const accounts = pubkeys.map((pubkeyStr: string) => {
-		try {
-			const pubkey = new PublicKey(pubkeyStr);
-			const account = context.svm.getAccount(pubkey);
-
-			if (!account) {
-				return null;
-			}
-
-			const owner = new PublicKey(account.owner).toBase58();
-			if (encoding === "jsonParsed") {
-				const program =
-					owner === "11111111111111111111111111111111" ? "system" : "unknown";
-				const space = account.data?.length ?? 0;
-				return {
-					lamports: Number(account.lamports),
-					owner,
-					executable: account.executable,
-					rentEpoch: Number(account.rentEpoch || 0),
-					data: {
-						program,
-						parsed: program === "system" ? { type: "account", info: {} } : null,
-						space,
-					},
-				};
-			}
-
-			return {
-				lamports: Number(account.lamports),
-				owner,
-				data: [Buffer.from(account.data).toString("base64"), "base64"] as const,
-				executable: account.executable,
-				rentEpoch: Number(account.rentEpoch || 0),
-			};
-		} catch {
-			return null;
-		}
-	});
-
-	// Opportunistic index update
-	try {
-		const snaps: AccountSnapshot[] = [];
-		for (const pubkeyStr of pubkeys) {
-			try {
-				const pubkey = new PublicKey(pubkeyStr);
-				const acc = context.svm.getAccount(pubkey);
-				if (!acc) continue;
-				const owner = new PublicKey(acc.owner).toBase58();
-				snaps.push({
-					address: pubkey.toBase58(),
-					lamports: Number(acc.lamports || 0n),
-					ownerProgram: owner,
-					executable: !!acc.executable,
-					rentEpoch: Number(acc.rentEpoch || 0),
-					dataLen: acc.data?.length ?? 0,
-					dataBase64: undefined,
-					lastSlot: Number(context.slot),
-				});
-			} catch {}
-		}
-		if (snaps.length) await context.store?.upsertAccounts(snaps);
-	} catch {}
-
-	return context.createSuccessResponse(id, {
-		context: { slot: Number(context.slot) },
-		value: accounts,
-	});
-};