tx-indexer 0.5.1 → 0.5.3

package/dist/client.js

@@ -12,12 +12,40 @@ function parseSignature(sig) {
 
 // ../domain/src/money/token-registry.ts
 var KNOWN_TOKENS = {
+  // Native
   SOL: "So11111111111111111111111111111111111111112",
+  // Stablecoins
   USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+  USDT: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+  PYUSD: "2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo",
+  USDG: "2u1tszSeqZ3qBWF3uNGPFc8TzMk2tdiwknnRMWGWjGWH",
   USDC_BRIDGED: "A9mUU4qviSctJVPJdBJWkb28deg915LYJKrzQ19ji3FM",
-  USDG: "2u1tszSeqZ3qBWF3uNGPFc8TzMk2tdiwknnRMWGWjGWH"
-};
+  DAI: "EjmyN6qEC1Tf1JxiG1ae7UTJhUxSwk1TCCi3Z4dPuFhh",
+  // Major tokens
+  JUP: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
+  JTO: "jtojtomepa8beP8AuQc6eXt5FriJwfFMwQx2v2f9mCL",
+  PYTH: "HZ1JovNiVvGrGNiiYvEozEVgZ58xaU3RKwX8eACQBCt3",
+  BONK: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
+  WIF: "EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm",
+  RENDER: "rndrizKT3MK1iimdxRdWabcF7Zg7AR5T4nud4EkHBof",
+  HNT: "hntyVP6YFm1Hg25TN9WGLqM12b8TQmcknKrdu1oxWux",
+  RAY: "4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R",
+  ORCA: "orcaEKTdK7LKz57vaAYr9QeNsVEPfiu6QeMU1kektZE",
+  MNGO: "MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac",
+  MSOL: "mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So",
+  JITOSOL: "J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn",
+  BSOL: "bSo13r4TkiE4KumL71LsHTPpL2euBYLFx6h9HP3piy1",
+  // Memecoins
+  POPCAT: "7GCihgDB8fe6KNjn2MYtkzZcRjQy3t9GHdC8uHYmW2hr",
+  MEW: "MEW1gQWJ3nEXg2qgERiKu7FAFj79PHvQVREQUzScPP5",
+  PNUT: "2qEHjDLDLbuBgRYvsxhc5D6uDWAivNFZGan56P1tpump",
+  FARTCOIN: "9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump",
+  AI16Z: "HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC",
+  // Wrapped tokens
+  WBTC: "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh",
+  WETH: "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs"};
 var TOKEN_INFO = {
+  // Native SOL
   [KNOWN_TOKENS.SOL]: {
     mint: KNOWN_TOKENS.SOL,
     symbol: "SOL",
@@ -25,6 +53,7 @@ var TOKEN_INFO = {
     decimals: 9,
     logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/So11111111111111111111111111111111111111112/logo.png"
   },
+  // Stablecoins
   [KNOWN_TOKENS.USDC]: {
     mint: KNOWN_TOKENS.USDC,
     symbol: "USDC",
@@ -32,22 +61,245 @@ var TOKEN_INFO = {
     decimals: 6,
     logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png"
   },
-  [KNOWN_TOKENS.USDC_BRIDGED]: {
-    mint: KNOWN_TOKENS.USDC_BRIDGED,
-    symbol: "USDCet",
-    name: "USDC (Bridged)",
-    decimals: 6
+  [KNOWN_TOKENS.USDT]: {
+    mint: KNOWN_TOKENS.USDT,
+    symbol: "USDT",
+    name: "Tether USD",
+    decimals: 6,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB/logo.svg"
+  },
+  [KNOWN_TOKENS.PYUSD]: {
+    mint: KNOWN_TOKENS.PYUSD,
+    symbol: "PYUSD",
+    name: "PayPal USD",
+    decimals: 6,
+    logoURI: "https://img.fotofolio.xyz/?url=https%3A%2F%2Fraw.githubusercontent.com%2Fsolana-labs%2Ftoken-list%2Fmain%2Fassets%2Fmainnet%2F2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo%2Flogo.png"
   },
   [KNOWN_TOKENS.USDG]: {
     mint: KNOWN_TOKENS.USDG,
     symbol: "USDG",
     name: "USD Glitter",
     decimals: 6
+  },
+  [KNOWN_TOKENS.USDC_BRIDGED]: {
+    mint: KNOWN_TOKENS.USDC_BRIDGED,
+    symbol: "USDCet",
+    name: "USDC (Wormhole)",
+    decimals: 6
+  },
+  [KNOWN_TOKENS.DAI]: {
+    mint: KNOWN_TOKENS.DAI,
+    symbol: "DAI",
+    name: "DAI (Wormhole)",
+    decimals: 8
+  },
+  // Major tokens
+  [KNOWN_TOKENS.JUP]: {
+    mint: KNOWN_TOKENS.JUP,
+    symbol: "JUP",
+    name: "Jupiter",
+    decimals: 6,
+    logoURI: "https://static.jup.ag/jup/icon.png"
+  },
+  [KNOWN_TOKENS.JTO]: {
+    mint: KNOWN_TOKENS.JTO,
+    symbol: "JTO",
+    name: "Jito",
+    decimals: 9,
+    logoURI: "https://metadata.jito.network/token/jto/image"
+  },
+  [KNOWN_TOKENS.PYTH]: {
+    mint: KNOWN_TOKENS.PYTH,
+    symbol: "PYTH",
+    name: "Pyth Network",
+    decimals: 6,
+    logoURI: "https://pyth.network/token.svg"
+  },
+  [KNOWN_TOKENS.BONK]: {
+    mint: KNOWN_TOKENS.BONK,
+    symbol: "BONK",
+    name: "Bonk",
+    decimals: 5,
+    logoURI: "https://arweave.net/hQiPZOsRZXGXBJd_82PhVdlM_hACsT_q6wqwf5cSY7I"
+  },
+  [KNOWN_TOKENS.WIF]: {
+    mint: KNOWN_TOKENS.WIF,
+    symbol: "WIF",
+    name: "dogwifhat",
+    decimals: 6,
+    logoURI: "https://bafkreibk3covs5ltyqxa272uodhber6kcclnlgrbwjee4kyqhstwmjqpfa.ipfs.nftstorage.link/"
+  },
+  [KNOWN_TOKENS.RENDER]: {
+    mint: KNOWN_TOKENS.RENDER,
+    symbol: "RENDER",
+    name: "Render Token",
+    decimals: 8,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/rndrizKT3MK1iimdxRdWabcF7Zg7AR5T4nud4EkHBof/logo.png"
+  },
+  [KNOWN_TOKENS.HNT]: {
+    mint: KNOWN_TOKENS.HNT,
+    symbol: "HNT",
+    name: "Helium",
+    decimals: 8,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/hntyVP6YFm1Hg25TN9WGLqM12b8TQmcknKrdu1oxWux/logo.png"
+  },
+  [KNOWN_TOKENS.RAY]: {
+    mint: KNOWN_TOKENS.RAY,
+    symbol: "RAY",
+    name: "Raydium",
+    decimals: 6,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/4k3Dyjzvzp8eMZWUXbBCjEvwSkkk59S5iCNLY3QrkX6R/logo.png"
+  },
+  [KNOWN_TOKENS.ORCA]: {
+    mint: KNOWN_TOKENS.ORCA,
+    symbol: "ORCA",
+    name: "Orca",
+    decimals: 6,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/orcaEKTdK7LKz57vaAYr9QeNsVEPfiu6QeMU1kektZE/logo.png"
+  },
+  [KNOWN_TOKENS.MNGO]: {
+    mint: KNOWN_TOKENS.MNGO,
+    symbol: "MNGO",
+    name: "Mango",
+    decimals: 6,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/MangoCzJ36AjZyKwVj3VnYU4GTonjfVEnJmvvWaxLac/logo.png"
+  },
+  // Liquid staking tokens
+  [KNOWN_TOKENS.MSOL]: {
+    mint: KNOWN_TOKENS.MSOL,
+    symbol: "mSOL",
+    name: "Marinade Staked SOL",
+    decimals: 9,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So/logo.png"
+  },
+  [KNOWN_TOKENS.JITOSOL]: {
+    mint: KNOWN_TOKENS.JITOSOL,
+    symbol: "JitoSOL",
+    name: "Jito Staked SOL",
+    decimals: 9,
+    logoURI: "https://storage.googleapis.com/token-metadata/JitoSOL-256.png"
+  },
+  [KNOWN_TOKENS.BSOL]: {
+    mint: KNOWN_TOKENS.BSOL,
+    symbol: "bSOL",
+    name: "BlazeStake Staked SOL",
+    decimals: 9,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/bSo13r4TkiE4KumL71LsHTPpL2euBYLFx6h9HP3piy1/logo.png"
+  },
+  // Memecoins
+  [KNOWN_TOKENS.POPCAT]: {
+    mint: KNOWN_TOKENS.POPCAT,
+    symbol: "POPCAT",
+    name: "Popcat",
+    decimals: 9,
+    logoURI: "https://bafkreidvkvuzyslw5jh5z242lgzwzhbi2kxxnpkm73fkuqzasyr34jj2o4.ipfs.nftstorage.link/"
+  },
+  [KNOWN_TOKENS.MEW]: {
+    mint: KNOWN_TOKENS.MEW,
+    symbol: "MEW",
+    name: "cat in a dogs world",
+    decimals: 5,
+    logoURI: "https://bafkreidlwyr565dxtao2ipsze6bmzpszqzybz7sqi2zaet5fs7k53henju.ipfs.nftstorage.link/"
+  },
+  [KNOWN_TOKENS.PNUT]: {
+    mint: KNOWN_TOKENS.PNUT,
+    symbol: "Peanut",
+    name: "Peanut the Squirrel",
+    decimals: 6,
+    logoURI: "https://ipfs.io/ipfs/QmNS3Hdb6pMheFzRdwXr3PPCrXcBohzhLrKHqEUV1n3HnJ"
+  },
+  [KNOWN_TOKENS.FARTCOIN]: {
+    mint: KNOWN_TOKENS.FARTCOIN,
+    symbol: "FARTCOIN",
+    name: "Fartcoin",
+    decimals: 6,
+    logoURI: "https://ipfs.io/ipfs/QmQHY6t8TxucH3F9LGPBBqqRLbyWx7NxWvrnoZKcq9ErrR"
+  },
+  [KNOWN_TOKENS.AI16Z]: {
+    mint: KNOWN_TOKENS.AI16Z,
+    symbol: "ai16z",
+    name: "ai16z",
+    decimals: 9,
+    logoURI: "https://ipfs.io/ipfs/QmRbm1mprqHmJ7PvCTrSNydkquLi5r41wq8kWbHvoRm3FX"
+  },
+  // Wrapped tokens
+  [KNOWN_TOKENS.WBTC]: {
+    mint: KNOWN_TOKENS.WBTC,
+    symbol: "WBTC",
+    name: "Wrapped BTC (Wormhole)",
+    decimals: 8,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh/logo.png"
+  },
+  [KNOWN_TOKENS.WETH]: {
+    mint: KNOWN_TOKENS.WETH,
+    symbol: "WETH",
+    name: "Wrapped ETH (Wormhole)",
+    decimals: 8,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs/logo.png"
   }
 };
 function getTokenInfo(mint) {
   return TOKEN_INFO[mint];
 }
+function createUnknownToken(mint, decimals) {
+  return {
+    mint,
+    symbol: mint.slice(0, 8),
+    name: `Unknown Token (${mint.slice(0, 8)}...)`,
+    decimals
+  };
+}
+
+// ../solana/src/constants/program-ids.ts
+var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
+var COMPUTE_BUDGET_PROGRAM_ID = "ComputeBudget111111111111111111111111111111";
+var STAKE_PROGRAM_ID = "Stake11111111111111111111111111111111111111";
+var STAKE_POOL_PROGRAM_ID = "SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy";
+var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+var ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+var SPL_MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+var MEMO_V1_PROGRAM_ID = "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo";
+var JUPITER_V6_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+var JUPITER_V4_PROGRAM_ID = "JUP4Fb2cqiRUcaTHdrPC8h2gNsA2ETXiPDD33WcGuJB";
+var JUPITER_ORDER_ENGINE_PROGRAM_ID = "61DFfeTKM7trxYcPQCM78bJ794ddZprZpAwAnLiwTpYH";
+var RAYDIUM_PROGRAM_ID = "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8";
+var RAYDIUM_CLMM_PROGRAM_ID = "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK";
+var RAYDIUM_CPMM_PROGRAM_ID = "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C";
+var RAYDIUM_STABLE_PROGRAM_ID = "5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h";
+var ORCA_WHIRLPOOL_PROGRAM_ID = "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc";
+var ORCA_TOKEN_SWAP_V1_PROGRAM_ID = "9W959DqEETiGZocYWCQPaJ6sBmUzgfxXfqGeTEdp3aQP";
+var OPENBOOK_V2_PROGRAM_ID = "opnb2LAfJYbRMAHHvqjCwQxanZn7ReEHp1k81EohpZb";
+var PHOENIX_PROGRAM_ID = "PhoeNiXZ8ByJGLkxNfZRnkUfjvmuYqLR89jjFHGqdXY";
+var SABER_STABLE_SWAP_PROGRAM_ID = "SSwpkEEcbUqx4vtoEByFjSkhKdCT862DNVb52nZg1UZ";
+var MERCURIAL_STABLE_SWAP_PROGRAM_ID = "MERLuDFBMmsHnsBPZw2sDQZHvXFMwp8EdjudcU2HKky";
+var METEORA_DLMM_PROGRAM_ID = "LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo";
+var METEORA_POOLS_PROGRAM_ID = "Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB";
+var PUMPFUN_AMM_PROGRAM_ID = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA";
+var PUMPFUN_BONDING_CURVE_PROGRAM_ID = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";
+var LIFINITY_V2_PROGRAM_ID = "2wT8Yq49kHgDzXuPxZSaeLaH1qbmGXtEyPy64bL7aD3c";
+var METAPLEX_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+var CANDY_MACHINE_V3_PROGRAM_ID = "CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR";
+var CANDY_GUARD_PROGRAM_ID = "Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g";
+var BUBBLEGUM_PROGRAM_ID = "BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY";
+var MAGIC_EDEN_CANDY_MACHINE_ID = "CMZYPASGWeTz7RNGHaRJfCq2XQ5pYK6nDvVQxzkH51zb";
+var WORMHOLE_PROGRAM_ID = "worm2ZoG2kUd4vFXhvjh93UUH596ayRfgQ2MgjNMTth";
+var WORMHOLE_TOKEN_BRIDGE_ID = "wormDTUJ6AWPNvk59vGQbDvGJmqbDTdgWgAqcLBCgUb";
+var DEGODS_BRIDGE_PROGRAM_ID = "35iLrpYNNR9ygHLcvE1xKFHbHq6paHthrF6wSovdWgGu";
+var DEBRIDGE_PROGRAM_ID = "DEbrdGj3HsRsAzx6uH4MKyREKxVAfBydijLUF3ygsFfh";
+var ALLBRIDGE_PROGRAM_ID = "BrdgN2RPzEMWF96ZbnnJaUtQDQx7VRXYaHHbYCBvceWB";
+var PAYAI_FACILITATOR = "2wKupLR9q6wXYppw8Gr2NvWxKBUqm4PPJKkQfoxHDBg4";
+var KNOWN_FACILITATORS = [PAYAI_FACILITATOR];
+function detectFacilitator(accountKeys) {
+  for (const facilitator of KNOWN_FACILITATORS) {
+    if (accountKeys.includes(facilitator)) {
+      if (facilitator === PAYAI_FACILITATOR) {
+        return "payai";
+      }
+    }
+  }
+  return null;
+}
 
 // ../solana/src/fetcher/balances.ts
 async function fetchWalletBalance(rpc, walletAddress, tokenMints) {
@@ -66,12 +318,17 @@ async function fetchWalletBalance(rpc, walletAddress, tokenMints) {
 }
 async function fetchTokenAccounts(rpc, walletAddress) {
   const accountsMap = /* @__PURE__ */ new Map();
-  try {
-    const response = await rpc.getTokenAccountsByOwner(
-      walletAddress,
-      { programId: address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") },
-      { encoding: "jsonParsed" }
-    ).send();
+  const tokenPrograms = [TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID];
+  const responses = await Promise.all(
+    tokenPrograms.map(
+      (programId) => rpc.getTokenAccountsByOwner(
+        walletAddress,
+        { programId: address(programId) },
+        { encoding: "jsonParsed" }
+      ).send().catch(() => ({ value: [] }))
+    )
+  );
+  for (const response of responses) {
     for (const account of response.value) {
       const parsedInfo = account.account.data.parsed.info;
       const mint = parsedInfo.mint;
@@ -88,8 +345,6 @@ async function fetchTokenAccounts(rpc, walletAddress) {
         symbol
       });
     }
-  } catch (error) {
-    console.error("Error fetching token accounts:", error);
   }
   return accountsMap;
 }
@@ -133,44 +388,6 @@ function extractProgramIds(transaction) {
   return Array.from(programIds);
 }
 
-// ../solana/src/constants/program-ids.ts
-var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
-var COMPUTE_BUDGET_PROGRAM_ID = "ComputeBudget111111111111111111111111111111";
-var STAKE_PROGRAM_ID = "Stake11111111111111111111111111111111111111";
-var STAKE_POOL_PROGRAM_ID = "SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy";
-var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-var ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-var SPL_MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
-var MEMO_V1_PROGRAM_ID = "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo";
-var JUPITER_V6_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
-var JUPITER_V4_PROGRAM_ID = "JUP4Fb2cqiRUcaTHdrPC8h2gNsA2ETXiPDD33WcGuJB";
-var RAYDIUM_PROGRAM_ID = "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8";
-var ORCA_WHIRLPOOL_PROGRAM_ID = "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc";
-var METAPLEX_PROGRAM_ID = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
-var CANDY_MACHINE_V3_PROGRAM_ID = "CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR";
-var CANDY_GUARD_PROGRAM_ID = "Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g";
-var BUBBLEGUM_PROGRAM_ID = "BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY";
-var MAGIC_EDEN_CANDY_MACHINE_ID = "CMZYPASGWeTz7RNGHaRJfCq2XQ5pYK6nDvVQxzkH51zb";
-var WORMHOLE_PROGRAM_ID = "worm2ZoG2kUd4vFXhvjh93UUH596ayRfgQ2MgjNMTth";
-var WORMHOLE_TOKEN_BRIDGE_ID = "wormDTUJ6AWPNvk59vGQbDvGJmqbDTdgWgAqcLBCgUb";
-var DEGODS_BRIDGE_PROGRAM_ID = "35iLrpYNNR9ygHLcvE1xKFHbHq6paHthrF6wSovdWgGu";
-var DEBRIDGE_PROGRAM_ID = "DEbrdGj3HsRsAzx6uH4MKyREKxVAfBydijLUF3ygsFfh";
-var ALLBRIDGE_PROGRAM_ID = "BrdgN2RPzEMWF96ZbnnJaUtQDQx7VRXYaHHbYCBvceWB";
-var PAYAI_FACILITATOR = "2wKupLR9q6wXYppw8Gr2NvWxKBUqm4PPJKkQfoxHDBg4";
-var KNOWN_FACILITATORS = [
-  PAYAI_FACILITATOR
-];
-function detectFacilitator(accountKeys) {
-  for (const facilitator of KNOWN_FACILITATORS) {
-    if (accountKeys.includes(facilitator)) {
-      if (facilitator === PAYAI_FACILITATOR) {
-        return "payai";
-      }
-    }
-  }
-  return null;
-}
-
 // ../../node_modules/.bun/base-x@5.0.1/node_modules/base-x/src/esm/index.js
 function base(ALPHABET2) {
   if (ALPHABET2.length >= 255) {
@@ -380,6 +597,189 @@ function isSolanaPayTransaction(programIds, memo) {
   return hasMemoProgram && memo !== null && memo !== void 0;
 }
 
+// ../solana/src/rpc/retry.ts
+var DEFAULT_CONFIG = {
+  maxAttempts: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4
+};
+function isRetryableError(error) {
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    return message.includes("timeout") || message.includes("econnreset") || message.includes("econnrefused") || message.includes("socket hang up") || message.includes("network") || message.includes("429") || message.includes("rate limit") || message.includes("too many requests") || message.includes("503") || message.includes("502") || message.includes("504");
+  }
+  return false;
+}
+function calculateDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt - 1);
+  const jitter = Math.random() * 0.3 * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, maxDelayMs);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, config = {}) {
+  const { maxAttempts, baseDelayMs, maxDelayMs } = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const isLastAttempt = attempt === maxAttempts;
+      const shouldRetry = !isLastAttempt && isRetryableError(error);
+      if (!shouldRetry) {
+        throw error;
+      }
+      const delay = calculateDelay(attempt, baseDelayMs, maxDelayMs);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+
+// ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    if (!this.#head) {
+      this.#tail = void 0;
+    }
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+};
+
+// ../../node_modules/.bun/p-limit@6.2.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  validateConcurrency(concurrency);
+  const queue = new Queue();
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      queue.dequeue()();
+      activeCount++;
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve, arguments_) => {
+    new Promise((internalResolve) => {
+      queue.enqueue(internalResolve);
+    }).then(
+      run.bind(void 0, function_, resolve, arguments_)
+    );
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency) {
+        resumeNext();
+      }
+    })();
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve) => {
+    enqueue(function_, resolve, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+
 // ../solana/src/fetcher/transactions.ts
 async function fetchWalletSignatures(rpc, walletAddress, config = {}) {
   const { limit = 100, before, until } = config;
@@ -398,12 +798,16 @@ async function fetchWalletSignatures(rpc, walletAddress, config = {}) {
     memo: sig.memo || null
   }));
 }
-async function fetchTransaction(rpc, signature2, commitment = "confirmed") {
-  const response = await rpc.getTransaction(signature2, {
-    commitment,
-    maxSupportedTransactionVersion: 0,
-    encoding: "json"
-  }).send();
+async function fetchTransaction(rpc, signature2, options = {}) {
+  const { commitment = "confirmed", retry } = options;
+  const response = await withRetry(
+    () => rpc.getTransaction(signature2, {
+      commitment,
+      maxSupportedTransactionVersion: 0,
+      encoding: "json"
+    }).send(),
+    retry
+  );
   if (!response) {
     return null;
   }
@@ -450,10 +854,29 @@ async function fetchTransaction(rpc, signature2, commitment = "confirmed") {
     memo
   };
 }
-async function fetchTransactionsBatch(rpc, signatures, commitment = "confirmed") {
-  const promises = signatures.map(
-    (sig) => fetchTransaction(rpc, sig, commitment)
-  );
+async function fetchTransactionsBatch(rpc, signatures, options = {}) {
+  const {
+    commitment = "confirmed",
+    concurrency = 10,
+    retry,
+    onFetchError
+  } = options;
+  if (signatures.length === 0) {
+    return [];
+  }
+  const limit = pLimit(concurrency);
+  const safeFetch = async (sig) => {
+    try {
+      return await fetchTransaction(rpc, sig, { commitment, retry });
+    } catch (error) {
+      onFetchError?.(
+        sig,
+        error instanceof Error ? error : new Error(String(error))
+      );
+      return null;
+    }
+  };
+  const promises = signatures.map((sig) => limit(() => safeFetch(sig)));
   const results = await Promise.all(promises);
   return results.filter((tx) => tx !== null);
 }
@@ -598,7 +1021,7 @@ function transactionToLegs(tx) {
         amountRaw: change.change.toString().replace("-", ""),
         amountUi: Math.abs(change.changeUi)
       },
-      role: determineSolRole(change, tx, feePayer)
+      role: determineSolRole(change, tx)
     });
   }
   const networkFee = totalSolDebits - totalSolCredits;
@@ -655,13 +1078,8 @@ function transactionToLegs(tx) {
   }
   return legs;
 }
-function determineSolRole(change, tx, feePayer) {
-  const isFeePayer = feePayer ? change.address.toLowerCase() === feePayer : false;
+function determineSolRole(change, tx, _feePayer) {
   const isPositive = change.change > 0n;
-  const amountSol = Math.abs(change.changeUi);
-  if (isFeePayer && !isPositive && amountSol < 0.01) {
-    return "fee";
-  }
   if (isPositive) {
     if (tx.protocol?.id === "stake") {
       return "reward";
@@ -721,6 +1139,7 @@ var TransferClassifier = class {
 
 // ../classification/src/protocols/detector.ts
 var KNOWN_PROGRAMS = {
+  // Jupiter aggregator
   [JUPITER_V6_PROGRAM_ID]: {
     id: "jupiter",
     name: "Jupiter"
@@ -729,10 +1148,19 @@ var KNOWN_PROGRAMS = {
     id: "jupiter-v4",
     name: "Jupiter V4"
   },
+  [JUPITER_ORDER_ENGINE_PROGRAM_ID]: {
+    id: "jupiter-limit-order",
+    name: "Jupiter Limit Order"
+  },
+  // Core token programs
   [TOKEN_PROGRAM_ID]: {
     id: "spl-token",
     name: "Token Program"
   },
+  [TOKEN_2022_PROGRAM_ID]: {
+    id: "token-2022",
+    name: "Token-2022 Program"
+  },
   [SYSTEM_PROGRAM_ID]: {
     id: "system",
     name: "System Program"
@@ -745,25 +1173,86 @@ var KNOWN_PROGRAMS = {
     id: "associated-token",
     name: "Associated Token Program"
   },
-  [METAPLEX_PROGRAM_ID]: {
-    id: "metaplex",
-    name: "Metaplex"
+  // Memo programs
+  [SPL_MEMO_PROGRAM_ID]: {
+    id: "memo",
+    name: "Memo Program"
   },
-  [ORCA_WHIRLPOOL_PROGRAM_ID]: {
-    id: "orca-whirlpool",
-    name: "Orca Whirlpool"
+  [MEMO_V1_PROGRAM_ID]: {
+    id: "memo-v1",
+    name: "Memo Program V1"
   },
+  // Raydium AMMs
   [RAYDIUM_PROGRAM_ID]: {
     id: "raydium",
     name: "Raydium"
   },
-  [STAKE_PROGRAM_ID]: {
-    id: "stake",
-    name: "Stake Program"
+  [RAYDIUM_CLMM_PROGRAM_ID]: {
+    id: "raydium-clmm",
+    name: "Raydium CLMM"
   },
-  [STAKE_POOL_PROGRAM_ID]: {
-    id: "stake-pool",
-    name: "Stake Pool Program"
+  [RAYDIUM_CPMM_PROGRAM_ID]: {
+    id: "raydium-cpmm",
+    name: "Raydium CPMM"
+  },
+  [RAYDIUM_STABLE_PROGRAM_ID]: {
+    id: "raydium-stable",
+    name: "Raydium Stable"
+  },
+  // Orca
+  [ORCA_WHIRLPOOL_PROGRAM_ID]: {
+    id: "orca-whirlpool",
+    name: "Orca Whirlpool"
+  },
+  [ORCA_TOKEN_SWAP_V1_PROGRAM_ID]: {
+    id: "orca-v1",
+    name: "Orca Token Swap V1"
+  },
+  // CLOBs (Central Limit Order Books)
+  [OPENBOOK_V2_PROGRAM_ID]: {
+    id: "openbook",
+    name: "OpenBook"
+  },
+  [PHOENIX_PROGRAM_ID]: {
+    id: "phoenix",
+    name: "Phoenix"
+  },
+  // Stableswap protocols
+  [SABER_STABLE_SWAP_PROGRAM_ID]: {
+    id: "saber",
+    name: "Saber"
+  },
+  [MERCURIAL_STABLE_SWAP_PROGRAM_ID]: {
+    id: "mercurial",
+    name: "Mercurial"
+  },
+  // Meteora
+  [METEORA_DLMM_PROGRAM_ID]: {
+    id: "meteora-dlmm",
+    name: "Meteora DLMM"
+  },
+  [METEORA_POOLS_PROGRAM_ID]: {
+    id: "meteora-pools",
+    name: "Meteora Pools"
+  },
+  // Pump.fun
+  [PUMPFUN_AMM_PROGRAM_ID]: {
+    id: "pumpfun",
+    name: "Pump.fun"
+  },
+  [PUMPFUN_BONDING_CURVE_PROGRAM_ID]: {
+    id: "pumpfun-bonding",
+    name: "Pump.fun Bonding Curve"
+  },
+  // Lifinity
+  [LIFINITY_V2_PROGRAM_ID]: {
+    id: "lifinity",
+    name: "Lifinity"
+  },
+  // NFT programs
+  [METAPLEX_PROGRAM_ID]: {
+    id: "metaplex",
+    name: "Metaplex"
   },
   [CANDY_GUARD_PROGRAM_ID]: {
     id: "candy-guard",
@@ -781,6 +1270,16 @@ var KNOWN_PROGRAMS = {
     id: "magic-eden-candy-machine",
     name: "Nft Candy Machine Program (Magic Eden)"
   },
+  // Staking programs
+  [STAKE_PROGRAM_ID]: {
+    id: "stake",
+    name: "Stake Program"
+  },
+  [STAKE_POOL_PROGRAM_ID]: {
+    id: "stake-pool",
+    name: "Stake Pool Program"
+  },
+  // Bridge programs
   [WORMHOLE_PROGRAM_ID]: {
     id: "wormhole",
     name: "Wormhole"
@@ -803,27 +1302,79 @@ var KNOWN_PROGRAMS = {
   }
 };
 var PRIORITY_ORDER = [
+  // Bridge protocols (highest priority - cross-chain operations)
   "wormhole",
   "wormhole-token-bridge",
   "degods-bridge",
   "debridge",
   "allbridge",
+  // DEX aggregators (route through multiple DEXes)
   "jupiter",
   "jupiter-v4",
+  "jupiter-limit-order",
+  // AMMs and DEXes
   "raydium",
+  "raydium-clmm",
+  "raydium-cpmm",
+  "raydium-stable",
   "orca-whirlpool",
+  "orca-v1",
+  "meteora-dlmm",
+  "meteora-pools",
+  "lifinity",
+  "pumpfun",
+  "pumpfun-bonding",
+  // CLOBs
+  "openbook",
+  "phoenix",
+  // Stableswap
+  "saber",
+  "mercurial",
+  // NFT
   "metaplex",
+  "candy-guard",
+  "candy-machine-v3",
+  "bubblegum",
+  "magic-eden-candy-machine",
+  // Staking
   "stake",
+  "stake-pool",
+  // Infrastructure (lowest priority)
+  "memo",
+  "memo-v1",
   "associated-token",
   "spl-token",
+  "token-2022",
   "compute-budget",
   "system"
 ];
 var DEX_PROTOCOL_IDS2 = /* @__PURE__ */ new Set([
+  // Jupiter aggregator
   "jupiter",
   "jupiter-v4",
+  "jupiter-limit-order",
+  // Raydium AMMs
   "raydium",
-  "orca-whirlpool"
+  "raydium-clmm",
+  "raydium-cpmm",
+  "raydium-stable",
+  // Orca
+  "orca-whirlpool",
+  "orca-v1",
+  // CLOBs
+  "openbook",
+  "phoenix",
+  // Stableswap
+  "saber",
+  "mercurial",
+  // Meteora
+  "meteora-dlmm",
+  "meteora-pools",
+  // Pump.fun
+  "pumpfun",
+  "pumpfun-bonding",
+  // Lifinity
+  "lifinity"
 ]);
 var NFT_MINT_PROTOCOL_IDS = /* @__PURE__ */ new Set([
   "metaplex",
@@ -872,15 +1423,28 @@ function detectProtocol(programIds) {
 }
 
 // ../classification/src/classifiers/swap-classifier.ts
+function findSwapPair(tokensOut, tokensIn) {
+  let bestPair = null;
+  let bestScore = 0;
+  for (const out of tokensOut) {
+    for (const inLeg of tokensIn) {
+      if (out.amount.token.symbol !== inLeg.amount.token.symbol) {
+        const score = Math.max(out.amount.amountUi, inLeg.amount.amountUi);
+        if (score > bestScore) {
+          bestScore = score;
+          bestPair = { initiatorOut: out, initiatorIn: inLeg };
+        }
+      }
+    }
+  }
+  return bestPair;
+}
 var SwapClassifier = class {
   name = "swap";
   priority = 80;
   classify(context) {
     const { legs, tx, walletAddress } = context;
-    const feeLeg = legs.find(
-      (leg) => leg.role === "fee" && leg.side === "debit"
-    );
-    const initiator = feeLeg?.accountId.replace("external:", "") ?? null;
+    const initiator = tx.accountKeys?.[0] ?? null;
     if (!initiator) {
       return null;
     }
@@ -894,11 +1458,11 @@ var SwapClassifier = class {
     if (initiatorTokensOut.length === 0 || initiatorTokensIn.length === 0) {
       return null;
     }
-    const initiatorOut = initiatorTokensOut[0];
-    const initiatorIn = initiatorTokensIn[0];
-    if (initiatorOut.amount.token.symbol === initiatorIn.amount.token.symbol) {
+    const swapPair = findSwapPair(initiatorTokensOut, initiatorTokensIn);
+    if (!swapPair) {
       return null;
     }
+    const { initiatorOut, initiatorIn } = swapPair;
     let tokenOut = initiatorOut;
     let tokenIn = initiatorIn;
     let perspectiveWallet = initiator;
@@ -1292,14 +1856,14 @@ function classifyTransaction(legs, tx, walletAddress) {
 }
 
 // ../domain/src/tx/spam-filter.ts
-var DEFAULT_CONFIG = {
+var DEFAULT_CONFIG2 = {
   minSolAmount: 1e-3,
   minTokenAmountUsd: 0.01,
   minConfidence: 0.5,
   allowFailed: false
 };
 function isSpamTransaction(tx, classification, config = {}) {
-  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const cfg = { ...DEFAULT_CONFIG2, ...config };
   if (!cfg.allowFailed && tx.err) {
     return true;
   }
@@ -1334,6 +1898,118 @@ function filterSpamTransactions(transactions, config) {
   );
 }
 
+// ../domain/src/money/token-fetcher.ts
+var DEFAULT_JUPITER_API_URL = "https://tokens.jup.ag/tokens?tags=verified";
+var DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
+function createTokenFetcher(options = {}) {
+  const {
+    jupiterApiUrl = DEFAULT_JUPITER_API_URL,
+    cacheTtlMs = DEFAULT_CACHE_TTL_MS,
+    prefetch = false
+  } = options;
+  const jupiterCache = /* @__PURE__ */ new Map();
+  let lastFetchTime = 0;
+  let fetchPromise = null;
+  async function fetchJupiterTokens() {
+    if (fetchPromise) {
+      return fetchPromise;
+    }
+    if (Date.now() - lastFetchTime < cacheTtlMs && jupiterCache.size > 0) {
+      return;
+    }
+    fetchPromise = (async () => {
+      try {
+        const response = await fetch(jupiterApiUrl);
+        if (!response.ok) {
+          console.warn(
+            `Jupiter API returned ${response.status}: ${response.statusText}`
+          );
+          return;
+        }
+        const tokens = await response.json();
+        jupiterCache.clear();
+        for (const token of tokens) {
+          jupiterCache.set(token.address, {
+            mint: token.address,
+            symbol: token.symbol,
+            name: token.name,
+            decimals: token.decimals,
+            logoURI: token.logoURI
+          });
+        }
+        lastFetchTime = Date.now();
+      } catch (error) {
+        console.warn("Failed to fetch Jupiter tokens:", error);
+      } finally {
+        fetchPromise = null;
+      }
+    })();
+    return fetchPromise;
+  }
+  async function getToken(mint, decimals = 9) {
+    const staticToken = TOKEN_INFO[mint];
+    if (staticToken) {
+      return staticToken;
+    }
+    const cachedToken = jupiterCache.get(mint);
+    if (cachedToken) {
+      return cachedToken;
+    }
+    await fetchJupiterTokens();
+    const fetchedToken = jupiterCache.get(mint);
+    if (fetchedToken) {
+      return fetchedToken;
+    }
+    return createUnknownToken(mint, decimals);
+  }
+  async function getTokens(mints, defaultDecimals = 9) {
+    const result = /* @__PURE__ */ new Map();
+    const missingMints = [];
+    for (const mint of mints) {
+      const staticToken = TOKEN_INFO[mint];
+      if (staticToken) {
+        result.set(mint, staticToken);
+        continue;
+      }
+      const cachedToken = jupiterCache.get(mint);
+      if (cachedToken) {
+        result.set(mint, cachedToken);
+        continue;
+      }
+      missingMints.push(mint);
+    }
+    if (missingMints.length > 0) {
+      await fetchJupiterTokens();
+      for (const mint of missingMints) {
+        const fetchedToken = jupiterCache.get(mint);
+        if (fetchedToken) {
+          result.set(mint, fetchedToken);
+        } else {
+          result.set(mint, createUnknownToken(mint, defaultDecimals));
+        }
+      }
+    }
+    return result;
+  }
+  async function refresh() {
+    lastFetchTime = 0;
+    await fetchJupiterTokens();
+  }
+  function getCacheSize() {
+    return jupiterCache.size;
+  }
+  if (prefetch) {
+    fetchJupiterTokens().catch(() => {
+    });
+  }
+  return {
+    getToken,
+    getTokens,
+    refresh,
+    getCacheSize
+  };
+}
+
 // src/nft.ts
 async function fetchNftMetadata(rpcUrl, mintAddress) {
   const response = await fetch(rpcUrl, {
@@ -1378,6 +2054,102 @@ async function fetchNftMetadataBatch(rpcUrl, mintAddresses) {
 
 // src/client.ts
 var NFT_TRANSACTION_TYPES = ["nft_mint", "nft_purchase", "nft_sale"];
+async function enrichTokenMetadata(tokenFetcher, classified) {
+  const mints = /* @__PURE__ */ new Set();
+  const decimalsMap = /* @__PURE__ */ new Map();
+  for (const leg of classified.legs) {
+    const mint = leg.amount.token.mint;
+    mints.add(mint);
+    decimalsMap.set(mint, leg.amount.token.decimals);
+  }
+  if (classified.classification.primaryAmount?.token.mint) {
+    const mint = classified.classification.primaryAmount.token.mint;
+    mints.add(mint);
+    decimalsMap.set(
+      mint,
+      classified.classification.primaryAmount.token.decimals
+    );
+  }
+  if (classified.classification.secondaryAmount?.token.mint) {
+    const mint = classified.classification.secondaryAmount.token.mint;
+    mints.add(mint);
+    decimalsMap.set(
+      mint,
+      classified.classification.secondaryAmount.token.decimals
+    );
+  }
+  if (mints.size === 0) {
+    return classified;
+  }
+  const tokenInfoMap = await tokenFetcher.getTokens(
+    Array.from(mints),
+    9
+    // default decimals
+  );
+  function enrichAmount(amount) {
+    if (!amount) return amount;
+    const enrichedToken = tokenInfoMap.get(amount.token.mint);
+    if (!enrichedToken || enrichedToken.symbol === amount.token.symbol) {
+      return amount;
+    }
+    return {
+      ...amount,
+      token: {
+        ...enrichedToken,
+        // Keep the decimals from the original (from RPC) as they're authoritative
+        decimals: amount.token.decimals
+      }
+    };
+  }
+  function enrichLeg(leg) {
+    const enrichedToken = tokenInfoMap.get(leg.amount.token.mint);
+    if (!enrichedToken || enrichedToken.symbol === leg.amount.token.symbol) {
+      return leg;
+    }
+    return {
+      ...leg,
+      amount: {
+        ...leg.amount,
+        token: {
+          ...enrichedToken,
+          decimals: leg.amount.token.decimals
+        }
+      }
+    };
+  }
+  const enrichedLegs = classified.legs.map(enrichLeg);
+  const enrichedClassification = {
+    ...classified.classification,
+    primaryAmount: enrichAmount(classified.classification.primaryAmount) ?? null,
+    secondaryAmount: enrichAmount(classified.classification.secondaryAmount)
+  };
+  return {
+    tx: classified.tx,
+    legs: enrichedLegs,
+    classification: enrichedClassification
+  };
+}
+async function enrichTokenMetadataBatch(tokenFetcher, transactions) {
+  const mints = /* @__PURE__ */ new Set();
+  for (const classified of transactions) {
+    for (const leg of classified.legs) {
+      mints.add(leg.amount.token.mint);
+    }
+    if (classified.classification.primaryAmount?.token.mint) {
+      mints.add(classified.classification.primaryAmount.token.mint);
+    }
+    if (classified.classification.secondaryAmount?.token.mint) {
+      mints.add(classified.classification.secondaryAmount.token.mint);
+    }
+  }
+  if (mints.size === 0) {
+    return transactions;
+  }
+  await tokenFetcher.getTokens(Array.from(mints));
+  return Promise.all(
+    transactions.map((tx) => enrichTokenMetadata(tokenFetcher, tx))
+  );
+}
 async function enrichNftClassification(rpcUrl, classified) {
   const { classification } = classified;
   if (!NFT_TRANSACTION_TYPES.includes(classification.primaryType)) {
@@ -1410,51 +2182,74 @@ async function enrichNftClassification(rpcUrl, classified) {
 function createIndexer(options) {
   const rpcUrl = "client" in options ? "" : options.rpcUrl;
   const client = "client" in options ? options.client : createSolanaClient(options.rpcUrl, options.wsUrl);
+  const tokenFetcher = createTokenFetcher();
   return {
     rpc: client.rpc,
     async getBalance(walletAddress, tokenMints) {
       return fetchWalletBalance(client.rpc, walletAddress, tokenMints);
     },
     async getTransactions(walletAddress, options2 = {}) {
-      const { limit = 10, before, until, filterSpam = true, spamConfig, enrichNftMetadata = true } = options2;
+      const {
+        limit = 10,
+        before,
+        until,
+        filterSpam = true,
+        spamConfig,
+        enrichNftMetadata = true,
+        enrichTokenMetadata: enrichTokens = true
+      } = options2;
       async function enrichBatch(transactions) {
-        if (!enrichNftMetadata || !rpcUrl) {
-          return transactions;
+        let result2 = transactions;
+        if (enrichTokens) {
+          result2 = await enrichTokenMetadataBatch(tokenFetcher, result2);
         }
-        const nftMints = transactions.filter((t) => NFT_TRANSACTION_TYPES.includes(t.classification.primaryType)).map((t) => t.classification.metadata?.nft_mint).filter(Boolean);
-        if (nftMints.length === 0) {
-          return transactions;
-        }
-        const nftMetadataMap = await fetchNftMetadataBatch(rpcUrl, nftMints);
-        return transactions.map((t) => {
-          const nftMint = t.classification.metadata?.nft_mint;
-          if (!nftMint || !nftMetadataMap.has(nftMint)) {
-            return t;
-          }
-          const nftData = nftMetadataMap.get(nftMint);
-          return {
-            ...t,
-            classification: {
-              ...t.classification,
-              metadata: {
-                ...t.classification.metadata,
-                nft_name: nftData.name,
-                nft_image: nftData.image,
-                nft_cdn_image: nftData.cdnImage,
-                nft_collection: nftData.collection,
-                nft_symbol: nftData.symbol,
-                nft_attributes: nftData.attributes
+        if (enrichNftMetadata && rpcUrl) {
+          const nftMints = result2.filter(
+            (t) => NFT_TRANSACTION_TYPES.includes(
+              t.classification.primaryType
+            )
+          ).map((t) => t.classification.metadata?.nft_mint).filter(Boolean);
+          if (nftMints.length > 0) {
+            const nftMetadataMap = await fetchNftMetadataBatch(
+              rpcUrl,
+              nftMints
+            );
+            result2 = result2.map((t) => {
+              const nftMint = t.classification.metadata?.nft_mint;
+              if (!nftMint || !nftMetadataMap.has(nftMint)) {
+                return t;
               }
-            }
-          };
-        });
+              const nftData = nftMetadataMap.get(nftMint);
+              return {
+                ...t,
+                classification: {
+                  ...t.classification,
+                  metadata: {
+                    ...t.classification.metadata,
+                    nft_name: nftData.name,
+                    nft_image: nftData.image,
+                    nft_cdn_image: nftData.cdnImage,
+                    nft_collection: nftData.collection,
+                    nft_symbol: nftData.symbol,
+                    nft_attributes: nftData.attributes
+                  }
+                }
+              };
+            });
+          }
+        }
+        return result2;
       }
       if (!filterSpam) {
-        const signatures = await fetchWalletSignatures(client.rpc, walletAddress, {
-          limit,
-          before,
-          until
-        });
+        const signatures = await fetchWalletSignatures(
+          client.rpc,
+          walletAddress,
+          {
+            limit,
+            before,
+            until
+          }
+        );
         if (signatures.length === 0) {
           return [];
         }
@@ -1469,7 +2264,11 @@ function createIndexer(options) {
         const classified = transactions.map((tx) => {
           tx.protocol = detectProtocol(tx.programIds);
           const legs = transactionToLegs(tx);
-          const classification = classifyTransaction(legs, tx, walletAddressStr2);
+          const classification = classifyTransaction(
+            legs,
+            tx,
+            walletAddressStr2
+          );
           return { tx, classification, legs };
         });
         return enrichBatch(classified);
@@ -1482,11 +2281,15 @@ function createIndexer(options) {
       while (accumulated.length < limit && iteration < MAX_ITERATIONS) {
         iteration++;
         const batchSize = iteration === 1 ? limit : limit * 2;
-        const signatures = await fetchWalletSignatures(client.rpc, walletAddress, {
-          limit: batchSize,
-          before: currentBefore,
-          until
-        });
+        const signatures = await fetchWalletSignatures(
+          client.rpc,
+          walletAddress,
+          {
+            limit: batchSize,
+            before: currentBefore,
+            until
+          }
+        );
         if (signatures.length === 0) {
           break;
         }
@@ -1500,7 +2303,11 @@ function createIndexer(options) {
         const classified = transactions.map((tx) => {
           tx.protocol = detectProtocol(tx.programIds);
           const legs = transactionToLegs(tx);
-          const classification = classifyTransaction(legs, tx, walletAddressStr);
+          const classification = classifyTransaction(
+            legs,
+            tx,
+            walletAddressStr
+          );
           return { tx, classification, legs };
         });
         const nonSpam = filterSpamTransactions(classified, spamConfig);
@@ -1516,7 +2323,10 @@ function createIndexer(options) {
       return enrichBatch(result);
     },
     async getTransaction(signature2, options2 = {}) {
-      const { enrichNftMetadata = true } = options2;
+      const {
+        enrichNftMetadata = true,
+        enrichTokenMetadata: enrichTokens = true
+      } = options2;
       const tx = await fetchTransaction(client.rpc, signature2);
       if (!tx) {
         return null;
@@ -1525,6 +2335,9 @@ function createIndexer(options) {
       const legs = transactionToLegs(tx);
       const classification = classifyTransaction(legs, tx);
       let classified = { tx, classification, legs };
+      if (enrichTokens) {
+        classified = await enrichTokenMetadata(tokenFetcher, classified);
+      }
       if (enrichNftMetadata && rpcUrl) {
         classified = await enrichNftClassification(rpcUrl, classified);
       }