solforge 0.2.7 → 0.2.9

package/server/rpc-server.ts

@@ -150,36 +150,34 @@ 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,
-                    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 {}
+			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 {
@@ -240,48 +238,46 @@ 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 : [];
-                            })(),
-                            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(() => {});
+					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
@@ -289,14 +285,28 @@ export class LiteSVMRpcServer {
 							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: new PublicKey(acc.owner).toBase58(),
+									ownerProgram: ownerStr,
 									executable: !!acc.executable,
 									rentEpoch: Number(acc.rentEpoch || 0),
 									dataLen: acc.data?.length ?? 0,
-									dataBase64: undefined,
+									dataBase64,
 									lastSlot: Number(this.slot),
 								};
 							} catch {

package/server/types.ts

@@ -44,62 +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[];
-            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;
+	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/transactions.ts

@@ -1,35 +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(),
-        // 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),
-    }),
+	"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

@@ -1,21 +1,23 @@
 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),
-  }),
+	"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

@@ -7,33 +7,33 @@ 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[];
-    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;
-    }>;
+	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 = {
@@ -48,81 +48,79 @@ 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 ?? []),
-                    innerInstructionsJson: JSON.stringify(bundle.innerInstructions ?? []),
-                    computeUnits:
-                        bundle.computeUnits == null
-                            ? null
-                            : Number(bundle.computeUnits),
-                    returnDataProgramId: bundle.returnData?.programId ?? null,
-                    returnDataBase64: bundle.returnData?.dataBase64 ?? 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();
+			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();
-            }
+				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();
-            }
-        });
-    }
+			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

@@ -13,11 +13,11 @@ 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",
+	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: "0002_graceful_caretaker.sql", path: mig0002 },
+	{ name: "0000_friendly_millenium_guard.sql", path: mig0000 },
+	{ name: "0001_stale_sentinels.sql", path: mig0001 },
+	{ name: "0002_graceful_caretaker.sql", path: mig0002 },
 ];