tx-indexer 0.1.0

package/dist/index.js

@@ -0,0 +1,1320 @@
+import { createSolanaRpc, createSolanaRpcSubscriptions, address, signature } from '@solana/kit';
+
+// ../solana/src/rpc/client.ts
+function createSolanaClient(rpcUrl, wsUrl) {
+  const rpc = createSolanaRpc(rpcUrl);
+  const rpcSubscriptions = wsUrl ? createSolanaRpcSubscriptions(wsUrl) : createSolanaRpcSubscriptions(rpcUrl.replace("https://", "wss://"));
+  return { rpc, rpcSubscriptions };
+}
+function parseAddress(addr) {
+  return address(addr);
+}
+function parseSignature(sig) {
+  return signature(sig);
+}
+
+// ../domain/src/money/token-registry.ts
+var KNOWN_TOKENS = {
+  SOL: "So11111111111111111111111111111111111111112",
+  USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+  USDC_BRIDGED: "A9mUU4qviSctJVPJdBJWkb28deg915LYJKrzQ19ji3FM",
+  USDG: "2u1tszSeqZ3qBWF3uNGPFc8TzMk2tdiwknnRMWGWjGWH"
+};
+var TOKEN_INFO = {
+  [KNOWN_TOKENS.SOL]: {
+    mint: KNOWN_TOKENS.SOL,
+    symbol: "SOL",
+    name: "Solana",
+    decimals: 9,
+    logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/So11111111111111111111111111111111111111112/logo.png"
+  },
+  [KNOWN_TOKENS.USDC]: {
+    mint: KNOWN_TOKENS.USDC,
+    symbol: "USDC",
+    name: "USD Coin",
+    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.USDG]: {
+    mint: KNOWN_TOKENS.USDG,
+    symbol: "USDG",
+    name: "USD Glitter",
+    decimals: 6
+  }
+};
+function getTokenInfo(mint) {
+  return TOKEN_INFO[mint];
+}
+[
+  KNOWN_TOKENS.USDC,
+  KNOWN_TOKENS.USDC_BRIDGED,
+  KNOWN_TOKENS.USDG
+];
+[
+  KNOWN_TOKENS.SOL,
+  KNOWN_TOKENS.USDC
+];
+
+// ../solana/src/fetcher/balances.ts
+async function fetchWalletBalance(rpc, walletAddress, tokenMints) {
+  const balanceResponse = await rpc.getBalance(walletAddress).send();
+  const lamports = balanceResponse.value;
+  const tokenAccounts = await fetchTokenAccounts(rpc, walletAddress);
+  const tokens = tokenMints ? filterToTrackedTokens(tokenAccounts, tokenMints) : Array.from(tokenAccounts.values());
+  return {
+    address: walletAddress,
+    sol: {
+      lamports,
+      ui: Number(lamports) / 1e9
+    },
+    tokens
+  };
+}
+async function fetchTokenAccounts(rpc, walletAddress) {
+  const accountsMap = /* @__PURE__ */ new Map();
+  try {
+    const response = await rpc.getTokenAccountsByOwner(
+      walletAddress,
+      { programId: address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") },
+      { encoding: "jsonParsed" }
+    ).send();
+    for (const account of response.value) {
+      const parsedInfo = account.account.data.parsed.info;
+      const mint = parsedInfo.mint;
+      const tokenInfo = getTokenInfo(mint);
+      const symbol = tokenInfo?.symbol || mint.substring(0, 8);
+      accountsMap.set(mint, {
+        mint,
+        tokenAccount: account.pubkey.toString(),
+        amount: {
+          raw: parsedInfo.tokenAmount.amount,
+          ui: parsedInfo.tokenAmount.uiAmountString ? parseFloat(parsedInfo.tokenAmount.uiAmountString) : 0
+        },
+        decimals: parsedInfo.tokenAmount.decimals,
+        symbol
+      });
+    }
+  } catch (error) {
+    console.error("Error fetching token accounts:", error);
+  }
+  return accountsMap;
+}
+function filterToTrackedTokens(fetchedAccounts, tokenMints) {
+  const result = [];
+  for (const mint of tokenMints) {
+    if (mint === KNOWN_TOKENS.SOL) continue;
+    const existing = fetchedAccounts.get(mint);
+    if (existing) {
+      result.push(existing);
+    } else {
+      const tokenInfo = getTokenInfo(mint);
+      if (tokenInfo) {
+        result.push({
+          mint,
+          amount: {
+            raw: "0",
+            ui: 0
+          },
+          decimals: tokenInfo.decimals,
+          symbol: tokenInfo.symbol
+        });
+      }
+    }
+  }
+  return result;
+}
+
+// ../solana/src/mappers/transaction-mapper.ts
+function extractProgramIds(transaction) {
+  const programIds = /* @__PURE__ */ new Set();
+  const { message } = transaction;
+  const { accountKeys, instructions } = message;
+  for (const ix of instructions) {
+    const { programIdIndex } = ix;
+    if (programIdIndex !== void 0 && accountKeys[programIdIndex]) {
+      const key = accountKeys[programIdIndex];
+      programIds.add(key.toString());
+    }
+  }
+  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 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 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) {
+    throw new TypeError("Alphabet too long");
+  }
+  const BASE_MAP = new Uint8Array(256);
+  for (let j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (let i = 0; i < ALPHABET2.length; i++) {
+    const x = ALPHABET2.charAt(i);
+    const xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  const BASE = ALPHABET2.length;
+  const LEADER = ALPHABET2.charAt(0);
+  const FACTOR = Math.log(BASE) / Math.log(256);
+  const iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source) {
+    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    let zeroes = 0;
+    let length = 0;
+    let pbegin = 0;
+    const pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    const b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      let carry = source[pbegin];
+      let i = 0;
+      for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i;
+      pbegin++;
+    }
+    let it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    let str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET2.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    let psz = 0;
+    let zeroes = 0;
+    let length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    const size = (source.length - psz) * FACTOR + 1 >>> 0;
+    const b256 = new Uint8Array(size);
+    while (psz < source.length) {
+      const charCode = source.charCodeAt(psz);
+      if (charCode > 255) {
+        return;
+      }
+      let carry = BASE_MAP[charCode];
+      if (carry === 255) {
+        return;
+      }
+      let i = 0;
+      for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i;
+      psz++;
+    }
+    let it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    const vch = new Uint8Array(zeroes + (size - it4));
+    let j = zeroes;
+    while (it4 !== size) {
+      vch[j++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode(string) {
+    const buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error("Non-base" + BASE + " character");
+  }
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  };
+}
+var esm_default = base;
+
+// ../../node_modules/.bun/bs58@6.0.0/node_modules/bs58/src/esm/index.js
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var esm_default2 = esm_default(ALPHABET);
+
+// ../solana/src/mappers/memo-parser.ts
+function decodeMemoData(base64Data) {
+  const buffer = Buffer.from(base64Data, "base64");
+  const text = buffer.toString("utf-8");
+  if (!text.includes("\uFFFD") && /^[\x20-\x7E\s]*$/.test(text)) {
+    return text;
+  }
+  if (buffer.length === 32) {
+    return esm_default2.encode(buffer);
+  }
+  if (buffer.length % 32 === 0 && buffer.length > 0) {
+    const addresses = [];
+    for (let i = 0; i < buffer.length; i += 32) {
+      const chunk = buffer.subarray(i, i + 32);
+      addresses.push(esm_default2.encode(chunk));
+    }
+    return addresses.join(", ");
+  }
+  if (buffer.length >= 16) {
+    const uuidBytes = buffer.subarray(0, 16);
+    const uuid = [
+      uuidBytes.subarray(0, 4).toString("hex"),
+      uuidBytes.subarray(4, 6).toString("hex"),
+      uuidBytes.subarray(6, 8).toString("hex"),
+      uuidBytes.subarray(8, 10).toString("hex"),
+      uuidBytes.subarray(10, 16).toString("hex")
+    ].join("-");
+    if (buffer.length === 16) {
+      return `Product: ${uuid}`;
+    }
+    const extraData = buffer.subarray(16);
+    const extraHex = extraData.toString("hex");
+    return `Product: ${uuid} | Meta: ${extraHex}`;
+  }
+  return esm_default2.encode(buffer);
+}
+function extractMemo(transaction) {
+  if (transaction.meta?.logMessages) {
+    const memoLogPattern = /Program log: Memo \(len \d+\): "(.+)"/;
+    for (const log of transaction.meta.logMessages) {
+      const match = log.match(memoLogPattern);
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+  }
+  const { message } = transaction;
+  const { accountKeys, instructions } = message;
+  for (const ix of instructions) {
+    const programId = accountKeys[ix.programIdIndex]?.toString();
+    if (programId === SPL_MEMO_PROGRAM_ID || programId === MEMO_V1_PROGRAM_ID) {
+      if (ix.data) {
+        try {
+          return decodeMemoData(ix.data);
+        } catch (e) {
+          console.warn("Failed to decode memo:", e);
+        }
+      }
+    }
+  }
+  return null;
+}
+function parseSolanaPayMemo(memo) {
+  try {
+    const parsed = JSON.parse(memo);
+    return { ...parsed, raw: memo };
+  } catch {
+    return { raw: memo };
+  }
+}
+function isSolanaPayTransaction(programIds, memo) {
+  const hasMemoProgram = programIds.includes(SPL_MEMO_PROGRAM_ID) || programIds.includes(MEMO_V1_PROGRAM_ID);
+  return hasMemoProgram && memo !== null && memo !== void 0;
+}
+
+// ../solana/src/fetcher/transactions.ts
+async function fetchWalletSignatures(rpc, walletAddress, config = {}) {
+  const { limit = 1e3, before, until } = config;
+  const response = await rpc.getSignaturesForAddress(walletAddress, {
+    limit,
+    before,
+    until
+  }).send();
+  return response.map((sig) => ({
+    signature: sig.signature,
+    slot: sig.slot,
+    blockTime: sig.blockTime,
+    err: sig.err,
+    programIds: [],
+    protocol: null,
+    memo: sig.memo || null
+  }));
+}
+async function fetchTransaction(rpc, signature2, commitment = "confirmed") {
+  const response = await rpc.getTransaction(signature2, {
+    commitment,
+    maxSupportedTransactionVersion: 0,
+    encoding: "json"
+  }).send();
+  if (!response) {
+    return null;
+  }
+  const transactionWithLogs = {
+    ...response.transaction,
+    meta: { logMessages: response.meta?.logMessages }
+  };
+  const memo = extractMemo(transactionWithLogs);
+  return {
+    signature: signature2,
+    slot: response.slot,
+    blockTime: response.blockTime,
+    err: response.meta?.err ?? null,
+    programIds: extractProgramIds(response.transaction),
+    protocol: null,
+    preTokenBalances: (response.meta?.preTokenBalances ?? []).map((bal) => ({
+      accountIndex: bal.accountIndex,
+      mint: bal.mint.toString(),
+      owner: bal.owner?.toString(),
+      programId: bal.programId?.toString(),
+      uiTokenAmount: {
+        amount: bal.uiTokenAmount.amount.toString(),
+        decimals: bal.uiTokenAmount.decimals,
+        uiAmountString: bal.uiTokenAmount.uiAmountString.toString()
+      }
+    })),
+    postTokenBalances: (response.meta?.postTokenBalances ?? []).map((bal) => ({
+      accountIndex: bal.accountIndex,
+      mint: bal.mint.toString(),
+      owner: bal.owner?.toString(),
+      programId: bal.programId?.toString(),
+      uiTokenAmount: {
+        amount: bal.uiTokenAmount.amount.toString(),
+        decimals: bal.uiTokenAmount.decimals,
+        uiAmountString: bal.uiTokenAmount.uiAmountString.toString()
+      }
+    })),
+    preBalances: (response.meta?.preBalances ?? []).map((bal) => Number(bal)),
+    postBalances: (response.meta?.postBalances ?? []).map((bal) => Number(bal)),
+    accountKeys: response.transaction.message.accountKeys.map(
+      (key) => key.toString()
+    ),
+    memo
+  };
+}
+async function fetchTransactionsBatch(rpc, signatures, commitment = "confirmed") {
+  const promises = signatures.map(
+    (sig) => fetchTransaction(rpc, sig, commitment)
+  );
+  const results = await Promise.all(promises);
+  return results.filter((tx) => tx !== null);
+}
+
+// ../domain/src/tx/account-id.ts
+function buildAccountId(params) {
+  const { type, address: address3, protocol, token } = params;
+  if (type === "wallet") {
+    return `wallet:${address3}`;
+  }
+  if (type === "protocol" && protocol) {
+    if (token) {
+      return `protocol:${protocol}:${token}:${address3}`;
+    }
+    return `protocol:${protocol}:${address3}`;
+  }
+  if (type === "external") {
+    return `external:${address3}`;
+  }
+  if (type === "fee") {
+    return "fee:network";
+  }
+  throw new Error(
+    `Invalid accountId parameters: type=${type}, address=${address3}, protocol=${protocol}`
+  );
+}
+function parseAccountId(accountId) {
+  const parts = accountId.split(":");
+  if (parts[0] === "wallet" && parts.length === 2) {
+    return { type: "wallet", address: parts[1] };
+  }
+  if (parts[0] === "protocol") {
+    if (parts.length === 4) {
+      return {
+        type: "protocol",
+        protocol: parts[1],
+        token: parts[2],
+        address: parts[3]
+      };
+    }
+    if (parts.length === 3) {
+      return {
+        type: "protocol",
+        protocol: parts[1],
+        address: parts[2]
+      };
+    }
+  }
+  if (parts[0] === "external" && parts.length === 2) {
+    return { type: "external", address: parts[1] };
+  }
+  if (parts[0] === "fee" && parts[1] === "network") {
+    return { type: "fee" };
+  }
+  return { type: "unknown", address: accountId };
+}
+
+// ../solana/src/mappers/balance-parser.ts
+function extractTokenBalanceChanges(tx, filterMints) {
+  const { preTokenBalances = [], postTokenBalances = [] } = tx;
+  const changes = [];
+  const preBalanceMap = /* @__PURE__ */ new Map();
+  for (const bal of preTokenBalances) {
+    preBalanceMap.set(bal.accountIndex, bal);
+  }
+  for (const postBal of postTokenBalances) {
+    const { accountIndex, mint } = postBal;
+    let tokenInfo = getTokenInfo(mint);
+    if (!tokenInfo) {
+      tokenInfo = {
+        mint,
+        symbol: mint.slice(0, 8),
+        decimals: postBal.uiTokenAmount.decimals,
+        name: `Unknown Token (${mint.slice(0, 8)}...)`
+      };
+    }
+    const preBal = preBalanceMap.get(accountIndex);
+    const preAmount = preBal?.uiTokenAmount.amount ?? "0";
+    const postAmount = postBal.uiTokenAmount.amount;
+    const preUi = preBal?.uiTokenAmount.uiAmountString ? parseFloat(preBal.uiTokenAmount.uiAmountString) : 0;
+    const postUi = postBal.uiTokenAmount.uiAmountString ? parseFloat(postBal.uiTokenAmount.uiAmountString) : 0;
+    const changeRaw = (BigInt(postAmount) - BigInt(preAmount)).toString();
+    const changeUi = postUi - preUi;
+    if (changeRaw !== "0") {
+      changes.push({
+        mint,
+        tokenInfo,
+        accountIndex,
+        owner: postBal.owner,
+        preBalance: {
+          raw: preAmount,
+          ui: preUi
+        },
+        postBalance: {
+          raw: postAmount,
+          ui: postUi
+        },
+        change: {
+          raw: changeRaw,
+          ui: changeUi
+        }
+      });
+    }
+  }
+  return changes;
+}
+function extractSolBalanceChanges(tx) {
+  const {
+    preBalances = [],
+    postBalances = [],
+    accountKeys = []
+  } = tx;
+  const changes = [];
+  for (let i = 0; i < accountKeys.length; i++) {
+    const address3 = accountKeys[i];
+    if (!address3) continue;
+    const preBal = BigInt(preBalances[i] ?? 0);
+    const postBal = BigInt(postBalances[i] ?? 0);
+    const change = postBal - preBal;
+    if (change !== 0n) {
+      changes.push({
+        accountIndex: i,
+        address: address3,
+        preBalance: preBal,
+        postBalance: postBal,
+        change,
+        changeUi: Number(change) / 1e9
+      });
+    }
+  }
+  return changes;
+}
+
+// ../solana/src/constants/protocol-constants.ts
+var DEX_PROTOCOL_IDS = /* @__PURE__ */ new Set([
+  "jupiter",
+  "jupiter-v4",
+  "raydium",
+  "orca-whirlpool"
+]);
+
+// ../solana/src/mappers/transaction-to-legs.ts
+function isDexProtocol(protocol) {
+  return protocol !== null && protocol !== void 0 && DEX_PROTOCOL_IDS.has(protocol.id);
+}
+function transactionToLegs(tx, walletAddress) {
+  const legs = [];
+  const feePayer = tx.accountKeys?.[0]?.toLowerCase();
+  const solChanges = extractSolBalanceChanges(tx);
+  let totalSolDebits = 0n;
+  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",
+      address: change.address
+    });
+    const solInfo = TOKEN_INFO[KNOWN_TOKENS.SOL];
+    if (!solInfo) {
+      throw new Error("SOL token info not found in registry");
+    }
+    if (change.change > 0n) {
+      totalSolCredits += change.change;
+    } else {
+      totalSolDebits += -change.change;
+    }
+    legs.push({
+      accountId,
+      side: change.change > 0n ? "credit" : "debit",
+      amount: {
+        token: solInfo,
+        amountRaw: change.change.toString().replace("-", ""),
+        amountUi: Math.abs(change.changeUi)
+      },
+      role: determineSolRole(change, walletAddress, tx, feePayer)
+    });
+  }
+  const networkFee = totalSolDebits - totalSolCredits;
+  if (networkFee > 0n) {
+    const solInfo = TOKEN_INFO[KNOWN_TOKENS.SOL];
+    if (solInfo) {
+      legs.push({
+        accountId: buildAccountId({ type: "fee", address: "" }),
+        side: "credit",
+        amount: {
+          token: solInfo,
+          amountRaw: networkFee.toString(),
+          amountUi: Number(networkFee) / 1e9
+        },
+        role: "fee"
+      });
+    }
+  }
+  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
+      });
+    } else {
+      accountId = buildAccountId({
+        type: "external",
+        address: change.owner || change.tokenInfo.mint
+      });
+    }
+    legs.push({
+      accountId,
+      side: change.change.ui > 0 ? "credit" : "debit",
+      amount: {
+        token: change.tokenInfo,
+        amountRaw: change.change.raw.replace("-", ""),
+        amountUi: Math.abs(change.change.ui)
+      },
+      role: determineTokenRole(change, walletAddress, 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;
+  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) {
+    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;
+  const isPositive = change.change.ui > 0;
+  if (isWallet || isFeePayer) {
+    return isPositive ? "received" : "sent";
+  }
+  if (isDexProtocol(tx.protocol)) {
+    return isPositive ? "protocol_withdraw" : "protocol_deposit";
+  }
+  return isPositive ? "received" : "sent";
+}
+
+// ../classification/src/classifiers/transfer-classifier.ts
+var TransferClassifier = class {
+  name = "transfer";
+  priority = 20;
+  classify(context) {
+    const { legs, walletAddress, 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 otherSent = legs.filter(
+      (l) => !l.accountId.toLowerCase().startsWith(participantPrefix.toLowerCase()) && l.accountId.startsWith("external:") && l.side === "debit" && l.role === "sent"
+    );
+    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" }
+          }
+        };
+      }
+    }
+    return null;
+  }
+};
+
+// ../classification/src/protocols/detector.ts
+var KNOWN_PROGRAMS = {
+  [JUPITER_V6_PROGRAM_ID]: {
+    id: "jupiter",
+    name: "Jupiter"
+  },
+  [JUPITER_V4_PROGRAM_ID]: {
+    id: "jupiter-v4",
+    name: "Jupiter V4"
+  },
+  [TOKEN_PROGRAM_ID]: {
+    id: "spl-token",
+    name: "Token Program"
+  },
+  [SYSTEM_PROGRAM_ID]: {
+    id: "system",
+    name: "System Program"
+  },
+  [COMPUTE_BUDGET_PROGRAM_ID]: {
+    id: "compute-budget",
+    name: "Compute Budget"
+  },
+  [ASSOCIATED_TOKEN_PROGRAM_ID]: {
+    id: "associated-token",
+    name: "Associated Token Program"
+  },
+  [METAPLEX_PROGRAM_ID]: {
+    id: "metaplex",
+    name: "Metaplex"
+  },
+  [ORCA_WHIRLPOOL_PROGRAM_ID]: {
+    id: "orca-whirlpool",
+    name: "Orca Whirlpool"
+  },
+  [RAYDIUM_PROGRAM_ID]: {
+    id: "raydium",
+    name: "Raydium"
+  },
+  [STAKE_PROGRAM_ID]: {
+    id: "stake",
+    name: "Stake Program"
+  }
+};
+var PRIORITY_ORDER = [
+  "jupiter",
+  "jupiter-v4",
+  "raydium",
+  "orca-whirlpool",
+  "metaplex",
+  "stake",
+  "associated-token",
+  "spl-token",
+  "compute-budget",
+  "system"
+];
+var DEX_PROTOCOL_IDS2 = /* @__PURE__ */ new Set([
+  "jupiter",
+  "jupiter-v4",
+  "raydium",
+  "orca-whirlpool"
+]);
+function isDexProtocolById(protocolId) {
+  return protocolId !== void 0 && DEX_PROTOCOL_IDS2.has(protocolId);
+}
+function detectProtocol(programIds) {
+  const detectedProtocols = [];
+  for (const programId of programIds) {
+    const protocol = KNOWN_PROGRAMS[programId];
+    if (protocol) {
+      detectedProtocols.push(protocol);
+    }
+  }
+  if (detectedProtocols.length === 0) {
+    return null;
+  }
+  detectedProtocols.sort((a, b) => {
+    const aPriority = PRIORITY_ORDER.indexOf(a.id);
+    const bPriority = PRIORITY_ORDER.indexOf(b.id);
+    return aPriority - bPriority;
+  });
+  return detectedProtocols[0] ?? null;
+}
+
+// ../classification/src/classifiers/swap-classifier.ts
+var SwapClassifier = class {
+  name = "swap";
+  priority = 80;
+  classify(context) {
+    const { legs, walletAddress, tx } = context;
+    const protocolLegs = legs.filter(
+      (leg) => leg.accountId.startsWith("protocol:")
+    );
+    const hasDexProtocol = isDexProtocolById(tx.protocol?.id);
+    if (protocolLegs.length === 0 && !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 tokensOut = participantDebits.filter(
+      (leg) => leg.role === "sent" || leg.role === "protocol_deposit"
+    );
+    const tokensIn = participantCredits.filter(
+      (leg) => 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 }
+          }
+        };
+      }
+    }
+    return null;
+  }
+};
+
+// ../classification/src/classifiers/airdrop-classifier.ts
+var AirdropClassifier = class {
+  name = "airdrop";
+  priority = 70;
+  classify(context) {
+    const { legs, walletAddress, tx } = context;
+    const facilitator = tx.accountKeys ? detectFacilitator(tx.accountKeys) : null;
+    const protocolLegs = legs.filter(
+      (leg) => leg.accountId.startsWith("protocol:")
+    );
+    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"
+    );
+    if (tokenReceived.length === 0) {
+      return null;
+    }
+    const tokenSent = participantDebits.filter(
+      (leg) => 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 sender = senderLegs.length > 0 ? senderLegs[0] : null;
+    const receiverAddress = mainToken.accountId.replace(/^(external:|wallet:)/, "");
+    return {
+      primaryType: "airdrop",
+      direction: isObserverMode ? "neutral" : "incoming",
+      primaryAmount: mainToken.amount,
+      secondaryAmount: null,
+      counterparty: sender ? {
+        type: "unknown",
+        address: sender.accountId.replace(/^(external:|protocol:|wallet:)/, "")
+      } : null,
+      confidence: isObserverMode ? 0.8 : 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" }
+      }
+    };
+  }
+};
+
+// ../classification/src/classifiers/fee-only-classifier.ts
+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) {
+      return null;
+    }
+    const feeLegs = legs.filter((leg) => leg.role === "fee");
+    if (feeLegs.length === 0) {
+      return null;
+    }
+    const totalFee = feeLegs.find((leg) => leg.amount.token.symbol === "SOL");
+    return {
+      primaryType: "fee_only",
+      direction: "outgoing",
+      primaryAmount: totalFee?.amount ?? null,
+      secondaryAmount: null,
+      counterparty: null,
+      confidence: isObserverMode ? 0.9 : 0.95,
+      isRelevant: false,
+      metadata: {
+        fee_type: "network",
+        ...isObserverMode && { observer_mode: true }
+      }
+    };
+  }
+};
+
+// ../classification/src/classifiers/solana-pay-classifier.ts
+var SolanaPayClassifier = class {
+  name = "solana-pay";
+  priority = 95;
+  classify(context) {
+    const { tx, walletAddress, 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 userReceived = legs.find(
+      (leg) => leg.accountId.includes(walletPrefix) && leg.side === "credit" && leg.role === "received"
+    );
+    const direction = userSent ? "outgoing" : "incoming";
+    const primaryAmount = userSent?.amount ?? userReceived?.amount ?? null;
+    return {
+      primaryType: "transfer",
+      direction,
+      primaryAmount,
+      secondaryAmount: null,
+      counterparty: memo.merchant ? { address: "", name: memo.merchant, type: "merchant" } : null,
+      confidence: 0.98,
+      isRelevant: true,
+      metadata: {
+        payment_type: "solana_pay",
+        memo: memo.raw,
+        merchant: memo.merchant,
+        item: memo.item,
+        reference: memo.reference,
+        label: memo.label,
+        message: memo.message
+      }
+    };
+  }
+};
+
+// ../classification/src/engine/classification-service.ts
+var ClassificationService = class {
+  classifiers = [];
+  constructor() {
+    this.registerClassifier(new SolanaPayClassifier());
+    this.registerClassifier(new SwapClassifier());
+    this.registerClassifier(new AirdropClassifier());
+    this.registerClassifier(new TransferClassifier());
+    this.registerClassifier(new FeeOnlyClassifier());
+  }
+  registerClassifier(classifier) {
+    this.classifiers.push(classifier);
+    this.classifiers.sort((a, b) => b.priority - a.priority);
+  }
+  classify(legs, walletAddress, tx) {
+    const context = { legs, walletAddress, tx };
+    for (const classifier of this.classifiers) {
+      const result = classifier.classify(context);
+      if (result && result.isRelevant) {
+        return result;
+      }
+    }
+    return {
+      primaryType: "other",
+      direction: "neutral",
+      primaryAmount: null,
+      secondaryAmount: null,
+      counterparty: null,
+      confidence: 0,
+      isRelevant: false,
+      metadata: {}
+    };
+  }
+};
+var classificationService = new ClassificationService();
+function classifyTransaction(legs, walletAddress, tx) {
+  return classificationService.classify(legs, walletAddress, tx);
+}
+
+// ../domain/src/tx/spam-filter.ts
+var DEFAULT_CONFIG = {
+  minSolAmount: 1e-3,
+  minTokenAmountUsd: 0.01,
+  minConfidence: 0.5,
+  allowFailed: false
+};
+function isSpamTransaction(tx, classification, config = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  if (!cfg.allowFailed && tx.err) {
+    return true;
+  }
+  if (classification.confidence < cfg.minConfidence) {
+    return true;
+  }
+  if (!classification.isRelevant) {
+    return true;
+  }
+  if (isDustTransaction(classification, cfg)) {
+    return true;
+  }
+  return false;
+}
+function isDustTransaction(classification, config) {
+  const { primaryAmount } = classification;
+  if (!primaryAmount) {
+    return false;
+  }
+  const { token, amountUi } = primaryAmount;
+  if (token.symbol === "SOL") {
+    return Math.abs(amountUi) < config.minSolAmount;
+  }
+  if (token.symbol === "USDC") {
+    return Math.abs(amountUi) < config.minTokenAmountUsd;
+  }
+  return Math.abs(amountUi) < config.minTokenAmountUsd;
+}
+function filterSpamTransactions(transactions, config) {
+  return transactions.filter(
+    ({ tx, classification }) => !isSpamTransaction(tx, classification, config)
+  );
+}
+
+// src/client.ts
+function createIndexer(options) {
+  const client = "client" in options ? options.client : createSolanaClient(options.rpcUrl, options.wsUrl);
+  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 } = options2;
+      const signatures = await fetchWalletSignatures(client.rpc, walletAddress, {
+        limit,
+        before,
+        until
+      });
+      if (signatures.length === 0) {
+        return [];
+      }
+      const signatureObjects = signatures.map(
+        (sig) => parseSignature(sig.signature)
+      );
+      const transactions = await fetchTransactionsBatch(
+        client.rpc,
+        signatureObjects
+      );
+      const classified = transactions.map((tx) => {
+        tx.protocol = detectProtocol(tx.programIds);
+        const legs = transactionToLegs(tx, walletAddress);
+        const classification = classifyTransaction(legs, walletAddress, tx);
+        return { tx, classification, legs };
+      });
+      if (filterSpam) {
+        return filterSpamTransactions(classified, spamConfig);
+      }
+      return classified;
+    },
+    async getTransaction(signature2, walletAddress) {
+      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 };
+    },
+    async getRawTransaction(signature2) {
+      return fetchTransaction(client.rpc, signature2);
+    }
+  };
+}
+
+// ../domain/src/tx/leg-validation.ts
+function validateLegsBalance(legs) {
+  const byToken = {};
+  for (const leg of legs) {
+    const token = leg.amount.token.symbol;
+    if (!byToken[token]) {
+      byToken[token] = { debits: 0, credits: 0 };
+    }
+    if (leg.side === "debit") {
+      byToken[token].debits += leg.amount.amountUi;
+    } else {
+      byToken[token].credits += leg.amount.amountUi;
+    }
+  }
+  const result = {};
+  let isBalanced = true;
+  for (const [token, amounts] of Object.entries(byToken)) {
+    const diff = Math.abs(amounts.debits - amounts.credits);
+    result[token] = { ...amounts, diff };
+    if (diff > 1e-6) {
+      isBalanced = false;
+    }
+  }
+  return { isBalanced, byToken: result };
+}
+function groupLegsByAccount(legs) {
+  const grouped = {};
+  for (const leg of legs) {
+    if (!grouped[leg.accountId]) {
+      grouped[leg.accountId] = [];
+    }
+    grouped[leg.accountId].push(leg);
+  }
+  return grouped;
+}
+function groupLegsByToken(legs) {
+  const grouped = {};
+  for (const leg of legs) {
+    const token = leg.amount.token.symbol;
+    if (!grouped[token]) {
+      grouped[token] = [];
+    }
+    grouped[token].push(leg);
+  }
+  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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map