solforge 0.1.6 → 0.2.0

package/server/methods/admin/load-program.ts

@@ -0,0 +1,52 @@
+import { PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+// Load a program ELF into LiteSVM for a given programId
+export const solforgeLoadProgram: RpcMethodHandler = async (
+	id,
+	params,
+	context,
+) => {
+	try {
+		const [programIdStr, elfBase64] = params as [string, string];
+		if (!programIdStr || !elfBase64)
+			return context.createErrorResponse(
+				id,
+				-32602,
+				"Invalid params: programId, base64 required",
+			);
+		const pid = new PublicKey(programIdStr);
+		const bytes = Uint8Array.from(Buffer.from(elfBase64, "base64"));
+		try {
+			context.svm.addProgram(pid, bytes);
+		} catch {}
+		// Mirror program account metadata as executable; owner = upgradeable loader for realism
+		const LOADER_UPGRADEABLE = new PublicKey(
+			"BPFLoaderUpgradeab1e11111111111111111111111",
+		);
+		context.svm.setAccount(pid, {
+			lamports: 1_000_000_000,
+			data: new Uint8Array(bytes.length), // minimal stub data for the program account itself
+			owner: LOADER_UPGRADEABLE,
+			executable: true,
+			rentEpoch: 0,
+		});
+		try {
+			context.registerProgram?.(pid);
+		} catch {}
+		return context.createSuccessResponse(id, {
+			ok: true,
+			programId: programIdStr,
+			size: bytes.length,
+		});
+	} catch (e) {
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"Load program failed",
+			(e as Error)?.message || String(e),
+		);
+	}
+};
+
+export type { RpcMethodHandler } from "../../types";

package/server/methods/admin/mint-to.ts

@@ -0,0 +1,278 @@
+import {
+	ACCOUNT_SIZE,
+	AccountLayout,
+	createAssociatedTokenAccountInstruction,
+	createMintToCheckedInstruction,
+	getAssociatedTokenAddressSync,
+	MINT_SIZE,
+	MintLayout,
+	TOKEN_2022_PROGRAM_ID,
+	TOKEN_PROGRAM_ID,
+} from "@solana/spl-token";
+import type { TransactionInstruction } from "@solana/web3.js";
+import {
+	PublicKey,
+	TransactionMessage,
+	VersionedTransaction,
+} from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+// Mint via a real SPL Token transaction signed by faucet (must be mint authority)
+export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
+	try {
+		const [mintStr, ownerStr, rawAmount] = params as [
+			string,
+			string,
+			number | string | bigint,
+		];
+		if (!mintStr || !ownerStr || rawAmount == null)
+			return context.createErrorResponse(
+				id,
+				-32602,
+				"Invalid params: mint, owner, amount required",
+			);
+		const mint = new PublicKey(mintStr);
+		const owner = new PublicKey(ownerStr);
+		const faucet = context.getFaucet();
+
+		// Read mint to get decimals and authority
+		const mintAcc = context.svm.getAccount(mint);
+		if (!mintAcc)
+			return context.createErrorResponse(
+				id,
+				-32004,
+				"Mint not found in LiteSVM",
+			);
+		const mintInfo = MintLayout.decode(
+			Buffer.from(mintAcc.data).slice(0, MINT_SIZE),
+		);
+		const decimals = mintInfo.decimals;
+		const hasAuth = mintInfo.mintAuthorityOption === 1;
+		const authPk = hasAuth ? new PublicKey(mintInfo.mintAuthority) : null;
+		if (!hasAuth || !authPk || !authPk.equals(faucet.publicKey)) {
+			return context.createErrorResponse(
+				id,
+				-32000,
+				"Mint has no faucet authority; cannot mint real tokens",
+			);
+		}
+
+		const ixs: TransactionInstruction[] = [];
+		// Detect which token program the mint belongs to (SPL v1 vs Token-2022)
+		const mintOwnerStr = (() => {
+			try {
+				return (mintAcc.owner as PublicKey).toBase58();
+			} catch {
+				return String(mintAcc.owner);
+			}
+		})();
+		const tokenProgramId =
+			mintOwnerStr === TOKEN_2022_PROGRAM_ID.toBase58()
+				? TOKEN_2022_PROGRAM_ID
+				: TOKEN_PROGRAM_ID;
+
+		// Derive ATA using the correct token program
+		const ata = getAssociatedTokenAddressSync(
+			mint,
+			owner,
+			true,
+			tokenProgramId,
+		);
+		const ataAcc = context.svm.getAccount(ata);
+
+		// Ensure ATA exists under the correct token program
+		if (!ataAcc || (ataAcc.data?.length ?? 0) < ACCOUNT_SIZE) {
+			ixs.push(
+				createAssociatedTokenAccountInstruction(
+					faucet.publicKey,
+					ata,
+					owner,
+					mint,
+					tokenProgramId,
+				),
+			);
+		}
+
+		const amount =
+			typeof rawAmount === "bigint" ? rawAmount : BigInt(rawAmount);
+		ixs.push(
+			createMintToCheckedInstruction(
+				mint,
+				ata,
+				faucet.publicKey,
+				amount,
+				decimals,
+				[],
+				tokenProgramId,
+			),
+		);
+
+		// Build a VersionedTransaction (legacy message) to ensure consistent encoding/decoding downstream
+		let rb = context.svm.latestBlockhash();
+		if (!rb || rb.length === 0) {
+			const bh = new Uint8Array(32);
+			crypto.getRandomValues(bh);
+			rb = context.encodeBase58(bh);
+		}
+		const msg = new TransactionMessage({
+			payerKey: faucet.publicKey,
+			recentBlockhash: rb,
+			instructions: ixs,
+		});
+		const legacy = msg.compileToLegacyMessage();
+		const vtx = new VersionedTransaction(legacy);
+		vtx.sign([faucet]);
+
+		// Capture preBalances for primary accounts referenced and token pre amount
+		const trackedKeys = [faucet.publicKey, ata, mint, owner];
+		const preBalances = trackedKeys.map((pk) => {
+			try {
+				return Number(context.svm.getBalance(pk) || 0n);
+			} catch {
+				return 0;
+			}
+		});
+		// Token mint decimals and pre amount
+		let decsForMint = 0;
+		let preTokenAmt: bigint = 0n;
+		try {
+			const mintAcc0 = context.svm.getAccount(mint);
+			const mintInfo0 = mintAcc0
+				? MintLayout.decode(Buffer.from(mintAcc0.data).slice(0, MINT_SIZE))
+				: undefined;
+			decsForMint = Number(mintInfo0?.decimals ?? decimals ?? 0);
+			const ataAcc0 = context.svm.getAccount(ata);
+			if (ataAcc0 && (ataAcc0.data?.length ?? 0) >= ACCOUNT_SIZE) {
+				const dec0 = AccountLayout.decode(Buffer.from(ataAcc0.data));
+				preTokenAmt = BigInt(dec0.amount.toString());
+			}
+		} 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()}`;
+
+		// Token balance deltas (pre/post) for ATA
+		type UiTokenAmount = {
+			amount: string;
+			decimals: number;
+			uiAmount: number;
+			uiAmountString: string;
+		};
+		type TokenBalance = {
+			accountIndex: number;
+			mint: string;
+			owner: string;
+			uiTokenAmount: UiTokenAmount;
+		};
+		let preTokenBalances: TokenBalance[] = [];
+		let postTokenBalances: TokenBalance[] = [];
+		try {
+			const decs = decsForMint;
+			const ui = (n: bigint) => ({
+				amount: n.toString(),
+				decimals: decs,
+				uiAmount: Number(n) / 10 ** decs,
+				uiAmountString: (Number(n) / 10 ** decs).toString(),
+			});
+			const preAmt = preTokenAmt;
+			const ataPostAcc = context.svm.getAccount(ata); // after send
+			const postAmt =
+				ataPostAcc && (ataPostAcc.data?.length ?? 0) >= ACCOUNT_SIZE
+					? BigInt(
+							AccountLayout.decode(
+								Buffer.from(ataPostAcc.data),
+							).amount.toString(),
+						)
+					: preAmt;
+			const msgAny = vtx.message as unknown as {
+				staticAccountKeys?: Array<string | PublicKey>;
+				accountKeys?: Array<string | PublicKey>;
+			};
+			const rawKeys: Array<string | PublicKey> = Array.isArray(
+				msgAny.staticAccountKeys,
+			)
+				? msgAny.staticAccountKeys
+				: Array.isArray(msgAny.accountKeys)
+					? msgAny.accountKeys
+					: [];
+			const keys = rawKeys.map((k: string | PublicKey) => {
+				try {
+					return typeof k === "string" ? k : new PublicKey(k).toBase58();
+				} catch {
+					return String(k);
+				}
+			});
+			const ataIndex = keys.indexOf(ata.toBase58());
+			preTokenBalances = [
+				{
+					accountIndex: ataIndex >= 0 ? ataIndex : 0,
+					mint: mint.toBase58(),
+					owner: owner.toBase58(),
+					uiTokenAmount: ui(preAmt),
+				},
+			];
+			postTokenBalances = [
+				{
+					accountIndex: ataIndex >= 0 ? ataIndex : 0,
+					mint: mint.toBase58(),
+					owner: owner.toBase58(),
+					uiTokenAmount: ui(postAmt),
+				},
+			];
+		} 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 {}
+
+		return context.createSuccessResponse(id, {
+			ok: true,
+			signature: signatureStr,
+			mint: mintStr,
+			owner: ownerStr,
+			amount: amount.toString(),
+		});
+	} catch (e) {
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"MintTo failed",
+			(e as Error)?.message || String(e),
+		);
+	}
+};
+
+export type { RpcMethodHandler } from "../../types";

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

@@ -0,0 +1,5 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getBlockHeight: RpcMethodHandler = (id, _params, context) => {
+	return context.createSuccessResponse(id, Number(context.blockHeight));
+};

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

@@ -0,0 +1,35 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getBlock: RpcMethodHandler = (id, params, context) => {
+	try {
+		const [slotRaw] = params || [];
+		const slot = Number(slotRaw);
+		if (!Number.isFinite(slot) || slot < 0) throw new Error("Invalid slot");
+		const parentSlot = Math.max(0, slot - 1);
+		const blockhash = context.svm.latestBlockhash();
+		const previousBlockhash = context.svm.latestBlockhash();
+		const SLOT_TIME_MS = 400;
+		const currentTime = Math.floor(Date.now() / 1000);
+		const slotDiff = Number(context.slot) - slot;
+		const blockTime =
+			slot > Number(context.slot)
+				? null
+				: currentTime -
+					Math.floor((Math.max(0, slotDiff) * SLOT_TIME_MS) / 1000);
+		return context.createSuccessResponse(id, {
+			blockhash,
+			previousBlockhash,
+			parentSlot,
+			transactions: [],
+			rewards: [],
+			blockTime,
+		});
+	} catch (error: any) {
+		return context.createErrorResponse(
+			id,
+			-32602,
+			"Invalid params",
+			error.message,
+		);
+	}
+};

package/server/methods/block/get-blocks-with-limit.ts

@@ -0,0 +1,23 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getBlocksWithLimit: RpcMethodHandler = (id, params, context) => {
+	try {
+		const [startSlotRaw, limitRaw] = params || [];
+		const start = Number(startSlotRaw);
+		const limit = Number(limitRaw);
+		if (!Number.isFinite(start) || start < 0)
+			throw new Error("Invalid start slot");
+		if (!Number.isFinite(limit) || limit <= 0) throw new Error("Invalid limit");
+		const end = Math.min(Number(context.slot), start + limit - 1);
+		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,
+		);
+	}
+};

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

@@ -0,0 +1,12 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getLatestBlockhash: RpcMethodHandler = (id, _params, context) => {
+	const blockhash = context.svm.latestBlockhash();
+	return context.createSuccessResponse(id, {
+		context: { slot: Number(context.slot) },
+		value: {
+			blockhash,
+			lastValidBlockHeight: Number(context.blockHeight + 150n),
+		},
+	});
+};

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

@@ -0,0 +1,5 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getSlot: RpcMethodHandler = (id, _params, context) => {
+	return context.createSuccessResponse(id, Number(context.slot));
+};

package/server/methods/block/index.ts

@@ -0,0 +1,6 @@
+export { getBlock } from "./get-block";
+export { getBlockHeight } from "./get-block-height";
+export { getBlocksWithLimit } from "./get-blocks-with-limit";
+export { getLatestBlockhash } from "./get-latest-blockhash";
+export { getSlot } from "./get-slot";
+export { isBlockhashValid } from "./is-blockhash-valid";

package/server/methods/block/is-blockhash-valid.ts

@@ -0,0 +1,23 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const isBlockhashValid: RpcMethodHandler = (id, params, context) => {
+	try {
+		const [blockhash] = params || [];
+		const current = context.svm.latestBlockhash();
+		const isValid =
+			typeof blockhash === "string" &&
+			blockhash.length > 0 &&
+			blockhash === current;
+		return context.createSuccessResponse(id, {
+			context: { slot: Number(context.slot) },
+			value: isValid,
+		});
+	} catch (error: any) {
+		return context.createErrorResponse(
+			id,
+			-32602,
+			"Invalid params",
+			error.message,
+		);
+	}
+};

package/server/methods/epoch/get-cluster-nodes.ts

@@ -0,0 +1,17 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getClusterNodes: RpcMethodHandler = (id, _params, _context) => {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result: [
+			{
+				pubkey: "11111111111111111111111111111111",
+				gossip: "127.0.0.1:8001",
+				tpu: "127.0.0.1:8003",
+				rpc: "127.0.0.1:8899",
+				version: "1.17.0",
+			},
+		],
+	};
+};

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

@@ -0,0 +1,16 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getEpochInfo: RpcMethodHandler = (id, _params, context) => {
+	const slotsPerEpoch = 432000;
+	const currentSlot = Number(context.slot);
+	const epoch = Math.floor(currentSlot / slotsPerEpoch);
+	const slotIndex = currentSlot % slotsPerEpoch;
+	return context.createSuccessResponse(id, {
+		absoluteSlot: currentSlot,
+		blockHeight: currentSlot,
+		epoch,
+		slotIndex,
+		slotsInEpoch: slotsPerEpoch,
+		transactionCount: currentSlot * 100,
+	});
+};

package/server/methods/epoch/get-epoch-schedule.ts

@@ -0,0 +1,15 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getEpochSchedule: RpcMethodHandler = (id, _params, _context) => {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result: {
+			slotsPerEpoch: 432000,
+			leaderScheduleSlotOffset: 432000,
+			warmup: false,
+			firstNormalEpoch: 0,
+			firstNormalSlot: 0,
+		},
+	};
+};

package/server/methods/epoch/get-highest-snapshot-slot.ts

@@ -0,0 +1,9 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getHighestSnapshotSlot: RpcMethodHandler = (
+	id,
+	_params,
+	_context,
+) => {
+	return { jsonrpc: "2.0", id, result: { full: 0, incremental: null } };
+};

package/server/methods/epoch/get-leader-schedule.ts

@@ -0,0 +1,8 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getLeaderSchedule: RpcMethodHandler = (id, _params, _context) => {
+	const identity = "11111111111111111111111111111111";
+	const schedule: Record<string, number[]> = {};
+	schedule[identity] = Array.from({ length: 100 }, (_, i) => i);
+	return { jsonrpc: "2.0", id, result: schedule };
+};

package/server/methods/epoch/get-max-retransmit-slot.ts

@@ -0,0 +1,9 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getMaxRetransmitSlot: RpcMethodHandler = (
+	id,
+	_params,
+	context,
+) => {
+	return context.createSuccessResponse(id, Number(context.slot));
+};

package/server/methods/epoch/get-max-shred-insert-slot.ts

@@ -0,0 +1,9 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getMaxShredInsertSlot: RpcMethodHandler = (
+	id,
+	_params,
+	context,
+) => {
+	return context.createSuccessResponse(id, Number(context.slot));
+};

package/server/methods/epoch/get-slot-leader.ts

@@ -0,0 +1,6 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getSlotLeader: RpcMethodHandler = (id, _params, _context) => {
+	const LEADER_PUBKEY = "11111111111111111111111111111111";
+	return { jsonrpc: "2.0", id, result: LEADER_PUBKEY };
+};

package/server/methods/epoch/get-slot-leaders.ts

@@ -0,0 +1,9 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getSlotLeaders: RpcMethodHandler = (id, params, _context) => {
+	const [_startSlot, limit] = params || [];
+	const LEADER_PUBKEY = "11111111111111111111111111111111";
+	const count = Math.min(Number(limit || 100), 5000);
+	const leaders = Array(count).fill(LEADER_PUBKEY);
+	return { jsonrpc: "2.0", id, result: leaders };
+};

package/server/methods/epoch/get-stake-activation.ts

@@ -0,0 +1,9 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getStakeActivation: RpcMethodHandler = (id, _params, _context) => {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result: { state: "active", active: 1000000000, inactive: 0 },
+	};
+};

package/server/methods/epoch/get-stake-minimum-delegation.ts

@@ -0,0 +1,9 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getStakeMinimumDelegation: RpcMethodHandler = (
+	id,
+	_params,
+	context,
+) => {
+	return context.createSuccessResponse(id, 1_000_000_000);
+};

package/server/methods/epoch/get-vote-accounts.ts

@@ -0,0 +1,19 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getVoteAccounts: RpcMethodHandler = (id, _params, context) => {
+	return context.createSuccessResponse(id, {
+		current: [
+			{
+				votePubkey: "11111111111111111111111111111111",
+				nodePubkey: "11111111111111111111111111111111",
+				activatedStake: 1000000000,
+				epochVoteAccount: true,
+				commission: 0,
+				lastVote: Number(context.slot),
+				epochCredits: [[0, 1000, 0]],
+				rootSlot: Number(context.slot) - 1,
+			},
+		],
+		delinquent: [],
+	});
+};

package/server/methods/epoch/index.ts

@@ -0,0 +1,13 @@
+export { getClusterNodes } from "./get-cluster-nodes";
+export { getEpochInfo } from "./get-epoch-info";
+export { getEpochSchedule } from "./get-epoch-schedule";
+export { getHighestSnapshotSlot } from "./get-highest-snapshot-slot";
+export { getLeaderSchedule } from "./get-leader-schedule";
+export { getMaxRetransmitSlot } from "./get-max-retransmit-slot";
+export { getMaxShredInsertSlot } from "./get-max-shred-insert-slot";
+export { getSlotLeader } from "./get-slot-leader";
+export { getSlotLeaders } from "./get-slot-leaders";
+export { getStakeActivation } from "./get-stake-activation";
+export { getStakeMinimumDelegation } from "./get-stake-minimum-delegation";
+export { getVoteAccounts } from "./get-vote-accounts";
+export { minimumLedgerSlot } from "./minimum-ledger-slot";

package/server/methods/epoch/minimum-ledger-slot.ts

@@ -0,0 +1,5 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const minimumLedgerSlot: RpcMethodHandler = (id, _params, _context) => {
+	return { jsonrpc: "2.0", id, result: 0 };
+};

package/server/methods/fee/get-fee-calculator-for-blockhash.ts

@@ -0,0 +1,12 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getFeeCalculatorForBlockhash: RpcMethodHandler = (
+	id,
+	_params,
+	context,
+) => {
+	return context.createSuccessResponse(id, {
+		context: { slot: Number(context.slot) },
+		value: { feeCalculator: { lamportsPerSignature: 5000 } },
+	});
+};

package/server/methods/fee/get-fee-for-message.ts

@@ -0,0 +1,8 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getFeeForMessage: RpcMethodHandler = (id, _params, context) => {
+	return context.createSuccessResponse(id, {
+		context: { slot: Number(context.slot), apiVersion: "1.17.9" },
+		value: 5000,
+	});
+};

package/server/methods/fee/get-fee-rate-governor.ts

@@ -0,0 +1,16 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getFeeRateGovernor: RpcMethodHandler = (id, _params, context) => {
+	return context.createSuccessResponse(id, {
+		context: { slot: Number(context.slot) },
+		value: {
+			feeRateGovernor: {
+				burnPercent: 50,
+				maxLamportsPerSignature: 100000,
+				minLamportsPerSignature: 5000,
+				targetLamportsPerSignature: 10000,
+				targetSignaturesPerSlot: 20000,
+			},
+		},
+	});
+};

package/server/methods/fee/get-fees.ts

@@ -0,0 +1,14 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getFees: RpcMethodHandler = (id, _params, context) => {
+	const blockhash = context.svm.latestBlockhash();
+	return context.createSuccessResponse(id, {
+		context: { slot: Number(context.slot) },
+		value: {
+			blockhash,
+			feeCalculator: { lamportsPerSignature: 5000 },
+			lastValidSlot: Number(context.slot) + 150,
+			lastValidBlockHeight: Number(context.slot) + 150,
+		},
+	});
+};