tx-indexer 0.4.0 → 0.5.0

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,
@@ -747,7 +748,7 @@ var TransferClassifier = class {
       sender,
       receiver,
       counterparty: {
-        type: "wallet",
+        type: "unknown",
         address: receiver,
         name: `${receiver.slice(0, 8)}...`
       },
@@ -918,19 +919,19 @@ var SwapClassifier = class {
   priority = 80;
   classify(context) {
     const { legs, tx } = context;
-    const hasDexProtocol = isDexProtocolById(tx.protocol?.id);
-    if (!hasDexProtocol) {
-      return null;
-    }
     const feeLeg = legs.find(
       (leg) => leg.role === "fee" && leg.side === "debit"
     );
     const initiator = feeLeg?.accountId.replace("external:", "") ?? null;
+    if (!initiator) {
+      return null;
+    }
+    const initiatorAccountId = `external:${initiator}`;
     const tokensOut = legs.filter(
-      (leg) => leg.accountId.startsWith("external:") && leg.side === "debit" && (leg.role === "sent" || leg.role === "protocol_deposit")
+      (leg) => leg.accountId === initiatorAccountId && leg.side === "debit" && (leg.role === "sent" || leg.role === "protocol_deposit")
     );
     const tokensIn = legs.filter(
-      (leg) => leg.accountId.startsWith("external:") && leg.side === "credit" && (leg.role === "received" || leg.role === "protocol_withdraw")
+      (leg) => leg.accountId === initiatorAccountId && leg.side === "credit" && (leg.role === "received" || leg.role === "protocol_withdraw")
     );
     if (tokensOut.length === 0 || tokensIn.length === 0) {
       return null;
@@ -940,6 +941,8 @@ var SwapClassifier = class {
     if (tokenOut.amount.token.symbol === tokenIn.amount.token.symbol) {
       return null;
     }
+    const hasDexProtocol = isDexProtocolById(tx.protocol?.id);
+    const confidence = hasDexProtocol ? 0.95 : 0.75;
     return {
       primaryType: "swap",
       primaryAmount: tokenOut.amount,
@@ -947,7 +950,7 @@ var SwapClassifier = class {
       sender: initiator,
       receiver: initiator,
       counterparty: null,
-      confidence: 0.9,
+      confidence,
       isRelevant: true,
       metadata: {
         swap_type: "token_to_token",
@@ -1079,7 +1082,7 @@ var SolanaPayClassifier = class {
       counterparty: receiver ? {
         address: receiver,
         name: memo.merchant ?? void 0,
-        type: memo.merchant ? "merchant" : "wallet"
+        type: memo.merchant ? "merchant" : "unknown"
       } : null,
       confidence: 0.98,
       isRelevant: true,
@@ -1356,8 +1359,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 +1441,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 +1496,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 +1535,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 +1547,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 +1618,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