solforge 0.2.6 → 0.2.8

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

@@ -6,12 +6,13 @@ import {
 	VersionedTransaction,
 } from "@solana/web3.js";
 import type { RpcMethodHandler } from "../../types";
+import { sendTransaction as sendTxRpc } from "../transaction/send-transaction";
 
 /**
  * Implements the requestAirdrop RPC method
  * @see https://docs.solana.com/api/http#requestairdrop
  */
-export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
+export const requestAirdrop: RpcMethodHandler = async (id, params, context) => {
 	const [pubkeyStr, lamports, _config] = params || [];
 
 	try {
@@ -68,20 +69,48 @@ export const requestAirdrop: RpcMethodHandler = (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 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
@@ -94,60 +123,58 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 						}
 					})();
 
-		const sendResult = context.svm.sendTransaction(tx);
-		// Surface errors to aid debugging
-		try {
-			const rawErr = (sendResult as { err?: unknown }).err;
-			const maybeErr =
-				typeof rawErr === "function" ? (rawErr as () => unknown)() : rawErr;
-			if (maybeErr) {
-				let logsForErr: string[] = [];
-				try {
-					const sr = sendResult as {
-						logs?: () => string[];
-						meta?: () => { logs?: () => string[] } | undefined;
-					};
-					if (typeof sr?.logs === "function") logsForErr = sr.logs();
-					else if (typeof sr?.meta === "function") {
-						const m = sr.meta();
-						const lg = m?.logs;
-						if (typeof lg === "function") logsForErr = lg();
-					}
-				} catch {}
-				console.warn(
-					"[requestAirdrop] transfer failed. err=",
-					maybeErr,
-					" logs=\n",
-					logsForErr.join("\n"),
-				);
-			}
-		} catch {}
+        // 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
 
-		let signature = tx.signatures[0]
-			? context.encodeBase58(tx.signatures[0])
-			: context.encodeBase58(new Uint8Array(64).fill(0));
-		context.notifySignature(signature);
-		// 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;
-			}
-		});
-		let logs: string[] = [];
-		try {
-			const sr = sendResult as {
-				logs?: () => string[];
-				meta?: () => { logs?: () => string[] } | undefined;
-			};
-			if (typeof sr?.logs === "function") logs = sr.logs();
-			else if (typeof sr?.meta === "function") {
-				const m = sr.meta();
-				const lg = m?.logs;
-				if (typeof lg === "function") logs = lg();
-			}
-		} catch {}
+        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
 		// Verify recipient received lamports; retry once if not
 		const afterTo =
 			toIndex >= 0
@@ -207,22 +234,18 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 		}
 
 		// Try to capture error again for accurate status reporting
-		let recErr: unknown = null;
-		try {
-			const rawErrFun = (sendResult as { err?: unknown }).err;
-			recErr =
-				typeof rawErrFun === "function"
-					? (rawErrFun as () => unknown)()
-					: rawErrFun;
-		} catch {}
-		context.recordTransaction(signature, tx, {
-			logs,
-			fee: 5000,
-			blockTime: Math.floor(Date.now() / 1000),
-			preBalances,
-			postBalances,
-			err: recErr,
-		});
+        // 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 {}
 
 		return context.createSuccessResponse(id, signature);
 	} catch (error: unknown) {

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

@@ -16,6 +16,7 @@ import {
 	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) => {
@@ -148,16 +149,15 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			}
 		} catch {}
 
-		// Send transaction via svm
-		const _res = context.svm.sendTransaction(vtx);
-		// Compute signature (base58) from the signed transaction
-		let signatureStr = "";
-		try {
-			const sigBytes = vtx.signatures?.[0];
-			if (sigBytes)
-				signatureStr = context.encodeBase58(new Uint8Array(sigBytes));
-		} catch {}
-		if (!signatureStr) signatureStr = `mint:${ata.toBase58()}:${Date.now()}`;
+        // 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 || "");
 
 		// Token balance deltas (pre/post) for ATA
 		type UiTokenAmount = {
@@ -229,34 +229,7 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			];
 		} catch {}
 
-		// Insert into DB for explorer via context.recordTransaction for richer details
-		try {
-			const rawBase64 = Buffer.from(vtx.serialize()).toString("base64");
-			const postBalances = trackedKeys.map((pk) => {
-				try {
-					return Number(context.svm.getBalance(pk) || 0n);
-				} catch {
-					return 0;
-				}
-			});
-			const logs: string[] = ["spl-token mintToChecked"];
-			try {
-				(vtx as unknown as { serialize: () => Uint8Array }).serialize = () =>
-					Buffer.from(rawBase64, "base64");
-			} catch {}
-			context.recordTransaction(signatureStr, vtx, {
-				logs,
-				fee: 0,
-				blockTime: Math.floor(Date.now() / 1000),
-				preBalances,
-				postBalances,
-				preTokenBalances,
-				postTokenBalances,
-			});
-		} catch {}
-		try {
-			context.notifySignature(signatureStr);
-		} catch {}
+        // send-transaction already records/announces signature and persists to DB
 
 		return context.createSuccessResponse(id, {
 			ok: true,