solforge 0.2.6 → 0.2.8

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;

package/src/db/schema/tx-account-states.ts

@@ -0,0 +1,21 @@
+import { index, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const txAccountStates = sqliteTable(
+  "tx_account_states",
+  {
+    signature: text("signature").notNull(),
+    address: text("address").notNull(),
+    // JSON blobs capturing minimal account snapshot
+    // { lamports, ownerProgram, executable, rentEpoch, dataLen, dataBase64? }
+    preJson: text("pre_json"),
+    postJson: text("post_json"),
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.signature, t.address], name: "pk_tx_account_states" }),
+    addrIdx: index("idx_tx_account_states_address").on(t.address),
+  }),
+);
+
+export type TxAccountStateRow = typeof txAccountStates.$inferSelect;
+export type NewTxAccountStateRow = typeof txAccountStates.$inferInsert;
+

package/src/db/tx-store.ts

@@ -4,27 +4,36 @@ import { accounts } from "./schema/accounts";
 import { addressSignatures } from "./schema/address-signatures";
 import { transactions } from "./schema/transactions";
 import { txAccounts } from "./schema/tx-accounts";
+import { txAccountStates } from "./schema/tx-account-states";
 
 export type InsertTxBundle = {
-	signature: string;
-	slot: number;
-	blockTime?: number;
-	version: 0 | "legacy";
-	fee: number;
-	err: unknown | null;
-	rawBase64: string;
-	preBalances: number[];
-	postBalances: number[];
-	logs: string[];
-	accounts: Array<{
-		address: string;
-		index: number;
-		signer: boolean;
-		writable: boolean;
-		programIdIndex?: number;
-	}>;
-	preTokenBalances?: unknown[];
-	postTokenBalances?: unknown[];
+    signature: string;
+    slot: number;
+    blockTime?: number;
+    version: 0 | "legacy";
+    fee: number;
+    err: unknown | null;
+    rawBase64: string;
+    preBalances: number[];
+    postBalances: number[];
+    logs: string[];
+    innerInstructions?: unknown[];
+    computeUnits?: number | bigint | null;
+    returnData?: { programId: string; dataBase64: string } | null;
+    accounts: Array<{
+        address: string;
+        index: number;
+        signer: boolean;
+        writable: boolean;
+        programIdIndex?: number;
+    }>;
+    preTokenBalances?: unknown[];
+    postTokenBalances?: unknown[];
+    accountStates?: Array<{
+        address: string;
+        pre?: Partial<AccountSnapshot> | null;
+        post?: Partial<AccountSnapshot> | null;
+    }>;
 };
 
 export type AccountSnapshot = {
@@ -39,57 +48,81 @@ export type AccountSnapshot = {
 };
 
 export class TxStore {
-	async insertTransactionBundle(bundle: InsertTxBundle): Promise<void> {
-		const errJson = bundle.err ? JSON.stringify(bundle.err) : null;
-		await db.transaction(async (tx) => {
-			await tx
-				.insert(transactions)
-				.values({
-					signature: bundle.signature,
-					slot: bundle.slot,
-					blockTime: bundle.blockTime ?? null,
-					version: String(bundle.version),
-					errJson,
-					fee: bundle.fee,
-					rawBase64: bundle.rawBase64,
-					preBalancesJson: JSON.stringify(bundle.preBalances ?? []),
-					postBalancesJson: JSON.stringify(bundle.postBalances ?? []),
-					logsJson: JSON.stringify(bundle.logs ?? []),
-					preTokenBalancesJson: JSON.stringify(bundle.preTokenBalances ?? []),
-					postTokenBalancesJson: JSON.stringify(bundle.postTokenBalances ?? []),
-				})
-				.onConflictDoNothing();
-
-			if (Array.isArray(bundle.accounts) && bundle.accounts.length > 0) {
-				await tx
-					.insert(txAccounts)
-					.values(
-						bundle.accounts.map((a) => ({
-							signature: bundle.signature,
-							accountIndex: a.index,
-							address: a.address,
-							signer: a.signer ? 1 : 0,
-							writable: a.writable ? 1 : 0,
-							programIdIndex: a.programIdIndex ?? null,
-						})),
-					)
-					.onConflictDoNothing();
-
-				await tx
-					.insert(addressSignatures)
-					.values(
-						bundle.accounts.map((a) => ({
-							address: a.address,
-							signature: bundle.signature,
-							slot: bundle.slot,
-							err: errJson ? 1 : 0,
-							blockTime: bundle.blockTime ?? null,
-						})),
-					)
-					.onConflictDoNothing();
-			}
-		});
-	}
+    async insertTransactionBundle(bundle: InsertTxBundle): Promise<void> {
+        const errJson = bundle.err ? JSON.stringify(bundle.err) : null;
+        await db.transaction(async (tx) => {
+            await tx
+                .insert(transactions)
+                .values({
+                    signature: bundle.signature,
+                    slot: bundle.slot,
+                    blockTime: bundle.blockTime ?? null,
+                    version: String(bundle.version),
+                    errJson,
+                    fee: bundle.fee,
+                    rawBase64: bundle.rawBase64,
+                    preBalancesJson: JSON.stringify(bundle.preBalances ?? []),
+                    postBalancesJson: JSON.stringify(bundle.postBalances ?? []),
+                    logsJson: JSON.stringify(bundle.logs ?? []),
+                    preTokenBalancesJson: JSON.stringify(bundle.preTokenBalances ?? []),
+                    postTokenBalancesJson: JSON.stringify(bundle.postTokenBalances ?? []),
+                    innerInstructionsJson: JSON.stringify(bundle.innerInstructions ?? []),
+                    computeUnits:
+                        bundle.computeUnits == null
+                            ? null
+                            : Number(bundle.computeUnits),
+                    returnDataProgramId: bundle.returnData?.programId ?? null,
+                    returnDataBase64: bundle.returnData?.dataBase64 ?? null,
+                })
+                .onConflictDoNothing();
+
+            if (Array.isArray(bundle.accounts) && bundle.accounts.length > 0) {
+                await tx
+                    .insert(txAccounts)
+                    .values(
+                        bundle.accounts.map((a) => ({
+                            signature: bundle.signature,
+                            accountIndex: a.index,
+                            address: a.address,
+                            signer: a.signer ? 1 : 0,
+                            writable: a.writable ? 1 : 0,
+                            programIdIndex: a.programIdIndex ?? null,
+                        })),
+                    )
+                    .onConflictDoNothing();
+
+                await tx
+                    .insert(addressSignatures)
+                    .values(
+                        bundle.accounts.map((a) => ({
+                            address: a.address,
+                            signature: bundle.signature,
+                            slot: bundle.slot,
+                            err: errJson ? 1 : 0,
+                            blockTime: bundle.blockTime ?? null,
+                        })),
+                    )
+                    .onConflictDoNothing();
+            }
+
+            if (
+                Array.isArray(bundle.accountStates) &&
+                bundle.accountStates.length > 0
+            ) {
+                await tx
+                    .insert(txAccountStates)
+                    .values(
+                        bundle.accountStates.map((s) => ({
+                            signature: bundle.signature,
+                            address: s.address,
+                            preJson: s.pre ? JSON.stringify(s.pre) : null,
+                            postJson: s.post ? JSON.stringify(s.post) : null,
+                        })),
+                    )
+                    .onConflictDoNothing();
+            }
+        });
+    }
 
 	async upsertAccounts(snapshots: AccountSnapshot[]): Promise<void> {
 		if (!Array.isArray(snapshots) || snapshots.length === 0) return;

package/src/migrations-bundled.ts

@@ -10,8 +10,14 @@ import mig0000 from "../drizzle/0000_friendly_millenium_guard.sql" with {
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-expect-error - Bun import attributes
 import mig0001 from "../drizzle/0001_stale_sentinels.sql" with { type: "file" };
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error - Bun import attributes
+import mig0002 from "../drizzle/0002_graceful_caretaker.sql" with {
+    type: "file",
+};
 
 export const bundledMigrations: Array<{ name: string; path: string }> = [
-	{ name: "0000_friendly_millenium_guard.sql", path: mig0000 },
-	{ name: "0001_stale_sentinels.sql", path: mig0001 },
+    { name: "0000_friendly_millenium_guard.sql", path: mig0000 },
+    { name: "0001_stale_sentinels.sql", path: mig0001 },
+    { name: "0002_graceful_caretaker.sql", path: mig0002 },
 ];