solforge 0.2.11 → 0.2.13

package/server/methods/program/get-inflation-rate.ts

@@ -1,10 +0,0 @@
-import type { RpcMethodHandler } from "../../types";
-
-export const getInflationRate: RpcMethodHandler = (id, _params, context) => {
-	return context.createSuccessResponse(id, {
-		epoch: 0,
-		foundation: 0.05,
-		total: 0.15,
-		validator: 0.1,
-	});
-};

package/server/methods/program/get-inflation-reward.ts

@@ -1,12 +0,0 @@
-import type { RpcMethodHandler } from "../../types";
-
-export const getInflationReward: RpcMethodHandler = (id, params, context) => {
-	const [addresses] = params || [[]];
-	const rewards = (addresses || []).map(() => ({
-		amount: 0,
-		effectiveSlot: Number(context.slot),
-		epoch: 0,
-		postBalance: 1000000000,
-	}));
-	return context.createSuccessResponse(id, rewards);
-};

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

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

package/server/methods/program/get-parsed-program-accounts.ts

@@ -1,12 +0,0 @@
-import type { RpcMethodHandler } from "../../types";
-import { getProgramAccounts } from "./get-program-accounts";
-
-export const getParsedProgramAccounts: RpcMethodHandler = (
-	id,
-	params,
-	context,
-) => {
-	const [programId, config] = params || [];
-	const cfg = { ...(config || {}), encoding: "jsonParsed" };
-	return getProgramAccounts(id, [programId, cfg], context);
-};

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

@@ -1,12 +0,0 @@
-import type { RpcMethodHandler } from "../../types";
-import { getTokenAccountsByDelegate } from "./get-token-accounts-by-delegate";
-
-export const getParsedTokenAccountsByDelegate: RpcMethodHandler = (
-	id,
-	params,
-	context,
-) => {
-	const [delegate, filter, config] = params || [];
-	const cfg = { ...(config || {}), encoding: "jsonParsed" };
-	return getTokenAccountsByDelegate(id, [delegate, filter, cfg], context);
-};

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

@@ -1,12 +0,0 @@
-import type { RpcMethodHandler } from "../../types";
-import { getTokenAccountsByOwner } from "./get-token-accounts-by-owner";
-
-export const getParsedTokenAccountsByOwner: RpcMethodHandler = (
-	id,
-	params,
-	context,
-) => {
-	const [owner, filter, config] = params || [];
-	const cfg = { ...(config || {}), encoding: "jsonParsed" };
-	return getTokenAccountsByOwner(id, [owner, filter, cfg], context);
-};

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

@@ -1,221 +0,0 @@
-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";
-import { parseUpgradeableLoader } from "../account/parsers/loader-upgradeable";
-
-export const getProgramAccounts: RpcMethodHandler = async (
-	id,
-	params,
-	context,
-) => {
-	const [programId, cfg] = params || [];
-	try {
-		const programPk = new PublicKey(programId);
-		const programStr = programPk.toBase58();
-		const encoding: string = cfg?.encoding || "base64";
-		const dataSlice = cfg?.dataSlice as
-			| { offset: number; length: number }
-			| undefined;
-		type GpaFilter = {
-			dataSize?: number;
-			memcmp?: { offset?: number; bytes?: string };
-		};
-		const filters: GpaFilter[] = (cfg?.filters as unknown as GpaFilter[]) || [];
-		const limit = Math.max(1, Math.min(Number(cfg?.limit ?? 10000), 50000));
-
-		let rows: Array<{ address: string }> = [];
-		try {
-			rows = (await context.store?.getAccountsByOwner(programStr, limit)) || [];
-		} catch {}
-
-		const out: unknown[] = [];
-		for (const r of rows) {
-			try {
-				const pk = new PublicKey(r.address);
-				const acc = context.svm.getAccount(pk);
-				if (!acc) continue;
-
-				// dataSize filter
-				if (
-					filters.some((f) => typeof f?.dataSize === "number") &&
-					!filters.every(
-						(f) => f.dataSize == null || (acc.data?.length ?? 0) === f.dataSize,
-					)
-				)
-					continue;
-				// memcmp filters
-				const raw = new Uint8Array(acc.data || []);
-				let memcmpOk = true;
-				for (const f of filters) {
-					if (!f?.memcmp) continue;
-					const off = Number(f.memcmp.offset || 0);
-					const bytesStr: string = String(f.memcmp.bytes || "");
-					let needle: Uint8Array;
-					try {
-						needle = context.decodeBase58(bytesStr);
-					} catch {
-						try {
-							needle = Buffer.from(bytesStr, "base64");
-						} catch {
-							needle = new Uint8Array();
-						}
-					}
-					for (let i = 0; i < needle.length; i++) {
-						if (raw[off + i] !== needle[i]) {
-							memcmpOk = false;
-							break;
-						}
-					}
-					if (!memcmpOk) break;
-				}
-				if (!memcmpOk) continue;
-
-				if (
-					encoding === "jsonParsed" &&
-					(programPk.equals(TOKEN_PROGRAM_ID) ||
-						programPk.equals(TOKEN_2022_PROGRAM_ID))
-				) {
-					if ((acc.data?.length ?? 0) < 165) continue;
-					const ownerPk = new PublicKey(acc.owner);
-					const dec = unpackAccount(
-						pk,
-						{ data: Buffer.from(acc.data), owner: ownerPk },
-						programPk,
-					);
-					// mint decimals
-					let decimals = 0;
-					try {
-						const mintAcc = context.svm.getAccount(dec.mint);
-						if (mintAcc) {
-							const mintProg = new PublicKey(mintAcc.owner).equals(
-								TOKEN_2022_PROGRAM_ID,
-							)
-								? TOKEN_2022_PROGRAM_ID
-								: TOKEN_PROGRAM_ID;
-							const mi = unpackMint(
-								dec.mint,
-								{
-									data: Buffer.from(mintAcc.data),
-									owner: new PublicKey(mintAcc.owner),
-								},
-								mintProg,
-							);
-							decimals = mi?.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 programLabel = programPk.equals(TOKEN_2022_PROGRAM_ID)
-						? "spl-token-2022"
-						: "spl-token";
-					out.push({
-						pubkey: r.address,
-						account: {
-							lamports: Number(acc.lamports || 0n),
-							owner: programStr,
-							executable: !!acc.executable,
-							rentEpoch: Number(acc.rentEpoch || 0),
-							data: {
-								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: BigInt(
-												dec.delegatedAmount?.toString?.() ??
-													dec.delegatedAmount ??
-													0,
-											).toString(),
-											decimals,
-											uiAmount: null,
-											uiAmountString: "0",
-										},
-										delegate: dec.delegate ? dec.delegate.toBase58() : null,
-										rentExemptReserve: dec.isNative
-											? {
-													amount: BigInt(
-														dec.rentExemptReserve?.toString?.() ??
-															dec.rentExemptReserve ??
-															0,
-													).toString(),
-													decimals: 9,
-													uiAmount: null,
-													uiAmountString: "0",
-												}
-											: null,
-										closeAuthority: dec.closeAuthority
-											? dec.closeAuthority.toBase58()
-											: null,
-									},
-								},
-								space: acc.data?.length ?? 0,
-							},
-						},
-					});
-				} else if (
-					encoding === "jsonParsed" &&
-					programStr === "BPFLoaderUpgradeab1e11111111111111111111111"
-				) {
-					const parsed = parseUpgradeableLoader(programStr, raw, context);
-					out.push({
-						pubkey: r.address,
-						account: {
-							lamports: Number(acc.lamports || 0n),
-							owner: programStr,
-							executable: !!acc.executable,
-							rentEpoch: Number(acc.rentEpoch || 0),
-							data: parsed,
-						},
-					});
-				} else {
-					let bytes = Buffer.from(acc.data);
-					if (
-						dataSlice &&
-						Number.isFinite(dataSlice.offset) &&
-						Number.isFinite(dataSlice.length)
-					) {
-						bytes = bytes.subarray(
-							dataSlice.offset,
-							dataSlice.offset + dataSlice.length,
-						);
-					}
-					out.push({
-						pubkey: r.address,
-						account: {
-							lamports: Number(acc.lamports || 0n),
-							owner: new PublicKey(acc.owner).toBase58(),
-							data: [bytes.toString("base64"), "base64"] as const,
-							executable: !!acc.executable,
-							rentEpoch: Number(acc.rentEpoch || 0),
-						},
-					});
-				}
-			} catch {}
-		}
-
-		return context.createSuccessResponse(id, out);
-	} catch (error: unknown) {
-		const message = error instanceof Error ? error.message : String(error);
-		return context.createErrorResponse(id, -32602, "Invalid params", message);
-	}
-};

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

@@ -1,13 +0,0 @@
-import type { RpcMethodHandler } from "../../types";
-
-export const getSupply: RpcMethodHandler = (id, _params, context) => {
-	return context.createSuccessResponse(id, {
-		context: { slot: Number(context.slot) },
-		value: {
-			circulating: 1000000000000,
-			nonCirculating: 0,
-			nonCirculatingAccounts: [],
-			total: 1000000000000,
-		},
-	});
-};

package/server/methods/program/get-token-account-balance.ts

@@ -1,60 +0,0 @@
-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 getTokenAccountBalance: RpcMethodHandler = (
-	id,
-	params,
-	context,
-) => {
-	const [pubkey] = params || [];
-	try {
-		const pubkeyBytes = context.decodeBase58(pubkey);
-		const address = new PublicKey(pubkeyBytes);
-		const account = context.svm.getAccount(address);
-		if (!account)
-			return context.createErrorResponse(id, -32602, "Account not found");
-		const ownerPk = new PublicKey(account.owner);
-		const programPk = ownerPk.equals(TOKEN_2022_PROGRAM_ID)
-			? TOKEN_2022_PROGRAM_ID
-			: TOKEN_PROGRAM_ID;
-		const decoded = unpackAccount(
-			address,
-			{ data: Buffer.from(account.data), owner: ownerPk },
-			programPk,
-		);
-		const mintAcc = context.svm.getAccount(decoded.mint);
-		const mintInfo = mintAcc
-			? unpackMint(
-					decoded.mint,
-					{
-						data: Buffer.from(mintAcc.data),
-						owner: new PublicKey(mintAcc.owner),
-					},
-					new PublicKey(mintAcc.owner).equals(TOKEN_2022_PROGRAM_ID)
-						? TOKEN_2022_PROGRAM_ID
-						: TOKEN_PROGRAM_ID,
-				)
-			: null;
-		const decimals = mintInfo?.decimals ?? 0;
-		const amount = BigInt(decoded.amount?.toString?.() ?? decoded.amount ?? 0);
-		const ui = Number(amount) / 10 ** decimals;
-		return context.createSuccessResponse(id, {
-			context: { slot: Number(context.slot) },
-			value: {
-				amount: amount.toString(),
-				decimals,
-				uiAmount: ui,
-				uiAmountString: ui.toString(),
-			},
-		});
-	} catch (error: unknown) {
-		const message = error instanceof Error ? error.message : String(error);
-		return context.createErrorResponse(id, -32602, "Invalid params", message);
-	}
-};

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

@@ -1,82 +0,0 @@
-import {
-	TOKEN_2022_PROGRAM_ID,
-	TOKEN_PROGRAM_ID,
-	unpackAccount,
-} from "@solana/spl-token";
-import { PublicKey } from "@solana/web3.js";
-import type { RpcMethodHandler } from "../../types";
-
-export const getTokenAccountsByDelegate: RpcMethodHandler = async (
-	id,
-	params,
-	context,
-) => {
-	const [delegateStr, filter, config] = params || [];
-	try {
-		const delegate = new PublicKey(delegateStr);
-		const requestedProgramId: string | null = filter?.programId
-			? String(filter.programId)
-			: null;
-		const classicId = TOKEN_PROGRAM_ID.toBase58();
-		const token2022Id = TOKEN_2022_PROGRAM_ID.toBase58();
-		const programFilter =
-			requestedProgramId === token2022Id ? token2022Id : classicId;
-		const rows =
-			(await context.store?.getAccountsByOwner(programFilter, 50_000)) || [];
-		const out: unknown[] = [];
-		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 programPk =
-					programFilter === token2022Id
-						? TOKEN_2022_PROGRAM_ID
-						: TOKEN_PROGRAM_ID;
-				const dec = unpackAccount(
-					new PublicKey(r.address),
-					{ data: Buffer.from(acc.data), owner: new PublicKey(acc.owner) },
-					programPk,
-				);
-				if (!dec.delegate || !dec.delegate.equals(delegate)) continue;
-				if ((config?.encoding || "jsonParsed") === "jsonParsed") {
-					out.push({
-						pubkey: r.address,
-						account: {
-							lamports: Number(acc.lamports || 0n),
-							owner: TOKEN_PROGRAM_ID.toBase58(),
-							executable: !!acc.executable,
-							rentEpoch: Number(acc.rentEpoch || 0),
-							data: {
-								program: "spl-token",
-								parsed: { type: "account", info: {} },
-								space: data.length,
-							},
-						},
-					});
-				} else {
-					out.push({
-						pubkey: r.address,
-						account: {
-							lamports: Number(acc.lamports || 0n),
-							owner: TOKEN_PROGRAM_ID.toBase58(),
-							executable: !!acc.executable,
-							rentEpoch: Number(acc.rentEpoch || 0),
-							data: [
-								Buffer.from(acc.data).toString("base64"),
-								"base64",
-							] as const,
-						},
-					});
-				}
-			} catch {}
-		}
-		return context.createSuccessResponse(id, {
-			context: { slot: Number(context.slot) },
-			value: out,
-		});
-	} catch (e: unknown) {
-		const message = e instanceof Error ? e.message : String(e);
-		return context.createErrorResponse(id, -32602, "Invalid params", message);
-	}
-};