solforge 0.2.6 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solforge",
-  "version": "0.2.6",
+  "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

@@ -0,0 +1,264 @@
+import {
+  AddressLookupTableInstruction,
+  ComputeBudgetInstruction,
+  PublicKey,
+  StakeInstruction,
+  SystemInstruction,
+  SystemProgram,
+  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 =
+  | { program: string; programId: string; parsed: { type: string; info: any } }
+  | { programId: string; accounts: string[]; data: string };
+
+function makeIx(
+  programId: string,
+  accountKeys: string[],
+  accounts: number[],
+  dataBase58: string,
+): TransactionInstruction {
+  const keys = accounts.map((i) => ({
+    pubkey: new PublicKey(accountKeys[i] || SystemProgram.programId),
+    isSigner: false,
+    isWritable: false,
+  }));
+  const data = Buffer.from(_decodeBase58(dataBase58));
+  return new TransactionInstruction({ programId: new PublicKey(programId), keys, data });
+}
+
+function ok(program: string, programId: string, type: string, info: any): ParsedInstruction {
+  return { program, programId, parsed: { type, info } };
+}
+
+export function parseInstruction(
+  programId: string,
+  accounts: number[],
+  dataBase58: string,
+  accountKeys: string[],
+): ParsedInstruction {
+  try {
+    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", {
+            // Explorer-compatible field names
+            source: from,
+            newAccount: newAcc,
+            owner,
+            lamports: Number(p.lamports),
+            space: Number(p.space),
+            // Keep legacy aliases too
+            fromPubkey: from,
+            newAccountPubkey: newAcc,
+            programId: owner,
+          });
+        }
+        case "Transfer": {
+          const p = SystemInstruction.decodeTransfer(ix);
+          return ok("system", programId, "transfer", {
+            source: p.fromPubkey.toBase58(),
+            destination: p.toPubkey.toBase58(),
+            lamports: Number(p.lamports),
+          });
+        }
+        case "TransferWithSeed": {
+          const p = SystemInstruction.decodeTransferWithSeed(ix);
+          return ok("system", programId, "transferWithSeed", {
+            fromPubkey: p.fromPubkey.toBase58(),
+            basePubkey: p.basePubkey.toBase58(),
+            toPubkey: p.toPubkey.toBase58(),
+            lamports: Number(p.lamports),
+            seed: p.seed,
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "Allocate": {
+          const p = SystemInstruction.decodeAllocate(ix);
+          return ok("system", programId, "allocate", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            space: Number(p.space),
+          });
+        }
+        case "AllocateWithSeed": {
+          const p = SystemInstruction.decodeAllocateWithSeed(ix);
+          return ok("system", programId, "allocateWithSeed", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            basePubkey: p.basePubkey.toBase58(),
+            seed: p.seed,
+            space: Number(p.space),
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "Assign": {
+          const p = SystemInstruction.decodeAssign(ix);
+          return ok("system", programId, "assign", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "AssignWithSeed": {
+          const p = SystemInstruction.decodeAssignWithSeed(ix);
+          return ok("system", programId, "assignWithSeed", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            basePubkey: p.basePubkey.toBase58(),
+            seed: p.seed,
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "InitializeNonceAccount":
+        case "AdvanceNonceAccount":
+        case "WithdrawNonceAccount":
+        case "AuthorizeNonceAccount":
+        case "CreateWithSeed":
+        case "UpgradeNonceAccount": {
+          // For brevity: rely on type only; details can be added if needed
+          return ok("system", programId, t, {});
+        }
+        default:
+          break;
+      }
+    }
+
+    // Compute Budget
+    try {
+      const t = ComputeBudgetInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "SetComputeUnitLimit": {
+          const p = ComputeBudgetInstruction.decodeSetComputeUnitLimit(ix);
+          return ok("computeBudget", programId, "setComputeUnitLimit", { units: Number(p.units) });
+        }
+        case "SetComputeUnitPrice": {
+          const p = ComputeBudgetInstruction.decodeSetComputeUnitPrice(ix);
+          return ok("computeBudget", programId, "setComputeUnitPrice", { microLamports: Number(p.microLamports) });
+        }
+        case "RequestHeapFrame": {
+          const p = ComputeBudgetInstruction.decodeRequestHeapFrame(ix);
+          return ok("computeBudget", programId, "requestHeapFrame", { bytes: Number(p.bytes) });
+        }
+        case "RequestUnits": {
+          const p = ComputeBudgetInstruction.decodeRequestUnits(ix);
+          return ok("computeBudget", programId, "requestUnits", { units: Number(p.units), additionalFee: Number(p.additionalFee) });
+        }
+      }
+    } catch {}
+
+    // Stake
+    try {
+      const t = StakeInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "Initialize":
+          return ok("stake", programId, "initialize", {});
+        case "Delegate": {
+          const p = StakeInstruction.decodeDelegate(ix);
+          return ok("stake", programId, "delegate", {
+            stakePubkey: p.stakePubkey.toBase58(),
+            votePubkey: p.votePubkey.toBase58(),
+            authorizedPubkey: p.authorizedPubkey.toBase58(),
+          });
+        }
+        case "Authorize": {
+          const p = StakeInstruction.decodeAuthorize(ix);
+          return ok("stake", programId, "authorize", {
+            stakePubkey: p.stakePubkey.toBase58(),
+            authorizedPubkey: p.authorizedPubkey.toBase58(),
+            newAuthorizedPubkey: p.newAuthorizedPubkey.toBase58(),
+            stakeAuthorizationType: p.stakeAuthorizationType.index,
+          });
+        }
+        case "AuthorizeWithSeed":
+          return ok("stake", programId, "authorizeWithSeed", {});
+        case "Split":
+          return ok("stake", programId, "split", {});
+        case "Withdraw":
+          return ok("stake", programId, "withdraw", {});
+        case "Deactivate":
+          return ok("stake", programId, "deactivate", {});
+        case "Merge":
+          return ok("stake", programId, "merge", {});
+      }
+    } catch {}
+
+    // Vote
+    try {
+      const t = VoteInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "InitializeAccount":
+          return ok("vote", programId, "initialize", {});
+        case "Authorize":
+          return ok("vote", programId, "authorize", {});
+        case "AuthorizeWithSeed":
+          return ok("vote", programId, "authorizeWithSeed", {});
+        case "Withdraw":
+          return ok("vote", programId, "withdraw", {});
+        default:
+          return ok("vote", programId, t, {});
+      }
+    } catch {}
+
+    // Address Lookup Table
+    try {
+      const t = AddressLookupTableInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "CreateLookupTable":
+        case "ExtendLookupTable":
+        case "CloseLookupTable":
+        case "FreezeLookupTable":
+        case "DeactivateLookupTable":
+          return ok("address-lookup-table", programId, t, {});
+      }
+    } catch {}
+
+    // Memo program: parse utf8 memo if possible
+    if (
+      programId === "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr" ||
+      programId === "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo"
+    ) {
+      try {
+        const bytes = _decodeBase58(dataBase58);
+        const memo = new TextDecoder().decode(bytes);
+        return ok("spl-memo", programId, "memo", { memo });
+      } catch {}
+      return ok("spl-memo", programId, "memo", {});
+    }
+
+    // Fallback: unknown program, return raw
+    return {
+      programId,
+      accounts: accounts.map((i) => accountKeys[i] || ""),
+      data: dataBase58,
+    };
+  } catch {
+    return {
+      programId,
+      accounts: accounts.map((i) => accountKeys[i] || ""),
+      data: dataBase58,
+    };
+  }
+}

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]);
+}