tx-indexer 0.3.0 → 0.4.1

package/dist/client.js

@@ -137,6 +137,7 @@ function extractProgramIds(transaction) {
 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";
@@ -146,6 +147,15 @@ 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
@@ -406,6 +416,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,
@@ -558,7 +569,7 @@ var DEX_PROTOCOL_IDS = /* @__PURE__ */ new Set([
 function isDexProtocol(protocol) {
   return protocol !== null && protocol !== void 0 && DEX_PROTOCOL_IDS.has(protocol.id);
 }
-function transactionToLegs(tx, walletAddress) {
+function transactionToLegs(tx) {
   const legs = [];
   const feePayer = tx.accountKeys?.[0]?.toLowerCase();
   const solChanges = extractSolBalanceChanges(tx);
@@ -566,9 +577,8 @@ function transactionToLegs(tx, walletAddress) {
   let totalSolCredits = 0n;
   for (const change of solChanges) {
     if (change.change === 0n) continue;
-    const isWallet = walletAddress ? change.address.toLowerCase() === walletAddress.toLowerCase() : false;
     const accountId = buildAccountId({
-      type: isWallet ? "wallet" : "external",
+      type: "external",
       address: change.address
     });
     const solInfo = TOKEN_INFO[KNOWN_TOKENS.SOL];
@@ -588,7 +598,7 @@ function transactionToLegs(tx, walletAddress) {
         amountRaw: change.change.toString().replace("-", ""),
         amountUi: Math.abs(change.changeUi)
       },
-      role: determineSolRole(change, walletAddress, tx, feePayer)
+      role: determineSolRole(change, tx, feePayer)
     });
   }
   const networkFee = totalSolDebits - totalSolCredits;
@@ -610,26 +620,22 @@ function transactionToLegs(tx, walletAddress) {
   const tokenChanges = extractTokenBalanceChanges(tx);
   for (const change of tokenChanges) {
     if (change.change.raw === "0") continue;
-    const isWallet = walletAddress ? change.owner?.toLowerCase() === walletAddress.toLowerCase() : false;
-    const isFeePayer = !walletAddress && feePayer ? change.owner?.toLowerCase() === feePayer : false;
     let accountId;
-    if (isWallet && walletAddress) {
-      accountId = buildAccountId({
-        type: "wallet",
-        address: change.owner || walletAddress
-      });
-    } else if (isFeePayer && feePayer) {
-      accountId = buildAccountId({
-        type: "external",
-        address: change.owner || feePayer
-      });
-    } else if (isDexProtocol(tx.protocol) && walletAddress) {
-      accountId = buildAccountId({
-        type: "protocol",
-        address: change.owner || change.tokenInfo.mint,
-        protocol: tx.protocol.id,
-        token: change.tokenInfo.symbol
-      });
+    if (isDexProtocol(tx.protocol)) {
+      const isFeePayer = feePayer && change.owner?.toLowerCase() === feePayer;
+      if (isFeePayer) {
+        accountId = buildAccountId({
+          type: "external",
+          address: change.owner || feePayer
+        });
+      } else {
+        accountId = buildAccountId({
+          type: "protocol",
+          address: change.owner || change.tokenInfo.mint,
+          protocol: tx.protocol.id,
+          token: change.tokenInfo.symbol
+        });
+      }
     } else {
       accountId = buildAccountId({
         type: "external",
@@ -644,41 +650,30 @@ function transactionToLegs(tx, walletAddress) {
         amountRaw: change.change.raw.replace("-", ""),
         amountUi: Math.abs(change.change.ui)
       },
-      role: determineTokenRole(change, walletAddress, tx, feePayer)
+      role: determineTokenRole(change, tx, feePayer)
     });
   }
   return legs;
 }
-function determineSolRole(change, walletAddress, tx, feePayer) {
-  const isWallet = walletAddress ? change.address.toLowerCase() === walletAddress.toLowerCase() : false;
-  const isFeePayer = !walletAddress && feePayer ? change.address.toLowerCase() === feePayer : false;
+function determineSolRole(change, tx, feePayer) {
+  const isFeePayer = feePayer ? change.address.toLowerCase() === feePayer : false;
   const isPositive = change.change > 0n;
   const amountSol = Math.abs(change.changeUi);
-  if (isWallet) {
-    if (!isPositive && amountSol < 0.01) {
-      return "fee";
-    }
-    if (isPositive) {
-      if (tx.protocol?.id === "stake") {
-        return "reward";
-      }
-      return "received";
-    }
-    return "sent";
-  }
   if (isFeePayer && !isPositive && amountSol < 0.01) {
     return "fee";
   }
   if (isPositive) {
+    if (tx.protocol?.id === "stake") {
+      return "reward";
+    }
     return "received";
   }
   return "sent";
 }
-function determineTokenRole(change, walletAddress, tx, feePayer) {
-  const isWallet = walletAddress ? change.owner?.toLowerCase() === walletAddress.toLowerCase() : false;
-  const isFeePayer = !walletAddress && feePayer ? change.owner?.toLowerCase() === feePayer : false;
+function determineTokenRole(change, tx, feePayer) {
+  const isFeePayer = feePayer ? change.owner?.toLowerCase() === feePayer : false;
   const isPositive = change.change.ui > 0;
-  if (isWallet || isFeePayer) {
+  if (isFeePayer) {
     return isPositive ? "received" : "sent";
   }
   if (isDexProtocol(tx.protocol)) {
@@ -692,85 +687,35 @@ var TransferClassifier = class {
   name = "transfer";
   priority = 20;
   classify(context) {
-    const { legs, walletAddress, tx } = context;
+    const { legs, tx } = context;
     const facilitator = tx.accountKeys ? detectFacilitator(tx.accountKeys) : null;
-    const isObserverMode = !walletAddress;
-    let participantAddress;
-    let participantPrefix;
-    if (walletAddress) {
-      participantAddress = walletAddress.toLowerCase();
-      participantPrefix = `wallet:${participantAddress}`;
-    } else {
-      const feeLeg = legs.find(
-        (leg) => leg.role === "fee" && leg.accountId.startsWith("external:")
-      );
-      if (!feeLeg) return null;
-      participantAddress = feeLeg.accountId.replace("external:", "").toLowerCase();
-      participantPrefix = `external:${participantAddress}`;
-    }
-    const participantSent = legs.filter(
-      (l) => l.accountId.toLowerCase().startsWith(participantPrefix.toLowerCase()) && l.side === "debit" && l.role === "sent"
-    );
-    const participantReceived = legs.filter(
-      (l) => l.accountId.toLowerCase().startsWith(participantPrefix.toLowerCase()) && l.side === "credit" && l.role === "received"
-    );
-    const otherReceived = legs.filter(
-      (l) => !l.accountId.toLowerCase().startsWith(participantPrefix.toLowerCase()) && l.accountId.startsWith("external:") && l.side === "credit" && l.role === "received"
+    const senderLeg = legs.find(
+      (l) => l.accountId.startsWith("external:") && l.side === "debit" && l.role === "sent"
     );
-    const otherSent = legs.filter(
-      (l) => !l.accountId.toLowerCase().startsWith(participantPrefix.toLowerCase()) && l.accountId.startsWith("external:") && l.side === "debit" && l.role === "sent"
+    if (!senderLeg) return null;
+    const sender = senderLeg.accountId.replace("external:", "");
+    const receiverLeg = legs.find(
+      (l) => l.accountId.startsWith("external:") && l.side === "credit" && l.role === "received" && l.amount.token.mint === senderLeg.amount.token.mint
     );
-    for (const sent of participantSent) {
-      const matchingReceived = otherReceived.find(
-        (r) => r.amount.token.mint === sent.amount.token.mint
-      );
-      if (matchingReceived) {
-        const receiverAddress = matchingReceived.accountId.replace("external:", "");
-        return {
-          primaryType: "transfer",
-          direction: isObserverMode ? "neutral" : "outgoing",
-          primaryAmount: sent.amount,
-          secondaryAmount: null,
-          counterparty: {
-            type: "unknown",
-            address: receiverAddress,
-            name: `${receiverAddress.slice(0, 8)}...`
-          },
-          confidence: isObserverMode ? 0.9 : 0.95,
-          isRelevant: true,
-          metadata: {
-            ...isObserverMode && { observer_mode: true, sender: participantAddress },
-            ...facilitator && { facilitator, payment_type: "facilitated" }
-          }
-        };
-      }
-    }
-    for (const received of participantReceived) {
-      const matchingSent = otherSent.find(
-        (s) => s.amount.token.mint === received.amount.token.mint
-      );
-      if (matchingSent) {
-        const senderAddress = matchingSent.accountId.replace("external:", "");
-        return {
-          primaryType: "transfer",
-          direction: isObserverMode ? "neutral" : "incoming",
-          primaryAmount: received.amount,
-          secondaryAmount: null,
-          counterparty: {
-            type: "unknown",
-            address: senderAddress,
-            name: `${senderAddress.slice(0, 8)}...`
-          },
-          confidence: isObserverMode ? 0.9 : 0.95,
-          isRelevant: true,
-          metadata: {
-            ...isObserverMode && { observer_mode: true, receiver: participantAddress },
-            ...facilitator && { facilitator, payment_type: "facilitated" }
-          }
-        };
+    if (!receiverLeg) return null;
+    const receiver = receiverLeg.accountId.replace("external:", "");
+    return {
+      primaryType: "transfer",
+      primaryAmount: senderLeg.amount,
+      secondaryAmount: null,
+      sender,
+      receiver,
+      counterparty: {
+        type: "wallet",
+        address: receiver,
+        name: `${receiver.slice(0, 8)}...`
+      },
+      confidence: 0.95,
+      isRelevant: true,
+      metadata: {
+        ...facilitator && { facilitator, payment_type: "facilitated" }
       }
-    }
-    return null;
+    };
   }
 };
 
@@ -815,9 +760,54 @@ var KNOWN_PROGRAMS = {
   [STAKE_PROGRAM_ID]: {
     id: "stake",
     name: "Stake Program"
+  },
+  [STAKE_POOL_PROGRAM_ID]: {
+    id: "stake-pool",
+    name: "Stake Pool Program"
+  },
+  [CANDY_GUARD_PROGRAM_ID]: {
+    id: "candy-guard",
+    name: "Metaplex Candy Guard Program"
+  },
+  [CANDY_MACHINE_V3_PROGRAM_ID]: {
+    id: "candy-machine-v3",
+    name: "Metaplex Candy Machine Core Program"
+  },
+  [BUBBLEGUM_PROGRAM_ID]: {
+    id: "bubblegum",
+    name: "Bubblegum Program"
+  },
+  [MAGIC_EDEN_CANDY_MACHINE_ID]: {
+    id: "magic-eden-candy-machine",
+    name: "Nft Candy Machine Program (Magic Eden)"
+  },
+  [WORMHOLE_PROGRAM_ID]: {
+    id: "wormhole",
+    name: "Wormhole"
+  },
+  [WORMHOLE_TOKEN_BRIDGE_ID]: {
+    id: "wormhole-token-bridge",
+    name: "Wormhole Token Bridge"
+  },
+  [DEGODS_BRIDGE_PROGRAM_ID]: {
+    id: "degods-bridge",
+    name: "DeGods Bridge"
+  },
+  [DEBRIDGE_PROGRAM_ID]: {
+    id: "debridge",
+    name: "deBridge"
+  },
+  [ALLBRIDGE_PROGRAM_ID]: {
+    id: "allbridge",
+    name: "Allbridge"
   }
 };
 var PRIORITY_ORDER = [
+  "wormhole",
+  "wormhole-token-bridge",
+  "degods-bridge",
+  "debridge",
+  "allbridge",
   "jupiter",
   "jupiter-v4",
   "raydium",
@@ -835,9 +825,33 @@ var DEX_PROTOCOL_IDS2 = /* @__PURE__ */ new Set([
   "raydium",
   "orca-whirlpool"
 ]);
+var NFT_MINT_PROTOCOL_IDS = /* @__PURE__ */ new Set([
+  "metaplex",
+  "candy-machine-v3",
+  "candy-guard",
+  "bubblegum",
+  "magic-eden-candy-machine"
+]);
+var STAKE_PROTOCOL_IDS = /* @__PURE__ */ new Set(["stake", "stake-pool"]);
+var BRIDGE_PROTOCOL_IDS = /* @__PURE__ */ new Set([
+  "wormhole",
+  "wormhole-token-bridge",
+  "degods-bridge",
+  "debridge",
+  "allbridge"
+]);
 function isDexProtocolById(protocolId) {
   return protocolId !== void 0 && DEX_PROTOCOL_IDS2.has(protocolId);
 }
+function isNftMintProtocolById(protocolId) {
+  return protocolId !== void 0 && NFT_MINT_PROTOCOL_IDS.has(protocolId);
+}
+function isStakeProtocolById(protocolId) {
+  return protocolId !== void 0 && STAKE_PROTOCOL_IDS.has(protocolId);
+}
+function isBridgeProtocolById(protocolId) {
+  return protocolId !== void 0 && BRIDGE_PROTOCOL_IDS.has(protocolId);
+}
 function detectProtocol(programIds) {
   const detectedProtocols = [];
   for (const programId of programIds) {
@@ -862,65 +876,46 @@ var SwapClassifier = class {
   name = "swap";
   priority = 80;
   classify(context) {
-    const { legs, walletAddress, tx } = context;
-    const protocolLegs = legs.filter(
-      (leg) => leg.accountId.startsWith("protocol:")
-    );
+    const { legs, tx } = context;
     const hasDexProtocol = isDexProtocolById(tx.protocol?.id);
-    if (protocolLegs.length === 0 && !hasDexProtocol) {
+    if (!hasDexProtocol) {
       return null;
     }
-    const isObserverMode = !walletAddress;
-    let participantPrefix;
-    if (walletAddress) {
-      participantPrefix = `wallet:${walletAddress}`;
-    } else {
-      const feeLeg = legs.find(
-        (leg) => leg.role === "fee" && leg.accountId.startsWith("external:")
-      );
-      if (!feeLeg) return null;
-      const feePayerAddress = feeLeg.accountId.replace("external:", "");
-      participantPrefix = `external:${feePayerAddress}`;
-    }
-    const participantDebits = legs.filter(
-      (leg) => leg.accountId.startsWith(participantPrefix) && leg.side === "debit"
-    );
-    const participantCredits = legs.filter(
-      (leg) => leg.accountId.startsWith(participantPrefix) && leg.side === "credit"
+    const feeLeg = legs.find(
+      (leg) => leg.role === "fee" && leg.side === "debit"
     );
-    const tokensOut = participantDebits.filter(
-      (leg) => leg.role === "sent" || leg.role === "protocol_deposit"
+    const initiator = feeLeg?.accountId.replace("external:", "") ?? null;
+    const tokensOut = legs.filter(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "debit" && (leg.role === "sent" || leg.role === "protocol_deposit")
     );
-    const tokensIn = participantCredits.filter(
-      (leg) => leg.role === "received" || leg.role === "protocol_withdraw"
+    const tokensIn = legs.filter(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "credit" && (leg.role === "received" || leg.role === "protocol_withdraw")
     );
     if (tokensOut.length === 0 || tokensIn.length === 0) {
       return null;
     }
-    if (tokensOut.length === 1 && tokensIn.length === 1) {
-      const tokenOut = tokensOut[0];
-      const tokenIn = tokensIn[0];
-      if (tokenOut.amount.token.symbol !== tokenIn.amount.token.symbol) {
-        return {
-          primaryType: "swap",
-          direction: "neutral",
-          primaryAmount: tokenOut.amount,
-          secondaryAmount: tokenIn.amount,
-          counterparty: null,
-          confidence: isObserverMode ? 0.85 : 0.9,
-          isRelevant: true,
-          metadata: {
-            swap_type: "token_to_token",
-            from_token: tokenOut.amount.token.symbol,
-            to_token: tokenIn.amount.token.symbol,
-            from_amount: tokenOut.amount.amountUi,
-            to_amount: tokenIn.amount.amountUi,
-            ...isObserverMode && { observer_mode: true }
-          }
-        };
-      }
+    const tokenOut = tokensOut[0];
+    const tokenIn = tokensIn[0];
+    if (tokenOut.amount.token.symbol === tokenIn.amount.token.symbol) {
+      return null;
     }
-    return null;
+    return {
+      primaryType: "swap",
+      primaryAmount: tokenOut.amount,
+      secondaryAmount: tokenIn.amount,
+      sender: initiator,
+      receiver: initiator,
+      counterparty: null,
+      confidence: 0.9,
+      isRelevant: true,
+      metadata: {
+        swap_type: "token_to_token",
+        from_token: tokenOut.amount.token.symbol,
+        to_token: tokenIn.amount.token.symbol,
+        from_amount: tokenOut.amount.amountUi,
+        to_amount: tokenIn.amount.amountUi
+      }
+    };
   }
 };
 
@@ -929,7 +924,7 @@ var AirdropClassifier = class {
   name = "airdrop";
   priority = 70;
   classify(context) {
-    const { legs, walletAddress, tx } = context;
+    const { legs, tx } = context;
     const facilitator = tx.accountKeys ? detectFacilitator(tx.accountKeys) : null;
     const protocolLegs = legs.filter(
       (leg) => leg.accountId.startsWith("protocol:")
@@ -937,49 +932,41 @@ var AirdropClassifier = class {
     if (protocolLegs.length === 0) {
       return null;
     }
-    const isObserverMode = !walletAddress;
-    const accountPrefix = walletAddress ? `wallet:${walletAddress}` : "external:";
-    const participantCredits = legs.filter(
-      (leg) => leg.accountId.startsWith(accountPrefix) && leg.side === "credit"
-    );
-    const participantDebits = legs.filter(
-      (leg) => leg.accountId.startsWith(accountPrefix) && leg.side === "debit"
-    );
-    const tokenReceived = participantCredits.filter(
-      (leg) => leg.role === "received" && leg.amount.token.symbol !== "SOL"
+    const tokenReceived = legs.filter(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "credit" && leg.role === "received" && leg.amount.token.symbol !== "SOL"
     );
     if (tokenReceived.length === 0) {
       return null;
     }
-    const tokenSent = participantDebits.filter(
-      (leg) => leg.role === "sent" && leg.amount.token.symbol !== "SOL"
+    const tokenSent = legs.filter(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "debit" && leg.role === "sent" && leg.amount.token.symbol !== "SOL"
     );
     if (tokenSent.length > 0) {
       return null;
     }
     const mainToken = tokenReceived[0];
-    const senderLegs = legs.filter(
-      (leg) => leg.side === "debit" && leg.amount.token.mint === mainToken.amount.token.mint && !leg.accountId.startsWith(accountPrefix)
+    const receiver = mainToken.accountId.replace("external:", "");
+    const senderLeg = legs.find(
+      (leg) => leg.side === "debit" && leg.amount.token.mint === mainToken.amount.token.mint
     );
-    const sender = senderLegs.length > 0 ? senderLegs[0] : null;
-    const receiverAddress = mainToken.accountId.replace(/^(external:|wallet:)/, "");
+    const sender = senderLeg ? senderLeg.accountId.replace(/^(external:|protocol:)/, "") : null;
     return {
       primaryType: "airdrop",
-      direction: isObserverMode ? "neutral" : "incoming",
       primaryAmount: mainToken.amount,
       secondaryAmount: null,
+      sender,
+      receiver,
       counterparty: sender ? {
-        type: "unknown",
-        address: sender.accountId.replace(/^(external:|protocol:|wallet:)/, "")
+        type: "protocol",
+        address: sender
       } : null,
-      confidence: isObserverMode ? 0.8 : 0.85,
+      confidence: 0.85,
       isRelevant: true,
       metadata: {
         airdrop_type: "token",
         token: mainToken.amount.token.symbol,
         amount: mainToken.amount.amountUi,
-        ...isObserverMode && { observer_mode: true, receiver: receiverAddress },
-        ...facilitator && { facilitator, payment_type: "facilitated" }
+        ...facilitator && { facilitator }
       }
     };
   }
@@ -990,30 +977,34 @@ var FeeOnlyClassifier = class {
   name = "fee-only";
   priority = 60;
   classify(context) {
-    const { legs, walletAddress } = context;
-    const isObserverMode = !walletAddress;
-    const accountPrefix = walletAddress ? `wallet:${walletAddress}` : "external:";
-    const participantLegs = legs.filter((leg) => leg.accountId.startsWith(accountPrefix));
-    const nonFeeParticipantLegs = participantLegs.filter((leg) => leg.role !== "fee");
-    if (nonFeeParticipantLegs.length > 0) {
+    const { legs } = context;
+    const externalLegs = legs.filter(
+      (leg) => leg.accountId.startsWith("external:")
+    );
+    const nonFeeLegs = externalLegs.filter((leg) => leg.role !== "fee");
+    if (nonFeeLegs.length > 0) {
       return null;
     }
     const feeLegs = legs.filter((leg) => leg.role === "fee");
     if (feeLegs.length === 0) {
       return null;
     }
+    const feePayerLeg = feeLegs.find(
+      (leg) => leg.side === "debit" && leg.amount.token.symbol === "SOL"
+    );
+    const feePayer = feePayerLeg?.accountId.replace("external:", "") ?? null;
     const totalFee = feeLegs.find((leg) => leg.amount.token.symbol === "SOL");
     return {
       primaryType: "fee_only",
-      direction: "outgoing",
       primaryAmount: totalFee?.amount ?? null,
       secondaryAmount: null,
+      sender: feePayer,
+      receiver: null,
       counterparty: null,
-      confidence: isObserverMode ? 0.9 : 0.95,
+      confidence: 0.95,
       isRelevant: false,
       metadata: {
-        fee_type: "network",
-        ...isObserverMode && { observer_mode: true }
+        fee_type: "network"
       }
     };
   }
@@ -1024,59 +1015,31 @@ var SolanaPayClassifier = class {
   name = "solana-pay";
   priority = 95;
   classify(context) {
-    const { tx, walletAddress, legs } = context;
+    const { tx, legs } = context;
     if (!isSolanaPayTransaction(tx.programIds, tx.memo)) {
       return null;
     }
     const memo = parseSolanaPayMemo(tx.memo);
-    const isObserverMode = !walletAddress;
-    if (isObserverMode) {
-      const senderLeg = legs.find(
-        (leg) => leg.accountId.startsWith("external:") && leg.side === "debit" && leg.role === "sent"
-      );
-      const receiverLeg = legs.find(
-        (leg) => leg.accountId.startsWith("external:") && leg.side === "credit" && leg.role === "received"
-      );
-      const primaryAmount2 = senderLeg?.amount ?? receiverLeg?.amount ?? null;
-      const senderAddress = senderLeg?.accountId.replace("external:", "");
-      const receiverAddress = receiverLeg?.accountId.replace("external:", "");
-      return {
-        primaryType: "transfer",
-        direction: "neutral",
-        primaryAmount: primaryAmount2,
-        secondaryAmount: null,
-        counterparty: memo.merchant ? { address: receiverAddress ?? "", name: memo.merchant, type: "merchant" } : null,
-        confidence: 0.95,
-        isRelevant: true,
-        metadata: {
-          payment_type: "solana_pay",
-          observer_mode: true,
-          sender: senderAddress,
-          receiver: receiverAddress,
-          memo: memo.raw,
-          merchant: memo.merchant,
-          item: memo.item,
-          reference: memo.reference,
-          label: memo.label,
-          message: memo.message
-        }
-      };
-    }
-    const walletPrefix = `wallet:${walletAddress}`;
-    const userSent = legs.find(
-      (leg) => leg.accountId.includes(walletPrefix) && leg.side === "debit" && leg.role === "sent"
+    const senderLeg = legs.find(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "debit" && leg.role === "sent"
     );
-    const userReceived = legs.find(
-      (leg) => leg.accountId.includes(walletPrefix) && leg.side === "credit" && leg.role === "received"
+    const receiverLeg = legs.find(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "credit" && leg.role === "received"
     );
-    const direction = userSent ? "outgoing" : "incoming";
-    const primaryAmount = userSent?.amount ?? userReceived?.amount ?? null;
+    const sender = senderLeg?.accountId.replace("external:", "") ?? null;
+    const receiver = receiverLeg?.accountId.replace("external:", "") ?? null;
+    const primaryAmount = senderLeg?.amount ?? receiverLeg?.amount ?? null;
     return {
       primaryType: "transfer",
-      direction,
       primaryAmount,
       secondaryAmount: null,
-      counterparty: memo.merchant ? { address: "", name: memo.merchant, type: "merchant" } : null,
+      sender,
+      receiver,
+      counterparty: receiver ? {
+        address: receiver,
+        name: memo.merchant ?? void 0,
+        type: memo.merchant ? "merchant" : "wallet"
+      } : null,
       confidence: 0.98,
       isRelevant: true,
       metadata: {
@@ -1092,11 +1055,188 @@ var SolanaPayClassifier = class {
   }
 };
 
+// ../classification/src/classifiers/nft-mint-classifier.ts
+var NftMintClassifier = class {
+  name = "nft-mint";
+  priority = 85;
+  classify(context) {
+    const { legs, tx } = context;
+    const hasNftMintProtocol = isNftMintProtocolById(tx.protocol?.id);
+    if (!hasNftMintProtocol) {
+      return null;
+    }
+    const nftCredits = legs.filter(
+      (leg) => leg.side === "credit" && leg.amount.token.decimals === 0 && leg.amount.amountUi >= 1 && (leg.role === "received" || leg.role === "protocol_withdraw")
+    );
+    if (nftCredits.length === 0) {
+      return null;
+    }
+    const primaryNft = nftCredits[0];
+    const minter = primaryNft.accountId.replace("external:", "");
+    const paymentLeg = legs.find(
+      (leg) => leg.side === "debit" && leg.role === "sent" && leg.amount.token.symbol === "SOL"
+    );
+    const totalMinted = nftCredits.reduce(
+      (sum, leg) => sum + leg.amount.amountUi,
+      0
+    );
+    return {
+      primaryType: "nft_mint",
+      primaryAmount: primaryNft.amount,
+      secondaryAmount: paymentLeg?.amount ?? null,
+      sender: null,
+      receiver: minter,
+      counterparty: null,
+      confidence: 0.9,
+      isRelevant: true,
+      metadata: {
+        nft_mint: primaryNft.amount.token.mint,
+        nft_name: primaryNft.amount.token.name,
+        quantity: totalMinted,
+        mint_price: paymentLeg?.amount.amountUi,
+        protocol: tx.protocol?.id
+      }
+    };
+  }
+};
+
+// ../classification/src/classifiers/stake-deposit-classifier.ts
+var StakeDepositClassifier = class {
+  name = "stake-deposit";
+  priority = 82;
+  classify(context) {
+    const { legs, tx } = context;
+    const hasStakeProtocol = isStakeProtocolById(tx.protocol?.id);
+    if (!hasStakeProtocol) {
+      return null;
+    }
+    const solDebit = legs.find(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "debit" && leg.amount.token.symbol === "SOL" && (leg.role === "sent" || leg.role === "protocol_deposit")
+    );
+    if (!solDebit) {
+      return null;
+    }
+    const staker = solDebit.accountId.replace("external:", "");
+    return {
+      primaryType: "stake_deposit",
+      primaryAmount: solDebit.amount,
+      secondaryAmount: null,
+      sender: staker,
+      receiver: null,
+      counterparty: null,
+      confidence: 0.9,
+      isRelevant: true,
+      metadata: {
+        stake_amount: solDebit.amount.amountUi,
+        protocol: tx.protocol?.id
+      }
+    };
+  }
+};
+
+// ../classification/src/classifiers/stake-withdraw-classifier.ts
+var StakeWithdrawClassifier = class {
+  name = "stake-withdraw";
+  priority = 81;
+  classify(context) {
+    const { legs, tx } = context;
+    const hasStakeProtocol = isStakeProtocolById(tx.protocol?.id);
+    if (!hasStakeProtocol) {
+      return null;
+    }
+    const solCredit = legs.find(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "credit" && leg.amount.token.symbol === "SOL" && (leg.role === "received" || leg.role === "protocol_withdraw")
+    );
+    if (!solCredit) {
+      return null;
+    }
+    const solDebit = legs.find(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "debit" && leg.amount.token.symbol === "SOL" && (leg.role === "sent" || leg.role === "protocol_deposit")
+    );
+    if (solDebit) {
+      return null;
+    }
+    const withdrawer = solCredit.accountId.replace("external:", "");
+    return {
+      primaryType: "stake_withdraw",
+      primaryAmount: solCredit.amount,
+      secondaryAmount: null,
+      sender: null,
+      receiver: withdrawer,
+      counterparty: null,
+      confidence: 0.9,
+      isRelevant: true,
+      metadata: {
+        withdraw_amount: solCredit.amount.amountUi,
+        protocol: tx.protocol?.id
+      }
+    };
+  }
+};
+
+// ../classification/src/classifiers/bridge-classifier.ts
+var BridgeClassifier = class {
+  name = "bridge";
+  priority = 88;
+  classify(context) {
+    const { legs, tx } = context;
+    const hasBridgeProtocol = isBridgeProtocolById(tx.protocol?.id);
+    if (!hasBridgeProtocol) {
+      return null;
+    }
+    const tokensOut = legs.filter(
+      (leg) => leg.accountId.startsWith("external:") && leg.side === "debit" && leg.role !== "fee" && (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")
+    );
+    let primaryType;
+    let primaryAmount = null;
+    let participant = null;
+    if (tokensIn.length > 0 && tokensOut.length === 0) {
+      primaryType = "bridge_in";
+      const creditLeg = tokensIn[0];
+      primaryAmount = creditLeg.amount;
+      participant = creditLeg.accountId.replace("external:", "");
+    } else if (tokensOut.length > 0 && tokensIn.length === 0) {
+      primaryType = "bridge_out";
+      const debitLeg = tokensOut[0];
+      primaryAmount = debitLeg.amount;
+      participant = debitLeg.accountId.replace("external:", "");
+    } else if (tokensIn.length > 0 && tokensOut.length > 0) {
+      primaryType = "bridge_in";
+      const creditLeg = tokensIn[0];
+      primaryAmount = creditLeg.amount;
+      participant = creditLeg.accountId.replace("external:", "");
+    } else {
+      return null;
+    }
+    return {
+      primaryType,
+      primaryAmount,
+      secondaryAmount: null,
+      sender: primaryType === "bridge_out" ? participant : null,
+      receiver: primaryType === "bridge_in" ? participant : null,
+      counterparty: null,
+      confidence: 0.9,
+      isRelevant: true,
+      metadata: {
+        bridge_protocol: tx.protocol?.id,
+        bridge_name: tx.protocol?.name
+      }
+    };
+  }
+};
+
 // ../classification/src/engine/classification-service.ts
 var ClassificationService = class {
   classifiers = [];
   constructor() {
     this.registerClassifier(new SolanaPayClassifier());
+    this.registerClassifier(new BridgeClassifier());
+    this.registerClassifier(new NftMintClassifier());
+    this.registerClassifier(new StakeDepositClassifier());
+    this.registerClassifier(new StakeWithdrawClassifier());
     this.registerClassifier(new SwapClassifier());
     this.registerClassifier(new AirdropClassifier());
     this.registerClassifier(new TransferClassifier());
@@ -1106,8 +1246,8 @@ var ClassificationService = class {
     this.classifiers.push(classifier);
     this.classifiers.sort((a, b) => b.priority - a.priority);
   }
-  classify(legs, walletAddress, tx) {
-    const context = { legs, walletAddress, tx };
+  classify(legs, tx) {
+    const context = { legs, tx };
     for (const classifier of this.classifiers) {
       const result = classifier.classify(context);
       if (result && result.isRelevant) {
@@ -1116,9 +1256,10 @@ var ClassificationService = class {
     }
     return {
       primaryType: "other",
-      direction: "neutral",
       primaryAmount: null,
       secondaryAmount: null,
+      sender: null,
+      receiver: null,
       counterparty: null,
       confidence: 0,
       isRelevant: false,
@@ -1127,8 +1268,8 @@ var ClassificationService = class {
   }
 };
 var classificationService = new ClassificationService();
-function classifyTransaction(legs, walletAddress, tx) {
-  return classificationService.classify(legs, walletAddress, tx);
+function classifyTransaction(legs, tx) {
+  return classificationService.classify(legs, tx);
 }
 
 // ../domain/src/tx/spam-filter.ts
@@ -1174,8 +1315,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,
@@ -1183,7 +1397,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,
@@ -1202,11 +1448,11 @@ function createIndexer(options) {
         );
         const classified = transactions.map((tx) => {
           tx.protocol = detectProtocol(tx.programIds);
-          const legs = transactionToLegs(tx, walletAddress);
-          const classification = classifyTransaction(legs, walletAddress, tx);
+          const legs = transactionToLegs(tx);
+          const classification = classifyTransaction(legs, tx);
           return { tx, classification, legs };
         });
-        return classified;
+        return enrichBatch(classified);
       }
       const accumulated = [];
       let currentBefore = before;
@@ -1232,8 +1478,8 @@ function createIndexer(options) {
         );
         const classified = transactions.map((tx) => {
           tx.protocol = detectProtocol(tx.programIds);
-          const legs = transactionToLegs(tx, walletAddress);
-          const classification = classifyTransaction(legs, walletAddress, tx);
+          const legs = transactionToLegs(tx);
+          const classification = classifyTransaction(legs, tx);
           return { tx, classification, legs };
         });
         const nonSpam = filterSpamTransactions(classified, spamConfig);
@@ -1245,20 +1491,38 @@ function createIndexer(options) {
           break;
         }
       }
-      return accumulated.slice(0, limit);
+      const result = accumulated.slice(0, limit);
+      return enrichBatch(result);
     },
-    async getTransaction(signature2, walletAddress) {
+    async getTransaction(signature2, options2 = {}) {
+      const { enrichNftMetadata = true } = options2;
       const tx = await fetchTransaction(client.rpc, signature2);
       if (!tx) {
         return null;
       }
       tx.protocol = detectProtocol(tx.programIds);
-      const legs = transactionToLegs(tx, walletAddress);
-      const classification = classifyTransaction(legs, walletAddress, tx);
-      return { tx, classification, legs };
+      const legs = transactionToLegs(tx);
+      const classification = classifyTransaction(legs, tx);
+      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);
     }
   };
 }