solforge 0.2.5 → 0.2.7

package/server/methods/transaction/inner-instructions.test.ts

@@ -0,0 +1,63 @@
+import { test, expect } from "bun:test";
+import {
+  Keypair,
+  LAMPORTS_PER_SOL,
+  TransactionMessage,
+  VersionedTransaction,
+  PublicKey,
+} from "@solana/web3.js";
+import {
+  getAssociatedTokenAddress,
+  createAssociatedTokenAccountInstruction,
+} from "@solana/spl-token";
+import { LiteSVMRpcServer } from "../../rpc-server";
+
+type RpcResp<T = any> = { jsonrpc: "2.0"; id: number; result?: T; error?: { code: number; message: string; data?: unknown } };
+
+function jsonReq(method: string, params?: unknown) {
+  return { jsonrpc: "2.0", id: Math.floor(Math.random() * 1e9), method, params };
+}
+
+test("captures inner instructions for ATA create (CPI)", async () => {
+  const server = new LiteSVMRpcServer();
+  async function call<T = any>(method: string, params?: unknown): Promise<RpcResp<T>> {
+    return (await server.handleRequest(jsonReq(method, params))) as RpcResp<T>;
+  }
+
+  // Payer + airdrop
+  const payer = Keypair.generate();
+  const recip = Keypair.generate();
+  await call("requestAirdrop", [payer.publicKey.toBase58(), 1 * LAMPORTS_PER_SOL]);
+
+  // Create a test mint via admin helper
+  const mintResp = await call<{ mint: string }>("solforgeCreateMint", [null, 6, null]);
+  expect(mintResp.error).toBeUndefined();
+  const mint = new PublicKey(mintResp.result!.mint);
+
+  // Build 1 ATA instruction that triggers CPIs into system + token
+  const bh = await call<{ value: { blockhash: string } }>("getLatestBlockhash", []);
+  const ata = await getAssociatedTokenAddress(mint, recip.publicKey, false);
+  const ix = createAssociatedTokenAccountInstruction(payer.publicKey, ata, recip.publicKey, mint);
+  const msg = new TransactionMessage({ payerKey: payer.publicKey, recentBlockhash: bh.result!.value.blockhash, instructions: [ix] }).compileToLegacyMessage();
+  const tx = new VersionedTransaction(msg);
+  tx.sign([payer]);
+
+  const sigResp = await call<string>("sendTransaction", [Buffer.from(tx.serialize()).toString("base64")]);
+  expect(sigResp.error).toBeUndefined();
+  const sig = sigResp.result!;
+
+  const txResp = await call<any>("getTransaction", [sig, { encoding: "json" }]);
+  expect(txResp.error).toBeUndefined();
+  const tr = txResp.result!;
+
+  // At least one top-level instruction
+  expect(Array.isArray(tr.transaction.message.instructions)).toBe(true);
+  expect(tr.transaction.message.instructions.length).toBe(1);
+
+  // Check inner instructions captured or (worst case) logs exist
+  const ii = tr.meta.innerInstructions;
+  const logs = tr.meta.logMessages || [];
+  expect(Array.isArray(ii)).toBe(true);
+  // At minimum, either we have structured inner ixs, or logs were captured
+  expect(ii.length > 0 || logs.length > 0).toBe(true);
+});

package/server/methods/transaction/send-transaction.ts

@@ -16,32 +16,67 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 		const tx = VersionedTransaction.deserialize(txData);
 
 		// Snapshot pre balances
-		const msg: any = tx.message as any;
-		const rawKeys: any[] = Array.isArray(msg.staticAccountKeys)
+		const msg = tx.message as unknown as {
+			staticAccountKeys?: unknown[];
+			accountKeys?: unknown[];
+		};
+		const rawKeys: unknown[] = Array.isArray(msg.staticAccountKeys)
 			? msg.staticAccountKeys
 			: Array.isArray(msg.accountKeys)
 				? msg.accountKeys
 				: [];
-		const staticKeys = rawKeys
-			.map((k: any) => {
-				try {
-					return typeof k === "string" ? new PublicKey(k) : (k as PublicKey);
-				} catch {
-					return undefined;
-				}
-			})
-			.filter(Boolean) as 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 undefined;
+                }
+            })
+            .filter(Boolean) as PublicKey[];
+        // Pre snapshots and balances
+        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 {}
 
 		// Collect SPL token accounts from instructions for pre/post token balance snapshots
-		const msgAny: any = msg;
-		const compiled = Array.isArray(msgAny.compiledInstructions)
+		const msgAny = msg as unknown as {
+			compiledInstructions?: unknown[];
+			instructions?: unknown[];
+		};
+		const compiled: unknown[] = Array.isArray(msgAny.compiledInstructions)
 			? msgAny.compiledInstructions
 			: Array.isArray(msgAny.instructions)
 				? msgAny.instructions
@@ -67,7 +102,7 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 			} catch {}
 		}
 		// Pre token balances
-		const preTokenBalances: any[] = [];
+		const preTokenBalances: unknown[] = [];
 		const ataToInfo = new Map<
 			string,
 			{
@@ -124,11 +159,12 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 			} catch {}
 		}
 
-		const result = context.svm.sendTransaction(tx);
+        const result = context.svm.sendTransaction(tx);
 
 		try {
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const maybeErr = (result as any).err?.();
+			const rawErr = (result as { err?: unknown }).err;
+			const maybeErr =
+				typeof rawErr === "function" ? (rawErr as () => unknown)() : rawErr;
 			if (maybeErr) {
 				return context.createErrorResponse(
 					id,
@@ -139,20 +175,48 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 			}
 		} catch {}
 
-		const signature = tx.signatures[0]
-			? context.encodeBase58(tx.signatures[0])
-			: context.encodeBase58(new Uint8Array(64).fill(0));
-		context.notifySignature(signature);
-		// Snapshot post balances and capture logs for rich view
-		const postBalances = staticKeys.map((pk) => {
-			try {
-				return Number(context.svm.getBalance(pk));
-			} catch {
-				return 0;
-			}
-		});
+        const signature = tx.signatures[0]
+            ? context.encodeBase58(tx.signatures[0])
+            : context.encodeBase58(new Uint8Array(64).fill(0));
+        context.notifySignature(signature);
+        // Snapshot post balances and capture logs for rich view
+        const 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 {}
 		// Post token balances
-		const postTokenBalances: any[] = [];
+		const postTokenBalances: unknown[] = [];
 		for (const addr of tokenAccountSet) {
 			try {
 				const pk = new PublicKey(addr);
@@ -202,31 +266,159 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 				}
 			} catch {}
 		}
-		let logs: string[] = [];
-		try {
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const anyRes: any = result;
-			if (typeof anyRes?.logs === "function") logs = anyRes.logs();
-			else if (typeof anyRes?.meta === "function")
-				logs = anyRes.meta()?.logs?.() ?? [];
-		} catch {}
-		context.recordTransaction(signature, tx, {
-			logs,
-			fee: 5000,
-			blockTime: Math.floor(Date.now() / 1000),
-			preBalances,
-			postBalances,
-			preTokenBalances,
-			postTokenBalances,
-		});
+        let logs: string[] = [];
+        let innerInstructions: unknown[] = [];
+        let computeUnits: number | null = null;
+        let returnData: { programId: string; dataBase64: string } | null = null;
+        try {
+            const DBG = process.env.DEBUG_TX_CAPTURE === "1";
+            const r: any = result as any;
+            // Logs can be on TransactionMetadata or in meta() for failures
+            try {
+                if (typeof r?.logs === "function") logs = r.logs();
+            } catch {}
+            let metaObj: any | undefined;
+            // Success shape: methods on result
+            if (
+                typeof r?.innerInstructions === "function" ||
+                typeof r?.computeUnitsConsumed === "function" ||
+                typeof r?.returnData === "function"
+            ) {
+                metaObj = r;
+            }
+            // Failed shape: meta() returns TransactionMetadata
+            if (!metaObj && typeof r?.meta === "function") {
+                try {
+                    metaObj = r.meta();
+                    if (!logs.length && typeof metaObj?.logs === "function") {
+                        logs = metaObj.logs();
+                    }
+                } catch (e) {
+                    if (DBG)
+                        console.debug("[tx-capture] meta() threw while extracting:", e);
+                }
+            }
+            // Extract richer metadata from whichever object exposes it
+            if (metaObj) {
+                try {
+                    const inner = metaObj.innerInstructions?.();
+                    if (Array.isArray(inner)) {
+                        innerInstructions = inner.map((group: any, index: number) => {
+                            const instructions = Array.isArray(group)
+                                ? group
+                                      .map((ii: any) => {
+                                          try {
+                                              const inst = ii.instruction?.();
+                                              const accIdxs: number[] = Array.from(
+                                                  inst?.accounts?.() || [],
+                                              );
+                                              const dataBytes: Uint8Array =
+                                                  inst?.data?.() || new Uint8Array();
+                                              return {
+                                                  programIdIndex: Number(
+                                                      inst?.programIdIndex?.() ?? 0,
+                                                  ),
+                                                  accounts: accIdxs,
+                                                  data: context.encodeBase58(dataBytes),
+                                                  stackHeight: Number(ii.stackHeight?.() ?? 0),
+                                              };
+                                          } catch {
+                                              return null;
+                                          }
+                                      })
+                                      .filter(Boolean)
+                                : [];
+                            return { index, instructions };
+                        });
+                    }
+                } catch (e) {
+                    if (DBG)
+                        console.debug(
+                            "[tx-capture] innerInstructions extraction failed:",
+                            e,
+                        );
+                }
+                try {
+                    const cu = metaObj.computeUnitsConsumed?.();
+                    if (typeof cu === "bigint") computeUnits = Number(cu);
+                } catch (e) {
+                    if (DBG)
+                        console.debug(
+                            "[tx-capture] computeUnitsConsumed extraction failed:",
+                            e,
+                        );
+                }
+                try {
+                    const rd = metaObj.returnData?.();
+                    if (rd) {
+                        const pid = new PublicKey(rd.programId()).toBase58();
+                        const dataB64 = Buffer.from(rd.data()).toString("base64");
+                        returnData = { programId: pid, dataBase64: dataB64 };
+                    }
+                } catch (e) {
+                    if (DBG)
+                        console.debug(
+                            "[tx-capture] returnData extraction failed:",
+                            e,
+                        );
+                }
+            } else if (DBG) {
+                console.debug(
+                    "[tx-capture] no metadata object found on result shape",
+                );
+            }
+        } catch {}
+        try {
+            if (process.env.DEBUG_TX_CAPTURE === "1") {
+                console.debug(
+                    `[tx-capture] sendTransaction meta: logs=${logs.length} innerGroups=${Array.isArray(innerInstructions) ? innerInstructions.length : 0} computeUnits=${computeUnits} returnData=${returnData ? "yes" : "no"}`,
+                );
+            }
+        } catch {}
+        context.recordTransaction(signature, tx, {
+            logs,
+            fee: 5000,
+            blockTime: Math.floor(Date.now() / 1000),
+            preBalances,
+            postBalances,
+            preTokenBalances,
+            postTokenBalances,
+            innerInstructions,
+            computeUnits,
+            returnData,
+            accountStates: (() => {
+                try {
+                    const byAddr = new Map<string, { pre?: any; post?: any }>();
+                    for (const s of preAccountStates)
+                        byAddr.set(s.address, { pre: s.pre || null });
+                    for (const s of postAccountStates) {
+                        const e = byAddr.get(s.address) || {};
+                        e.post = s.post || null;
+                        byAddr.set(s.address, e);
+                    }
+                    return Array.from(byAddr.entries()).map(([address, v]) => ({
+                        address,
+                        pre: v.pre || null,
+                        post: v.post || null,
+                    }));
+                } catch {
+                    return [] as Array<{
+                        address: string;
+                        pre?: unknown;
+                        post?: unknown;
+                    }>;
+                }
+            })(),
+        });
 
 		return context.createSuccessResponse(id, signature);
-	} catch (error: any) {
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
 		return context.createErrorResponse(
 			id,
 			-32003,
 			"Transaction failed",
-			error.message,
+			message,
 		);
 	}
 };

package/server/methods/transaction/simulate-transaction.ts

@@ -45,12 +45,13 @@ export const simulateTransaction: RpcMethodHandler = (id, params, context) => {
 					: null,
 			},
 		});
-	} catch (error: any) {
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : String(error);
 		return context.createErrorResponse(
 			id,
 			-32003,
 			"Simulation failed",
-			error.message,
+			message,
 		);
 	}
 };