solforge 0.1.7 → 0.2.1

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

@@ -0,0 +1,52 @@
+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: any; // 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 any);
+	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

@@ -0,0 +1,66 @@
+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;
+	let parsed: any = 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

@@ -0,0 +1,237 @@
+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 mintOwner =
+						typeof (mintAcc as any).owner?.toBase58 === "function"
+							? ((mintAcc as any).owner as PublicKey)
+							: new PublicKey(mintAcc.owner);
+					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, any>> | 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>> = [];
+	for (const ext of types) {
+		const entry: Record<string, any> = {
+			type: ExtensionType[ext] ?? String(ext),
+		};
+		try {
+			if (ext === ExtensionType.MetadataPointer) {
+				const state = getMetadataPointerState(mint as any);
+				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: any, owner: PublicKey): AccountInfo<Buffer> {
+	const data =
+		raw.data instanceof Buffer ? raw.data : Buffer.from(raw.data ?? []);
+	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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,219 @@
+import {
+	PublicKey,
+	SystemProgram,
+	TransactionInstruction,
+	TransactionMessage,
+	VersionedTransaction,
+} from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+/**
+ * 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 || [];
+
+	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 txMsg: any = tx.message as any;
+		const rawKeys: any[] = Array.isArray(txMsg.staticAccountKeys)
+			? txMsg.staticAccountKeys
+			: Array.isArray(txMsg.accountKeys)
+				? txMsg.accountKeys
+				: [];
+		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 toIndex = staticKeys.findIndex((pk) => pk.equals(toPubkey));
+		const beforeTo =
+			toIndex >= 0
+				? preBalances[toIndex]
+				: (() => {
+						try {
+							return Number(context.svm.getBalance(toPubkey));
+						} catch {
+							return 0;
+						}
+					})();
+
+		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 {}
+
+		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 {}
+		// 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 e2 = (res2 as any).err?.() ?? (res2 as any).err;
+					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
+		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,
+		});
+
+		return context.createSuccessResponse(id, signature);
+	} catch (error: any) {
+		return context.createErrorResponse(
+			id,
+			-32602,
+			"Invalid params",
+			error.message,
+		);
+	}
+};

package/server/methods/admin/adopt-mint-authority.ts

@@ -0,0 +1,94 @@
+import { MINT_SIZE, MintLayout } from "@solana/spl-token";
+import { PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+// Adopt faucet as mint authority for a given mint (LiteSVM-only, overwrites account data)
+export const solforgeAdoptMintAuthority: RpcMethodHandler = async (
+	id,
+	params,
+	context,
+) => {
+	try {
+		const [mintStr] = params as [string];
+		if (!mintStr)
+			return context.createErrorResponse(
+				id,
+				-32602,
+				"Invalid params: mint required",
+			);
+		const mint = new PublicKey(mintStr);
+		const acct = context.svm.getAccount(mint);
+		if (!acct)
+			return context.createErrorResponse(
+				id,
+				-32004,
+				"Mint not found in LiteSVM",
+			);
+		if (!acct.data || acct.data.length < MINT_SIZE)
+			return context.createErrorResponse(
+				id,
+				-32000,
+				"Account not a valid mint",
+			);
+
+		const faucet = context.getFaucet();
+		const buf = Buffer.from(acct.data);
+		type MintStruct = Parameters<typeof MintLayout.encode>[0];
+		const mintDecoded = MintLayout.decode(
+			buf.slice(0, MINT_SIZE),
+		) as unknown as MintStruct;
+		// Update authority fields
+		(
+			mintDecoded as unknown as { mintAuthorityOption: number }
+		).mintAuthorityOption = 1;
+		(mintDecoded as unknown as { mintAuthority: PublicKey }).mintAuthority =
+			faucet.publicKey;
+		const out = Buffer.from(buf); // preserve any extensions beyond MintLayout
+		MintLayout.encode(mintDecoded as MintStruct, out);
+
+		const ownerBase58 =
+			typeof acct.owner === "string"
+				? new PublicKey(acct.owner).toBase58()
+				: (acct.owner as PublicKey).toBase58();
+		const ownerPk = new PublicKey(ownerBase58);
+
+		context.svm.setAccount(mint, {
+			lamports: Number(acct.lamports || 0n),
+			data: new Uint8Array(out),
+			owner: ownerPk,
+			executable: false,
+			rentEpoch: 0,
+		});
+		try {
+			context.registerMint?.(mint);
+		} catch {}
+		try {
+			await context.store?.upsertAccounts([
+				{
+					address: mint.toBase58(),
+					lamports: Number(acct.lamports || 0n),
+					ownerProgram: ownerBase58,
+					executable: false,
+					rentEpoch: 0,
+					dataLen: out.length,
+					dataBase64: undefined,
+					lastSlot: Number(context.slot),
+				},
+			]);
+		} catch {}
+		return context.createSuccessResponse(id, {
+			ok: true,
+			mint: mintStr,
+			authority: faucet.publicKey.toBase58(),
+		});
+	} catch (e) {
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"Adopt mint authority failed",
+			(e as Error)?.message || String(e),
+		);
+	}
+};
+
+export type { RpcMethodHandler } from "../../types";