solforge 0.2.6 → 0.2.8

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

@@ -25,22 +25,51 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 			: Array.isArray(msg.accountKeys)
 				? msg.accountKeys
 				: [];
-		const staticKeys = rawKeys
-			.map((k) => {
-				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 = msg as unknown as {
@@ -57,14 +86,15 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 			TOKEN_2022_PROGRAM_ID.toBase58(),
 		]);
 		const tokenAccountSet = new Set<string>();
+		// 1) Collect from compiled ixs (best-effort)
 		for (const ci of compiled) {
 			try {
-				const pid = staticKeys[ci.programIdIndex]?.toBase58();
+				const pid = staticKeys[(ci as any).programIdIndex]?.toBase58();
 				if (!pid || !tokenProgramIds.has(pid)) continue;
-				const accIdxs: number[] = Array.isArray(ci.accountKeyIndexes)
-					? ci.accountKeyIndexes
-					: Array.isArray(ci.accounts)
-						? ci.accounts
+				const accIdxs: number[] = Array.isArray((ci as any).accountKeyIndexes)
+					? (ci as any).accountKeyIndexes
+					: Array.isArray((ci as any).accounts)
+						? (ci as any).accounts
 						: [];
 				for (const ix of accIdxs) {
 					const addr = staticKeys[ix]?.toBase58();
@@ -72,6 +102,17 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 				}
 			} catch {}
 		}
+		// 2) Also collect from all static keys that are SPL token accounts pre-send
+		for (const pk of staticKeys) {
+			try {
+				const acc = context.svm.getAccount(pk);
+				if (!acc) continue;
+				const ownerStr = new PublicKey(acc.owner).toBase58();
+				if (tokenProgramIds.has(ownerStr) && (acc.data?.length ?? 0) >= ACCOUNT_SIZE) {
+					tokenAccountSet.add(pk.toBase58());
+				}
+			} catch {}
+		}
 		// Pre token balances
 		const preTokenBalances: unknown[] = [];
 		const ataToInfo = new Map<
@@ -130,7 +171,7 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 			} catch {}
 		}
 
-		const result = context.svm.sendTransaction(tx);
+        const result = context.svm.sendTransaction(tx);
 
 		try {
 			const rawErr = (result as { err?: unknown }).err;
@@ -146,19 +187,47 @@ 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;
-			}
-		});
-		// Post token balances
+        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 (scan token accounts among static keys)
 		const postTokenBalances: unknown[] = [];
 		for (const addr of tokenAccountSet) {
 			try {
@@ -209,28 +278,150 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
 				}
 			} catch {}
 		}
-		let logs: string[] = [];
-		try {
-			const sr = result 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 {}
-		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: unknown) {

package/server/rpc-server.ts

@@ -150,23 +150,36 @@ export class LiteSVMRpcServer {
 				} catch {}
 			},
 			listPrograms: () => Array.from(this.knownPrograms),
-			recordTransaction: (signature, tx, meta) => {
-				this.txRecords.set(signature, {
-					tx,
-					logs: meta?.logs || [],
-					err: meta?.err ?? null,
-					fee: meta?.fee ?? 5000,
-					slot: Number(this.slot),
-					blockTime: meta?.blockTime,
-					preBalances: meta?.preBalances,
-					postBalances: meta?.postBalances,
-					preTokenBalances: (
-						meta as { preTokenBalances?: unknown[] } | undefined
-					)?.preTokenBalances,
-					postTokenBalances: (
-						meta as { postTokenBalances?: unknown[] } | undefined
-					)?.postTokenBalances,
-				});
+            recordTransaction: (signature, tx, meta) => {
+                this.txRecords.set(signature, {
+                    tx,
+                    logs: meta?.logs || [],
+                    err: meta?.err ?? null,
+                    fee: meta?.fee ?? 5000,
+                    slot: Number(this.slot),
+                    blockTime: meta?.blockTime,
+                    preBalances: meta?.preBalances,
+                    postBalances: meta?.postBalances,
+                    preTokenBalances: (
+                        meta as { preTokenBalances?: unknown[] } | undefined
+                    )?.preTokenBalances,
+                    postTokenBalances: (
+                        meta as { postTokenBalances?: unknown[] } | undefined
+                    )?.postTokenBalances,
+                    innerInstructions: meta?.innerInstructions || [],
+                    computeUnits:
+                        meta?.computeUnits == null
+                            ? null
+                            : Number(meta.computeUnits),
+                    returnData: meta?.returnData ?? null,
+                });
+                try {
+                    if (process.env.DEBUG_TX_CAPTURE === "1") {
+                        console.debug(
+                            `[tx-capture] recordTransaction: sig=${signature} slot=${this.slot} logs=${meta?.logs?.length || 0} inner=${Array.isArray(meta?.innerInstructions) ? meta?.innerInstructions?.length : 0} cu=${meta?.computeUnits ?? null} returnData=${meta?.returnData ? "yes" : "no"}`,
+                        );
+                    }
+                } catch {}
 
 				// Persist to SQLite for durability and history queries
 				try {
@@ -227,58 +240,82 @@ export class LiteSVMRpcServer {
 								: "legacy"
 							: 0;
 					const rawBase64 = Buffer.from(tx.serialize()).toString("base64");
-					this.store
-						.insertTransactionBundle({
-							signature,
-							slot: Number(this.slot),
-							blockTime: meta?.blockTime,
-							version,
-							fee: Number(meta?.fee ?? 5000),
-							err: meta?.err ?? null,
-							rawBase64,
-							preBalances: Array.isArray(meta?.preBalances)
-								? (meta?.preBalances as number[])
-								: [],
-							postBalances: Array.isArray(meta?.postBalances)
-								? (meta?.postBalances as number[])
-								: [],
-							logs: Array.isArray(meta?.logs) ? (meta?.logs as string[]) : [],
-							preTokenBalances: (() => {
-								const arr = (
-									meta as { preTokenBalances?: unknown[] } | undefined
-								)?.preTokenBalances;
-								return Array.isArray(arr) ? arr : [];
-							})(),
-							postTokenBalances: (() => {
-								const arr = (
-									meta as { postTokenBalances?: unknown[] } | undefined
-								)?.postTokenBalances;
-								return Array.isArray(arr) ? arr : [];
-							})(),
-							accounts,
-						})
-						.catch(() => {});
+                    this.store
+                        .insertTransactionBundle({
+                            signature,
+                            slot: Number(this.slot),
+                            blockTime: meta?.blockTime,
+                            version,
+                            fee: Number(meta?.fee ?? 5000),
+                            err: meta?.err ?? null,
+                            rawBase64,
+                            preBalances: Array.isArray(meta?.preBalances)
+                                ? (meta?.preBalances as number[])
+                                : [],
+                            postBalances: Array.isArray(meta?.postBalances)
+                                ? (meta?.postBalances as number[])
+                                : [],
+                            logs: Array.isArray(meta?.logs) ? (meta?.logs as string[]) : [],
+                            preTokenBalances: (() => {
+                                const arr = (
+                                    meta as { preTokenBalances?: unknown[] } | undefined
+                                )?.preTokenBalances;
+                                return Array.isArray(arr) ? arr : [];
+                            })(),
+                            postTokenBalances: (() => {
+                                const arr = (
+                                    meta as { postTokenBalances?: unknown[] } | undefined
+                                )?.postTokenBalances;
+                                return Array.isArray(arr) ? arr : [];
+                            })(),
+                            innerInstructions: Array.isArray(meta?.innerInstructions)
+                                ? meta?.innerInstructions
+                                : [],
+                            computeUnits:
+                                meta?.computeUnits == null
+                                    ? null
+                                    : Number(meta.computeUnits),
+                            returnData: meta?.returnData ?? null,
+                            accounts,
+                            accountStates: Array.isArray(meta?.accountStates)
+                                ? meta?.accountStates
+                                : [],
+                        })
+                        .catch(() => {});
 
 					// Upsert account snapshots for static keys
-					const snapshots = keys
-						.map((addr) => {
-							try {
-								const acc = this.svm.getAccount(new PublicKey(addr));
-								if (!acc) return null;
-								return {
-									address: addr,
-									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(this.slot),
-								};
-							} catch {
-								return null;
-							}
-						})
+                    const snapshots = keys
+                        .map((addr) => {
+                            try {
+                                const acc = this.svm.getAccount(new PublicKey(addr));
+                                if (!acc) return null;
+                                const ownerStr = new PublicKey(acc.owner).toBase58();
+                                let dataBase64: string | undefined;
+                                // Store raw data for SPL Token accounts to reflect balance changes
+                                try {
+                                    if (
+                                        ownerStr === "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" ||
+                                        ownerStr === "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+                                    ) {
+                                        if (acc.data && acc.data.length > 0) {
+                                            dataBase64 = Buffer.from(acc.data).toString("base64");
+                                        }
+                                    }
+                                } catch {}
+                                return {
+                                    address: addr,
+                                    lamports: Number(acc.lamports || 0n),
+                                    ownerProgram: ownerStr,
+                                    executable: !!acc.executable,
+                                    rentEpoch: Number(acc.rentEpoch || 0),
+                                    dataLen: acc.data?.length ?? 0,
+                                    dataBase64,
+                                    lastSlot: Number(this.slot),
+                                };
+                            } catch {
+                                return null;
+                            }
+                        })
 						.filter(Boolean) as import("../src/db/tx-store").AccountSnapshot[];
 					if (snapshots.length > 0)
 						this.store.upsertAccounts(snapshots).catch(() => {});