solforge 0.2.11 → 0.2.13

package/server/methods/admin/adopt-mint-authority.ts

@@ -1,94 +0,0 @@
-import { MINT_SIZE, MintLayout } from "@solana/spl-token";
-import { PublicKey } from "@solana/web3.js";
-import type { RpcMethodHandler } from "../../types";
-
-// Adopt faucet as mint authority for a given mint (LiteSVM-only, overwrites account data)
-export const solforgeAdoptMintAuthority: RpcMethodHandler = async (
-	id,
-	params,
-	context,
-) => {
-	try {
-		const [mintStr] = params as [string];
-		if (!mintStr)
-			return context.createErrorResponse(
-				id,
-				-32602,
-				"Invalid params: mint required",
-			);
-		const mint = new PublicKey(mintStr);
-		const acct = context.svm.getAccount(mint);
-		if (!acct)
-			return context.createErrorResponse(
-				id,
-				-32004,
-				"Mint not found in LiteSVM",
-			);
-		if (!acct.data || acct.data.length < MINT_SIZE)
-			return context.createErrorResponse(
-				id,
-				-32000,
-				"Account not a valid mint",
-			);
-
-		const faucet = context.getFaucet();
-		const buf = Buffer.from(acct.data);
-		type MintStruct = Parameters<typeof MintLayout.encode>[0];
-		const mintDecoded = MintLayout.decode(
-			buf.slice(0, MINT_SIZE),
-		) as unknown as MintStruct;
-		// Update authority fields
-		(
-			mintDecoded as unknown as { mintAuthorityOption: number }
-		).mintAuthorityOption = 1;
-		(mintDecoded as unknown as { mintAuthority: PublicKey }).mintAuthority =
-			faucet.publicKey;
-		const out = Buffer.from(buf); // preserve any extensions beyond MintLayout
-		MintLayout.encode(mintDecoded as MintStruct, out);
-
-		const ownerBase58 =
-			typeof acct.owner === "string"
-				? new PublicKey(acct.owner).toBase58()
-				: (acct.owner as PublicKey).toBase58();
-		const ownerPk = new PublicKey(ownerBase58);
-
-		context.svm.setAccount(mint, {
-			lamports: Number(acct.lamports || 0n),
-			data: new Uint8Array(out),
-			owner: ownerPk,
-			executable: false,
-			rentEpoch: 0,
-		});
-		try {
-			context.registerMint?.(mint);
-		} catch {}
-		try {
-			await context.store?.upsertAccounts([
-				{
-					address: mint.toBase58(),
-					lamports: Number(acct.lamports || 0n),
-					ownerProgram: ownerBase58,
-					executable: false,
-					rentEpoch: 0,
-					dataLen: out.length,
-					dataBase64: undefined,
-					lastSlot: Number(context.slot),
-				},
-			]);
-		} catch {}
-		return context.createSuccessResponse(id, {
-			ok: true,
-			mint: mintStr,
-			authority: faucet.publicKey.toBase58(),
-		});
-	} catch (e) {
-		return context.createErrorResponse(
-			id,
-			-32603,
-			"Adopt mint authority failed",
-			(e as Error)?.message || String(e),
-		);
-	}
-};
-
-export type { RpcMethodHandler } from "../../types";

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

@@ -1,55 +0,0 @@
-import { Connection, PublicKey } from "@solana/web3.js";
-import type { RpcMethodHandler } from "../../types";
-
-export const solforgeAdminCloneProgramAccounts: RpcMethodHandler = async (
-	id,
-	params,
-	context,
-) => {
-	const [programId, options] = params as [
-		string,
-		{ endpoint?: string; limit?: number; filters?: unknown[] }?,
-	];
-	if (!programId)
-		return context.createErrorResponse(
-			id,
-			-32602,
-			"Invalid params: programId required",
-		);
-	const endpoint = options?.endpoint || "https://api.mainnet-beta.solana.com";
-	const limit = options?.limit
-		? Math.max(1, Math.min(10000, options.limit))
-		: undefined;
-	try {
-		const conn = new Connection(endpoint, "confirmed");
-		const pid = new PublicKey(programId);
-		const list = await conn.getProgramAccounts(pid, {
-			commitment: "confirmed",
-			// @ts-expect-error: filters type is loose
-			filters: Array.isArray(options?.filters) ? options?.filters : undefined,
-		});
-		let count = 0;
-		for (const { pubkey, account } of list.slice(0, limit ?? list.length)) {
-			try {
-				context.svm.setAccount(pubkey, {
-					data: new Uint8Array(account.data as Buffer),
-					executable: account.executable,
-					lamports: Number(account.lamports),
-					owner: account.owner,
-					rentEpoch: 0,
-				});
-				count++;
-			} catch {}
-		}
-		return context.createSuccessResponse(id, { ok: true, count });
-	} catch (e) {
-		return context.createErrorResponse(
-			id,
-			-32603,
-			"Clone program accounts failed",
-			(e as Error)?.message || String(e),
-		);
-	}
-};
-
-export type { RpcMethodHandler } from "../../types";

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

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

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

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

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