@net-protocol/score 0.1.8 → 0.1.10

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { readContract } from 'viem/actions';
-import { getPublicClient, getBaseDataSuffix } from '@net-protocol/core';
+import { getPublicClient, getBaseDataSuffix, NetClient } from '@net-protocol/core';
 import { decodeAbiParameters, keccak256, encodePacked, getAddress, encodeAbiParameters, isAddressEqual } from 'viem';
-import { getStorageKeyBytes } from '@net-protocol/storage';
+import { getStorageKeyBytes, STORAGE_CONTRACT } from '@net-protocol/storage';
 
 // src/client/ScoreClient.ts
 
@@ -2482,6 +2482,44 @@ var user_upvote_default = [
   { type: "error", name: "ZeroUpvotes", inputs: [] }
 ];
 
+// src/abis/erc20-bulk-info-helper.json
+var erc20_bulk_info_helper_default = [
+  {
+    type: "function",
+    name: "getTokenInfo",
+    inputs: [
+      {
+        name: "tokenAddresses",
+        type: "address[]",
+        internalType: "address[]"
+      }
+    ],
+    outputs: [
+      {
+        name: "tokenInfos",
+        type: "tuple[]",
+        internalType: "struct ERC20BulkInfoHelper.TokenInfo[]",
+        components: [
+          { name: "name", type: "string", internalType: "string" },
+          { name: "symbol", type: "string", internalType: "string" },
+          { name: "decimals", type: "uint8", internalType: "uint8" },
+          {
+            name: "totalSupply",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "burnedTokens",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+
 // src/constants.ts
 var SCORE_CONTRACT = {
   address: "0x0000000fa09b022e5616e5a173b4b67fa2fbcf28",
@@ -2526,8 +2564,10 @@ var MULTI_VERSION_UNISWAP_POOL_INFO_RETRIEVER = {
 var WETH_BY_CHAIN = {
   8453: "0x4200000000000000000000000000000000000006",
   // Base (L2 predeploy)
-  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
   // Ethereum mainnet
+  4663: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73"
+  // Robinhood Chain (non-standard WETH; not the OP predeploy)
 };
 function getWethAddress(chainId) {
   const addr = WETH_BY_CHAIN[chainId];
@@ -2542,6 +2582,10 @@ var USER_UPVOTE_CONTRACT = {
   address: "0xa4bc2c63dd0157692fd5f409389e5032e37d8895",
   abi: user_upvote_default
 };
+var ERC20_BULK_INFO_HELPER_CONTRACT = {
+  address: "0x00000051809cbfacdf7d08ada813836822b880a2",
+  abi: erc20_bulk_info_helper_default
+};
 var encodeUpvoteKey = (tokenAddress) => {
   return `0x${BigInt(`0x${tokenAddress.slice(2)}`).toString(16).padStart(64, "0")}`;
 };
@@ -3207,41 +3251,6 @@ var UserUpvoteClient = class {
     return hash;
   }
 };
-var encodePoolKey = (poolKey) => {
-  if (!poolKey || !isValidPoolKey2(poolKey)) {
-    return "0x";
-  }
-  try {
-    return encodeAbiParameters(
-      [
-        {
-          type: "tuple",
-          components: [
-            { name: "currency0", type: "address" },
-            { name: "currency1", type: "address" },
-            { name: "fee", type: "uint24" },
-            { name: "tickSpacing", type: "int24" },
-            { name: "hooks", type: "address" }
-          ]
-        }
-      ],
-      [
-        {
-          currency0: poolKey.currency0,
-          currency1: poolKey.currency1,
-          fee: poolKey.fee,
-          tickSpacing: poolKey.tickSpacing,
-          hooks: poolKey.hooks
-        }
-      ]
-    );
-  } catch {
-    return "0x";
-  }
-};
-function isValidPoolKey2(poolKey) {
-  return poolKey.fee !== void 0 || poolKey.tickSpacing !== void 0 || poolKey.currency0 !== void 0;
-}
 var V3_V4_FEE_TIERS = [500, 3e3, 1e4, 12e3, 8388608];
 var V4_TICK_SPACINGS = [200];
 var V4_HOOKS = [
@@ -3595,6 +3604,433 @@ async function discoverTokenPool({
   return results[0] ?? null;
 }
 
-export { ALL_STRATEGY_ADDRESSES, DYNAMIC_SPLIT_STRATEGY, LEGACY_UPVOTE_V1_ADDRESS, LEGACY_UPVOTE_V2_ADDRESS, MULTI_VERSION_UNISWAP_BULK_POOL_FINDER, MULTI_VERSION_UNISWAP_POOL_INFO_RETRIEVER, NULL_ADDRESS, PURE_ALPHA_STRATEGY, SCORE_CONTRACT, SUPPORTED_SCORE_CHAINS, ScoreClient, UNIV234_POOLS_STRATEGY, UPVOTE_APP, UPVOTE_PRICE_ETH, UPVOTE_STORAGE_APP, USER_UPVOTE_CONTRACT, UserUpvoteClient, buildUserUpvote, buildUserUpvoteReceived, calculatePriceFromSqrtPriceX96, calculatePriceInUsdc, calculateUpvoteCost, calculateUserTokenBalance, decodeStrategyMetadata, decodeUpvoteMessage, decodeUpvoteStorageBlob, discoverPools, discoverTokenPool, encodePoolKey, encodeUpvoteKey, extractStrategyAddress, extractTokenAddressFromScoreKey, extractTokenAddressesFromMessages, getFeedContentKey, getScoreKey, getStorageScoreKey, getStorageUpvoteContext, getTokenScoreKey, getWethAddress, isDynamicSplitStrategy, isPureAlphaStrategy, isStrategyMessage, isTokenScoreKey, isUniv234PoolsStrategy, isUserUpvoteMessage, parseUserUpvoteMessage, selectStrategy, tokenAddressToUpvoteKeyString, validateUpvoteParams, validateUserUpvoteMessage };
+// src/ranking/getTokenRankings.ts
+var DEFAULT_MESSAGE_SCAN_WINDOW = 150;
+var DEFAULT_MAX_TOKENS = 50;
+var DEFAULT_MIN_UPVOTES = 500;
+var DEFAULT_MIN_MARKET_CAP = 4e4;
+var DEFAULT_RECENCY_HOURS = 48;
+var USDC_ADDRESS_BY_CHAIN = {
+  8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+};
+var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+async function getTokenRankings(options) {
+  const {
+    chainId,
+    sort = "trending",
+    maxTokens = DEFAULT_MAX_TOKENS,
+    messageScanWindow = DEFAULT_MESSAGE_SCAN_WINDOW,
+    rpcUrl
+  } = options;
+  validateChainSupported(chainId);
+  const minUpvotes = options.thresholds?.minUpvotes ?? DEFAULT_MIN_UPVOTES;
+  const minMarketCap = options.thresholds?.minMarketCap ?? DEFAULT_MIN_MARKET_CAP;
+  const recencyHours = options.thresholds?.recencyHours ?? DEFAULT_RECENCY_HOURS;
+  const nowSec = Date.now() / 1e3;
+  const rpcOverride = rpcUrl ? { rpcUrls: Array.isArray(rpcUrl) ? rpcUrl : [rpcUrl] } : void 0;
+  const publicClient = getPublicClient({ chainId, rpcUrl });
+  const netClient = new NetClient({ chainId, overrides: rpcOverride });
+  const messageGroups = await fetchUpvoteMessages({
+    netClient,
+    messageScanWindow
+  });
+  const storageBlobByKey = await fetchStrategyStorage({
+    publicClient,
+    messageGroups
+  });
+  const wethAddress = getWethAddress(chainId);
+  const { tokenAddresses, latestUpvoteTimestamps } = aggregateAndRank({
+    messageGroups,
+    storageBlobByKey,
+    sort,
+    maxTokens,
+    excludeAddresses: [wethAddress.toLowerCase()],
+    nowSec
+  });
+  if (tokenAddresses.length === 0) return [];
+  const usdcAddress = USDC_ADDRESS_BY_CHAIN[chainId];
+  const pairs = [
+    ...tokenAddresses.map((tokenAddress) => ({
+      tokenAddress,
+      baseTokenAddress: wethAddress
+    })),
+    ...usdcAddress ? [{ tokenAddress: wethAddress, baseTokenAddress: usdcAddress }] : []
+  ];
+  const [tokenInfos, pools, upvoteCounts] = await Promise.all([
+    fetchBulkErc20Info({ publicClient, addresses: tokenAddresses }),
+    discoverPools({ publicClient, pairs, chainId }),
+    fetchAggregateUpvotes({ publicClient, tokenAddresses })
+  ]);
+  if (tokenInfos.length !== tokenAddresses.length) {
+    throw new Error(
+      `ERC20 bulk info returned ${tokenInfos.length} entries for ${tokenAddresses.length} addresses`
+    );
+  }
+  if (upvoteCounts.length !== tokenAddresses.length) {
+    throw new Error(
+      `getUpvotesWithLegacy returned ${upvoteCounts.length} entries for ${tokenAddresses.length} addresses`
+    );
+  }
+  return composeAndFilter({
+    tokenAddresses,
+    tokenInfos,
+    pools,
+    upvoteCounts,
+    latestUpvoteTimestamps,
+    wethAddress,
+    usdcAddress,
+    sort,
+    maxTokens,
+    minUpvotes,
+    minMarketCap,
+    recencyHours,
+    nowSec
+  });
+}
+function validateChainSupported(chainId) {
+  if (!SUPPORTED_SCORE_CHAINS.includes(chainId)) {
+    throw new Error(
+      `getTokenRankings: chainId ${chainId} is not supported. Supported chains: ${SUPPORTED_SCORE_CHAINS.join(", ")}`
+    );
+  }
+}
+async function fetchUpvoteMessages({
+  netClient,
+  messageScanWindow
+}) {
+  const legacyFilter = {
+    appAddress: LEGACY_UPVOTE_V1_ADDRESS,
+    topic: "t"
+  };
+  const strategyFilters = [
+    UNIV234_POOLS_STRATEGY.address,
+    PURE_ALPHA_STRATEGY.address,
+    DYNAMIC_SPLIT_STRATEGY.address
+  ].map((stratAddr) => ({
+    appAddress: SCORE_CONTRACT.address,
+    topic: `t${stratAddr.toLowerCase()}`
+  }));
+  const [legacyCount, ...strategyCounts] = await Promise.all([
+    netClient.getMessageCount({ filter: legacyFilter }),
+    ...strategyFilters.map((filter) => netClient.getMessageCount({ filter }))
+  ]);
+  const sliceRange = (count) => ({
+    startIndex: Math.max(0, count - messageScanWindow),
+    endIndex: count
+  });
+  const [legacy, strategy1, strategy2, strategy3] = await Promise.all([
+    legacyCount > 0 ? netClient.getMessagesBatch({
+      filter: legacyFilter,
+      ...sliceRange(legacyCount)
+    }) : Promise.resolve([]),
+    ...strategyFilters.map(
+      (filter, i) => strategyCounts[i] > 0 ? netClient.getMessagesBatch({
+        filter,
+        ...sliceRange(strategyCounts[i])
+      }) : Promise.resolve([])
+    )
+  ]);
+  return { legacy, strategy1, strategy2, strategy3 };
+}
+async function fetchStrategyStorage({
+  publicClient,
+  messageGroups
+}) {
+  const seen = /* @__PURE__ */ new Set();
+  const keys = [];
+  for (const msg of [
+    ...messageGroups.strategy1,
+    ...messageGroups.strategy2,
+    ...messageGroups.strategy3
+  ]) {
+    if (!msg.data || !msg.data.startsWith("0x")) continue;
+    const key = msg.data;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    keys.push({ key, operator: SCORE_CONTRACT.address });
+  }
+  if (keys.length === 0) return /* @__PURE__ */ new Map();
+  const results = await readContract(publicClient, {
+    address: STORAGE_CONTRACT.address,
+    abi: STORAGE_CONTRACT.abi,
+    functionName: "bulkGet",
+    args: [keys]
+  });
+  return buildStorageMapFromBulkGetResults(results, keys);
+}
+function buildStorageMapFromBulkGetResults(results, keys) {
+  if (results.length !== keys.length) {
+    throw new Error(
+      `bulkGet returned ${results.length} entries for ${keys.length} keys`
+    );
+  }
+  const map = /* @__PURE__ */ new Map();
+  results.forEach((item, idx) => {
+    const value = item?.value;
+    if (value && value !== "0x") {
+      map.set(keys[idx].key, value);
+    }
+  });
+  return map;
+}
+function aggregateAndRank({
+  messageGroups,
+  storageBlobByKey,
+  sort,
+  maxTokens,
+  excludeAddresses = [],
+  nowSec
+}) {
+  const tokenUpvoteEvents = /* @__PURE__ */ new Map();
+  const excludeSet = new Set(excludeAddresses.map((a) => a.toLowerCase()));
+  const addEvent = (tokenAddress, timestamp, count) => {
+    if (!ADDRESS_RE.test(tokenAddress)) return;
+    const lower = tokenAddress.toLowerCase();
+    if (lower === NULL_ADDRESS || excludeSet.has(lower)) return;
+    if (!Number.isFinite(timestamp) || !Number.isFinite(count)) return;
+    const events = tokenUpvoteEvents.get(lower) ?? [];
+    events.push({ timestamp, count });
+    tokenUpvoteEvents.set(lower, events);
+  };
+  for (const msg of messageGroups.legacy) {
+    if (msg.topic !== "t" || !msg.text) continue;
+    let count = 1;
+    if (msg.data && msg.data.startsWith("0x")) {
+      try {
+        const [votes] = decodeAbiParameters(
+          [{ type: "uint256" }],
+          msg.data
+        );
+        count = Number(votes);
+      } catch {
+        count = 1;
+      }
+    }
+    addEvent(msg.text, Number(msg.timestamp), count);
+  }
+  for (const msg of [
+    ...messageGroups.strategy1,
+    ...messageGroups.strategy2,
+    ...messageGroups.strategy3
+  ]) {
+    if (!msg.topic.startsWith("t") || !msg.data || !msg.data.startsWith("0x")) {
+      continue;
+    }
+    const blob = storageBlobByKey.get(msg.data);
+    if (!blob) continue;
+    const decoded = decodeUpvoteStorageBlob(blob);
+    if (!decoded || !decoded.scoreKey) continue;
+    const tokenAddress = extractTokenAddressFromScoreKey(decoded.scoreKey);
+    if (!tokenAddress) continue;
+    addEvent(tokenAddress, Number(msg.timestamp), decoded.scoreDelta);
+  }
+  const timeWeight = (ts) => Math.exp(-0.1 * ((nowSec - ts) / 3600));
+  const latestUpvoteTimestamps = /* @__PURE__ */ new Map();
+  for (const [addr, events] of tokenUpvoteEvents) {
+    let latest = events[0].timestamp;
+    for (const e of events) if (e.timestamp > latest) latest = e.timestamp;
+    latestUpvoteTimestamps.set(addr, latest);
+  }
+  let ordered;
+  if (sort === "top") {
+    ordered = Array.from(tokenUpvoteEvents.keys());
+  } else {
+    const scores = /* @__PURE__ */ new Map();
+    for (const [addr, events] of tokenUpvoteEvents) {
+      if (sort === "recent") {
+        scores.set(addr, latestUpvoteTimestamps.get(addr) ?? 0);
+      } else {
+        const score = events.reduce(
+          (total, e) => total + e.count * timeWeight(e.timestamp),
+          0
+        );
+        scores.set(addr, score);
+      }
+    }
+    ordered = Array.from(scores.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([address]) => address);
+  }
+  const fetchLimit = Math.max(maxTokens * 3, 30);
+  return {
+    tokenAddresses: ordered.slice(0, fetchLimit),
+    latestUpvoteTimestamps
+  };
+}
+async function fetchBulkErc20Info({
+  publicClient,
+  addresses
+}) {
+  if (addresses.length === 0) return [];
+  try {
+    const data = await readContract(publicClient, {
+      address: ERC20_BULK_INFO_HELPER_CONTRACT.address,
+      abi: ERC20_BULK_INFO_HELPER_CONTRACT.abi,
+      functionName: "getTokenInfo",
+      args: [addresses]
+    });
+    if (Array.isArray(data) && data.length === addresses.length) return data;
+  } catch {
+  }
+  const results = await Promise.all(
+    addresses.map(async (addr) => {
+      try {
+        const data = await readContract(publicClient, {
+          address: ERC20_BULK_INFO_HELPER_CONTRACT.address,
+          abi: ERC20_BULK_INFO_HELPER_CONTRACT.abi,
+          functionName: "getTokenInfo",
+          args: [[addr]]
+        });
+        if (Array.isArray(data) && data[0]) return data[0];
+      } catch {
+      }
+      return {
+        name: "",
+        symbol: "",
+        decimals: 0,
+        totalSupply: 0n,
+        burnedTokens: 0n
+      };
+    })
+  );
+  return results;
+}
+async function fetchAggregateUpvotes({
+  publicClient,
+  tokenAddresses
+}) {
+  if (tokenAddresses.length === 0) return [];
+  const data = await readContract(publicClient, {
+    address: UPVOTE_APP.address,
+    abi: UPVOTE_APP.abi,
+    functionName: "getUpvotesWithLegacy",
+    args: [
+      tokenAddresses.map((addr) => encodeUpvoteKey(addr)),
+      ALL_STRATEGY_ADDRESSES
+    ]
+  });
+  if (!Array.isArray(data)) {
+    throw new Error(
+      "getUpvotesWithLegacy returned non-array; contract or RPC misbehaving"
+    );
+  }
+  return data.map(Number);
+}
+function composeAndFilter({
+  tokenAddresses,
+  tokenInfos,
+  pools,
+  upvoteCounts,
+  latestUpvoteTimestamps,
+  wethAddress,
+  usdcAddress,
+  sort,
+  maxTokens,
+  minUpvotes,
+  minMarketCap,
+  recencyHours,
+  nowSec
+}) {
+  const wethLower = wethAddress.toLowerCase();
+  const usdcLower = usdcAddress?.toLowerCase();
+  let ethPriceInUsdc;
+  if (usdcLower) {
+    const wethUsdcPool = pools.find(
+      (p) => p.tokenAddress.toLowerCase() === wethLower && p.baseTokenAddress.toLowerCase() === usdcLower
+    );
+    const usdcWethPool = pools.find(
+      (p) => p.tokenAddress.toLowerCase() === usdcLower && p.baseTokenAddress.toLowerCase() === wethLower
+    );
+    if (wethUsdcPool?.price) {
+      ethPriceInUsdc = wethUsdcPool.price;
+    } else if (usdcWethPool?.price) {
+      ethPriceInUsdc = 1 / usdcWethPool.price;
+    }
+  }
+  const tokenAddressToPool = /* @__PURE__ */ new Map();
+  for (const pool of pools) {
+    if (pool.baseTokenAddress.toLowerCase() === wethLower) {
+      tokenAddressToPool.set(pool.tokenAddress.toLowerCase(), pool);
+    }
+  }
+  const composed = tokenAddresses.map((address, i) => {
+    const info = tokenInfos[i];
+    const pool = tokenAddressToPool.get(address.toLowerCase());
+    const priceInUsdc = pool?.price && ethPriceInUsdc ? pool.price * ethPriceInUsdc : void 0;
+    let circulating;
+    if (info?.totalSupply) {
+      const burned = info.burnedTokens ?? 0n;
+      const c = info.totalSupply - burned;
+      circulating = c > 0n ? c : 0n;
+    }
+    const decimals = info?.decimals || void 0;
+    const fdv = circulating != null && decimals != null && priceInUsdc != null ? Number(circulating) / 10 ** decimals * priceInUsdc : void 0;
+    return {
+      address,
+      name: info?.name || void 0,
+      symbol: info?.symbol || void 0,
+      decimals,
+      fdv,
+      priceInUsdc,
+      upvotes: upvoteCounts[i] ?? 0,
+      latestUpvoteTimestamp: latestUpvoteTimestamps.get(address.toLowerCase()) ?? 0
+    };
+  });
+  const valid = composed.filter((t) => {
+    if (!t.name?.trim() || !t.symbol?.trim()) return false;
+    const belowFloor = t.fdv == null || t.fdv < minMarketCap;
+    if (belowFloor) {
+      const hoursSince = (nowSec - t.latestUpvoteTimestamp) / 3600;
+      if (hoursSince > recencyHours) return false;
+    }
+    return true;
+  });
+  let sorted;
+  if (sort === "top") {
+    sorted = [...valid].sort((a, b) => b.upvotes - a.upvotes);
+  } else {
+    const byAddr = new Map(valid.map((t) => [t.address.toLowerCase(), t]));
+    sorted = tokenAddresses.map((addr) => byAddr.get(addr.toLowerCase())).filter((t) => t != null);
+  }
+  const qualifies = (t) => t.upvotes >= minUpvotes || t.fdv != null && t.fdv >= minMarketCap;
+  const top = sorted.filter(qualifies);
+  const rest = sorted.filter((t) => !qualifies(t));
+  return [...top, ...rest].slice(0, maxTokens);
+}
+var encodePoolKey = (poolKey) => {
+  if (!poolKey || !isValidPoolKey2(poolKey)) {
+    return "0x";
+  }
+  try {
+    return encodeAbiParameters(
+      [
+        {
+          type: "tuple",
+          components: [
+            { name: "currency0", type: "address" },
+            { name: "currency1", type: "address" },
+            { name: "fee", type: "uint24" },
+            { name: "tickSpacing", type: "int24" },
+            { name: "hooks", type: "address" }
+          ]
+        }
+      ],
+      [
+        {
+          currency0: poolKey.currency0,
+          currency1: poolKey.currency1,
+          fee: poolKey.fee,
+          tickSpacing: poolKey.tickSpacing,
+          hooks: poolKey.hooks
+        }
+      ]
+    );
+  } catch {
+    return "0x";
+  }
+};
+function isValidPoolKey2(poolKey) {
+  return poolKey.fee !== void 0 || poolKey.tickSpacing !== void 0 || poolKey.currency0 !== void 0;
+}
+
+export { ALL_STRATEGY_ADDRESSES, DYNAMIC_SPLIT_STRATEGY, ERC20_BULK_INFO_HELPER_CONTRACT, LEGACY_UPVOTE_V1_ADDRESS, LEGACY_UPVOTE_V2_ADDRESS, MULTI_VERSION_UNISWAP_BULK_POOL_FINDER, MULTI_VERSION_UNISWAP_POOL_INFO_RETRIEVER, NULL_ADDRESS, PURE_ALPHA_STRATEGY, SCORE_CONTRACT, SUPPORTED_SCORE_CHAINS, ScoreClient, UNIV234_POOLS_STRATEGY, UPVOTE_APP, UPVOTE_PRICE_ETH, UPVOTE_STORAGE_APP, USER_UPVOTE_CONTRACT, UserUpvoteClient, buildUserUpvote, buildUserUpvoteReceived, calculatePriceFromSqrtPriceX96, calculatePriceInUsdc, calculateUpvoteCost, calculateUserTokenBalance, decodeStrategyMetadata, decodeUpvoteMessage, decodeUpvoteStorageBlob, discoverPools, discoverTokenPool, encodePoolKey, encodeUpvoteKey, extractStrategyAddress, extractTokenAddressFromScoreKey, extractTokenAddressesFromMessages, getFeedContentKey, getScoreKey, getStorageScoreKey, getStorageUpvoteContext, getTokenRankings, getTokenScoreKey, getWethAddress, isDynamicSplitStrategy, isPureAlphaStrategy, isStrategyMessage, isTokenScoreKey, isUniv234PoolsStrategy, isUserUpvoteMessage, parseUserUpvoteMessage, selectStrategy, tokenAddressToUpvoteKeyString, validateUpvoteParams, validateUserUpvoteMessage };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map