solforge 0.2.7 → 0.2.9

package/server/lib/parsers/spl-token.ts

@@ -0,0 +1,315 @@
+import type { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import {
+    decodeMintToCheckedInstruction,
+    decodeTransferInstruction,
+    decodeTransferCheckedInstruction,
+    decodeInitializeAccount3Instruction,
+    decodeInitializeImmutableOwnerInstruction,
+    decodeTransferCheckedInstructionUnchecked,
+    decodeTransferInstructionUnchecked,
+    decodeInitializeAccount3InstructionUnchecked,
+    decodeInitializeImmutableOwnerInstructionUnchecked,
+} from "@solana/spl-token";
+import { u8 } from "@solana/buffer-layout";
+import { PublicKey as PK } from "@solana/web3.js";
+
+// Keep shape compatible with instruction-parser
+export type ParsedInstruction =
+	| {
+			program: string;
+			programId: string;
+			parsed: { type: string; info: unknown };
+	  }
+	| { programId: string; accounts: string[]; data: string };
+
+function ok(programId: string, type: string, info: unknown): ParsedInstruction {
+    // Use a single label for both SPL v1 and Token-2022 for compatibility with UIs
+    return { program: "spl-token", programId, parsed: { type, info } };
+}
+
+function asBase58(pk: PublicKey | undefined): string | undefined {
+	try {
+		return pk ? pk.toBase58() : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function tryParseSplToken(
+    ix: TransactionInstruction,
+    programIdStr: string,
+    _accountKeys: string[],
+    dataBase58: string,
+    tokenBalanceHints?: Array<{ mint: string; decimals: number }>,
+): ParsedInstruction | null {
+	try {
+		// Accept both SPL Token and Token-2022 program ids
+		// We pass the actual program id to decoders for strict match
+		const programPk = new PK(programIdStr);
+		// Don't early-return on program id; allow both programs
+
+		// MintToChecked
+		try {
+			const m = decodeMintToCheckedInstruction(ix, programPk);
+			const amount = m.data.amount;
+			const decimals = m.data.decimals;
+			const amtStr =
+				typeof amount === "bigint" ? amount.toString() : String(amount);
+			const base = BigInt(10) ** BigInt(decimals);
+			const whole = BigInt(amtStr) / base;
+			const frac = BigInt(amtStr) % base;
+			const fracStr = frac
+				.toString()
+				.padStart(decimals, "0")
+				.replace(/0+$/, "");
+			const uiStr = fracStr.length ? `${whole}.${fracStr}` : `${whole}`;
+			return ok(programIdStr, "mintToChecked", {
+				account: asBase58(m.keys.destination.pubkey),
+				mint: asBase58(m.keys.mint.pubkey),
+				mintAuthority: asBase58(m.keys.authority.pubkey),
+				tokenAmount: {
+					amount: amtStr,
+					decimals,
+					uiAmount: Number(uiStr),
+					uiAmountString: uiStr,
+				},
+			});
+		} catch {}
+
+		// Transfer / TransferChecked (strict)
+		try {
+			const t = decodeTransferInstruction(ix, programPk);
+			const amt = t.data.amount;
+			return ok(programIdStr, "transfer", {
+				amount: typeof amt === "bigint" ? amt.toString() : String(amt),
+				source: asBase58(t.keys.source.pubkey),
+				destination: asBase58(t.keys.destination.pubkey),
+				authority: asBase58(t.keys.owner.pubkey),
+			});
+		} catch {}
+
+		try {
+			const t = decodeTransferCheckedInstruction(ix, programPk);
+			const amt = t.data.amount;
+			const decimals = t.data.decimals;
+			return ok(programIdStr, "transferChecked", {
+				tokenAmount: {
+					amount: typeof amt === "bigint" ? amt.toString() : String(amt),
+					decimals,
+				},
+				source: asBase58(t.keys.source.pubkey),
+				destination: asBase58(t.keys.destination.pubkey),
+				authority: asBase58(t.keys.owner.pubkey),
+				mint: asBase58(t.keys.mint.pubkey),
+			});
+		} catch {}
+
+		// InitializeAccount3 (strict)
+		try {
+			const a = decodeInitializeAccount3Instruction(ix, programPk);
+			return ok(programIdStr, "initializeAccount3", {
+				account: asBase58(a.keys.account.pubkey),
+				mint: asBase58(a.keys.mint.pubkey),
+				owner: asBase58(a.data.owner),
+			});
+		} catch {}
+
+		// InitializeImmutableOwner
+		try {
+			const im = decodeInitializeImmutableOwnerInstruction(ix, programPk);
+			return ok(programIdStr, "initializeImmutableOwner", {
+				account: asBase58(im.keys.account.pubkey),
+			});
+		} catch {}
+
+		// GetAccountDataSize: decode extension types (u16 little-endian sequence)
+		try {
+			const bytes = Buffer.from(bs58decode(dataBase58));
+			const t = u8().decode(bytes);
+			// 21 corresponds to TokenInstruction.GetAccountDataSize
+			if (t === 21) {
+				const mint = asBase58(ix.keys[0]?.pubkey);
+				const extCodes: number[] = [];
+				for (let i = 1; i + 1 < bytes.length; i += 2) {
+					const code = bytes[i] | (bytes[i + 1] << 8);
+					extCodes.push(code);
+				}
+				const extMap: Record<number, string> = {
+					7: "immutableOwner",
+					8: "memoTransfer",
+					9: "nonTransferable",
+					12: "permanentDelegate",
+					14: "transferHook",
+					15: "transferHookAccount",
+					18: "metadataPointer",
+					19: "tokenMetadata",
+					20: "groupPointer",
+					21: "tokenGroup",
+					22: "groupMemberPointer",
+					23: "tokenGroupMember",
+					25: "scaledUiAmountConfig",
+					26: "pausableConfig",
+					27: "pausableAccount",
+				};
+				const extensionTypes = extCodes.map((c) => extMap[c] || String(c));
+				return ok(programIdStr, "getAccountDataSize", { mint, extensionTypes });
+			}
+		} catch {}
+
+		// Unchecked fallbacks: decode data fields even if keys/validation missing
+		try {
+			const raw = bs58decode(dataBase58);
+			const op = raw[0];
+			// Transfer
+			if (op === 3) {
+				const t = decodeTransferInstructionUnchecked(ix);
+				const amt = t.data.amount;
+				return ok(programIdStr, "transfer", {
+					amount: typeof amt === "bigint" ? amt.toString() : String(amt),
+					source: asBase58(t.keys.source?.pubkey),
+					destination: asBase58(t.keys.destination?.pubkey),
+					authority: asBase58(t.keys.owner?.pubkey),
+				});
+			}
+			// TransferChecked
+            if (op === 12) {
+                const t = decodeTransferCheckedInstructionUnchecked(ix);
+                const amt = t.data.amount;
+                const decimals = t.data.decimals;
+                const hintMint = (() => {
+                    try {
+                        const dec = Number(decimals);
+                        const candidates = (tokenBalanceHints || []).filter(
+                            (h) => Number(h.decimals) === dec,
+                        );
+                        if (candidates.length === 1) return candidates[0].mint;
+                        // Prefer non-zero decimals over 0 (filters out native 4uQe mint in many cases)
+                        const nonZero = candidates.filter((c) => c.decimals > 0);
+                        if (nonZero.length === 1) return nonZero[0].mint;
+                        // Fall back to first candidate if multiple
+                        return candidates[0]?.mint;
+                    } catch {
+                        return undefined;
+                    }
+                })();
+                return ok(programIdStr, "transferChecked", {
+                    tokenAmount: {
+                        amount: typeof amt === "bigint" ? amt.toString() : String(amt),
+                        decimals,
+                    },
+                    source: asBase58(t.keys.source?.pubkey),
+                    destination: asBase58(t.keys.destination?.pubkey),
+                    authority: asBase58(t.keys.owner?.pubkey),
+                    mint: asBase58(t.keys.mint?.pubkey) || hintMint,
+                });
+            }
+			// InitializeAccount3
+            if (op === 18) {
+                const a = decodeInitializeAccount3InstructionUnchecked(ix);
+                const hintMint = (() => {
+                    try {
+                        // Prefer single non-zero-decimals mint in this tx
+                        const nonZero = (tokenBalanceHints || []).filter(
+                            (h) => h.decimals > 0,
+                        );
+                        if (nonZero.length === 1) return nonZero[0].mint;
+                        // Fall back to first available mint
+                        return (tokenBalanceHints || [])[0]?.mint;
+                    } catch {
+                        return undefined;
+                    }
+                })();
+                return ok(programIdStr, "initializeAccount3", {
+                    account: asBase58(a.keys.account?.pubkey),
+                    mint: asBase58(a.keys.mint?.pubkey) || hintMint,
+                    owner: asBase58(a.data.owner),
+                });
+            }
+			// InitializeImmutableOwner
+			if (op === 22) {
+				const im = decodeInitializeImmutableOwnerInstructionUnchecked(ix);
+				return ok(programIdStr, "initializeImmutableOwner", {
+					account: asBase58(im.keys.account?.pubkey),
+				});
+			}
+		} catch {}
+
+		// Fallback: classify by TokenInstruction opcode (first byte) when nothing else matched
+		try {
+			const raw = bs58decode(dataBase58);
+			if (raw.length > 0) {
+				const op = raw[0];
+				const map: Record<number, string> = {
+					0: "initializeMint",
+					1: "initializeAccount",
+					2: "initializeMultisig",
+					3: "transfer",
+					4: "approve",
+					5: "revoke",
+					6: "setAuthority",
+					7: "mintTo",
+					8: "burn",
+					9: "closeAccount",
+					10: "freezeAccount",
+					11: "thawAccount",
+					12: "transferChecked",
+					13: "approveChecked",
+					14: "mintToChecked",
+					15: "burnChecked",
+					16: "initializeAccount2",
+					17: "syncNative",
+					18: "initializeAccount3",
+					19: "initializeMultisig2",
+					20: "initializeMint2",
+					21: "getAccountDataSize",
+					22: "initializeImmutableOwner",
+					23: "amountToUiAmount",
+					24: "uiAmountToAmount",
+					25: "initializeMintCloseAuthority",
+					26: "transferFeeExtension",
+					27: "confidentialTransferExtension",
+					28: "defaultAccountStateExtension",
+					29: "reallocate",
+					30: "memoTransferExtension",
+					31: "createNativeMint",
+					32: "initializeNonTransferableMint",
+					33: "interestBearingMintExtension",
+					34: "cpiGuardExtension",
+					35: "initializePermanentDelegate",
+					36: "transferHookExtension",
+					39: "metadataPointerExtension",
+					40: "groupPointerExtension",
+					41: "groupMemberPointerExtension",
+					43: "scaledUiAmountExtension",
+					44: "pausableExtension",
+				};
+				const type = map[op];
+				if (type) return ok(programIdStr, type, {});
+			}
+		} catch {}
+
+		// Unknown SPL token instruction (unrecognized opcode)
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+// Local base58 decode to avoid importing from sibling file
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const BASE = BigInt(ALPHABET.length);
+function bs58decode(str: string): Uint8Array {
+	let num = 0n;
+	for (const char of str) {
+		const index = ALPHABET.indexOf(char);
+		if (index === -1) throw new Error("Invalid base58 character");
+		num = num * BASE + BigInt(index);
+	}
+	const bytes: number[] = [];
+	while (num > 0n) {
+		bytes.unshift(Number(num % 256n));
+		num = num / 256n;
+	}
+	for (let i = 0; i < str.length && str[i] === "1"; i++) bytes.unshift(0);
+	return new Uint8Array(bytes.length > 0 ? bytes : [0]);
+}

package/server/methods/account/request-airdrop.ts

@@ -69,48 +69,48 @@ export const requestAirdrop: RpcMethodHandler = async (id, params, context) => {
 			: Array.isArray(msg.accountKeys)
 				? (msg.accountKeys as unknown[])
 				: [];
-        const staticKeys = rawKeys.map((k) => {
-            try {
-                return typeof k === "string" ? new PublicKey(k) : (k as PublicKey);
-            } catch {
-                return faucet.publicKey;
-            }
-        });
-        const preBalances = staticKeys.map((pk) => {
-            try {
-                return Number(context.svm.getBalance(pk));
-            } catch {
-                return 0;
-            }
-        });
-        const preAccountStates = staticKeys.map((pk) => {
-            try {
-                const addr = pk.toBase58();
-                const acc = context.svm.getAccount(pk);
-                if (!acc) return { address: addr, pre: null } as const;
-                return {
-                    address: addr,
-                    pre: {
-                        lamports: Number(acc.lamports || 0n),
-                        ownerProgram: new PublicKey(acc.owner).toBase58(),
-                        executable: !!acc.executable,
-                        rentEpoch: Number(acc.rentEpoch || 0),
-                        dataLen: acc.data?.length ?? 0,
-                        dataBase64: undefined,
-                        lastSlot: Number(context.slot),
-                    },
-                } as const;
-            } catch {
-                return { address: pk.toBase58(), pre: null } as const;
-            }
-        });
-        try {
-            if (process.env.DEBUG_TX_CAPTURE === "1") {
-                console.debug(
-                    `[tx-capture] pre snapshots: keys=${staticKeys.length} captured=${preAccountStates.length}`,
-                );
-            }
-        } catch {}
+		const staticKeys = rawKeys.map((k) => {
+			try {
+				return typeof k === "string" ? new PublicKey(k) : (k as PublicKey);
+			} catch {
+				return faucet.publicKey;
+			}
+		});
+		const preBalances = staticKeys.map((pk) => {
+			try {
+				return Number(context.svm.getBalance(pk));
+			} catch {
+				return 0;
+			}
+		});
+		const preAccountStates = staticKeys.map((pk) => {
+			try {
+				const addr = pk.toBase58();
+				const acc = context.svm.getAccount(pk);
+				if (!acc) return { address: addr, pre: null } as const;
+				return {
+					address: addr,
+					pre: {
+						lamports: Number(acc.lamports || 0n),
+						ownerProgram: new PublicKey(acc.owner).toBase58(),
+						executable: !!acc.executable,
+						rentEpoch: Number(acc.rentEpoch || 0),
+						dataLen: acc.data?.length ?? 0,
+						dataBase64: undefined,
+						lastSlot: Number(context.slot),
+					},
+				} as const;
+			} catch {
+				return { address: pk.toBase58(), pre: null } as const;
+			}
+		});
+		try {
+			if (process.env.DEBUG_TX_CAPTURE === "1") {
+				console.debug(
+					`[tx-capture] pre snapshots: keys=${staticKeys.length} captured=${preAccountStates.length}`,
+				);
+			}
+		} catch {}
 		const toIndex = staticKeys.findIndex((pk) => pk.equals(toPubkey));
 		const beforeTo =
 			toIndex >= 0
@@ -123,58 +123,73 @@ export const requestAirdrop: RpcMethodHandler = async (id, params, context) => {
 						}
 					})();
 
-        // Send via standard sendTransaction RPC to unify capture + persistence
-        const rawB64 = Buffer.from(tx.serialize()).toString("base64");
-        const resp = await (sendTxRpc as RpcMethodHandler)(id, [rawB64], context);
-        if ((resp as any)?.error) return resp;
-        // Surface errors to aid debugging
-        const sendResult = undefined as unknown as { err?: unknown };
-        // Any send errors would have been returned by send-transaction already
+		// Send via standard sendTransaction RPC to unify capture + persistence
+		const rawB64 = Buffer.from(tx.serialize()).toString("base64");
+		const resp = await (sendTxRpc as RpcMethodHandler)(id, [rawB64], context);
+		if (
+			resp &&
+			typeof resp === "object" &&
+			"error" in (resp as Record<string, unknown>) &&
+			(resp as Record<string, unknown>).error != null
+		) {
+			return resp;
+		}
+		// Any send errors would have been returned by send-transaction already
 
-        let signature = String((resp as any)?.result || "");
-        if (!signature) {
-            signature = tx.signatures[0]
-                ? context.encodeBase58(tx.signatures[0])
-                : context.encodeBase58(new Uint8Array(64).fill(0));
-        }
-        try { context.notifySignature(signature); } catch {}
-        // Compute post balances and capture logs if available for explorer detail view
-        let postBalances = staticKeys.map((pk) => {
-            try {
-                return Number(context.svm.getBalance(pk));
-            } catch {
-                return 0;
-            }
-        });
-        const postAccountStates = staticKeys.map((pk) => {
-            try {
-                const addr = pk.toBase58();
-                const acc = context.svm.getAccount(pk);
-                if (!acc) return { address: addr, post: null } as const;
-                return {
-                    address: addr,
-                    post: {
-                        lamports: Number(acc.lamports || 0n),
-                        ownerProgram: new PublicKey(acc.owner).toBase58(),
-                        executable: !!acc.executable,
-                        rentEpoch: Number(acc.rentEpoch || 0),
-                        dataLen: acc.data?.length ?? 0,
-                        dataBase64: undefined,
-                        lastSlot: Number(context.slot),
-                    },
-                } as const;
-            } catch {
-                return { address: pk.toBase58(), post: null } as const;
-            }
-        });
-        try {
-            if (process.env.DEBUG_TX_CAPTURE === "1") {
-                console.debug(
-                    `[tx-capture] post snapshots: keys=${staticKeys.length} captured=${postAccountStates.length}`,
-                );
-            }
-        } catch {}
-        // Parsing, recording etc. are performed by send-transaction
+		let signature = (() => {
+			try {
+				const r = resp as Record<string, unknown>;
+				const v = r?.result;
+				return v == null ? "" : String(v);
+			} catch {
+				return "";
+			}
+		})();
+		if (!signature) {
+			signature = tx.signatures[0]
+				? context.encodeBase58(tx.signatures[0])
+				: context.encodeBase58(new Uint8Array(64).fill(0));
+		}
+		try {
+			context.notifySignature(signature);
+		} catch {}
+		// Compute post balances and capture logs if available for explorer detail view
+		let postBalances = staticKeys.map((pk) => {
+			try {
+				return Number(context.svm.getBalance(pk));
+			} catch {
+				return 0;
+			}
+		});
+		const postAccountStates = staticKeys.map((pk) => {
+			try {
+				const addr = pk.toBase58();
+				const acc = context.svm.getAccount(pk);
+				if (!acc) return { address: addr, post: null } as const;
+				return {
+					address: addr,
+					post: {
+						lamports: Number(acc.lamports || 0n),
+						ownerProgram: new PublicKey(acc.owner).toBase58(),
+						executable: !!acc.executable,
+						rentEpoch: Number(acc.rentEpoch || 0),
+						dataLen: acc.data?.length ?? 0,
+						dataBase64: undefined,
+						lastSlot: Number(context.slot),
+					},
+				} as const;
+			} catch {
+				return { address: pk.toBase58(), post: null } as const;
+			}
+		});
+		try {
+			if (process.env.DEBUG_TX_CAPTURE === "1") {
+				console.debug(
+					`[tx-capture] post snapshots: keys=${staticKeys.length} captured=${postAccountStates.length}`,
+				);
+			}
+		} catch {}
+		// Parsing, recording etc. are performed by send-transaction
 		// Verify recipient received lamports; retry once if not
 		const afterTo =
 			toIndex >= 0
@@ -234,18 +249,19 @@ export const requestAirdrop: RpcMethodHandler = async (id, params, context) => {
 		}
 
 		// Try to capture error again for accurate status reporting
-        // No additional error capture; send-transaction has already recorded it
-        // Pre/post snapshots are still useful for account cache; we can upsert
-        try {
-            const snapshots = new Map<string, { pre?: any; post?: any }>();
-            for (const s of preAccountStates) snapshots.set(s.address, { pre: s.pre || null });
-            for (const s of postAccountStates) {
-                const e = snapshots.get(s.address) || {};
-                e.post = s.post || null;
-                snapshots.set(s.address, e);
-            }
-            // Not persisted here; DB already has the transaction via send-transaction
-        } catch {}
+		// No additional error capture; send-transaction has already recorded it
+		// Pre/post snapshots are still useful for account cache; we can upsert
+		try {
+			const snapshots = new Map<string, { pre?: unknown; post?: unknown }>();
+			for (const s of preAccountStates)
+				snapshots.set(s.address, { pre: s.pre || null });
+			for (const s of postAccountStates) {
+				const e = snapshots.get(s.address) || {};
+				e.post = s.post || null;
+				snapshots.set(s.address, e);
+			}
+			// Not persisted here; DB already has the transaction via send-transaction
+		} catch {}
 
 		return context.createSuccessResponse(id, signature);
 	} catch (error: unknown) {

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

@@ -126,7 +126,7 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 
 		// Capture preBalances for primary accounts referenced and token pre amount
 		const trackedKeys = [faucet.publicKey, ata, mint, owner];
-		const preBalances = trackedKeys.map((pk) => {
+		const _preBalances = trackedKeys.map((pk) => {
 			try {
 				return Number(context.svm.getBalance(pk) || 0n);
 			} catch {
@@ -149,15 +149,30 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			}
 		} 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 as any)?.error) return rpcResp;
-        const signatureStr = String((rpcResp as any)?.result || "");
+		// 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 = {
@@ -172,8 +187,8 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			owner: string;
 			uiTokenAmount: UiTokenAmount;
 		};
-		let preTokenBalances: TokenBalance[] = [];
-		let postTokenBalances: TokenBalance[] = [];
+		const _preTokenBalances: TokenBalance[] = [];
+		let _postTokenBalances: TokenBalance[] = [];
 		try {
 			const decs = decsForMint;
 			const ui = (n: bigint) => ({
@@ -219,7 +234,7 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 					uiTokenAmount: ui(preAmt),
 				},
 			];
-			postTokenBalances = [
+			_postTokenBalances = [
 				{
 					accountIndex: ataIndex >= 0 ? ataIndex : 0,
 					mint: mint.toBase58(),
@@ -229,7 +244,7 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			];
 		} catch {}
 
-        // send-transaction already records/announces signature and persists to DB
+		// send-transaction already records/announces signature and persists to DB
 
 		return context.createSuccessResponse(id, {
 			ok: true,