@vtx-labs/solana-explain 0.1.0

package/dist/programs.js

@@ -0,0 +1,919 @@
+import bs58 from 'bs58';
+
+// src/decode/known-programs.ts
+var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
+var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+var ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+var MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+var MEMO_V1_PROGRAM_ID = "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo";
+var COMPUTE_BUDGET_PROGRAM_ID = "ComputeBudget111111111111111111111111111111";
+var KNOWN_PROGRAMS = Object.freeze({
+  // Core / decoded
+  [SYSTEM_PROGRAM_ID]: { name: "System", kind: "system" },
+  [TOKEN_PROGRAM_ID]: { name: "SPL Token", kind: "token" },
+  [TOKEN_2022_PROGRAM_ID]: { name: "Token-2022", kind: "token-2022" },
+  [ASSOCIATED_TOKEN_PROGRAM_ID]: { name: "Associated Token Account", kind: "ata" },
+  [MEMO_PROGRAM_ID]: { name: "Memo", kind: "memo" },
+  [MEMO_V1_PROGRAM_ID]: { name: "Memo (v1)", kind: "memo" },
+  [COMPUTE_BUDGET_PROGRAM_ID]: { name: "Compute Budget", kind: "compute-budget" },
+  // Native
+  Stake11111111111111111111111111111111111111: { name: "Stake", kind: "stake" },
+  Vote111111111111111111111111111111111111111: { name: "Vote", kind: "vote" },
+  BPFLoaderUpgradeab1e11111111111111111111111: { name: "BPF Upgradeable Loader", kind: "loader" },
+  BPFLoader2111111111111111111111111111111111: { name: "BPF Loader 2", kind: "loader" },
+  AddressLookupTab1e1111111111111111111111111: {
+    name: "Address Lookup Table",
+    kind: "other"
+  },
+  // Metaplex
+  metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s: {
+    name: "Metaplex Token Metadata",
+    kind: "nft"
+  },
+  BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY: {
+    name: "Metaplex Bubblegum",
+    kind: "nft"
+  },
+  cndy3Z4yxLzowg4ZTHTHJYjBmtkk3vd6yMJ4r8x7q3o: {
+    name: "Metaplex Candy Machine",
+    kind: "nft"
+  },
+  // Aggregators / DEX
+  JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4: { name: "Jupiter v6", kind: "aggregator" },
+  JUP4Fb2cqiRUcaTHdrPC8h2gNsA2ETXiPDD33WconZX: { name: "Jupiter v4", kind: "aggregator" },
+  "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8": { name: "Raydium AMM v4", kind: "amm" },
+  CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK: { name: "Raydium CLMM", kind: "amm" },
+  whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc: { name: "Orca Whirlpool", kind: "amm" },
+  "9W959DqEETiGZocYWCQPaJ6sBmUzgfxXfqGeTEdp3aQP": { name: "Orca v2", kind: "amm" },
+  PhoeNiXZ8ByJGLkxNfZRnkUfjvmuYqLR89jjFHGqdXY: { name: "Phoenix", kind: "amm" },
+  LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo: { name: "Meteora DLMM", kind: "amm" }
+});
+function knownProgram(programId) {
+  return KNOWN_PROGRAMS[programId];
+}
+
+// src/errors.ts
+var SolanaExplainError = class extends Error {
+  code;
+  cause;
+  /** Optional, CLI-friendly remediation hint. */
+  hint;
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    if (options.cause !== void 0) this.cause = options.cause;
+    if (options.hint !== void 0) this.hint = options.hint;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var DecodeError = class extends SolanaExplainError {
+};
+function encodeBase58(bytes) {
+  return bs58.encode(bytes);
+}
+
+// src/decode/reader.ts
+var Reader = class {
+  view;
+  bytes;
+  offset = 0;
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  get remaining() {
+    return this.bytes.length - this.offset;
+  }
+  ensure(n, field) {
+    if (this.offset + n > this.bytes.length) {
+      throw new DecodeError(
+        "DECODE_FAILED",
+        `unexpected end while reading ${field} (need ${n} bytes at offset ${this.offset}, have ${this.remaining})`
+      );
+    }
+  }
+  u8(field = "u8") {
+    this.ensure(1, field);
+    const v = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return v;
+  }
+  u16(field = "u16") {
+    this.ensure(2, field);
+    const v = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return v;
+  }
+  u32(field = "u32") {
+    this.ensure(4, field);
+    const v = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return v;
+  }
+  u64(field = "u64") {
+    this.ensure(8, field);
+    const v = this.view.getBigUint64(this.offset, true);
+    this.offset += 8;
+    return v;
+  }
+  i64(field = "i64") {
+    this.ensure(8, field);
+    const v = this.view.getBigInt64(this.offset, true);
+    this.offset += 8;
+    return v;
+  }
+  bytes_(n, field = "bytes") {
+    this.ensure(n, field);
+    const out = this.bytes.subarray(this.offset, this.offset + n);
+    this.offset += n;
+    return out;
+  }
+  /** Read a 32-byte pubkey and return base58. */
+  pubkey(field = "pubkey") {
+    return encodeBase58(this.bytes_(32, field));
+  }
+  /**
+   * Solana compact-u16 (a.k.a. ShortVec) length prefix. 1–3 bytes, 7 bits each.
+   */
+  compactU16(field = "compact-u16") {
+    let value = 0;
+    let shift = 0;
+    for (let i = 0; i < 3; i++) {
+      const byte = this.u8(`${field} length byte`);
+      value |= (byte & 127) << shift;
+      if ((byte & 128) === 0) return value >>> 0;
+      shift += 7;
+    }
+    return value >>> 0;
+  }
+  /** Remaining bytes (no copy). */
+  rest() {
+    const out = this.bytes.subarray(this.offset);
+    this.offset = this.bytes.length;
+    return out;
+  }
+};
+
+// src/decode/programs/system.ts
+function acc(ix, i) {
+  return ix.accounts[i]?.pubkey;
+}
+function decodeSystem(ix) {
+  if (ix.data.length < 4) {
+    return { decoded: false, program: "System", warning: "instruction data too short" };
+  }
+  const r = new Reader(ix.data);
+  const disc = r.u32("discriminator");
+  try {
+    switch (disc) {
+      case 0: {
+        const lamports = r.u64("lamports");
+        const space = r.u64("space");
+        const owner = r.pubkey("owner");
+        const newAccount = acc(ix, 1) ?? "";
+        return {
+          program: "System",
+          type: "createAccount",
+          decoded: true,
+          args: { lamports: lamports.toString(), space: space.toString(), owner },
+          accountNames: ["funding", "new"],
+          effects: [
+            {
+              kind: "account-created",
+              address: newAccount,
+              owner,
+              lamports,
+              space: Number(space),
+              as: "system"
+            }
+          ]
+        };
+      }
+      case 1: {
+        const owner = r.pubkey("owner");
+        return {
+          program: "System",
+          type: "assign",
+          decoded: true,
+          args: { owner },
+          accountNames: ["account"]
+        };
+      }
+      case 2: {
+        const lamports = r.u64("lamports");
+        const from = acc(ix, 0) ?? "";
+        const to = acc(ix, 1) ?? "";
+        return {
+          program: "System",
+          type: "transfer",
+          decoded: true,
+          args: { lamports: lamports.toString() },
+          accountNames: ["from", "to"],
+          effects: [{ kind: "sol-transfer", from, to, lamports }]
+        };
+      }
+      case 3: {
+        const base = r.pubkey("base");
+        const seedLen = Number(r.u64("seed length"));
+        const seed = new TextDecoder().decode(r.bytes_(seedLen, "seed"));
+        const lamports = r.u64("lamports");
+        const space = r.u64("space");
+        const owner = r.pubkey("owner");
+        const newAccount = acc(ix, 1) ?? "";
+        return {
+          program: "System",
+          type: "createAccountWithSeed",
+          decoded: true,
+          args: { base, seed, lamports: lamports.toString(), space: space.toString(), owner },
+          accountNames: ["funding", "new", "base"],
+          effects: [
+            {
+              kind: "account-created",
+              address: newAccount,
+              owner,
+              lamports,
+              space: Number(space),
+              as: "system"
+            }
+          ]
+        };
+      }
+      case 8: {
+        const space = r.u64("space");
+        return {
+          program: "System",
+          type: "allocate",
+          decoded: true,
+          args: { space: space.toString() },
+          accountNames: ["account"]
+        };
+      }
+      case 9: {
+        const base = r.pubkey("base");
+        const seedLen = Number(r.u64("seed length"));
+        const seed = new TextDecoder().decode(r.bytes_(seedLen, "seed"));
+        const space = r.u64("space");
+        const owner = r.pubkey("owner");
+        return {
+          program: "System",
+          type: "allocateWithSeed",
+          decoded: true,
+          args: { base, seed, space: space.toString(), owner },
+          accountNames: ["account", "base"]
+        };
+      }
+      case 10: {
+        const base = r.pubkey("base");
+        const seedLen = Number(r.u64("seed length"));
+        const seed = new TextDecoder().decode(r.bytes_(seedLen, "seed"));
+        const owner = r.pubkey("owner");
+        return {
+          program: "System",
+          type: "assignWithSeed",
+          decoded: true,
+          args: { base, seed, owner },
+          accountNames: ["account", "base"]
+        };
+      }
+      case 11: {
+        const lamports = r.u64("lamports");
+        const seedLen = Number(r.u64("seed length"));
+        const fromSeed = new TextDecoder().decode(r.bytes_(seedLen, "fromSeed"));
+        const fromOwner = r.pubkey("fromOwner");
+        const from = acc(ix, 0) ?? "";
+        const to = acc(ix, 2) ?? "";
+        return {
+          program: "System",
+          type: "transferWithSeed",
+          decoded: true,
+          args: { lamports: lamports.toString(), fromSeed, fromOwner },
+          accountNames: ["from", "base", "to"],
+          effects: [{ kind: "sol-transfer", from, to, lamports }]
+        };
+      }
+      default: {
+        const names = {
+          4: "advanceNonceAccount",
+          5: "withdrawNonceAccount",
+          6: "initializeNonceAccount",
+          7: "authorizeNonceAccount"
+        };
+        return {
+          program: "System",
+          type: names[disc] ?? `unknown(${disc})`,
+          decoded: disc in names
+        };
+      }
+    }
+  } catch (err) {
+    return {
+      program: "System",
+      decoded: false,
+      warning: err instanceof Error ? err.message : "system decode failed",
+      warningCode: "partial-decode"
+    };
+  }
+}
+var systemDecoder = {
+  programId: SYSTEM_PROGRAM_ID,
+  name: "System",
+  kind: "system",
+  decode: decodeSystem
+};
+
+// src/decode/programs/spl-token.ts
+var MAX_U64 = (1n << 64n) - 1n;
+function acc2(ix, i) {
+  return ix.accounts[i]?.pubkey;
+}
+function decodeTokenInstruction(ix, programName, variant) {
+  if (ix.data.length < 1) {
+    return { decoded: false, program: programName, warning: "empty instruction data" };
+  }
+  const r = new Reader(ix.data);
+  const tag = r.u8("tag");
+  try {
+    switch (tag) {
+      case 0: {
+        const decimals = r.u8("decimals");
+        return {
+          program: programName,
+          type: "initializeMint",
+          decoded: true,
+          args: { decimals },
+          accountNames: ["mint", "rent"]
+        };
+      }
+      case 20: {
+        const decimals = r.u8("decimals");
+        return {
+          program: programName,
+          type: "initializeMint2",
+          decoded: true,
+          args: { decimals },
+          accountNames: ["mint"]
+        };
+      }
+      case 1:
+      case 16:
+      case 18: {
+        const account = acc2(ix, 0) ?? "";
+        const mint = acc2(ix, 1) ?? "";
+        const owner = acc2(ix, 2);
+        const type = tag === 1 ? "initializeAccount" : tag === 16 ? "initializeAccount2" : "initializeAccount3";
+        return {
+          program: programName,
+          type,
+          decoded: true,
+          accountNames: ["account", "mint", "owner"],
+          effects: [
+            {
+              kind: "account-created",
+              address: account,
+              owner: owner ?? mint,
+              as: "token-account"
+            }
+          ]
+        };
+      }
+      case 3: {
+        const amount = r.u64("amount");
+        const from = acc2(ix, 0) ?? "";
+        const to = acc2(ix, 1) ?? "";
+        return {
+          program: programName,
+          type: "transfer",
+          decoded: true,
+          args: { amount: amount.toString() },
+          accountNames: ["source", "destination", "authority"],
+          // No decimals/mint in unchecked transfer — correlate fills from diff.
+          effects: [{ kind: "token-transfer", from, to, amount, tokenProgram: variant }],
+          warning: "unchecked transfer carries no mint/decimals",
+          warningCode: "ambiguous-amount"
+        };
+      }
+      case 12: {
+        const amount = r.u64("amount");
+        const decimals = r.u8("decimals");
+        const source = acc2(ix, 0) ?? "";
+        const mint = acc2(ix, 1) ?? "";
+        const dest = acc2(ix, 2) ?? "";
+        return {
+          program: programName,
+          type: "transferChecked",
+          decoded: true,
+          args: { amount: amount.toString(), decimals },
+          accountNames: ["source", "mint", "destination", "authority"],
+          effects: [
+            { kind: "token-transfer", from: source, to: dest, mint, amount, decimals, tokenProgram: variant }
+          ]
+        };
+      }
+      case 4: {
+        const amount = r.u64("amount");
+        const delegate = acc2(ix, 1) ?? "";
+        const owner = acc2(ix, 2) ?? "";
+        return {
+          program: programName,
+          type: "approve",
+          decoded: true,
+          args: { amount: amount.toString() },
+          accountNames: ["source", "delegate", "owner"],
+          effects: [
+            {
+              kind: "approval",
+              owner,
+              delegate,
+              mint: "",
+              amount: amount === MAX_U64 ? "unlimited" : amount
+            }
+          ]
+        };
+      }
+      case 13: {
+        const amount = r.u64("amount");
+        const decimals = r.u8("decimals");
+        const mint = acc2(ix, 1) ?? "";
+        const delegate = acc2(ix, 2) ?? "";
+        const owner = acc2(ix, 3) ?? "";
+        return {
+          program: programName,
+          type: "approveChecked",
+          decoded: true,
+          args: { amount: amount.toString(), decimals },
+          accountNames: ["source", "mint", "delegate", "owner"],
+          effects: [
+            {
+              kind: "approval",
+              owner,
+              delegate,
+              mint,
+              amount: amount === MAX_U64 ? "unlimited" : amount
+            }
+          ]
+        };
+      }
+      case 5: {
+        const owner = acc2(ix, 1) ?? "";
+        return {
+          program: programName,
+          type: "revoke",
+          decoded: true,
+          accountNames: ["source", "owner"],
+          effects: [{ kind: "approval", owner, delegate: "", mint: "", amount: 0n, revoke: true }]
+        };
+      }
+      case 6: {
+        return {
+          program: programName,
+          type: "setAuthority",
+          decoded: true,
+          accountNames: ["account", "currentAuthority"]
+        };
+      }
+      case 7: {
+        const amount = r.u64("amount");
+        const mint = acc2(ix, 0) ?? "";
+        const to = acc2(ix, 1) ?? "";
+        return {
+          program: programName,
+          type: "mintTo",
+          decoded: true,
+          args: { amount: amount.toString() },
+          accountNames: ["mint", "destination", "authority"],
+          effects: [{ kind: "mint", mint, to, amount }]
+        };
+      }
+      case 14: {
+        const amount = r.u64("amount");
+        const decimals = r.u8("decimals");
+        const mint = acc2(ix, 0) ?? "";
+        const to = acc2(ix, 1) ?? "";
+        return {
+          program: programName,
+          type: "mintToChecked",
+          decoded: true,
+          args: { amount: amount.toString(), decimals },
+          accountNames: ["mint", "destination", "authority"],
+          effects: [{ kind: "mint", mint, to, amount, decimals }]
+        };
+      }
+      case 8: {
+        const amount = r.u64("amount");
+        const from = acc2(ix, 0) ?? "";
+        const mint = acc2(ix, 1) ?? "";
+        return {
+          program: programName,
+          type: "burn",
+          decoded: true,
+          args: { amount: amount.toString() },
+          accountNames: ["account", "mint", "authority"],
+          effects: [{ kind: "burn", mint, from, amount }]
+        };
+      }
+      case 15: {
+        const amount = r.u64("amount");
+        const decimals = r.u8("decimals");
+        const from = acc2(ix, 0) ?? "";
+        const mint = acc2(ix, 1) ?? "";
+        return {
+          program: programName,
+          type: "burnChecked",
+          decoded: true,
+          args: { amount: amount.toString(), decimals },
+          accountNames: ["account", "mint", "authority"],
+          effects: [{ kind: "burn", mint, from, amount, decimals }]
+        };
+      }
+      case 9: {
+        const account = acc2(ix, 0) ?? "";
+        const destination = acc2(ix, 1) ?? "";
+        return {
+          program: programName,
+          type: "closeAccount",
+          decoded: true,
+          accountNames: ["account", "destination", "owner"],
+          effects: [{ kind: "close-account", account, destination }]
+        };
+      }
+      case 10:
+        return {
+          program: programName,
+          type: "freezeAccount",
+          decoded: true,
+          accountNames: ["account", "mint", "authority"]
+        };
+      case 11:
+        return {
+          program: programName,
+          type: "thawAccount",
+          decoded: true,
+          accountNames: ["account", "mint", "authority"]
+        };
+      case 17: {
+        const account = acc2(ix, 0) ?? "";
+        return {
+          program: programName,
+          type: "syncNative",
+          decoded: true,
+          accountNames: ["account"],
+          effects: [{ kind: "sync-native", account }]
+        };
+      }
+      default:
+        return {
+          program: programName,
+          type: `unknown(${tag})`,
+          decoded: false,
+          warning: `unrecognized ${programName} instruction tag ${tag}`,
+          warningCode: "partial-decode"
+        };
+    }
+  } catch (err) {
+    return {
+      program: programName,
+      decoded: false,
+      warning: err instanceof Error ? err.message : "token decode failed",
+      warningCode: "partial-decode"
+    };
+  }
+}
+
+// src/decode/programs/token-2022.ts
+var EXTENSION_TAGS = {
+  21: "getAccountDataSize",
+  22: "initializeMintCloseAuthority",
+  23: "transferFeeExtension",
+  24: "confidentialTransferExtension",
+  25: "defaultAccountStateExtension",
+  26: "reallocate",
+  27: "memoTransferExtension",
+  28: "createNativeMint",
+  29: "initializeNonTransferableMint",
+  30: "interestBearingMintExtension",
+  31: "cpiGuardExtension",
+  32: "initializePermanentDelegate",
+  33: "transferHookExtension",
+  34: "confidentialTransferFeeExtension",
+  35: "withdrawExcessLamports",
+  36: "metadataPointerExtension",
+  37: "groupPointerExtension",
+  38: "groupMemberPointerExtension"
+};
+function decodeToken2022(ix) {
+  if (ix.data.length < 1) {
+    return { decoded: false, program: "Token-2022", warning: "empty instruction data" };
+  }
+  const tag = ix.data[0];
+  if (tag >= 21) {
+    const name = EXTENSION_TAGS[tag] ?? `extension(${tag})`;
+    return {
+      program: "Token-2022",
+      type: name,
+      decoded: false,
+      warning: `Token-2022 extension instruction "${name}" not byte-decoded; effect visible in balance diff`,
+      warningCode: "token-2022-extension-unparsed"
+    };
+  }
+  return decodeTokenInstruction(ix, "Token-2022", "token-2022");
+}
+var token2022Decoder = {
+  programId: TOKEN_2022_PROGRAM_ID,
+  name: "Token-2022",
+  kind: "token-2022",
+  decode: decodeToken2022
+};
+var splTokenDecoder = {
+  programId: TOKEN_PROGRAM_ID,
+  name: "SPL Token",
+  kind: "token",
+  decode: (ix) => decodeTokenInstruction(ix, "SPL Token", "spl-token")
+};
+
+// src/decode/programs/ata.ts
+function acc3(ix, i) {
+  return ix.accounts[i]?.pubkey;
+}
+function decodeAta(ix) {
+  const tag = ix.data.length === 0 ? 0 : ix.data[0];
+  const type = tag === 0 ? "create" : tag === 1 ? "createIdempotent" : tag === 2 ? "recoverNested" : void 0;
+  if (type === void 0) {
+    return {
+      program: "Associated Token Account",
+      decoded: false,
+      warning: `unrecognized ATA instruction tag ${tag}`,
+      warningCode: "partial-decode"
+    };
+  }
+  if (type === "recoverNested") {
+    return {
+      program: "Associated Token Account",
+      type,
+      decoded: true,
+      accountNames: ["nestedAta", "nestedMint", "destinationAta", "ownerAta", "ownerMint", "wallet"]
+    };
+  }
+  const ata = acc3(ix, 1) ?? "";
+  const owner = acc3(ix, 2) ?? "";
+  const tokenProgram = acc3(ix, 5);
+  return {
+    program: "Associated Token Account",
+    type,
+    decoded: true,
+    accountNames: ["payer", "ata", "owner", "mint", "systemProgram", "tokenProgram"],
+    effects: [
+      {
+        kind: "account-created",
+        address: ata,
+        owner: owner || (tokenProgram ?? ""),
+        as: "ata"
+      }
+    ]
+  };
+}
+var ataDecoder = {
+  programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+  name: "Associated Token Account",
+  kind: "ata",
+  decode: decodeAta
+};
+
+// src/decode/programs/memo.ts
+var MAX_DISPLAY = 256;
+function decodeMemoData(ix, name) {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(ix.data);
+  const display = text.length > MAX_DISPLAY ? `${text.slice(0, MAX_DISPLAY)}\u2026` : text;
+  const truncated = text.length > MAX_DISPLAY;
+  return {
+    program: name,
+    type: "memo",
+    decoded: true,
+    args: { text: display, ...truncated ? { truncated: true } : {} },
+    effects: [{ kind: "memo", text: display }],
+    ...truncated ? { warning: "memo truncated for display; full bytes available via --raw", warningCode: "partial-decode" } : {}
+  };
+}
+var memoDecoder = {
+  programId: MEMO_PROGRAM_ID,
+  name: "Memo",
+  kind: "memo",
+  decode: (ix) => decodeMemoData(ix, "Memo")
+};
+var memoV1Decoder = {
+  programId: MEMO_V1_PROGRAM_ID,
+  name: "Memo (v1)",
+  kind: "memo",
+  decode: (ix) => decodeMemoData(ix, "Memo (v1)")
+};
+
+// src/decode/programs/compute-budget.ts
+function decodeComputeBudget(ix) {
+  if (ix.data.length < 1) {
+    return { decoded: false, program: "Compute Budget", warning: "empty instruction data" };
+  }
+  const r = new Reader(ix.data);
+  const tag = r.u8("tag");
+  try {
+    switch (tag) {
+      case 1: {
+        const bytes = r.u32("heap bytes");
+        return {
+          program: "Compute Budget",
+          type: "requestHeapFrame",
+          decoded: true,
+          args: { bytes }
+        };
+      }
+      case 2: {
+        const units = r.u32("unit limit");
+        return {
+          program: "Compute Budget",
+          type: "setComputeUnitLimit",
+          decoded: true,
+          args: { units },
+          effects: [{ kind: "compute-budget", unitLimit: units }]
+        };
+      }
+      case 3: {
+        const price = r.u64("micro-lamports");
+        return {
+          program: "Compute Budget",
+          type: "setComputeUnitPrice",
+          decoded: true,
+          args: { microLamports: price.toString() },
+          effects: [{ kind: "compute-budget", unitPriceMicroLamports: price }]
+        };
+      }
+      case 4: {
+        const bytes = r.u32("data size limit");
+        return {
+          program: "Compute Budget",
+          type: "setLoadedAccountsDataSizeLimit",
+          decoded: true,
+          args: { bytes }
+        };
+      }
+      case 0:
+        return {
+          program: "Compute Budget",
+          type: "requestUnits",
+          decoded: true
+        };
+      default:
+        return {
+          program: "Compute Budget",
+          type: `unknown(${tag})`,
+          decoded: false,
+          warningCode: "partial-decode"
+        };
+    }
+  } catch (err) {
+    return {
+      program: "Compute Budget",
+      decoded: false,
+      warning: err instanceof Error ? err.message : "compute-budget decode failed",
+      warningCode: "partial-decode"
+    };
+  }
+}
+var computeBudgetDecoder = {
+  programId: COMPUTE_BUDGET_PROGRAM_ID,
+  name: "Compute Budget",
+  kind: "compute-budget",
+  decode: decodeComputeBudget
+};
+
+// src/decode/programs/recognize.ts
+var ALREADY_DECODED = /* @__PURE__ */ new Set([
+  "11111111111111111111111111111111",
+  "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+  "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb",
+  "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+  "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr",
+  "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo",
+  "ComputeBudget111111111111111111111111111111"
+]);
+function buildRecognizers() {
+  const decoders = [];
+  for (const [programId, info] of Object.entries(KNOWN_PROGRAMS)) {
+    if (ALREADY_DECODED.has(programId)) continue;
+    decoders.push({
+      programId,
+      name: info.name,
+      kind: info.kind,
+      decode: () => ({
+        program: info.name,
+        decoded: false,
+        // Honest signal: we know *who* but not the exact ix semantics.
+        warning: `${info.name} recognized by program id; semantics inferred from balance diff (no IDL)`
+      })
+    });
+  }
+  return decoders;
+}
+
+// src/decode/registry.ts
+var Registry = class _Registry {
+  map;
+  constructor(decoders) {
+    this.map = /* @__PURE__ */ new Map();
+    for (const d of decoders) this.map.set(d.programId, d);
+  }
+  get(programId) {
+    return this.map.get(programId);
+  }
+  has(programId) {
+    return this.map.has(programId);
+  }
+  list() {
+    return [...this.map.values()];
+  }
+  merge(decoders) {
+    const merged = new Map(this.map);
+    for (const d of decoders) merged.set(d.programId, d);
+    return new _Registry([...merged.values()]);
+  }
+};
+var BUNDLED_DECODERS = [
+  systemDecoder,
+  splTokenDecoder,
+  token2022Decoder,
+  ataDecoder,
+  memoDecoder,
+  memoV1Decoder,
+  computeBudgetDecoder
+];
+function createRegistry(decoders) {
+  const base = [...BUNDLED_DECODERS, ...buildRecognizers()];
+  const reg = new Registry(base);
+  return decoders && decoders.length > 0 ? reg.merge(decoders) : reg;
+}
+var defaultRegistry = createRegistry();
+function decodeInstruction(ix, registry = defaultRegistry, precomputed) {
+  const decoder = registry.get(ix.programId);
+  const known = knownProgram(ix.programId);
+  const baseAccounts = ix.accounts.map((a) => ({
+    pubkey: a.pubkey,
+    isSigner: a.isSigner,
+    isWritable: a.isWritable
+  }));
+  if (!decoder) {
+    return {
+      index: ix.index,
+      programId: ix.programId,
+      ...known ? { program: known.name } : {},
+      decoded: false,
+      accounts: baseAccounts,
+      warning: known ? `${known.name} recognized by program id (no byte decoder)` : "unknown program (no decoder)"
+    };
+  }
+  let out;
+  try {
+    out = precomputed ?? decoder.decode(ix);
+  } catch (err) {
+    return {
+      index: ix.index,
+      programId: ix.programId,
+      program: decoder.name,
+      decoded: false,
+      accounts: baseAccounts,
+      warning: `decoder error: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const accounts = baseAccounts.map((a, i) => {
+    const name = out.accountNames?.[i];
+    return name !== void 0 ? { ...a, name } : a;
+  });
+  return {
+    index: ix.index,
+    programId: ix.programId,
+    ...out.program !== void 0 ? { program: out.program } : {},
+    ...out.type !== void 0 ? { type: out.type } : {},
+    decoded: out.decoded,
+    accounts,
+    ...out.args !== void 0 ? { args: out.args } : {},
+    ...out.warning !== void 0 ? { warning: out.warning } : {}
+  };
+}
+function decodeInstructionRaw(ix, registry = defaultRegistry) {
+  const decoder = registry.get(ix.programId);
+  if (!decoder) return { decoded: decodeInstruction(ix, registry), effects: [] };
+  let out;
+  try {
+    out = decoder.decode(ix);
+  } catch {
+    return { decoded: decodeInstruction(ix, registry), effects: [] };
+  }
+  const decoded = decodeInstruction(ix, registry, out);
+  return {
+    decoded,
+    effects: out.effects ?? [],
+    ...out.warningCode !== void 0 ? { warningCode: out.warningCode } : {}
+  };
+}
+
+export { BUNDLED_DECODERS, KNOWN_PROGRAMS, createRegistry, decodeInstruction, decodeInstructionRaw, defaultRegistry, knownProgram };
+//# sourceMappingURL=programs.js.map
+//# sourceMappingURL=programs.js.map