solforge 0.1.7 → 0.2.0

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

@@ -0,0 +1,152 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+import { parseUpgradeableLoader } from "../account/parsers/loader-upgradeable";
+
+export const solforgeAdminCloneProgram: RpcMethodHandler = async (
+	id,
+	params,
+	context,
+) => {
+	const [programId, options] = params as [
+		string,
+		{ endpoint?: string; withAccounts?: boolean; accountsLimit?: number }?,
+	];
+	if (!programId)
+		return context.createErrorResponse(
+			id,
+			-32602,
+			"Invalid params: programId required",
+		);
+	const endpoint = options?.endpoint || "https://api.mainnet-beta.solana.com";
+	try {
+		const conn = new Connection(endpoint, "confirmed");
+		const pid = new PublicKey(programId);
+		const info = await conn.getAccountInfo(pid, "confirmed");
+		if (!info)
+			return context.createErrorResponse(
+				id,
+				-32004,
+				"Program account not found on endpoint",
+				{ programId, endpoint },
+			);
+
+		console.log("[admin] clone program start", {
+			programId: pid.toBase58(),
+			owner: info.owner.toBase58(),
+			exec: info.executable,
+			dataLen: info.data?.length ?? 0,
+		});
+		const ownerStr = info.owner.toBase58();
+		let addSource: "programData" | "program" | null = null;
+
+		// If upgradeable loader: fetch program data, extract ELF and addProgram
+		const parsed = parseUpgradeableLoader(
+			ownerStr,
+			new Uint8Array(info.data),
+			context,
+		);
+		if (parsed?.parsed?.type === "program") {
+			const programDataAddr = parsed.parsed.info?.programData as
+				| string
+				| undefined;
+			if (programDataAddr) {
+				const pda = new PublicKey(programDataAddr);
+				const pinfo = await conn.getAccountInfo(pda, "confirmed");
+				if (pinfo) {
+					const pdataParsed = parseUpgradeableLoader(
+						ownerStr,
+						new Uint8Array(pinfo.data),
+						context,
+					);
+					const base64 = pdataParsed?.parsed?.info?.data?.[0] as
+						| string
+						| undefined;
+					if (base64) {
+						const bytes = Uint8Array.from(Buffer.from(base64, "base64"));
+						try {
+							context.svm.addProgram(pid, bytes);
+							addSource = "programData";
+						} catch (e) {
+							console.warn("[admin] addProgram failed (programData bytes)", e);
+							return context.createErrorResponse(
+								id,
+								-32603,
+								"Clone program failed",
+								{
+									message: String(e),
+									programId,
+									endpoint,
+									source: "programData",
+								},
+							);
+						}
+					} else {
+						console.warn("[admin] programData bytes missing");
+						return context.createErrorResponse(
+							id,
+							-32603,
+							"Clone program failed",
+							{
+								message: "ProgramData bytes missing",
+								programId,
+								endpoint,
+							},
+						);
+					}
+				}
+			}
+		} else {
+			// Legacy loaders keep ELF in the program account directly
+			try {
+				context.svm.addProgram(pid, new Uint8Array(info.data));
+				addSource = "program";
+			} catch (e) {
+				console.warn("[admin] addProgram failed (program account data)", e);
+				return context.createErrorResponse(id, -32603, "Clone program failed", {
+					message: String(e),
+					programId,
+					endpoint,
+					source: "program",
+				});
+			}
+		}
+
+		// Optionally clone owned accounts
+		if (options?.withAccounts) {
+			const { solforgeAdminCloneProgramAccounts } = await import(
+				"./clone-program-accounts"
+			);
+			const res = await solforgeAdminCloneProgramAccounts(
+				id,
+				[programId, { endpoint, limit: options.accountsLimit }],
+				context,
+			);
+			void res;
+		}
+
+		console.log("[admin] clone program done", {
+			programId: pid.toBase58(),
+			added: true,
+			source: addSource,
+		});
+		try {
+			context.registerProgram?.(pid);
+		} catch {}
+		return context.createSuccessResponse(id, {
+			ok: true,
+			programId,
+			added: true,
+			source: addSource,
+		});
+	} catch (e) {
+		console.error("[admin] clone program error", e);
+		return context.createErrorResponse(id, -32603, "Clone program failed", {
+			message: (e as Error)?.message || String(e),
+			stack: (e as Error)?.stack,
+			programId,
+			endpoint,
+		});
+	}
+};
+
+export type { RpcMethodHandler } from "../../types";

package/server/methods/admin/clone-token-accounts.ts

@@ -0,0 +1,117 @@
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+export const solforgeAdminCloneTokenAccounts: RpcMethodHandler = async (
+	id,
+	params,
+	context,
+) => {
+	const [mint, options] = params as [
+		string,
+		{ endpoint?: string; holders?: number; allAccounts?: boolean }?,
+	];
+	if (!mint)
+		return context.createErrorResponse(
+			id,
+			-32602,
+			"Invalid params: mint required",
+		);
+	const endpoint = options?.endpoint || "https://api.mainnet-beta.solana.com";
+	const limit =
+		options?.holders && !options?.allAccounts
+			? Math.max(1, Math.min(10000, options.holders))
+			: undefined;
+	try {
+		const conn = new Connection(endpoint, "confirmed");
+		const mintPk = new PublicKey(mint);
+		let accounts: Array<{
+			pubkey: PublicKey;
+			data: Buffer;
+			lamports: number;
+			owner: PublicKey;
+			executable: boolean;
+			rentEpoch: number;
+		}>;
+		if (options?.allAccounts) {
+			const list = await conn.getProgramAccounts(TOKEN_PROGRAM_ID, {
+				commitment: "confirmed",
+				filters: [
+					{ dataSize: 165 },
+					{ memcmp: { offset: 0, bytes: mintPk.toBase58() } },
+				],
+			});
+			accounts = list.map(({ pubkey, account }) => ({
+				pubkey,
+				data: account.data as Buffer,
+				lamports: account.lamports,
+				owner: account.owner,
+				executable: account.executable,
+				rentEpoch: account.rentEpoch,
+			}));
+		} else if (typeof limit === "number") {
+			const largest = await conn.getTokenLargestAccounts(mintPk, "confirmed");
+			const addrs = largest.value.slice(0, limit).map((x) => x.address);
+			const multi = await conn.getMultipleAccountsInfo(addrs, {
+				commitment: "confirmed",
+			});
+			accounts = [];
+			for (let i = 0; i < addrs.length; i++) {
+				const info = multi[i];
+				const pk = addrs[i];
+				if (!info || !pk) continue;
+				accounts.push({
+					pubkey: pk,
+					data: info.data as Buffer,
+					lamports: info.lamports,
+					owner: info.owner,
+					executable: info.executable,
+					rentEpoch: info.rentEpoch,
+				});
+			}
+		} else {
+			const largest = await conn.getTokenLargestAccounts(mintPk, "confirmed");
+			const addrs = largest.value.slice(0, 100).map((x) => x.address);
+			const multi = await conn.getMultipleAccountsInfo(addrs, {
+				commitment: "confirmed",
+			});
+			accounts = [];
+			for (let i = 0; i < addrs.length; i++) {
+				const info = multi[i];
+				const pk = addrs[i];
+				if (!info || !pk) continue;
+				accounts.push({
+					pubkey: pk,
+					data: info.data as Buffer,
+					lamports: info.lamports,
+					owner: info.owner,
+					executable: info.executable,
+					rentEpoch: info.rentEpoch,
+				});
+			}
+		}
+		let count = 0;
+		for (const a of accounts) {
+			try {
+				context.svm.setAccount(a.pubkey, {
+					data: new Uint8Array(a.data),
+					executable: a.executable,
+					lamports: Number(a.lamports),
+					owner: a.owner,
+					rentEpoch: 0,
+				});
+				count++;
+			} catch {}
+		}
+		return context.createSuccessResponse(id, { ok: true, count });
+	} catch (e) {
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"Clone token accounts failed",
+			(e as Error)?.message || String(e),
+		);
+	}
+};
+
+export type { RpcMethodHandler } from "../../types";

package/server/methods/admin/clone-token-mint.ts

@@ -0,0 +1,82 @@
+import { MINT_SIZE, MintLayout } from "@solana/spl-token";
+import type { AccountInfo } from "@solana/web3.js";
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+import { cloneMintExtensionAccounts } from "./helpers";
+
+export const solforgeAdminCloneTokenMint: RpcMethodHandler = async (
+	id,
+	params,
+	context,
+) => {
+	const [mint, options] = params as [string, { endpoint?: string }?];
+	if (!mint)
+		return context.createErrorResponse(
+			id,
+			-32602,
+			"Invalid params: mint required",
+		);
+	const endpoint = options?.endpoint || "https://api.mainnet-beta.solana.com";
+	try {
+		const conn = new Connection(endpoint, "confirmed");
+		const mintPk = new PublicKey(mint);
+		console.log(`[admin] clone mint start`, {
+			mint: mintPk.toBase58(),
+			endpoint,
+		});
+		const info = await conn.getAccountInfo(mintPk, "confirmed");
+		if (!info) {
+			console.warn(`[admin] clone mint: account not found`, {
+				mint: mintPk.toBase58(),
+				endpoint,
+			});
+			return context.createErrorResponse(
+				id,
+				-32004,
+				"Mint account not found on endpoint",
+				{ endpoint, mint },
+			);
+		}
+		try {
+			const dec = MintLayout.decode(
+				(info.data as Buffer).slice(0, MINT_SIZE),
+			).decimals;
+			console.log(`[admin] clone mint fetched`, {
+				owner: info.owner.toBase58(),
+				dataLen: info.data.length,
+				decimals: dec,
+				lamports: info.lamports,
+			});
+		} catch {}
+		// Write raw account into LiteSVM
+		context.svm.setAccount(mintPk, {
+			data: new Uint8Array(info.data),
+			executable: info.executable,
+			lamports: Number(info.lamports),
+			owner: info.owner,
+			rentEpoch: 0,
+		});
+
+		await cloneMintExtensionAccounts(
+			conn,
+			context,
+			mintPk,
+			info as AccountInfo<Buffer>,
+		);
+		try {
+			context.registerMint?.(mintPk);
+		} catch {}
+		console.log(`[admin] clone mint done`, { mint: mintPk.toBase58() });
+		return context.createSuccessResponse(id, { ok: true, address: mint });
+	} catch (e) {
+		console.error(`[admin] clone mint error`, e);
+		return context.createErrorResponse(id, -32603, "Clone mint failed", {
+			message: (e as Error)?.message || String(e),
+			stack: (e as Error)?.stack,
+			endpoint,
+			mint,
+		});
+	}
+};
+
+export type { RpcMethodHandler } from "../../types";

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

@@ -0,0 +1,114 @@
+import { MINT_SIZE, MintLayout, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { PublicKey } from "@solana/web3.js";
+import type { RpcMethodHandler } from "../../types";
+
+// Create a new SPL Mint locally with given decimals and mint authority
+export const solforgeCreateMint: RpcMethodHandler = async (
+	id,
+	params,
+	context,
+) => {
+	try {
+		const [mintStr, decimals, authorityStr] = params as [
+			string | null | undefined,
+			number,
+			string | null | undefined,
+		];
+		if (typeof decimals !== "number" || decimals < 0 || decimals > 18)
+			return context.createErrorResponse(
+				id,
+				-32602,
+				"Invalid params: decimals required (0-18)",
+			);
+		const authority = authorityStr
+			? new PublicKey(authorityStr)
+			: context.getFaucet().publicKey;
+		const mintPk = mintStr ? new PublicKey(mintStr) : PublicKey.unique();
+
+		const buf = Buffer.alloc(MINT_SIZE);
+		type MintStruct = Parameters<typeof MintLayout.encode>[0];
+		const initialMint = {
+			mintAuthorityOption: 1,
+			mintAuthority: authority,
+			supply: 0n,
+			decimals,
+			isInitialized: true,
+			freezeAuthorityOption: 0,
+			freezeAuthority: PublicKey.default,
+		} satisfies Partial<MintStruct> as MintStruct;
+		MintLayout.encode(initialMint, buf);
+
+		const rentLamports = Number(
+			context.svm.minimumBalanceForRentExemption(BigInt(MINT_SIZE)),
+		);
+		context.svm.setAccount(mintPk, {
+			lamports: rentLamports,
+			data: new Uint8Array(buf),
+			owner: TOKEN_PROGRAM_ID,
+			executable: false,
+			rentEpoch: 0,
+		});
+		try {
+			context.registerMint?.(mintPk);
+		} catch {}
+		try {
+			await context.store?.upsertAccounts([
+				{
+					address: mintPk.toBase58(),
+					lamports: rentLamports,
+					ownerProgram: TOKEN_PROGRAM_ID.toBase58(),
+					executable: false,
+					rentEpoch: 0,
+					dataLen: MINT_SIZE,
+					dataBase64: undefined,
+					lastSlot: Number(context.slot),
+				},
+			]);
+		} catch {}
+		// Synthetic transaction for explorers
+		try {
+			const sig = `admin:create-mint:${mintPk.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 create mint"],
+				accounts: [
+					{
+						address: mintPk.toBase58(),
+						index: 0,
+						signer: false,
+						writable: true,
+					},
+					{
+						address: authority.toBase58(),
+						index: 1,
+						signer: false,
+						writable: false,
+					},
+				],
+			});
+		} catch {}
+		return context.createSuccessResponse(id, {
+			ok: true,
+			mint: mintPk.toBase58(),
+			decimals,
+			authority: authority.toBase58(),
+		});
+	} catch (e) {
+		return context.createErrorResponse(
+			id,
+			-32603,
+			"Create mint failed",
+			(e as Error)?.message || String(e),
+		);
+	}
+};
+
+export type { RpcMethodHandler } from "../../types";

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

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

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

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

@@ -0,0 +1,21 @@
+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";