Labeled Wallets & Programs

curl "https://api.vybenetwork.com/wallets/known-accounts?labels=CEX" \
  -H "X-API-Key: YOUR_API_KEY"

{
  "data": [
    {
      "ownerAddress": "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
      "name": "Binance Hot Wallet 1",
      "entityName": "Binance",
      "labels": ["CEX"],
      "entityId": 1
    },
    {
      "ownerAddress": "2AQdpHJ2JpcEgPiATUXjQxA8QmafFegfQwSLWSprPicm",
      "name": "Coinbase Commerce",
      "entityName": "Coinbase",
      "labels": ["CEX"],
      "entityId": 2
    },
    {
      "ownerAddress": "H8sMJSCQxfKiFTCfDR3DUMLPwcRbM61LGFJ8N4dK3WjS",
      "name": "Kraken Hot Wallet",
      "entityName": "Kraken",
      "labels": ["CEX"],
      "entityId": 3
    }
  ]
}

curl "https://api.vybenetwork.com/wallets/known-accounts?ownerAddress=9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM" \
  -H "X-API-Key: YOUR_API_KEY"

{
  "data": [
    {
      "ownerAddress": "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
      "name": "Binance Hot Wallet 1",
      "entityName": "Binance",
      "labels": ["CEX"],
      "entityId": 1
    }
  ]
}

async function monitorCEXFlows(tokenMint, minAmount = 10000) {
  // Step 1: Get all CEX wallets
  const cexResponse = await fetch(
    "https://api.vybenetwork.com/wallets/known-accounts?labels=CEX",
    { headers: { "X-API-Key": API_KEY } }
  );
  const { data: cexWallets } = await cexResponse.json();
  
  // Build lookup maps
  const cexAddresses = new Set(cexWallets.map(w => w.ownerAddress));
  const cexNames = Object.fromEntries(
    cexWallets.map(w => [w.ownerAddress, w.entityName])
  );
  
  // Step 2: Get recent transfers for this token
  const transfersResponse = await fetch(
    `https://api.vybenetwork.com/transfers?mintAddress=${tokenMint}&minAmount=${minAmount}&limit=100`,
    { headers: { "X-API-Key": API_KEY } }
  );
  const { data: transfers } = await transfersResponse.json();
  
  // Step 3: Categorize transfers
  const inflows = [];  // To CEX (potential sells)
  const outflows = []; // From CEX (potential buys)
  
  transfers.forEach(tx => {
    if (cexAddresses.has(tx.receiverAddress)) {
      inflows.push({
        ...tx,
        cex: cexNames[tx.receiverAddress],
        interpretation: "Potential sell incoming"
      });
    }
    if (cexAddresses.has(tx.senderAddress)) {
      outflows.push({
        ...tx,
        cex: cexNames[tx.senderAddress],
        interpretation: "Potential buy / withdrawal"
      });
    }
  });
  
  // Calculate totals
  const totalInflow = inflows.reduce((sum, tx) => sum + parseFloat(tx.amount), 0);
  const totalOutflow = outflows.reduce((sum, tx) => sum + parseFloat(tx.amount), 0);
  
  return {
    summary: {
      netFlow: totalOutflow - totalInflow > 0 ? "NET OUTFLOW (Bullish)" : "NET INFLOW (Bearish)",
      totalInflow: totalInflow.toLocaleString(),
      totalOutflow: totalOutflow.toLocaleString()
    },
    inflows,
    outflows
  };
}

async function trackSmartMoney() {
  // Get KOL and VC wallets
  const [kolResponse, vcResponse] = await Promise.all([
    fetch("https://api.vybenetwork.com/wallets/known-accounts?labels=KOL", {
      headers: { "X-API-Key": API_KEY }
    }),
    fetch("https://api.vybenetwork.com/wallets/known-accounts?labels=VC", {
      headers: { "X-API-Key": API_KEY }
    })
  ]);
  
  const kols = await kolResponse.json();
  const vcs = await vcResponse.json();
  const smartMoney = [...kols.data, ...vcs.data];
  
  // Get recent trades for each (limit to prevent rate limiting)
  const recentActivity = await Promise.all(
    smartMoney.slice(0, 20).map(async wallet => {
      const trades = await fetch(
        `https://api.vybenetwork.com/trades?authorityAddress=${wallet.ownerAddress}&limit=10`,
        { headers: { "X-API-Key": API_KEY } }
      ).then(r => r.json());
      
      return {
        name: wallet.name,
        entity: wallet.entityName,
        label: wallet.labels[0],
        wallet: wallet.ownerAddress,
        recentTrades: trades.data
      };
    })
  );
  
  // Find tokens multiple smart money wallets are buying
  const tokenBuys = {};
  recentActivity.forEach(wallet => {
    wallet.recentTrades?.forEach(trade => {
      if (trade.side === 'buy') {
        if (!tokenBuys[trade.mintAddress]) {
          tokenBuys[trade.mintAddress] = {
            symbol: trade.symbol,
            buyers: []
          };
        }
        tokenBuys[trade.mintAddress].buyers.push(wallet.name);
      }
    });
  });
  
  // Tokens bought by multiple smart money wallets = interesting
  const hotTokens = Object.entries(tokenBuys)
    .filter(([_, data]) => data.buyers.length > 1)
    .map(([mint, data]) => ({
      mint,
      symbol: data.symbol,
      buyerCount: data.buyers.length,
      buyers: data.buyers
    }))
    .sort((a, b) => b.buyerCount - a.buyerCount);
  
  return {
    trackedWallets: smartMoney.length,
    recentActivity,
    hotTokens
  };
}

async function enrichWalletData(walletAddress) {
  // Check if wallet is labeled
  const response = await fetch(
    `https://api.vybenetwork.com/wallets/known-accounts?ownerAddress=${walletAddress}`,
    { headers: { "X-API-Key": API_KEY } }
  );
  const { data } = await response.json();
  
  if (data.length > 0) {
    const label = data[0];
    return {
      address: walletAddress,
      isLabeled: true,
      name: label.name,
      entity: label.entityName,
      type: label.labels[0],
      displayName: `${label.name} (${label.entityName})`
    };
  }
  
  return {
    address: walletAddress,
    isLabeled: false,
    displayName: `${walletAddress.slice(0, 4)}...${walletAddress.slice(-4)}`
  };
}