solforge 0.2.6 → 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

@@ -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 {
@@ -130,7 +159,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,18 +175,46 @@ 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: unknown[] = [];
 		for (const addr of tokenAccountSet) {
@@ -209,28 +266,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,37 +240,48 @@ 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

package/server/types.ts

@@ -44,30 +44,62 @@ export interface RpcMethodContext {
 	listMints?: () => string[];
 	registerProgram?: (program: PublicKey | string) => void;
 	listPrograms?: () => string[];
-	recordTransaction: (
-		signature: string,
-		tx: VersionedTransaction,
-		meta?: {
-			logs?: string[];
-			err?: unknown;
-			fee?: number;
-			blockTime?: number;
-			preBalances?: number[];
-			postBalances?: number[];
-		},
-	) => void;
-	getRecordedTransaction: (signature: string) =>
-		| {
-				tx: VersionedTransaction;
-				logs: string[];
-				err: unknown;
-				fee: number;
-				slot: number;
-				blockTime?: number;
-				preBalances?: number[];
-				postBalances?: number[];
-		  }
-		| undefined;
+    recordTransaction: (
+        signature: string,
+        tx: VersionedTransaction,
+        meta?: {
+            logs?: string[];
+            err?: unknown;
+            fee?: number;
+            blockTime?: number;
+            preBalances?: number[];
+            postBalances?: number[];
+            preTokenBalances?: unknown[];
+            postTokenBalances?: unknown[];
+            innerInstructions?: unknown[];
+            computeUnits?: number | bigint | null;
+            returnData?: { programId: string; dataBase64: string } | null;
+            // Optional rich per-account snapshots captured around execution
+            accountStates?: Array<{
+                address: string;
+                pre?: {
+                    lamports?: number;
+                    ownerProgram?: string;
+                    executable?: boolean;
+                    rentEpoch?: number;
+                    dataLen?: number;
+                    dataBase64?: string | null;
+                    lastSlot?: number;
+                } | null;
+                post?: {
+                    lamports?: number;
+                    ownerProgram?: string;
+                    executable?: boolean;
+                    rentEpoch?: number;
+                    dataLen?: number;
+                    dataBase64?: string | null;
+                    lastSlot?: number;
+                } | null;
+            }>;
+        },
+    ) => void;
+    getRecordedTransaction: (signature: string) =>
+        | {
+                tx: VersionedTransaction;
+                logs: string[];
+                err: unknown;
+                fee: number;
+                slot: number;
+                blockTime?: number;
+                preBalances?: number[];
+                postBalances?: number[];
+                preTokenBalances?: unknown[];
+                postTokenBalances?: unknown[];
+                innerInstructions?: unknown[];
+                computeUnits?: number | null;
+                returnData?: { programId: string; dataBase64: string } | null;
+          }
+        | undefined;
 }
 
 export type RpcMethodHandler = (

package/src/db/schema/index.ts

@@ -3,3 +3,4 @@ export * from "./address-signatures";
 export * from "./meta-kv";
 export * from "./transactions";
 export * from "./tx-accounts";
+export * from "./tx-account-states";

package/src/db/schema/transactions.ts

@@ -1,28 +1,35 @@
 import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
 export const transactions = sqliteTable(
-	"transactions",
-	{
-		signature: text("signature").primaryKey(),
-		slot: integer("slot").notNull(),
-		blockTime: integer("block_time"),
-		version: text("version").notNull(), // 0 | "legacy"
-		errJson: text("err_json"),
-		fee: integer("fee").notNull(),
-		rawBase64: text("raw_base64").notNull(),
-		preBalancesJson: text("pre_balances_json").notNull(),
-		postBalancesJson: text("post_balances_json").notNull(),
-		logsJson: text("logs_json").notNull(),
-		preTokenBalancesJson: text("pre_token_balances_json")
-			.default("[]")
-			.notNull(),
-		postTokenBalancesJson: text("post_token_balances_json")
-			.default("[]")
-			.notNull(),
-	},
-	(t) => ({
-		slotIdx: index("idx_transactions_slot").on(t.slot),
-	}),
+    "transactions",
+    {
+        signature: text("signature").primaryKey(),
+        slot: integer("slot").notNull(),
+        blockTime: integer("block_time"),
+        version: text("version").notNull(), // 0 | "legacy"
+        errJson: text("err_json"),
+        fee: integer("fee").notNull(),
+        rawBase64: text("raw_base64").notNull(),
+        preBalancesJson: text("pre_balances_json").notNull(),
+        postBalancesJson: text("post_balances_json").notNull(),
+        logsJson: text("logs_json").notNull(),
+        preTokenBalancesJson: text("pre_token_balances_json")
+            .default("[]")
+            .notNull(),
+        postTokenBalancesJson: text("post_token_balances_json")
+            .default("[]")
+            .notNull(),
+        // Additional rich metadata captured after execution
+        innerInstructionsJson: text("inner_instructions_json")
+            .default("[]")
+            .notNull(),
+        computeUnits: integer("compute_units"),
+        returnDataProgramId: text("return_data_program_id"),
+        returnDataBase64: text("return_data_base64"),
+    },
+    (t) => ({
+        slotIdx: index("idx_transactions_slot").on(t.slot),
+    }),
 );
 
 export type TransactionRow = typeof transactions.$inferSelect;