solforge 0.2.12 → 0.2.13

package/server/methods/admin/create-token-account.ts

@@ -1,137 +0,0 @@
-import {
-	ACCOUNT_SIZE,
-	AccountLayout,
-	getAssociatedTokenAddressSync,
-	TOKEN_PROGRAM_ID,
-} from "@solana/spl-token";
-import { PublicKey } from "@solana/web3.js";
-import type { RpcMethodHandler } from "../../types";
-
-// Create or overwrite a token account (ATA) with a specified amount
-export const solforgeCreateTokenAccount: RpcMethodHandler = async (
-	id,
-	params,
-	context,
-) => {
-	try {
-		const [mintStr, ownerStr, rawAmount, decimals] = params as [
-			string,
-			string | null | undefined,
-			number | string | bigint,
-			number?,
-		];
-		if (!mintStr || rawAmount == null)
-			return context.createErrorResponse(
-				id,
-				-32602,
-				"Invalid params: mint and amount required",
-			);
-		const mint = new PublicKey(mintStr);
-		const owner = ownerStr
-			? new PublicKey(ownerStr)
-			: context.getFaucet().publicKey;
-		// Amount is in base units (not UI). The layout stores a u64 bigint
-		const amount =
-			typeof rawAmount === "bigint" ? rawAmount : BigInt(rawAmount);
-
-		const buf = Buffer.alloc(ACCOUNT_SIZE);
-		type TokenAccountStruct = Parameters<typeof AccountLayout.encode>[0];
-		const tokenAccount = {
-			mint,
-			owner,
-			amount,
-			delegateOption: 0,
-			delegate: PublicKey.default,
-			delegatedAmount: 0n,
-			state: 1,
-			isNativeOption: 0,
-			isNative: 0n,
-			closeAuthorityOption: 0,
-			closeAuthority: PublicKey.default,
-		} satisfies Partial<TokenAccountStruct> as TokenAccountStruct;
-		AccountLayout.encode(tokenAccount, buf);
-
-		const rentLamports = Number(
-			context.svm.minimumBalanceForRentExemption(BigInt(ACCOUNT_SIZE)),
-		);
-
-		// Compute the canonical associated token account address for mint+owner
-		const address = getAssociatedTokenAddressSync(mint, owner, true);
-
-		context.svm.setAccount(address, {
-			lamports: rentLamports,
-			data: new Uint8Array(buf),
-			owner: TOKEN_PROGRAM_ID,
-			executable: false,
-			rentEpoch: 0,
-		});
-		try {
-			await context.store?.upsertAccounts([
-				{
-					address: address.toBase58(),
-					lamports: rentLamports,
-					ownerProgram: TOKEN_PROGRAM_ID.toBase58(),
-					executable: false,
-					rentEpoch: 0,
-					dataLen: ACCOUNT_SIZE,
-					dataBase64: undefined,
-					lastSlot: Number(context.slot),
-				},
-			]);
-		} catch {}
-		// Record a synthetic transaction so explorers can show activity
-		try {
-			const sig = `admin:mint:${address.toBase58()}:${Date.now()}`;
-			await context.store?.insertTransactionBundle({
-				signature: sig,
-				slot: Number(context.slot),
-				blockTime: Math.floor(Date.now() / 1000),
-				version: "legacy",
-				fee: 0,
-				err: null,
-				rawBase64: "",
-				preBalances: [],
-				postBalances: [],
-				logs: ["admin mint"],
-				accounts: [
-					{
-						address: address.toBase58(),
-						index: 0,
-						signer: false,
-						writable: true,
-					},
-					{
-						address: mint.toBase58(),
-						index: 1,
-						signer: false,
-						writable: false,
-					},
-					{
-						address: owner.toBase58(),
-						index: 2,
-						signer: false,
-						writable: false,
-					},
-				],
-			});
-		} catch {}
-
-		return context.createSuccessResponse(id, {
-			ok: true,
-			address: address.toBase58(),
-			mint: mintStr,
-			owner: owner.toBase58(),
-			amount: amount.toString(),
-			decimals: decimals ?? null,
-		});
-	} catch (e) {
-		return context.createErrorResponse(
-			id,
-			-32603,
-			"Create token account failed",
-			(e as Error)?.message || String(e),
-		);
-	}
-};
-
-export type { RpcMethodHandler } from "../../types";

package/server/methods/admin/helpers.ts

@@ -1,70 +0,0 @@
-import {
-	getMetadataPointerState,
-	MINT_SIZE,
-	TOKEN_2022_PROGRAM_ID,
-	TOKEN_PROGRAM_ID,
-	unpackMint,
-} from "@solana/spl-token";
-import type { AccountInfo, Connection, PublicKey } from "@solana/web3.js";
-
-import type { RpcMethodContext } from "../../types";
-
-export async function cloneMintExtensionAccounts(
-	conn: Connection,
-	context: RpcMethodContext,
-	mint: PublicKey,
-	info: AccountInfo<Buffer>,
-): Promise<void> {
-	if (!info.data || info.data.length <= MINT_SIZE) return;
-	try {
-		const programId = info.owner.equals(TOKEN_2022_PROGRAM_ID)
-			? TOKEN_2022_PROGRAM_ID
-			: TOKEN_PROGRAM_ID;
-		const mintState = unpackMint(mint, info, programId);
-		if (!mintState.tlvData || mintState.tlvData.length === 0) return;
-
-		const metadataPtr = getMetadataPointerState(mintState);
-		if (metadataPtr?.metadataAddress) {
-			await cloneSingleAccount(
-				conn,
-				context,
-				metadataPtr.metadataAddress,
-				"metadata",
-			);
-		}
-	} catch (error) {
-		console.warn("[admin] mint extension clone skipped", {
-			mint: mint.toBase58(),
-			error: String(error),
-		});
-	}
-}
-
-export async function cloneSingleAccount(
-	conn: Connection,
-	context: RpcMethodContext,
-	address: PublicKey,
-	label: string,
-): Promise<void> {
-	try {
-		const info = await conn.getAccountInfo(address, "confirmed");
-		if (!info) {
-			console.warn(`[admin] ${label} account not found on endpoint`, {
-				address: address.toBase58(),
-			});
-			return;
-		}
-		context.svm.setAccount(address, {
-			data: new Uint8Array(info.data as Buffer),
-			executable: info.executable,
-			lamports: Number(info.lamports),
-			owner: info.owner,
-			rentEpoch: 0,
-		});
-	} catch (error) {
-		console.warn(`[admin] clone ${label} account failed`, {
-			address: address.toBase58(),
-			error: String(error),
-		});
-	}
-}

package/server/methods/admin/index.ts

@@ -1,10 +0,0 @@
-export { solforgeAdoptMintAuthority } from "./adopt-mint-authority";
-export { solforgeAdminCloneProgram } from "./clone-program";
-export { solforgeAdminCloneProgramAccounts } from "./clone-program-accounts";
-export { solforgeAdminCloneTokenAccounts } from "./clone-token-accounts";
-export { solforgeAdminCloneTokenMint } from "./clone-token-mint";
-export { solforgeCreateMint } from "./create-mint";
-export { solforgeCreateTokenAccount } from "./create-token-account";
-export { solforgeListMints } from "./list-mints";
-export { solforgeLoadProgram } from "./load-program";
-export { solforgeMintTo } from "./mint-to";

package/server/methods/admin/list-mints.ts

@@ -1,21 +0,0 @@
-import type { RpcMethodHandler } from "../../types";
-
-export const solforgeListMints: RpcMethodHandler = async (
-	id,
-	_params,
-	context,
-) => {
-	try {
-		const list = context.listMints ? context.listMints() : [];
-		return context.createSuccessResponse(id, list);
-	} catch (e) {
-		return context.createErrorResponse(
-			id,
-			-32603,
-			"List mints failed",
-			(e as Error)?.message || String(e),
-		);
-	}
-};
-
-export type { RpcMethodHandler } from "../../types";

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

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

@@ -1,266 +0,0 @@
-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";
-import { sendTransaction as sendTxRpc } from "../transaction/send-transaction";
-
-// 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 via the standard RPC sendTransaction path to unify capture/parsing
-		const rawBase64ForRpc = Buffer.from(vtx.serialize()).toString("base64");
-		const rpcResp = await (sendTxRpc as RpcMethodHandler)(
-			id,
-			[rawBase64ForRpc],
-			context,
-		);
-		if (
-			rpcResp &&
-			typeof rpcResp === "object" &&
-			"error" in (rpcResp as Record<string, unknown>) &&
-			(rpcResp as Record<string, unknown>).error != null
-		) {
-			return rpcResp;
-		}
-		const signatureStr = (() => {
-			try {
-				const r = rpcResp as Record<string, unknown>;
-				const v = r?.result;
-				return v == null ? "" : String(v);
-			} catch {
-				return "";
-			}
-		})();
-
-		// 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;
-		};
-		const _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 {}
-
-		// send-transaction already records/announces signature and persists to DB
-
-		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

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

@@ -1,31 +0,0 @@
-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: unknown) {
-		const message = error instanceof Error ? error.message : String(error);
-		return context.createErrorResponse(id, -32602, "Invalid params", message);
-	}
-};

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

@@ -1,19 +0,0 @@
-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: unknown) {
-		const message = error instanceof Error ? error.message : String(error);
-		return context.createErrorResponse(id, -32602, "Invalid params", message);
-	}
-};

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

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

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

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

@@ -1,19 +0,0 @@
-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: unknown) {
-		const message = error instanceof Error ? error.message : String(error);
-		return context.createErrorResponse(id, -32602, "Invalid params", message);
-	}
-};

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

@@ -1,17 +0,0 @@
-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",
-			},
-		],
-	};
-};