solforge 0.1.7 → 0.2.1

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,
+		},
+	});
+};

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

@@ -0,0 +1,22 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getRecentPrioritizationFees: RpcMethodHandler = (
+	id,
+	params,
+	context,
+) => {
+	const addresses = params?.[0] || [];
+	const fees =
+		addresses.length > 0
+			? addresses.map(() => ({
+					slot: Number(context.slot),
+					prioritizationFee: 0,
+				}))
+			: Array(150)
+					.fill(null)
+					.map((_, i) => ({
+						slot: Math.max(0, Number(context.slot) - i),
+						prioritizationFee: 0,
+					}));
+	return context.createSuccessResponse(id, fees);
+};

package/server/methods/fee/index.ts

@@ -0,0 +1,5 @@
+export { getFeeCalculatorForBlockhash } from "./get-fee-calculator-for-blockhash";
+export { getFeeForMessage } from "./get-fee-for-message";
+export { getFeeRateGovernor } from "./get-fee-rate-governor";
+export { getFees } from "./get-fees";
+export { getRecentPrioritizationFees } from "./get-recent-prioritization-fees";

package/server/methods/get-address-lookup-table.ts

@@ -0,0 +1,31 @@
+import type { RpcMethodHandler } from "../types";
+
+export const getAddressLookupTable: RpcMethodHandler = (
+	id,
+	params,
+	context,
+) => {
+	try {
+		const [arg] = params || [];
+		const address: string =
+			typeof arg === "string" ? arg : arg?.accountKey || arg?.address;
+		if (!address || typeof address !== "string") {
+			throw new Error("Missing address");
+		}
+		const bytes = context.decodeBase58(address);
+		if (!(bytes instanceof Uint8Array) || bytes.length !== 32) {
+			throw new Error("Invalid address length");
+		}
+		return context.createSuccessResponse(id, {
+			context: { slot: Number(context.slot) },
+			value: null,
+		});
+	} catch (error: any) {
+		return context.createErrorResponse(
+			id,
+			-32602,
+			"Invalid params",
+			error.message,
+		);
+	}
+};

package/server/methods/index.ts

@@ -0,0 +1,265 @@
+import type { RpcMethodHandler } from "../types";
+
+// Account methods are now in a subdirectory for better organization
+import {
+	getAccountInfo,
+	getBalance,
+	getMultipleAccounts,
+	getParsedAccountInfo,
+	requestAirdrop,
+} from "./account";
+import {
+	solforgeAdminCloneProgram,
+	solforgeAdminCloneProgramAccounts,
+	solforgeAdminCloneTokenAccounts,
+	solforgeAdminCloneTokenMint,
+	solforgeAdoptMintAuthority,
+	solforgeCreateMint,
+	solforgeCreateTokenAccount,
+	solforgeListMints,
+	solforgeLoadProgram,
+	solforgeMintTo,
+} from "./admin";
+
+import {
+	getBlock,
+	getBlockHeight,
+	getBlocksWithLimit,
+	getLatestBlockhash,
+	getSlot,
+	isBlockhashValid,
+} from "./block";
+import {
+	getClusterNodes,
+	getEpochInfo,
+	getEpochSchedule,
+	getHighestSnapshotSlot,
+	getLeaderSchedule,
+	getMaxRetransmitSlot,
+	getMaxShredInsertSlot,
+	getSlotLeader,
+	getSlotLeaders,
+	getStakeActivation,
+	getStakeMinimumDelegation,
+	getVoteAccounts,
+	minimumLedgerSlot,
+} from "./epoch";
+import {
+	getFeeCalculatorForBlockhash,
+	getFeeForMessage,
+	getFeeRateGovernor,
+	getFees,
+	getRecentPrioritizationFees,
+} from "./fee";
+import { getAddressLookupTable } from "./get-address-lookup-table";
+import {
+	getRecentPerformanceSamples,
+	getTransactionCount,
+} from "./performance";
+import {
+	getBlockCommitment,
+	getBlockProduction,
+	getBlocks,
+	getBlockTime,
+	getFirstAvailableBlock,
+	getGenesisHash,
+	getIdentity,
+	getInflationGovernor,
+	getInflationRate,
+	getInflationReward,
+	getLargestAccounts,
+	getParsedProgramAccounts,
+	getParsedTokenAccountsByDelegate,
+	getParsedTokenAccountsByOwner,
+	getProgramAccounts,
+	getSupply,
+	getTokenAccountBalance,
+	getTokenAccountsByDelegate,
+	getTokenAccountsByOwner,
+	getTokenLargestAccounts,
+	getTokenSupply,
+} from "./program";
+import {
+	solforgeGetStatus,
+	solforgeListPrograms,
+	solforgeListTokensDetailed,
+} from "./solforge";
+import {
+	getHealth,
+	getMinimumBalanceForRentExemption,
+	getVersion,
+} from "./system";
+import {
+	getConfirmedTransaction,
+	getParsedTransaction,
+	getSignatureStatuses,
+	getSignaturesForAddress,
+	getTransaction,
+	sendTransaction,
+	simulateTransaction,
+} from "./transaction";
+
+export const rpcMethods: Record<string, RpcMethodHandler> = {
+	// Account methods
+	getAccountInfo,
+	getBalance,
+	getMultipleAccounts,
+	requestAirdrop,
+	getParsedAccountInfo,
+
+	// Transaction methods
+	sendTransaction,
+	simulateTransaction,
+	getTransaction,
+	getParsedTransaction,
+	getSignatureStatuses,
+	getSignaturesForAddress,
+	getConfirmedTransaction,
+
+	// Block methods
+	getLatestBlockhash,
+	getSlot,
+	getBlockHeight,
+	isBlockhashValid,
+	getBlock,
+	getBlocksWithLimit,
+
+	// System methods
+	getMinimumBalanceForRentExemption,
+	getHealth,
+	getVersion,
+	// Program/network info methods
+	getBlockTime,
+	getBlocks,
+	getFirstAvailableBlock,
+	getGenesisHash,
+	getIdentity,
+	getInflationGovernor,
+	getInflationRate,
+	getInflationReward,
+	getSupply,
+	getBlockProduction,
+	getParsedProgramAccounts,
+	getProgramAccounts,
+	getTokenAccountBalance,
+	getTokenAccountsByOwner,
+	getTokenAccountsByDelegate,
+	getParsedTokenAccountsByOwner,
+	getParsedTokenAccountsByDelegate,
+	getTokenLargestAccounts,
+	getTokenSupply,
+	getBlockCommitment,
+	getLargestAccounts,
+
+	// Epoch/cluster methods
+	getEpochSchedule,
+	getEpochInfo,
+	getLeaderSchedule,
+	getSlotLeader,
+	getSlotLeaders,
+	getVoteAccounts,
+	getClusterNodes,
+	getStakeActivation,
+	getMaxRetransmitSlot,
+	getHighestSnapshotSlot,
+	minimumLedgerSlot,
+	getStakeMinimumDelegation,
+	getMaxShredInsertSlot,
+	// Performance metrics
+	getRecentPerformanceSamples,
+	getTransactionCount,
+	getAddressLookupTable,
+
+	// Fee methods
+	getRecentPrioritizationFees,
+	getFeeForMessage,
+	getFees,
+	getFeeCalculatorForBlockhash,
+	getFeeRateGovernor,
+
+	// Solforge helpers
+	solforgeGetStatus,
+	solforgeListPrograms,
+	solforgeListTokensDetailed,
+};
+
+// Admin methods (gated by SOLFORGE_ADMIN=1)
+export const adminMethods: Record<string, RpcMethodHandler> = {
+	solforgeAdminCloneProgram,
+	solforgeAdminCloneProgramAccounts,
+	solforgeAdminCloneTokenMint,
+	solforgeAdminCloneTokenAccounts,
+	solforgeCreateTokenAccount,
+	solforgeLoadProgram,
+	solforgeCreateMint,
+	solforgeListMints,
+	solforgeMintTo,
+	solforgeAdoptMintAuthority,
+};
+
+Object.assign(rpcMethods, adminMethods);
+
+export {
+	getAccountInfo,
+	getBalance,
+	getMultipleAccounts,
+	requestAirdrop,
+	sendTransaction,
+	simulateTransaction,
+	getTransaction,
+	getSignatureStatuses,
+	getSignaturesForAddress,
+	getConfirmedTransaction,
+	getLatestBlockhash,
+	getSlot,
+	getBlockHeight,
+	isBlockhashValid,
+	getBlock,
+	getBlocksWithLimit,
+	getMinimumBalanceForRentExemption,
+	getHealth,
+	getVersion,
+	getBlockTime,
+	getBlocks,
+	getFirstAvailableBlock,
+	getGenesisHash,
+	getIdentity,
+	getInflationGovernor,
+	getInflationRate,
+	getInflationReward,
+	getSupply,
+	getBlockProduction,
+	getParsedProgramAccounts,
+	getProgramAccounts,
+	getTokenAccountBalance,
+	getTokenAccountsByOwner,
+	getTokenAccountsByDelegate,
+	getTokenLargestAccounts,
+	getTokenSupply,
+	getBlockCommitment,
+	getLargestAccounts,
+	getEpochSchedule,
+	getEpochInfo,
+	getLeaderSchedule,
+	getSlotLeader,
+	getSlotLeaders,
+	getVoteAccounts,
+	getClusterNodes,
+	getStakeActivation,
+	getMaxRetransmitSlot,
+	getHighestSnapshotSlot,
+	minimumLedgerSlot,
+	getStakeMinimumDelegation,
+	getMaxShredInsertSlot,
+	getRecentPerformanceSamples,
+	getTransactionCount,
+	getAddressLookupTable,
+	solforgeGetStatus,
+	solforgeListPrograms,
+	solforgeListTokensDetailed,
+	getRecentPrioritizationFees,
+	getFeeForMessage,
+	getFees,
+	getFeeCalculatorForBlockhash,
+	getFeeRateGovernor,
+};

package/server/methods/performance/get-recent-performance-samples.ts

@@ -0,0 +1,25 @@
+import type { RpcMethodHandler } from "../../types";
+
+const SLOTS_PER_60S_SAMPLE = 150;
+
+export const getRecentPerformanceSamples: RpcMethodHandler = (
+	id,
+	params,
+	context,
+) => {
+	const [limitRaw] = params || [];
+	const limit = Math.max(1, Math.min(Number(limitRaw ?? 1), 720));
+	const samples = Array.from({ length: limit }, (_v, i) => {
+		const slot = Math.max(0, Number(context.slot) - i * SLOTS_PER_60S_SAMPLE);
+		const numSlots = SLOTS_PER_60S_SAMPLE;
+		const totalTx = Number(context.getTxCount());
+		const estPerSample = Math.max(0, Math.min(totalTx, 5000));
+		return {
+			numSlots,
+			numTransactions: estPerSample,
+			samplePeriodSecs: 60,
+			slot,
+		};
+	});
+	return context.createSuccessResponse(id, samples);
+};

package/server/methods/performance/get-transaction-count.ts

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

package/server/methods/performance/index.ts

@@ -0,0 +1,2 @@
+export { getRecentPerformanceSamples } from "./get-recent-performance-samples";
+export { getTransactionCount } from "./get-transaction-count";

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

@@ -0,0 +1,9 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getBlockCommitment: RpcMethodHandler = (id, params, context) => {
+	const [_slot] = params || [];
+	return context.createSuccessResponse(id, {
+		commitment: [Number(context.slot), 0],
+		totalStake: 1000000000,
+	});
+};

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

@@ -0,0 +1,14 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getBlockProduction: RpcMethodHandler = (id, _params, context) => {
+	return context.createSuccessResponse(id, {
+		context: { slot: Number(context.slot) },
+		value: {
+			byIdentity: {},
+			range: {
+				firstSlot: 0,
+				lastSlot: Number(context.slot),
+			},
+		},
+	});
+};

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

@@ -0,0 +1,21 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getBlockTime: RpcMethodHandler = async (id, params, context) => {
+	const [slot] = params || [];
+	// Prefer persisted time if available
+	try {
+		const fromDb = await context.store?.getBlockTimeForSlot(Number(slot));
+		if (typeof fromDb === "number") {
+			return context.createSuccessResponse(id, fromDb);
+		}
+	} catch {}
+
+	if (Number(slot) > Number(context.slot)) {
+		return context.createSuccessResponse(id, null);
+	}
+	const SLOT_TIME_MS = 400;
+	const currentTime = Math.floor(Date.now() / 1000);
+	const slotDiff = Number(context.slot) - Number(slot);
+	const blockTime = currentTime - Math.floor((slotDiff * SLOT_TIME_MS) / 1000);
+	return context.createSuccessResponse(id, blockTime);
+};

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

@@ -0,0 +1,11 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getBlocks: RpcMethodHandler = (id, params, context) => {
+	const [startSlot, endSlot] = params || [];
+	const start = Number(startSlot || 0);
+	const end = Number(endSlot || context.slot);
+	const blocks: number[] = [];
+	for (let i = start; i <= end && i <= Number(context.slot); i++)
+		blocks.push(i);
+	return context.createSuccessResponse(id, blocks);
+};

package/server/methods/program/get-first-available-block.ts

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

package/server/methods/program/get-genesis-hash.ts

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

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

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

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

@@ -0,0 +1,15 @@
+import type { RpcMethodHandler } from "../../types";
+
+export const getInflationGovernor: RpcMethodHandler = (
+	id,
+	_params,
+	context,
+) => {
+	return context.createSuccessResponse(id, {
+		foundation: 0.05,
+		foundationTerm: 7,
+		initial: 0.15,
+		taper: 0.15,
+		terminal: 0.015,
+	});
+};

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+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);
+};