tx-indexer 0.5.0 → 0.5.2

package/dist/client.js

@@ -49,6 +49,57 @@ function getTokenInfo(mint) {
   return TOKEN_INFO[mint];
 }
 
+// ../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) {
   const balanceResponse = await rpc.getBalance(walletAddress).send();
@@ -66,12 +117,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 +144,6 @@ async function fetchTokenAccounts(rpc, walletAddress) {
         symbol
       });
     }
-  } catch (error) {
-    console.error("Error fetching token accounts:", error);
   }
   return accountsMap;
 }
@@ -133,44 +187,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 +396,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 +597,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 +653,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 +820,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 +877,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 +938,7 @@ var TransferClassifier = class {
 
 // ../classification/src/protocols/detector.ts
 var KNOWN_PROGRAMS = {
+  // Jupiter aggregator
   [JUPITER_V6_PROGRAM_ID]: {
     id: "jupiter",
     name: "Jupiter"
@@ -729,10 +947,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 +972,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 +1069,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 +1101,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,41 +1222,71 @@ 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 } = context;
-    const feeLeg = legs.find(
-      (leg) => leg.role === "fee" && leg.side === "debit"
-    );
-    const initiator = feeLeg?.accountId.replace("external:", "") ?? null;
+    const { legs, tx, walletAddress } = context;
+    const initiator = tx.accountKeys?.[0] ?? null;
     if (!initiator) {
       return null;
     }
     const initiatorAccountId = `external:${initiator}`;
-    const tokensOut = legs.filter(
+    const initiatorTokensOut = legs.filter(
       (leg) => leg.accountId === initiatorAccountId && leg.side === "debit" && (leg.role === "sent" || leg.role === "protocol_deposit")
     );
-    const tokensIn = legs.filter(
+    const initiatorTokensIn = legs.filter(
       (leg) => leg.accountId === initiatorAccountId && leg.side === "credit" && (leg.role === "received" || leg.role === "protocol_withdraw")
     );
-    if (tokensOut.length === 0 || tokensIn.length === 0) {
+    if (initiatorTokensOut.length === 0 || initiatorTokensIn.length === 0) {
       return null;
     }
-    const tokenOut = tokensOut[0];
-    const tokenIn = tokensIn[0];
-    if (tokenOut.amount.token.symbol === tokenIn.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;
+    if (walletAddress) {
+      const walletAccountId = `external:${walletAddress}`;
+      const walletOut = legs.find(
+        (leg) => leg.accountId === walletAccountId && leg.side === "debit" && (leg.role === "sent" || leg.role === "protocol_deposit")
+      );
+      const walletIn = legs.find(
+        (leg) => leg.accountId === walletAccountId && leg.side === "credit" && (leg.role === "received" || leg.role === "protocol_withdraw")
+      );
+      if (walletOut && walletIn && walletOut.amount.token.symbol !== walletIn.amount.token.symbol) {
+        tokenOut = walletOut;
+        tokenIn = walletIn;
+        perspectiveWallet = walletAddress;
+      }
+    }
     const hasDexProtocol = isDexProtocolById(tx.protocol?.id);
     const confidence = hasDexProtocol ? 0.95 : 0.75;
     return {
       primaryType: "swap",
       primaryAmount: tokenOut.amount,
       secondaryAmount: tokenIn.amount,
-      sender: initiator,
-      receiver: initiator,
+      sender: perspectiveWallet,
+      receiver: perspectiveWallet,
       counterparty: null,
       confidence,
       isRelevant: true,
@@ -1248,8 +1628,8 @@ var ClassificationService = class {
     this.classifiers.push(classifier);
     this.classifiers.sort((a, b) => b.priority - a.priority);
   }
-  classify(legs, tx) {
-    const context = { legs, tx };
+  classify(legs, tx, walletAddress) {
+    const context = { legs, tx, walletAddress };
     for (const classifier of this.classifiers) {
       const result = classifier.classify(context);
       if (result && result.isRelevant) {
@@ -1270,19 +1650,19 @@ var ClassificationService = class {
   }
 };
 var classificationService = new ClassificationService();
-function classifyTransaction(legs, tx) {
-  return classificationService.classify(legs, tx);
+function classifyTransaction(legs, tx, walletAddress) {
+  return classificationService.classify(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;
   }
@@ -1448,10 +1828,11 @@ function createIndexer(options) {
           client.rpc,
           signatureObjects
         );
+        const walletAddressStr2 = walletAddress.toString();
         const classified = transactions.map((tx) => {
           tx.protocol = detectProtocol(tx.programIds);
           const legs = transactionToLegs(tx);
-          const classification = classifyTransaction(legs, tx);
+          const classification = classifyTransaction(legs, tx, walletAddressStr2);
           return { tx, classification, legs };
         });
         return enrichBatch(classified);
@@ -1460,6 +1841,7 @@ function createIndexer(options) {
       let currentBefore = before;
       const MAX_ITERATIONS = 10;
       let iteration = 0;
+      const walletAddressStr = walletAddress.toString();
       while (accumulated.length < limit && iteration < MAX_ITERATIONS) {
         iteration++;
         const batchSize = iteration === 1 ? limit : limit * 2;
@@ -1481,7 +1863,7 @@ function createIndexer(options) {
         const classified = transactions.map((tx) => {
           tx.protocol = detectProtocol(tx.programIds);
           const legs = transactionToLegs(tx);
-          const classification = classifyTransaction(legs, tx);
+          const classification = classifyTransaction(legs, tx, walletAddressStr);
           return { tx, classification, legs };
         });
         const nonSpam = filterSpamTransactions(classified, spamConfig);