solforge 0.1.7 → 0.2.1

package/server/methods/program/get-token-accounts-by-owner.ts

@@ -0,0 +1,390 @@
+import {
+	ACCOUNT_SIZE,
+	getAssociatedTokenAddressSync,
+	TOKEN_2022_PROGRAM_ID,
+	TOKEN_PROGRAM_ID,
+	unpackAccount,
+	unpackMint,
+} from "@solana/spl-token";
+import { type AccountInfo, PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+export const getTokenAccountsByOwner: RpcMethodHandler = async (
+	id,
+	params,
+	context,
+) => {
+	try {
+		const [ownerStr, filter, config] = params || [];
+		if (!ownerStr) throw new Error("owner public key required");
+		const owner = new PublicKey(ownerStr);
+		const wantMint: string | null = filter?.mint ? String(filter.mint) : null;
+		const requestedProgramId: string | null = filter?.programId
+			? String(filter.programId)
+			: null;
+		const encoding: string = config?.encoding || "jsonParsed";
+		const classicId = TOKEN_PROGRAM_ID.toBase58();
+		const token2022Id = TOKEN_2022_PROGRAM_ID.toBase58();
+		const programIds = requestedProgramId
+			? [requestedProgramId]
+			: [classicId, token2022Id];
+
+		// Query DB for accounts owned by both SPL Token programs (classic + 2022)
+		const rows: Array<{ address: string; lastSlot: number } & any> = [];
+		for (const programId of programIds) {
+			try {
+				const found =
+					(await context.store?.getAccountsByOwner(programId, 50_000)) || [];
+				rows.push(...found);
+			} catch (dbErr) {
+				try {
+					console.warn("[rpc] getTokenAccountsByOwner: db read failed", dbErr);
+				} catch {}
+			}
+		}
+
+		const out: any[] = [];
+		const seen = new Set<string>();
+		for (const r of rows) {
+			if (seen.has(r.address)) continue;
+			try {
+				const pk = new PublicKey(r.address);
+				const acc = context.svm.getAccount(pk);
+				if (!acc) continue;
+				if ((acc.data?.length ?? 0) < 165) continue;
+				let ownerPk: PublicKey;
+				try {
+					// acc.owner may already be a PublicKey in LiteSVM
+					const anyOwner: any = (acc as any).owner;
+					ownerPk =
+						typeof anyOwner?.toBase58 === "function"
+							? (anyOwner as PublicKey)
+							: new PublicKey(anyOwner);
+				} catch {
+					ownerPk = TOKEN_PROGRAM_ID; // fallback avoids throw; unpackAccount will fail if wrong and be skipped
+				}
+				const programPk = ownerPk.equals(TOKEN_2022_PROGRAM_ID)
+					? TOKEN_2022_PROGRAM_ID
+					: TOKEN_PROGRAM_ID;
+				const dec = unpackAccount(
+					pk,
+					{ data: Buffer.from(acc.data), owner: ownerPk },
+					programPk,
+				);
+				const decMint = dec.mint.toBase58();
+				const decOwner = dec.owner.toBase58();
+				if (decOwner !== owner.toBase58()) continue;
+				if (wantMint && decMint !== wantMint) continue;
+				if (encoding === "jsonParsed") {
+					let decimals = 0;
+					try {
+						const mintAcc = context.svm.getAccount(dec.mint);
+						const mintOwnerPk = mintAcc
+							? typeof (mintAcc as any).owner?.toBase58 === "function"
+								? (mintAcc as any).owner
+								: new PublicKey(mintAcc.owner)
+							: programPk;
+						const info = mintAcc
+							? unpackMint(
+									dec.mint,
+									{
+										data: Buffer.from(mintAcc.data),
+										owner: mintOwnerPk,
+									} as AccountInfo<Buffer>,
+									mintOwnerPk,
+								)
+							: null;
+						decimals = info?.decimals ?? 0;
+					} catch {}
+					const amount = BigInt(dec.amount?.toString?.() ?? dec.amount ?? 0);
+					const ui = decimals >= 0 ? Number(amount) / 10 ** decimals : null;
+					const state = dec.isFrozen
+						? "frozen"
+						: dec.isInitialized
+							? "initialized"
+							: "uninitialized";
+					const amountUi = {
+						amount: amount.toString(),
+						decimals,
+						uiAmount: ui,
+						uiAmountString: (ui ?? 0).toString(),
+					};
+					// delegatedAmount as UiTokenAmount per RPC schema
+					const delegated = BigInt(
+						dec.delegatedAmount?.toString?.() ?? dec.delegatedAmount ?? 0n,
+					);
+					const delegatedUiAmount =
+						decimals >= 0 ? Number(delegated) / 10 ** decimals : null;
+					const delegatedAmount = {
+						amount: delegated.toString(),
+						decimals,
+						uiAmount: delegatedUiAmount,
+						uiAmountString: (delegatedUiAmount ?? 0).toString(),
+					};
+					// rentExemptReserve only for native (wrapped SOL) accounts; value in lamports (9 decimals)
+					let rentExemptReserve = null as any;
+					if (dec.isNative) {
+						const lamports = BigInt(
+							dec.rentExemptReserve?.toString?.() ??
+								dec.rentExemptReserve ??
+								0n,
+						);
+						const lamportsUi = Number(lamports) / 1_000_000_000;
+						rentExemptReserve = {
+							amount: lamports.toString(),
+							decimals: 9,
+							uiAmount: lamportsUi,
+							uiAmountString: lamportsUi.toString(),
+						};
+					}
+					const programLabel = programPk.equals(TOKEN_2022_PROGRAM_ID)
+						? "spl-token-2022"
+						: "spl-token";
+					out.push({
+						pubkey: r.address,
+						account: {
+							lamports: Number(acc.lamports || 0n),
+							owner: ownerPk.toBase58(),
+							executable: !!acc.executable,
+							rentEpoch: Number(acc.rentEpoch || 0),
+							data: {
+								program: programLabel,
+								parsed: {
+									type: "account",
+									info: {
+										mint: decMint,
+										owner: decOwner,
+										tokenAmount: amountUi,
+										state,
+										isNative: !!dec.isNative,
+										delegatedAmount: delegatedAmount,
+										delegate: dec.delegate ? dec.delegate.toBase58() : null,
+										rentExemptReserve,
+										closeAuthority: dec.closeAuthority
+											? dec.closeAuthority.toBase58()
+											: null,
+									},
+								},
+								space: acc.data?.length ?? 0,
+							},
+						},
+					});
+					seen.add(r.address);
+				} else {
+					out.push({
+						pubkey: r.address,
+						account: {
+							lamports: Number(acc.lamports || 0n),
+							owner: ownerPk.toBase58(),
+							executable: !!acc.executable,
+							rentEpoch: Number(acc.rentEpoch || 0),
+							data: [
+								Buffer.from(acc.data).toString("base64"),
+								"base64",
+							] as const,
+						},
+					});
+					seen.add(r.address);
+				}
+			} catch {}
+		}
+		// Fallback: probe known mints' ATAs for this owner
+		try {
+			const mints = context.listMints ? context.listMints() : [];
+			for (const m of mints) {
+				try {
+					const mintPk = new PublicKey(m);
+					const mintAcc = context.svm.getAccount(mintPk);
+					const mintOwnerPk = mintAcc
+						? typeof (mintAcc as any).owner?.toBase58 === "function"
+							? (mintAcc as any).owner
+							: new PublicKey(mintAcc.owner)
+						: TOKEN_PROGRAM_ID;
+					// Determine which token program this mint belongs to
+					const programForMint = mintOwnerPk.equals(TOKEN_2022_PROGRAM_ID)
+						? TOKEN_2022_PROGRAM_ID
+						: TOKEN_PROGRAM_ID;
+					// If a specific programId filter was requested, honor it strictly
+					if (
+						requestedProgramId &&
+						programForMint.toBase58() !== requestedProgramId
+					) {
+						continue;
+					}
+
+					const ata = getAssociatedTokenAddressSync(
+						mintPk,
+						owner,
+						true,
+						programForMint,
+					);
+					const acc = context.svm.getAccount(ata);
+					if (!acc || (acc.data?.length ?? 0) < ACCOUNT_SIZE) continue;
+					if (seen.has(ata.toBase58())) continue;
+					let ownerPk: PublicKey;
+					const anyOwner: any = (acc as any).owner;
+					ownerPk =
+						typeof anyOwner?.toBase58 === "function"
+							? (anyOwner as PublicKey)
+							: new PublicKey(anyOwner);
+					const programPk = ownerPk.equals(TOKEN_2022_PROGRAM_ID)
+						? TOKEN_2022_PROGRAM_ID
+						: TOKEN_PROGRAM_ID;
+					// If a programId filter was provided, skip non-matching accounts
+					if (
+						requestedProgramId &&
+						programPk.toBase58() !== requestedProgramId
+					) {
+						continue;
+					}
+					const dec = unpackAccount(
+						ata,
+						{ data: Buffer.from(acc.data), owner: ownerPk },
+						programPk,
+					);
+					const decMint = dec.mint.toBase58();
+					const decOwner = dec.owner.toBase58();
+					if (decOwner !== owner.toBase58()) continue;
+					let decimals = 0;
+					try {
+						const mintAcc = context.svm.getAccount(dec.mint);
+						const mintOwnerPk = mintAcc
+							? typeof (mintAcc as any).owner?.toBase58 === "function"
+								? (mintAcc as any).owner
+								: new PublicKey(mintAcc.owner)
+							: programPk;
+						const info = mintAcc
+							? unpackMint(
+									dec.mint,
+									{
+										data: Buffer.from(mintAcc.data),
+										owner: mintOwnerPk,
+									} as AccountInfo<Buffer>,
+									mintOwnerPk,
+								)
+							: null;
+						decimals = info?.decimals ?? 0;
+					} catch {}
+					const amount = BigInt(dec.amount?.toString?.() ?? dec.amount ?? 0);
+					const ui = decimals >= 0 ? Number(amount) / 10 ** decimals : null;
+					const state = dec.isFrozen
+						? "frozen"
+						: dec.isInitialized
+							? "initialized"
+							: "uninitialized";
+					const amountUi = {
+						amount: amount.toString(),
+						decimals,
+						uiAmount: ui,
+						uiAmountString: (ui ?? 0).toString(),
+					};
+					const programLabel = programPk.equals(TOKEN_2022_PROGRAM_ID)
+						? "spl-token-2022"
+						: "spl-token";
+					out.push({
+						pubkey: ata.toBase58(),
+						account: {
+							lamports: Number(acc.lamports || 0n),
+							owner: ownerPk.toBase58(),
+							executable: !!acc.executable,
+							rentEpoch: Number(acc.rentEpoch || 0),
+							data: {
+								program: programLabel,
+								parsed: {
+									type: "account",
+									info: {
+										mint: decMint,
+										owner: decOwner,
+										tokenAmount: amountUi,
+										state,
+										isNative: !!dec.isNative,
+									},
+								},
+								space: acc.data?.length ?? 0,
+							},
+						},
+					});
+					seen.add(ata.toBase58());
+				} catch {}
+			}
+		} catch {}
+
+		// Deduplicate: prefer the canonical ATA for each (owner,mint) under the mint's token program
+		if (encoding === "jsonParsed") {
+			try {
+				const pick = new Map<string, number>();
+				for (let i = 0; i < out.length; i++) {
+					const entry = out[i];
+					const pubkey: string = entry.pubkey;
+					const info = entry.account?.data?.parsed?.info;
+					const mintStr: string | undefined = info?.mint;
+					const ownerStr: string | undefined = info?.owner;
+					if (!mintStr || !ownerStr) continue;
+					let canonical = pubkey;
+					try {
+						const mintPk = new PublicKey(mintStr);
+						const ownerPk = new PublicKey(ownerStr);
+						const mintAcc = context.svm.getAccount(mintPk);
+						const mintOwnerPk = mintAcc
+							? typeof (mintAcc as any).owner?.toBase58 === "function"
+								? (mintAcc as any).owner
+								: new PublicKey(mintAcc.owner)
+							: TOKEN_PROGRAM_ID;
+						const programForMint = mintOwnerPk.equals(TOKEN_2022_PROGRAM_ID)
+							? TOKEN_2022_PROGRAM_ID
+							: TOKEN_PROGRAM_ID;
+						const ata = getAssociatedTokenAddressSync(
+							mintPk,
+							ownerPk,
+							true,
+							programForMint,
+						);
+						canonical = ata.toBase58();
+					} catch {}
+					const key = `${ownerStr}:${mintStr}`;
+					const prev = pick.get(key);
+					if (prev === undefined) {
+						// First time; keep if canonical, otherwise tentatively keep
+						pick.set(key, i);
+						// Prefer canonical if current isn't canonical but later we may find it
+						if (pubkey !== canonical) pick.set(`${key}:prefer`, -1);
+					} else {
+						// If previous wasn't canonical and this one is, replace
+						const prefer = pick.get(`${key}:prefer`) === -1;
+						if (prefer && pubkey === canonical) {
+							pick.set(key, i);
+							pick.delete(`${key}:prefer`);
+						}
+					}
+				}
+
+				// Build filtered list keeping only chosen indices
+				const keep = new Set<number>(Array.from(pick.values()).filter((v) => typeof v === "number" && v >= 0));
+				const filtered: any[] = [];
+				for (let i = 0; i < out.length; i++) {
+					const e = out[i];
+					const info = e.account?.data?.parsed?.info;
+					const key = info?.owner && info?.mint ? `${info.owner}:${info.mint}` : null;
+					if (key && keep.has(i)) filtered.push(e);
+					else if (!key) filtered.push(e); // non-parsed or unexpected shape
+				}
+				out.length = 0;
+				out.push(...filtered);
+			} catch {}
+		}
+		return context.createSuccessResponse(id, {
+			context: { slot: Number(context.slot) },
+			value: out,
+		});
+	} catch (e: any) {
+		try {
+			console.error("[rpc] getTokenAccountsByOwner error", e);
+		} catch {}
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"Internal error",
+			e?.message || String(e),
+		);
+	}
+};

package/server/methods/program/get-token-largest-accounts.ts

@@ -0,0 +1,80 @@
+import {
+	TOKEN_2022_PROGRAM_ID,
+	TOKEN_PROGRAM_ID,
+	unpackAccount,
+	unpackMint,
+} from "@solana/spl-token";
+import { PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+export const getTokenLargestAccounts: RpcMethodHandler = async (
+	id,
+	params,
+	context,
+) => {
+	const [mintStr] = params || [];
+	try {
+		const mint = new PublicKey(mintStr);
+		const mintAcc = context.svm.getAccount(mint);
+		const programPk =
+			mintAcc && new PublicKey(mintAcc.owner).equals(TOKEN_2022_PROGRAM_ID)
+				? TOKEN_2022_PROGRAM_ID
+				: TOKEN_PROGRAM_ID;
+		const mintInfo = mintAcc
+			? unpackMint(
+					mint,
+					{
+						data: Buffer.from(mintAcc.data),
+						owner: new PublicKey(mintAcc.owner),
+					},
+					programPk,
+				)
+			: null;
+		const decimals = mintInfo?.decimals ?? 0;
+		// Scan DB list of SPL token accounts and pick those with this mint
+		const rows =
+			(await context.store?.getAccountsByOwner(
+				TOKEN_PROGRAM_ID.toBase58(),
+				50_000,
+			)) || [];
+		const list: Array<{ address: string; amount: bigint }> = [];
+		for (const r of rows) {
+			try {
+				const acc = context.svm.getAccount(new PublicKey(r.address));
+				if (!acc) continue;
+				if ((acc.data?.length ?? 0) < 165) continue;
+				const accOwnerPk = new PublicKey(acc.owner);
+				const accProgramPk = accOwnerPk.equals(TOKEN_2022_PROGRAM_ID)
+					? TOKEN_2022_PROGRAM_ID
+					: TOKEN_PROGRAM_ID;
+				const dec = unpackAccount(
+					new PublicKey(r.address),
+					{ data: Buffer.from(acc.data), owner: accOwnerPk },
+					accProgramPk,
+				);
+				if (!dec.mint.equals(mint)) continue;
+				const amount = BigInt(dec.amount?.toString?.() ?? dec.amount ?? 0);
+				list.push({ address: r.address, amount });
+			} catch {}
+		}
+		list.sort((a, b) =>
+			a.amount < b.amount ? 1 : a.amount > b.amount ? -1 : 0,
+		);
+		const top = list.slice(0, 20).map((e) => {
+			const ui = Number(e.amount) / 10 ** decimals;
+			return {
+				address: e.address,
+				amount: e.amount.toString(),
+				decimals,
+				uiAmount: ui,
+				uiAmountString: ui.toString(),
+			};
+		});
+		return context.createSuccessResponse(id, {
+			context: { slot: Number(context.slot) },
+			value: top,
+		});
+	} catch (e: any) {
+		return context.createErrorResponse(id, -32602, "Invalid params", e.message);
+	}
+};

package/server/methods/program/get-token-supply.ts

@@ -0,0 +1,38 @@
+import {
+	TOKEN_2022_PROGRAM_ID,
+	TOKEN_PROGRAM_ID,
+	unpackMint,
+} from "@solana/spl-token";
+import { PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+export const getTokenSupply: RpcMethodHandler = (id, params, context) => {
+	const [mintStr] = params || [];
+	try {
+		const mint = new PublicKey(mintStr);
+		const acc = context.svm.getAccount(mint);
+		if (!acc) return context.createErrorResponse(id, -32602, "Mint not found");
+		const ownerPk = new PublicKey(acc.owner);
+		const programPk = ownerPk.equals(TOKEN_2022_PROGRAM_ID)
+			? TOKEN_2022_PROGRAM_ID
+			: TOKEN_PROGRAM_ID;
+		const info = unpackMint(
+			mint,
+			{ data: Buffer.from(acc.data), owner: ownerPk },
+			programPk,
+		);
+		const supply = BigInt(info.supply?.toString?.() ?? info.supply ?? 0);
+		const ui = Number(supply) / 10 ** info.decimals;
+		return context.createSuccessResponse(id, {
+			context: { slot: Number(context.slot) },
+			value: {
+				amount: supply.toString(),
+				decimals: info.decimals,
+				uiAmount: ui,
+				uiAmountString: ui.toString(),
+			},
+		});
+	} catch (e: any) {
+		return context.createErrorResponse(id, -32602, "Invalid params", e.message);
+	}
+};

package/server/methods/program/index.ts

@@ -0,0 +1,21 @@
+export { getBlockCommitment } from "./get-block-commitment";
+export { getBlockProduction } from "./get-block-production";
+export { getBlockTime } from "./get-block-time";
+export { getBlocks } from "./get-blocks";
+export { getFirstAvailableBlock } from "./get-first-available-block";
+export { getGenesisHash } from "./get-genesis-hash";
+export { getIdentity } from "./get-identity";
+export { getInflationGovernor } from "./get-inflation-governor";
+export { getInflationRate } from "./get-inflation-rate";
+export { getInflationReward } from "./get-inflation-reward";
+export { getLargestAccounts } from "./get-largest-accounts";
+export { getParsedProgramAccounts } from "./get-parsed-program-accounts";
+export { getParsedTokenAccountsByDelegate } from "./get-parsed-token-accounts-by-delegate";
+export { getParsedTokenAccountsByOwner } from "./get-parsed-token-accounts-by-owner";
+export { getProgramAccounts } from "./get-program-accounts";
+export { getSupply } from "./get-supply";
+export { getTokenAccountBalance } from "./get-token-account-balance";
+export { getTokenAccountsByDelegate } from "./get-token-accounts-by-delegate";
+export { getTokenAccountsByOwner } from "./get-token-accounts-by-owner";
+export { getTokenLargestAccounts } from "./get-token-largest-accounts";
+export { getTokenSupply } from "./get-token-supply";

package/server/methods/solforge/index.ts

@@ -0,0 +1,155 @@
+import { MINT_SIZE, MintLayout } from "@solana/spl-token";
+import { PublicKey } from "@solana/web3.js";
+import { formatUiAmount } from "../../lib/spl-token";
+import type { RpcMethodHandler } from "../../types";
+
+const LAMPORTS_PER_SOL = 1_000_000_000n;
+
+function formatLamports(lamports: bigint) {
+	const sol = Number(lamports) / Number(LAMPORTS_PER_SOL);
+	return {
+		lamports: lamports.toString(),
+		sol,
+	};
+}
+
+export const solforgeGetStatus: RpcMethodHandler = async (
+	id,
+	_params,
+	context,
+) => {
+	try {
+		const latestBlockhash = (() => {
+			try {
+				return context.svm.latestBlockhash();
+			} catch {
+				return "";
+			}
+		})();
+		const faucet = context.getFaucet();
+		let faucetLamports = 0n;
+		try {
+			faucetLamports =
+				context.svm.getBalance(faucet.publicKey as PublicKey) ?? 0n;
+		} catch {}
+
+		return context.createSuccessResponse(id, {
+			slot: Number(context.slot),
+			slotBigint: context.slot.toString(),
+			blockHeight: Number(context.blockHeight),
+			blockHeightBigint: context.blockHeight.toString(),
+			txCount: Number(context.getTxCount()),
+			txCountBigint: context.getTxCount().toString(),
+			latestBlockhash,
+			faucet: {
+				address: faucet.publicKey.toBase58(),
+				...formatLamports(faucetLamports),
+			},
+		});
+	} catch (error: any) {
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"Status unavailable",
+			error?.message || String(error),
+		);
+	}
+};
+
+export const solforgeListPrograms: RpcMethodHandler = async (
+	id,
+	_params,
+	context,
+) => {
+	try {
+		const programs = context.listPrograms ? context.listPrograms() : [];
+		const detailed = programs
+			.map((programId) => {
+				try {
+					const info = context.svm.getAccount(new PublicKey(programId));
+					if (!info) return null;
+					const owner = (() => {
+						try {
+							return (info.owner as PublicKey).toBase58();
+						} catch {
+							return String(info.owner);
+						}
+					})();
+					const lamports = BigInt(info.lamports ?? 0);
+					return {
+						programId,
+						owner,
+						executable: !!info.executable,
+						dataLen: info.data?.length ?? 0,
+						lamports: lamports.toString(),
+					};
+				} catch {
+					return null;
+				}
+			})
+			.filter(Boolean);
+
+		return context.createSuccessResponse(id, detailed);
+	} catch (error: any) {
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"List programs failed",
+			error?.message || String(error),
+		);
+	}
+};
+
+export const solforgeListTokensDetailed: RpcMethodHandler = async (
+	id,
+	_params,
+	context,
+) => {
+	try {
+		const mints = context.listMints ? context.listMints() : [];
+		const detailed = mints
+			.map((mint) => {
+				try {
+					const info = context.svm.getAccount(new PublicKey(mint));
+					if (!info) return null;
+					const data = Buffer.from(info.data?.slice(0, MINT_SIZE) ?? []);
+					if (data.length < MINT_SIZE) return null;
+					const decoded = MintLayout.decode(data);
+					const supply = BigInt(decoded.supply.toString());
+					const decimals = Number(decoded.decimals ?? 0);
+					const ui = formatUiAmount(supply, decimals);
+					const hasAuthority = decoded.mintAuthorityOption === 1;
+					const authority = hasAuthority
+						? (() => {
+								try {
+									return new PublicKey(decoded.mintAuthority).toBase58();
+								} catch {
+									return null;
+								}
+							})()
+						: null;
+					return {
+						mint,
+						supply: supply.toString(),
+						decimals,
+						uiAmount: ui.uiAmount,
+						uiAmountString: ui.uiAmountString,
+						mintAuthority: authority,
+						isInitialized: decoded.isInitialized ?? false,
+					};
+				} catch {
+					return null;
+				}
+			})
+			.filter(Boolean);
+
+		return context.createSuccessResponse(id, detailed);
+	} catch (error: any) {
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"List tokens failed",
+			error?.message || String(error),
+		);
+	}
+};

package/server/methods/system/get-health.ts

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

package/server/methods/system/get-minimum-balance-for-rent-exemption.ts

@@ -0,0 +1,13 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getMinimumBalanceForRentExemption: RpcMethodHandler = (
+	id,
+	params,
+	context,
+) => {
+	const [dataLength] = params || [];
+	const minBalance = context.svm.minimumBalanceForRentExemption(
+		BigInt(dataLength),
+	);
+	return context.createSuccessResponse(id, Number(minBalance));
+};