tx-indexer 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { C as ClassifiedTransaction, F as FetchTransactionsConfig, G as GetTransactionsOptions, I as IndexerRpcApi, S as SolanaClient, l as SpamFilterConfig, e as TokenAccountBalance, T as TxIndexer, a as TxIndexerOptions, W as WalletBalance, c as createIndexer, b as createSolanaClient, h as fetchTransaction, i as fetchTransactionsBatch, f as fetchWalletBalance, g as fetchWalletSignatures, k as filterSpamTransactions, j as isSpamTransaction, p as parseAddress, d as parseSignature, t as transactionToLegs } from './client-yGDWPKKf.js';
-import { T as TxLeg, R as RawTransaction, a as TransactionClassification } from './classification.types-DlJe6bDZ.js';
-export { f as RawTransactionSchema, k as TokenBalance, e as TokenBalanceSchema, n as TransactionClassificationSchema, j as TxCategory, d as TxCategorySchema, h as TxDirection, b as TxDirectionSchema, m as TxLegRole, g as TxLegSchema, l as TxLegSide, i as TxPrimaryType, c as TxPrimaryTypeSchema } from './classification.types-DlJe6bDZ.js';
+export { C as ClassifiedTransaction, F as FetchTransactionsConfig, b as GetTransactionOptions, G as GetTransactionsOptions, I as IndexerRpcApi, N as NftMetadata, S as SolanaClient, m as SpamFilterConfig, g as TokenAccountBalance, T as TxIndexer, a as TxIndexerOptions, W as WalletBalance, c as createIndexer, d as createSolanaClient, n as fetchNftMetadata, o as fetchNftMetadataBatch, i as fetchTransaction, j as fetchTransactionsBatch, f as fetchWalletBalance, h as fetchWalletSignatures, l as filterSpamTransactions, k as isSpamTransaction, p as parseAddress, e as parseSignature, t as transactionToLegs } from './client-iLW2_DnL.js';
+import { T as TxLeg, R as RawTransaction, a as TransactionClassification } from './classification.types-Cn9IGtEC.js';
+export { f as RawTransactionSchema, k as TokenBalance, e as TokenBalanceSchema, n as TransactionClassificationSchema, j as TxCategory, d as TxCategorySchema, h as TxDirection, b as TxDirectionSchema, m as TxLegRole, g as TxLegSchema, l as TxLegSide, i as TxPrimaryType, c as TxPrimaryTypeSchema } from './classification.types-Cn9IGtEC.js';
 import { ProtocolInfo, TokenInfo } from './types.js';
 export { Categorization, CategorizationSchema, Counterparty, CounterpartySchema, FiatValue, MoneyAmount, ProtocolInfoSchema } from './types.js';
 import { z } from 'zod';

package/dist/index.js

@@ -428,6 +428,7 @@ async function fetchTransaction(rpc, signature2, commitment = "confirmed") {
     signature: signature2,
     slot: response.slot,
     blockTime: response.blockTime,
+    fee: Number(response.meta?.fee ?? 0),
     err: response.meta?.err ?? null,
     programIds: extractProgramIds(response.transaction),
     protocol: null,
@@ -1356,8 +1357,81 @@ function filterSpamTransactions(transactions, config) {
   );
 }
 
+// src/nft.ts
+async function fetchNftMetadata(rpcUrl, mintAddress) {
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: "get-asset",
+      method: "getAsset",
+      params: { id: mintAddress }
+    })
+  });
+  const data = await response.json();
+  if (data.error || !data.result?.content?.metadata) {
+    return null;
+  }
+  const { result } = data;
+  const { content, grouping } = result;
+  return {
+    mint: mintAddress,
+    name: content.metadata.name,
+    symbol: content.metadata.symbol,
+    image: content.links.image ?? content.files?.[0]?.uri ?? "",
+    cdnImage: content.files?.[0]?.cdn_uri,
+    description: content.metadata.description,
+    collection: grouping?.find((g) => g.group_key === "collection")?.group_value,
+    attributes: content.metadata.attributes
+  };
+}
+async function fetchNftMetadataBatch(rpcUrl, mintAddresses) {
+  const results = await Promise.all(
+    mintAddresses.map((mint) => fetchNftMetadata(rpcUrl, mint))
+  );
+  const map = /* @__PURE__ */ new Map();
+  results.forEach((metadata, index) => {
+    if (metadata) {
+      map.set(mintAddresses[index], metadata);
+    }
+  });
+  return map;
+}
+
 // src/client.ts
+var NFT_TRANSACTION_TYPES = ["nft_mint", "nft_purchase", "nft_sale"];
+async function enrichNftClassification(rpcUrl, classified) {
+  const { classification } = classified;
+  if (!NFT_TRANSACTION_TYPES.includes(classification.primaryType)) {
+    return classified;
+  }
+  const nftMint = classification.metadata?.nft_mint;
+  if (!nftMint) {
+    return classified;
+  }
+  const nftData = await fetchNftMetadata(rpcUrl, nftMint);
+  if (!nftData) {
+    return classified;
+  }
+  return {
+    ...classified,
+    classification: {
+      ...classification,
+      metadata: {
+        ...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
+      }
+    }
+  };
+}
 function createIndexer(options) {
+  const rpcUrl = "client" in options ? "" : options.rpcUrl;
   const client = "client" in options ? options.client : createSolanaClient(options.rpcUrl, options.wsUrl);
   return {
     rpc: client.rpc,
@@ -1365,7 +1439,39 @@ function createIndexer(options) {
       return fetchWalletBalance(client.rpc, walletAddress, tokenMints);
     },
     async getTransactions(walletAddress, options2 = {}) {
-      const { limit = 10, before, until, filterSpam = true, spamConfig } = options2;
+      const { limit = 10, before, until, filterSpam = true, spamConfig, enrichNftMetadata = true } = options2;
+      async function enrichBatch(transactions) {
+        if (!enrichNftMetadata || !rpcUrl) {
+          return transactions;
+        }
+        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 (!filterSpam) {
         const signatures = await fetchWalletSignatures(client.rpc, walletAddress, {
           limit,
@@ -1388,7 +1494,7 @@ function createIndexer(options) {
           const classification = classifyTransaction(legs, tx);
           return { tx, classification, legs };
         });
-        return classified;
+        return enrichBatch(classified);
       }
       const accumulated = [];
       let currentBefore = before;
@@ -1427,9 +1533,11 @@ function createIndexer(options) {
           break;
         }
       }
-      return accumulated.slice(0, limit);
+      const result = accumulated.slice(0, limit);
+      return enrichBatch(result);
     },
-    async getTransaction(signature2) {
+    async getTransaction(signature2, options2 = {}) {
+      const { enrichNftMetadata = true } = options2;
       const tx = await fetchTransaction(client.rpc, signature2);
       if (!tx) {
         return null;
@@ -1437,10 +1545,26 @@ function createIndexer(options) {
       tx.protocol = detectProtocol(tx.programIds);
       const legs = transactionToLegs(tx);
       const classification = classifyTransaction(legs, tx);
-      return { tx, classification, legs };
+      let classified = { tx, classification, legs };
+      if (enrichNftMetadata && rpcUrl) {
+        classified = await enrichNftClassification(rpcUrl, classified);
+      }
+      return classified;
     },
     async getRawTransaction(signature2) {
       return fetchTransaction(client.rpc, signature2);
+    },
+    async getNftMetadata(mintAddress) {
+      if (!rpcUrl) {
+        throw new Error("getNftMetadata requires rpcUrl to be set");
+      }
+      return fetchNftMetadata(rpcUrl, mintAddress);
+    },
+    async getNftMetadataBatch(mintAddresses) {
+      if (!rpcUrl) {
+        throw new Error("getNftMetadataBatch requires rpcUrl to be set");
+      }
+      return fetchNftMetadataBatch(rpcUrl, mintAddresses);
     }
   };
 }
@@ -1492,6 +1616,6 @@ function groupLegsByToken(legs) {
   return grouped;
 }
 
-export { JUPITER_V4_PROGRAM_ID, JUPITER_V6_PROGRAM_ID, KNOWN_TOKENS, SPL_MEMO_PROGRAM_ID, SYSTEM_PROGRAM_ID, TOKEN_INFO, TOKEN_PROGRAM_ID, buildAccountId, classifyTransaction, createIndexer, createSolanaClient, detectFacilitator, detectProtocol, extractMemo, fetchTransaction, fetchTransactionsBatch, fetchWalletBalance, fetchWalletSignatures, filterSpamTransactions, getTokenInfo, groupLegsByAccount, groupLegsByToken, isSolanaPayTransaction, isSpamTransaction, parseAccountId, parseAddress, parseSignature, parseSolanaPayMemo, transactionToLegs, validateLegsBalance };
+export { JUPITER_V4_PROGRAM_ID, JUPITER_V6_PROGRAM_ID, KNOWN_TOKENS, SPL_MEMO_PROGRAM_ID, SYSTEM_PROGRAM_ID, TOKEN_INFO, TOKEN_PROGRAM_ID, buildAccountId, classifyTransaction, createIndexer, createSolanaClient, detectFacilitator, detectProtocol, extractMemo, fetchNftMetadata, fetchNftMetadataBatch, fetchTransaction, fetchTransactionsBatch, fetchWalletBalance, fetchWalletSignatures, filterSpamTransactions, getTokenInfo, groupLegsByAccount, groupLegsByToken, isSolanaPayTransaction, isSpamTransaction, parseAccountId, parseAddress, parseSignature, parseSolanaPayMemo, transactionToLegs, validateLegsBalance };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map