solforge 0.2.7 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solforge",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "module": "index.ts",
   "type": "module",
   "private": false,

package/scripts/decode-b58.ts

@@ -0,0 +1,6 @@
+import { decodeBase58 } from "../server/lib/base58";
+
+const s = process.argv[2] || "84eT";
+const bytes = decodeBase58(s);
+console.log(bytes);
+console.log(Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(" "));

package/server/lib/instruction-parser.ts

@@ -8,6 +8,9 @@ import {
   TransactionInstruction,
   VoteInstruction,
 } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { tryParseSplToken } from "./parsers/spl-token";
+import { tryParseAta } from "./parsers/spl-associated-token-account";
 import { decodeBase58 as _decodeBase58 } from "./base58";
 
 export type ParsedInstruction =
@@ -43,18 +46,38 @@ export function parseInstruction(
     const pid = new PublicKey(programId);
     const ix = makeIx(programId, accountKeys, accounts, dataBase58);
 
+    // SPL Token
+    if (pid.equals(TOKEN_PROGRAM_ID)) {
+      const parsed = tryParseSplToken(ix, programId, accountKeys, dataBase58);
+      if (parsed) return parsed;
+    }
+
+    // Associated Token Account
+    if (pid.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const parsed = tryParseAta(ix, programId);
+      if (parsed) return parsed;
+    }
+
     // System Program
     if (pid.equals(SystemProgram.programId)) {
       const t = SystemInstruction.decodeInstructionType(ix);
       switch (t) {
         case "Create": {
           const p = SystemInstruction.decodeCreateAccount(ix);
+          const from = p.fromPubkey.toBase58();
+          const newAcc = p.newAccountPubkey.toBase58();
+          const owner = p.programId.toBase58();
           return ok("system", programId, "createAccount", {
-            fromPubkey: p.fromPubkey.toBase58(),
-            newAccountPubkey: p.newAccountPubkey.toBase58(),
+            // Explorer-compatible field names
+            source: from,
+            newAccount: newAcc,
+            owner,
             lamports: Number(p.lamports),
             space: Number(p.space),
-            programId: p.programId.toBase58(),
+            // Keep legacy aliases too
+            fromPubkey: from,
+            newAccountPubkey: newAcc,
+            programId: owner,
           });
         }
         case "Transfer": {
@@ -239,4 +262,3 @@ export function parseInstruction(
     };
   }
 }
-

package/server/lib/parsers/spl-associated-token-account.ts

@@ -0,0 +1,44 @@
+import type { TransactionInstruction } from "@solana/web3.js";
+import { ASSOCIATED_TOKEN_PROGRAM_ID } from "@solana/spl-token";
+
+// Keep shape compatible with instruction-parser
+export type ParsedInstruction =
+  | { program: string; programId: string; parsed: { type: string; info: any } }
+  | { programId: string; accounts: string[]; data: string };
+
+function ok(programId: string, type: string, info: any): ParsedInstruction {
+  return { program: "spl-associated-token-account", programId, parsed: { type, info } };
+}
+
+function asBase58(ix: TransactionInstruction, idx: number): string | undefined {
+  try {
+    return ix.keys[idx]?.pubkey?.toBase58();
+  } catch {
+    return undefined;
+  }
+}
+
+export function tryParseAta(
+  ix: TransactionInstruction,
+  programIdStr: string,
+): ParsedInstruction | null {
+  try {
+    if (!ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) return null;
+    const dataLen = ix.data?.length ?? 0;
+    // Both create (empty) and createIdempotent ([1]) map to type "create" in explorers
+    const type = "create";
+    // Expected keys: [payer, associatedToken, owner, mint, systemProgram, tokenProgram]
+    const info = {
+      source: asBase58(ix, 0),
+      account: asBase58(ix, 1),
+      wallet: asBase58(ix, 2),
+      mint: asBase58(ix, 3),
+      systemProgram: asBase58(ix, 4),
+      tokenProgram: asBase58(ix, 5),
+    };
+    return ok(programIdStr, type, info);
+  } catch {
+    return null;
+  }
+}
+

package/server/lib/parsers/spl-token.ts

@@ -0,0 +1,172 @@
+import type { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import {
+  TOKEN_PROGRAM_ID,
+  decodeInstruction as splDecodeInstruction,
+  decodeMintToCheckedInstruction,
+  decodeTransferInstruction,
+  decodeTransferCheckedInstruction,
+  decodeInitializeAccount3Instruction,
+  decodeInitializeImmutableOwnerInstruction,
+} from "@solana/spl-token";
+import { u8 } from "@solana/buffer-layout";
+
+// Keep shape compatible with instruction-parser
+export type ParsedInstruction =
+  | { program: string; programId: string; parsed: { type: string; info: any } }
+  | { programId: string; accounts: string[]; data: string };
+
+function ok(programId: string, type: string, info: any): ParsedInstruction {
+  return { program: "spl-token", programId, parsed: { type, info } };
+}
+
+function asBase58(pk: PublicKey | undefined): string | undefined {
+  try {
+    return pk ? pk.toBase58() : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function tryParseSplToken(
+  ix: TransactionInstruction,
+  programIdStr: string,
+  accountKeys: string[],
+  dataBase58: string,
+): ParsedInstruction | null {
+  try {
+    if (!ix.programId.equals(TOKEN_PROGRAM_ID)) return null;
+
+    // Probe with generic decoder (ignore result), then try specific decoders
+    try {
+      splDecodeInstruction(ix);
+    } catch {}
+
+    // MintToChecked
+    try {
+        const m = decodeMintToCheckedInstruction(ix);
+        const amount = m.data.amount;
+        const decimals = m.data.decimals;
+        const amtStr = typeof amount === "bigint" ? amount.toString() : String(amount);
+        const base = BigInt(10) ** BigInt(decimals);
+        const whole = BigInt(amtStr) / base;
+        const frac = BigInt(amtStr) % base;
+        const fracStr = frac.toString().padStart(decimals, "0").replace(/0+$/, "");
+        const uiStr = fracStr.length ? `${whole}.${fracStr}` : `${whole}`;
+        return ok(programIdStr, "mintToChecked", {
+          account: asBase58(m.keys.destination.pubkey),
+          mint: asBase58(m.keys.mint.pubkey),
+          mintAuthority: asBase58(m.keys.authority.pubkey),
+          tokenAmount: {
+            amount: amtStr,
+            decimals,
+            uiAmount: Number(uiStr),
+            uiAmountString: uiStr,
+          },
+        });
+    } catch {}
+
+    // Transfer / TransferChecked
+    try {
+        const t = decodeTransferInstruction(ix);
+        const amt = t.data.amount;
+        return ok(programIdStr, "transfer", {
+          amount: (typeof amt === "bigint" ? amt.toString() : String(amt)),
+          source: asBase58(t.keys.source.pubkey),
+          destination: asBase58(t.keys.destination.pubkey),
+          authority: asBase58(t.keys.owner.pubkey),
+        });
+    } catch {}
+
+    try {
+        const t = decodeTransferCheckedInstruction(ix);
+        const amt = t.data.amount;
+        const decimals = t.data.decimals;
+        return ok(programIdStr, "transferChecked", {
+          tokenAmount: {
+            amount: (typeof amt === "bigint" ? amt.toString() : String(amt)),
+            decimals,
+          },
+          source: asBase58(t.keys.source.pubkey),
+          destination: asBase58(t.keys.destination.pubkey),
+          authority: asBase58(t.keys.owner.pubkey),
+          mint: asBase58(t.keys.mint.pubkey),
+        });
+    } catch {}
+
+    // InitializeAccount3
+    try {
+        const a = decodeInitializeAccount3Instruction(ix);
+        return ok(programIdStr, "initializeAccount3", {
+          account: asBase58(a.keys.account.pubkey),
+          mint: asBase58(a.keys.mint.pubkey),
+          owner: asBase58(a.data.owner),
+        });
+    } catch {}
+
+    // InitializeImmutableOwner
+    try {
+        const im = decodeInitializeImmutableOwnerInstruction(ix, TOKEN_PROGRAM_ID);
+        return ok(programIdStr, "initializeImmutableOwner", {
+          account: asBase58(im.keys.account.pubkey),
+        });
+    } catch {}
+
+    // GetAccountDataSize: decode extension types (u16 little-endian sequence)
+    try {
+      const bytes = Buffer.from(bs58decode(dataBase58));
+      const t = u8().decode(bytes);
+      // 21 corresponds to TokenInstruction.GetAccountDataSize
+      if (t === 21) {
+        const mint = asBase58(ix.keys[0]?.pubkey);
+        const extCodes: number[] = [];
+        for (let i = 1; i + 1 < bytes.length; i += 2) {
+          const code = bytes[i] | (bytes[i + 1] << 8);
+          extCodes.push(code);
+        }
+        const extMap: Record<number, string> = {
+          7: "immutableOwner",
+          8: "memoTransfer",
+          9: "nonTransferable",
+          12: "permanentDelegate",
+          14: "transferHook",
+          15: "transferHookAccount",
+          18: "metadataPointer",
+          19: "tokenMetadata",
+          20: "groupPointer",
+          21: "tokenGroup",
+          22: "groupMemberPointer",
+          23: "tokenGroupMember",
+          25: "scaledUiAmountConfig",
+          26: "pausableConfig",
+          27: "pausableAccount",
+        };
+        const extensionTypes = extCodes.map((c) => extMap[c] || String(c));
+        return ok(programIdStr, "getAccountDataSize", { mint, extensionTypes });
+      }
+    } catch {}
+
+    // Unknown SPL token instruction
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// Local base58 decode to avoid importing from sibling file
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const BASE = BigInt(ALPHABET.length);
+function bs58decode(str: string): Uint8Array {
+  let num = 0n;
+  for (const char of str) {
+    const index = ALPHABET.indexOf(char);
+    if (index === -1) throw new Error("Invalid base58 character");
+    num = num * BASE + BigInt(index);
+  }
+  const bytes: number[] = [];
+  while (num > 0n) {
+    bytes.unshift(Number(num % 256n));
+    num = num / 256n;
+  }
+  for (let i = 0; i < str.length && str[i] === "1"; i++) bytes.unshift(0);
+  return new Uint8Array(bytes.length > 0 ? bytes : [0]);
+}

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

@@ -86,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();
@@ -101,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<
@@ -215,7 +227,7 @@ export const sendTransaction: RpcMethodHandler = (id, params, context) => {
                 );
             }
         } catch {}
-		// Post token balances
+		// Post token balances (scan token accounts among static keys)
 		const postTokenBalances: unknown[] = [];
 		for (const addr of tokenAccountSet) {
 			try {

package/server/rpc-server.ts

@@ -284,25 +284,38 @@ export class LiteSVMRpcServer {
                         .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(() => {});