tx-indexer 0.5.2 → 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,194 @@ 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";
@@ -1697,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, {
@@ -1741,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)) {
@@ -1773,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 [];
         }
@@ -1832,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);
@@ -1845,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;
         }
@@ -1863,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);
@@ -1879,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;
@@ -1888,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);
       }