solforge 0.2.12 → 0.2.13

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

@@ -1,17 +0,0 @@
-import type { RpcMethodHandler } from "../../types";
-import { getAccountInfo } from "./get-account-info";
-
-export const getParsedAccountInfo: RpcMethodHandler = async (
-	id,
-	params,
-	context,
-) => {
-	const [pubkey, config] = params || [];
-	const cfg = { ...(config || {}), encoding: "jsonParsed" };
-	try {
-		return await getAccountInfo(id, [pubkey, cfg], context);
-	} catch (error: unknown) {
-		const message = error instanceof Error ? error.message : String(error);
-		return context.createErrorResponse(id, -32603, "Internal error", message);
-	}
-};

package/server/methods/account/index.ts

@@ -1,12 +0,0 @@
-/**
- * Account-related RPC methods
- *
- * This module contains all account-related RPC methods.
- * Each method is in its own file to maintain modularity.
- */
-
-export { getAccountInfo } from "./get-account-info";
-export { getBalance } from "./get-balance";
-export { getMultipleAccounts } from "./get-multiple-accounts";
-export { getParsedAccountInfo } from "./get-parsed-account-info";
-export { requestAirdrop } from "./request-airdrop";

package/server/methods/account/parsers/index.ts

@@ -1,52 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import type { RpcMethodContext } from "../../../server/types";
-import { parseUpgradeableLoader } from "./loader-upgradeable";
-import { parseSplTokenAccountOrMint } from "./spl-token";
-import { parseSystemAccount } from "./system";
-
-export type ParsedAccountData = {
-	program: string;
-	parsed: unknown; // match Solana RPC jsonParsed payloads
-	space: number;
-} | null;
-
-export function parseAccountJson(
-	pubkey: PublicKey,
-	account: {
-		owner: PublicKey | string;
-		data: Uint8Array | Buffer | number[];
-		lamports: bigint | number;
-		executable?: boolean;
-		rentEpoch?: bigint | number;
-	},
-	context: RpcMethodContext,
-): ParsedAccountData {
-	const ownerStr =
-		typeof account.owner === "string"
-			? account.owner
-			: new PublicKey(account.owner).toBase58();
-	const ownerPk =
-		typeof account.owner === "string"
-			? new PublicKey(account.owner)
-			: (account.owner as PublicKey);
-	const dataBytes =
-		account.data instanceof Uint8Array
-			? account.data
-			: Buffer.from(account.data as ReadonlyArray<number>);
-	const space = dataBytes.length;
-
-	// 1) System program
-	const sys = parseSystemAccount(ownerStr, space);
-	if (sys) return sys;
-
-	// 2) SPL Token (v1) & Token-2022
-	const token = parseSplTokenAccountOrMint(pubkey, ownerPk, dataBytes, context);
-	if (token) return token;
-
-	// 3) BPF Upgradeable Loader
-	const loader = parseUpgradeableLoader(ownerStr, dataBytes, context);
-	if (loader) return loader;
-
-	// 4) Unknown
-	return { program: "unknown", parsed: null, space };
-}

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

@@ -1,79 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import type { RpcMethodContext } from "../../../server/types";
-
-const LOADER_UPGRADEABLE = "BPFLoaderUpgradeab1e11111111111111111111111";
-
-export function parseUpgradeableLoader(
-	owner: string,
-	data: Uint8Array,
-	context: RpcMethodContext,
-) {
-	if (owner !== LOADER_UPGRADEABLE) return null;
-	const bytes = data;
-	const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	const space = bytes.length;
-	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);
-			if (tag === 2 && bytes.length >= 36) {
-				// Program: [u32 tag][32 programDataPubkey]
-				const pd = new PublicKey(bytes.slice(4, 36)).toBase58();
-				parsed = { type: "program", info: { programData: pd } };
-			} else if (tag === 3 && bytes.length >= 4 + 8 + 1) {
-				// ProgramData: [u32 tag][u64 slot][Option<Pubkey> upgradeAuthority]
-				const slot = Number(dv.getBigUint64(4, true));
-				let upgradeAuthority: string | null = null;
-				const opt = dv.getUint8(12);
-				let hdr = 13; // after u8 option
-				if (opt === 1 && bytes.length >= 13 + 32) {
-					upgradeAuthority = new PublicKey(bytes.slice(13, 45)).toBase58();
-					hdr = 45;
-				} else if (opt === 0) {
-					hdr = 13;
-				} else if (bytes.length >= 12 + 4) {
-					// Fallback u32 option at offset 12
-					const opt32 = dv.getUint32(12, true);
-					hdr = 16;
-					if (opt32 === 1 && bytes.length >= 16 + 32) {
-						upgradeAuthority = new PublicKey(bytes.slice(16, 48)).toBase58();
-						hdr = 48;
-					}
-				}
-				const programBytes = bytes.slice(hdr);
-				parsed = {
-					type: "programData",
-					info: {
-						slot: slot === 0 ? Number(context.slot) : slot,
-						upgradeAuthority,
-						authority: upgradeAuthority,
-						data: [Buffer.from(programBytes).toString("base64"), "base64"],
-					},
-				};
-			} else if (tag === 1) {
-				// Buffer: [u32 tag][Option<Pubkey> authority]
-				let authority: string | null = null;
-				if (bytes.length >= 5) {
-					const hasAuth = dv.getUint8(4);
-					if (hasAuth === 1 && bytes.length >= 5 + 32)
-						authority = new PublicKey(bytes.slice(5, 37)).toBase58();
-				}
-				parsed = { type: "buffer", info: { authority } };
-			}
-		}
-	} catch {}
-	return { program: "bpf-upgradeable-loader", parsed, space };
-}

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

@@ -1,256 +0,0 @@
-import {
-	ExtensionType,
-	getExtensionData,
-	getExtensionTypes,
-	getMetadataPointerState,
-	TOKEN_2022_PROGRAM_ID,
-	TOKEN_PROGRAM_ID,
-	unpackAccount,
-	unpackMint,
-} from "@solana/spl-token";
-import { unpack as unpackTokenMetadata } from "@solana/spl-token-metadata";
-import { type AccountInfo, PublicKey } from "@solana/web3.js";
-import type { RpcMethodContext } from "../../../server/types";
-
-export function parseSplTokenAccountOrMint(
-	pubkey: PublicKey,
-	ownerPk: PublicKey,
-	data: Uint8Array,
-	context: RpcMethodContext,
-) {
-	const isTokenOwner =
-		ownerPk.equals(TOKEN_PROGRAM_ID) || ownerPk.equals(TOKEN_2022_PROGRAM_ID);
-	if (!isTokenOwner) return null;
-	const programPk = ownerPk.equals(TOKEN_2022_PROGRAM_ID)
-		? TOKEN_2022_PROGRAM_ID
-		: TOKEN_PROGRAM_ID;
-	const programLabel = ownerPk.equals(TOKEN_2022_PROGRAM_ID)
-		? "spl-token-2022"
-		: "spl-token";
-	const space = data.length;
-
-	// Try token account first
-	if (space >= 165) {
-		try {
-			const dec = unpackAccount(
-				pubkey,
-				toAccountInfo(
-					{
-						data,
-						lamports: 0,
-						owner: ownerPk,
-						executable: false,
-						rentEpoch: 0,
-					},
-					ownerPk,
-				),
-				programPk,
-			);
-			// fetch mint decimals
-			let decimals = 0;
-			try {
-				const mintAcc = context.svm.getAccount(dec.mint);
-				if (mintAcc) {
-					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;
-					const mi = unpackMint(
-						dec.mint,
-						toAccountInfo(mintAcc, mintOwner),
-						mintProg,
-					);
-					decimals = mi?.decimals ?? 0;
-				}
-			} catch {}
-			const amount = BigInt(dec.amount?.toString?.() ?? dec.amount ?? 0);
-			const ui = Number.isFinite(decimals)
-				? Number(amount) / 10 ** decimals
-				: null;
-			const state = dec.isFrozen
-				? "frozen"
-				: dec.isInitialized
-					? "initialized"
-					: "uninitialized";
-			const delegated = BigInt(
-				dec.delegatedAmount?.toString?.() ?? dec.delegatedAmount ?? 0n,
-			);
-			const delegatedUi = Number.isFinite(decimals)
-				? Number(delegated) / 10 ** decimals
-				: null;
-			const rentExemptReserve = dec.isNative
-				? {
-						amount: BigInt(
-							dec.rentExemptReserve?.toString?.() ?? dec.rentExemptReserve ?? 0,
-						).toString(),
-						decimals: 9,
-						uiAmount: null,
-						uiAmountString: "0",
-					}
-				: null;
-			const extensions = buildAccountExtensions(dec);
-			return {
-				program: programLabel,
-				parsed: {
-					type: "account",
-					info: {
-						mint: dec.mint.toBase58(),
-						owner: dec.owner.toBase58(),
-						tokenAmount: {
-							amount: amount.toString(),
-							decimals,
-							uiAmount: ui,
-							uiAmountString: (ui ?? 0).toString(),
-						},
-						state,
-						isNative: !!dec.isNative,
-						delegatedAmount: {
-							amount: delegated.toString(),
-							decimals,
-							uiAmount: delegatedUi,
-							uiAmountString: (delegatedUi ?? 0).toString(),
-						},
-						delegate: dec.delegate ? dec.delegate.toBase58() : null,
-						rentExemptReserve,
-						closeAuthority: dec.closeAuthority
-							? dec.closeAuthority.toBase58()
-							: null,
-						extensions,
-					},
-				},
-				space,
-			};
-		} catch {}
-	}
-
-	// Try mint
-	try {
-		const dec = unpackMint(
-			pubkey,
-			toAccountInfo(
-				{ data, lamports: 0, owner: ownerPk, executable: false, rentEpoch: 0 },
-				ownerPk,
-			),
-			programPk,
-		);
-		const supply = BigInt(dec.supply?.toString?.() ?? dec.supply ?? 0);
-		const mintAuthority = dec.mintAuthority
-			? dec.mintAuthority.toBase58()
-			: null;
-		const freezeAuthority = dec.freezeAuthority
-			? dec.freezeAuthority.toBase58()
-			: null;
-		const extensions = buildMintExtensions(dec);
-		return {
-			program: programLabel,
-			parsed: {
-				type: "mint",
-				info: {
-					mintAuthority,
-					supply: supply.toString(),
-					decimals: dec.decimals,
-					isInitialized: !!dec.isInitialized,
-					freezeAuthority,
-					extensions,
-				},
-			},
-			space,
-		};
-	} catch {}
-
-	// Fallback if not parsed
-	return { program: programLabel, parsed: null, space };
-}
-
-function buildAccountExtensions(account: {
-	tlvData: Buffer;
-}): Array<{ type: string }> | undefined {
-	if (!account.tlvData || account.tlvData.length === 0) return undefined;
-	const types = getExtensionTypes(account.tlvData);
-	if (!types.length) return undefined;
-	return types.map((ext) => ({ type: ExtensionType[ext] ?? String(ext) }));
-}
-
-function buildMintExtensions(mint: {
-	tlvData: Buffer;
-}): 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, unknown>> = [];
-	for (const ext of types) {
-		const entry: Record<string, unknown> = {
-			type: ExtensionType[ext] ?? String(ext),
-		};
-		try {
-			if (ext === ExtensionType.MetadataPointer) {
-				const state = getMetadataPointerState(mint as { tlvData: Buffer });
-				if (state) {
-					entry.info = {
-						authority: state.authority ? state.authority.toBase58() : null,
-						metadataAddress: state.metadataAddress
-							? state.metadataAddress.toBase58()
-							: null,
-					};
-				}
-			} else if (ext === ExtensionType.TokenMetadata) {
-				const data = getExtensionData(ext, mint.tlvData);
-				if (data) {
-					const meta = unpackTokenMetadata(data);
-					entry.info = {
-						updateAuthority: meta.updateAuthority
-							? meta.updateAuthority.toBase58()
-							: null,
-						mint: meta.mint.toBase58(),
-						name: meta.name,
-						symbol: meta.symbol,
-						uri: meta.uri,
-						additionalMetadata: meta.additionalMetadata.map(([k, v]) => [k, v]),
-					};
-				}
-			}
-		} catch (error) {
-			try {
-				console.warn("[rpc] decode mint extension failed", error);
-			} catch {}
-		}
-		out.push(entry);
-	}
-	return out.length ? out : undefined;
-}
-
-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
-			: raw.data instanceof Uint8Array
-				? Buffer.from(raw.data)
-				: Buffer.from((raw.data ?? []) as number[]);
-	return {
-		data,
-		executable: !!raw.executable,
-		lamports: Number(
-			typeof raw.lamports === "bigint" ? raw.lamports : (raw.lamports ?? 0),
-		),
-		owner,
-		rentEpoch: Number(raw.rentEpoch ?? 0),
-	} as AccountInfo<Buffer>;
-}

package/server/methods/account/parsers/system.ts

@@ -1,4 +0,0 @@
-export function parseSystemAccount(owner: string, space: number) {
-	if (owner !== "11111111111111111111111111111111") return null;
-	return { program: "system", parsed: { type: "account", info: {} }, space };
-}

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

@@ -1,271 +0,0 @@
-import {
-	PublicKey,
-	SystemProgram,
-	TransactionInstruction,
-	TransactionMessage,
-	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 = async (id, params, context) => {
-	const [pubkeyStr, lamports, _config] = params || [];
-
-	try {
-		const toPubkey = new PublicKey(pubkeyStr);
-		const faucet = context.getFaucet();
-		// Use SVM's latest blockhash; uniqueness ensured via memo nonce
-		let recentBlockhash: string | undefined;
-		try {
-			recentBlockhash = context.svm.latestBlockhash();
-		} catch {}
-		if (!recentBlockhash) {
-			const bh = new Uint8Array(32);
-			crypto.getRandomValues(bh);
-			recentBlockhash = context.encodeBase58(bh);
-		}
-
-		// No per-request top-up; faucet is funded heavily at startup
-
-		const ix = SystemProgram.transfer({
-			fromPubkey: faucet.publicKey,
-			toPubkey,
-			lamports: Number(BigInt(lamports)),
-		});
-		// Add a memo with random nonce to guarantee unique signatures
-		const memoProgramId = new PublicKey(
-			"MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr",
-		);
-		const nonce = new Uint8Array(8);
-		crypto.getRandomValues(nonce);
-		const memoIx = new TransactionInstruction({
-			keys: [],
-			programId: memoProgramId,
-			data: Buffer.from(`airdrop:${Buffer.from(nonce).toString("hex")}`),
-		});
-
-		const messageV0 = new TransactionMessage({
-			payerKey: faucet.publicKey,
-			recentBlockhash,
-			instructions: [ix, memoIx],
-		});
-		// Prefer legacy message for maximum LiteSVM compatibility
-		const compiled = messageV0.compileToLegacyMessage();
-
-		const tx = new VersionedTransaction(compiled);
-		tx.sign([faucet]);
-
-		// Compute pre balances for all static account keys
-		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) => {
-			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
-				? preBalances[toIndex]
-				: (() => {
-						try {
-							return Number(context.svm.getBalance(toPubkey));
-						} catch {
-							return 0;
-						}
-					})();
-
-		// 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 &&
-			typeof resp === "object" &&
-			"error" in (resp as Record<string, unknown>) &&
-			(resp as Record<string, unknown>).error != null
-		) {
-			return resp;
-		}
-		// Any send errors would have been returned by send-transaction already
-
-		let signature = (() => {
-			try {
-				const r = resp as Record<string, unknown>;
-				const v = r?.result;
-				return v == null ? "" : String(v);
-			} catch {
-				return "";
-			}
-		})();
-		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
-				? postBalances[toIndex]
-				: (() => {
-						try {
-							return Number(context.svm.getBalance(toPubkey));
-						} catch {
-							return 0;
-						}
-					})();
-		const expectedDelta = Number(BigInt(lamports));
-		if (afterTo - beforeTo < expectedDelta) {
-			// Retry once with fresh blockhash + memo
-			try {
-				const bh2 = new Uint8Array(32);
-				crypto.getRandomValues(bh2);
-				const rb2 = context.encodeBase58(bh2);
-				const memoProgramId2 = new PublicKey(
-					"MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr",
-				);
-				const nonce2 = new Uint8Array(8);
-				crypto.getRandomValues(nonce2);
-				const memoIx2 = new TransactionInstruction({
-					keys: [],
-					programId: memoProgramId2,
-					data: Buffer.from(
-						`airdrop-retry:${Buffer.from(nonce2).toString("hex")}`,
-					),
-				});
-				const msg2 = new TransactionMessage({
-					payerKey: faucet.publicKey,
-					recentBlockhash: rb2,
-					instructions: [ix, memoIx2],
-				}).compileToV0Message();
-				const tx2 = new VersionedTransaction(msg2);
-				tx2.sign([faucet]);
-				const res2 = context.svm.sendTransaction(tx2);
-				try {
-					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]
-					? context.encodeBase58(tx2.signatures[0])
-					: signature;
-				context.notifySignature(signature);
-				postBalances = staticKeys.map((pk) => {
-					try {
-						return Number(context.svm.getBalance(pk));
-					} catch {
-						return 0;
-					}
-				});
-			} catch {}
-		}
-
-		// Try to capture error again for accurate status reporting
-		// 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?: unknown; post?: unknown }>();
-			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: unknown) {
-		const message = error instanceof Error ? error.message : String(error);
-		return context.createErrorResponse(id, -32602, "Invalid params", message);
-	}
-};