levr-sdk 0.4.0 → 0.5.0-alpha.10

package/dist/esm/{project.js → src/project.js}

@@ -1,10 +1,13 @@
 import { erc20Abi, zeroAddress } from "viem";
-import { IClankerFeeLocker, IClankerLpLockerFeeConversion, IClankerToken, LevrFactory_v1, LevrGovernor_v1, LevrStaking_v1, } from "./abis/index.js";
+import { IClankerFeeLocker, IClankerLpLockerFeeConversion, LevrFactory_v1, LevrStaking_v1, } from "./abis/index.js";
 import { formatBalanceWithUsd } from "./balance.js";
 import { GET_FACTORY_ADDRESS, GET_FEE_LOCKER_ADDRESS, GET_LP_LOCKER_ADDRESS, WETH, } from "./constants/index.js";
 import { getFeeReceiverContracts, getFeeSplitterDynamicContracts, getFeeSplitterStaticContracts, parseFeeReceivers, parseFeeSplitterDynamic, parseFeeSplitterStatic, } from "./fee-receivers.js";
 import { getFeeSplitter } from "./fee-splitter.js";
-import { getUsdPrice, getWethUsdPrice } from "./usd-price.js";
+import { query } from "./graphql/index.js";
+import { getLevrProjectByIdFields } from "./graphql/fields/project.js";
+import { getPairedTokenUsdPrice, getUsdPrice } from "./usd-price.js";
+import { isWETH } from "./util.js";
 async function fetchFeePreferences({ publicClient, chainId, clankerToken, slotCount, }) {
     if (!slotCount)
         return undefined;
@@ -35,52 +38,71 @@ async function fetchFeePreferences({ publicClient, chainId, clankerToken, slotCo
     }
 }
 // ---
-// Contract Getters
-function getTokenContracts(clankerToken) {
-    return [
-        {
-            address: clankerToken,
-            abi: erc20Abi,
-            functionName: "decimals",
-        },
-        {
-            address: clankerToken,
-            abi: erc20Abi,
-            functionName: "name",
-        },
-        {
-            address: clankerToken,
-            abi: erc20Abi,
-            functionName: "symbol",
-        },
-        {
-            address: clankerToken,
-            abi: erc20Abi,
-            functionName: "totalSupply",
-        },
-        {
-            address: clankerToken,
-            abi: IClankerToken,
-            functionName: "allData",
-        },
-    ];
+// Paired Token Resolution
+/**
+ * Resolves paired token info from pool key and indexed data.
+ * Handles WETH/WBNB detection and fallback symbol resolution.
+ */
+function resolvePairedToken(poolKey, clankerToken, clankerSymbol, v4Pool, chainId) {
+    // Get paired token address from pool key (case-insensitive)
+    const isCurrency0Clanker = poolKey.currency0.toLowerCase() === clankerToken.toLowerCase();
+    const pairedTokenAddress = isCurrency0Clanker ? poolKey.currency1 : poolKey.currency0;
+    // Check if paired token is native (WETH/WBNB)
+    const wethInfo = WETH(chainId);
+    const isNativeByAddress = isWETH(pairedTokenAddress, chainId);
+    // Find paired token from indexed v4Pool data
+    const indexedPairedToken = findIndexedPairedToken(v4Pool, pairedTokenAddress);
+    // Also check if native by symbol (fallback when address doesn't match)
+    const isNativeBySymbol = wethInfo && indexedPairedToken?.symbol === wethInfo.symbol;
+    // Return native token info if WETH/WBNB
+    if ((isNativeByAddress || isNativeBySymbol) && wethInfo) {
+        return {
+            address: wethInfo.address,
+            symbol: wethInfo.symbol,
+            decimals: wethInfo.decimals,
+            isNative: true,
+        };
+    }
+    // Return non-native paired token info
+    const symbol = resolveSymbol(indexedPairedToken?.symbol);
+    return {
+        address: pairedTokenAddress,
+        symbol,
+        decimals: indexedPairedToken?.decimals ?? 18,
+        isNative: false,
+    };
 }
-function getFactoryContracts(factoryAddress, clankerToken) {
-    return [
-        {
-            address: factoryAddress,
-            abi: LevrFactory_v1,
-            functionName: "getProject",
-            args: [clankerToken],
-        },
-        {
-            address: factoryAddress,
-            abi: LevrFactory_v1,
-            functionName: "trustedForwarder",
-        },
-    ];
+/**
+ * Finds the paired token from indexed v4Pool data by address matching.
+ */
+function findIndexedPairedToken(v4Pool, pairedTokenAddress) {
+    if (!v4Pool)
+        return null;
+    const { token0, token1 } = v4Pool;
+    const targetAddress = pairedTokenAddress.toLowerCase();
+    // Match by address
+    if (token0?.address?.toLowerCase() === targetAddress)
+        return token0;
+    if (token1?.address?.toLowerCase() === targetAddress)
+        return token1;
+    return null;
 }
-function getTreasuryContracts(clankerToken, treasury, staking, wethAddress) {
+/**
+ * Resolves symbol for paired token.
+ * Returns the symbol if available, otherwise falls back to 'PAIRED'.
+ *
+ * Note: We no longer check against clankerSymbol because tokens can legitimately
+ * have the same symbol (e.g., a clanker named "U" paired with U stablecoin).
+ * Address matching in findIndexedPairedToken ensures we get the correct token.
+ */
+function resolveSymbol(symbol) {
+    if (symbol)
+        return symbol;
+    return "PAIRED";
+}
+// ---
+// Contract Getters
+function getTreasuryContracts(clankerToken, treasury, staking, pairedTokenAddress) {
     const contracts = [
         {
             address: clankerToken,
@@ -101,9 +123,9 @@ function getTreasuryContracts(clankerToken, treasury, staking, wethAddress) {
             args: [clankerToken],
         },
     ];
-    if (wethAddress) {
+    if (pairedTokenAddress) {
         contracts.push({
-            address: wethAddress,
+            address: pairedTokenAddress,
             abi: erc20Abi,
             functionName: "balanceOf",
             args: [staking],
@@ -111,28 +133,7 @@ function getTreasuryContracts(clankerToken, treasury, staking, wethAddress) {
     }
     return contracts;
 }
-function getGovernanceContracts(governor) {
-    return [
-        {
-            address: governor,
-            abi: LevrGovernor_v1,
-            functionName: "currentCycleId",
-        },
-        {
-            address: governor,
-            abi: LevrGovernor_v1,
-            functionName: "activeProposalCount",
-            args: [0], // boost type
-        },
-        {
-            address: governor,
-            abi: LevrGovernor_v1,
-            functionName: "activeProposalCount",
-            args: [1], // transfer type
-        },
-    ];
-}
-function getStakingContracts(staking, clankerToken, wethAddress) {
+function getStakingContracts(staking, clankerToken, pairedTokenAddress) {
     const baseContracts = [
         {
             address: staking,
@@ -163,31 +164,31 @@ function getStakingContracts(staking, clankerToken, wethAddress) {
             args: [clankerToken],
         },
     ];
-    const wethContracts = wethAddress
+    const pairedContracts = pairedTokenAddress
         ? [
             {
                 address: staking,
                 abi: LevrStaking_v1,
                 functionName: "outstandingRewards",
-                args: [wethAddress],
+                args: [pairedTokenAddress],
             },
             {
                 address: staking,
                 abi: LevrStaking_v1,
                 functionName: "rewardRatePerSecond",
-                args: [wethAddress],
+                args: [pairedTokenAddress],
             },
             {
                 address: staking,
                 abi: LevrStaking_v1,
                 functionName: "getTokenStreamInfo",
-                args: [wethAddress],
+                args: [pairedTokenAddress],
             },
         ]
         : [];
-    return [...baseContracts, ...wethContracts];
+    return [...baseContracts, ...pairedContracts];
 }
-function getPendingFeesContracts(feeLockerAddress, feeRecipient, clankerToken, wethAddress) {
+function getPendingFeesContracts(feeLockerAddress, feeRecipient, clankerToken, pairedTokenAddress) {
     const baseContracts = [
         {
             address: feeLockerAddress,
@@ -196,64 +197,26 @@ function getPendingFeesContracts(feeLockerAddress, feeRecipient, clankerToken, w
             args: [feeRecipient, clankerToken],
         },
     ];
-    const wethContracts = wethAddress
+    const pairedContracts = pairedTokenAddress
         ? [
             {
                 address: feeLockerAddress,
                 abi: IClankerFeeLocker,
                 functionName: "availableFees",
-                args: [feeRecipient, wethAddress],
+                args: [feeRecipient, pairedTokenAddress],
             },
         ]
         : [];
-    return [...baseContracts, ...wethContracts];
+    return [...baseContracts, ...pairedContracts];
 }
 // ---
 // Parsers
-function parseTokenData(results, clankerToken) {
-    const [decimals, name, symbol, totalSupply, allData] = results;
-    // Extract allData fields: [originalAdmin, admin, image, metadata, context]
-    const [originalAdmin, admin, image, metadata, context] = allData.result;
-    // Parse metadata JSON
-    let parsedMetadata = null;
-    if (metadata && typeof metadata === "string") {
-        try {
-            parsedMetadata = JSON.parse(metadata);
-        }
-        catch {
-            // If parsing fails, leave as null
-        }
-    }
-    return {
-        address: clankerToken,
-        decimals: decimals.result,
-        name: name.result,
-        symbol: symbol.result,
-        totalSupply: totalSupply.result,
-        metadata: parsedMetadata,
-        imageUrl: image || undefined,
-        originalAdmin,
-        admin,
-        context,
-    };
-}
-function parseFactoryData(results) {
-    const [projectContracts, forwarder] = results;
-    const { treasury, governor, staking, stakedToken } = projectContracts.result;
-    return {
-        treasury,
-        governor,
-        staking,
-        stakedToken,
-        forwarder: forwarder.result,
-    };
-}
-function parseTreasuryStats(results, tokenDecimals, totalSupply, tokenUsdPrice, wethUsdPrice) {
-    const [treasuryBalance, stakingBalance, escrowBalance, stakingWethBalance] = results;
+function parseTreasuryStats(results, tokenDecimals, totalSupply, tokenUsdPrice, pairedTokenUsdPrice, pairedTokenDecimals = 18) {
+    const [treasuryBalance, stakingBalance, escrowBalance, stakingPairedBalance] = results;
     const treasuryBalanceRaw = treasuryBalance.result;
     const stakingBalanceRaw = stakingBalance.result;
     const escrowBalanceRaw = escrowBalance.result;
-    const stakingWethBalanceRaw = stakingWethBalance ? stakingWethBalance.result : null;
+    const stakingPairedBalanceRaw = stakingPairedBalance ? stakingPairedBalance.result : null;
     // Total allocated = treasury + staking balances (protocol-controlled tokens)
     const totalAllocatedRaw = treasuryBalanceRaw + stakingBalanceRaw;
     // Utilization = (total allocated / total supply) * 100
@@ -265,22 +228,12 @@ function parseTreasuryStats(results, tokenDecimals, totalSupply, tokenUsdPrice,
         utilization,
         stakingContractBalance: formatBalanceWithUsd(stakingBalanceRaw, tokenDecimals, tokenUsdPrice),
         escrowBalance: formatBalanceWithUsd(escrowBalanceRaw, tokenDecimals, tokenUsdPrice),
-        stakingContractWethBalance: stakingWethBalanceRaw
-            ? formatBalanceWithUsd(stakingWethBalanceRaw, 18, wethUsdPrice ?? null)
+        stakingContractPairedBalance: stakingPairedBalanceRaw
+            ? formatBalanceWithUsd(stakingPairedBalanceRaw, pairedTokenDecimals, pairedTokenUsdPrice ?? null)
             : undefined,
     };
 }
-function parseGovernanceData(results) {
-    const [currentCycleId, boostCount, transferCount] = results;
-    return {
-        currentCycleId: currentCycleId.result === 0n ? 1n : currentCycleId.result,
-        activeProposalCount: {
-            boost: boostCount.result,
-            transfer: transferCount.result,
-        },
-    };
-}
-function parseStakingStats(results, pendingFeesResults, tokenDecimals, tokenUsdPrice, wethUsdPrice, blockTimestamp, pricing, feeSplitterPending) {
+function parseStakingStats(results, pendingFeesResults, tokenDecimals, tokenUsdPrice, pairedTokenUsdPrice, pairedTokenDecimals = 18, blockTimestamp, pricing, feeSplitterPending) {
     const totalStakedRaw = results[0].result;
     const aprBpsRaw = results[1].result;
     const outstandingRewardsTokenAvailable = results[2].result; // Now returns only available
@@ -289,73 +242,74 @@ function parseStakingStats(results, pendingFeesResults, tokenDecimals, tokenUsdP
     const streamInfoRaw = results[4].result;
     const tokenStreamStartRaw = streamInfoRaw[0];
     const tokenStreamEndRaw = streamInfoRaw[1];
-    // Check if WETH data is present
-    const hasWethData = results.length > 5;
-    const outstandingRewardsWethAvailable = hasWethData && results[5] ? results[5].result : null;
-    const wethRewardRateRaw = hasWethData && results[6] ? results[6].result : null;
+    // Check if pairedToken data is present
+    const hasPairedTokenData = results.length > 5;
+    const outstandingRewardsPairedAvailable = hasPairedTokenData && results[5] ? results[5].result : null;
+    const pairedTokenRewardRateRaw = hasPairedTokenData && results[6] ? results[6].result : null;
     // Check if token stream is currently active
     const isTokenStreamActive = tokenStreamStartRaw <= blockTimestamp && blockTimestamp <= tokenStreamEndRaw;
-    // Check if WETH stream is active (if available) and get longest active stream window
-    let isWethStreamActive = false;
-    let wethStreamStartRaw = 0n;
-    let wethStreamEndRaw = 0n;
-    if (hasWethData && results[7]) {
-        const wethStreamInfoRaw = results[7].result;
-        wethStreamStartRaw = wethStreamInfoRaw[0];
-        wethStreamEndRaw = wethStreamInfoRaw[1];
-        isWethStreamActive = wethStreamStartRaw <= blockTimestamp && blockTimestamp <= wethStreamEndRaw;
+    // Check if pairedToken stream is active (if available) and get longest active stream window
+    let isPairedTokenStreamActive = false;
+    let pairedTokenStreamStartRaw = 0n;
+    let pairedTokenStreamEndRaw = 0n;
+    if (hasPairedTokenData && results[7]) {
+        const pairedTokenStreamInfoRaw = results[7].result;
+        pairedTokenStreamStartRaw = pairedTokenStreamInfoRaw[0];
+        pairedTokenStreamEndRaw = pairedTokenStreamInfoRaw[1];
+        isPairedTokenStreamActive =
+            pairedTokenStreamStartRaw <= blockTimestamp && blockTimestamp <= pairedTokenStreamEndRaw;
     }
-    // Stream is active if either token or WETH reward stream is active
-    const isStreamActive = isTokenStreamActive || isWethStreamActive;
+    // Stream is active if either token or pairedToken reward stream is active
+    const isStreamActive = isTokenStreamActive || isPairedTokenStreamActive;
     // Determine which stream window to display
     let displayStreamStartRaw = tokenStreamStartRaw;
     let displayStreamEndRaw = tokenStreamEndRaw;
     const tokenStreamDuration = tokenStreamEndRaw > tokenStreamStartRaw ? tokenStreamEndRaw - tokenStreamStartRaw : 0n;
-    const wethStreamDuration = wethStreamStartRaw > 0n && wethStreamEndRaw > wethStreamStartRaw
-        ? wethStreamEndRaw - wethStreamStartRaw
+    const pairedTokenStreamDuration = pairedTokenStreamStartRaw > 0n && pairedTokenStreamEndRaw > pairedTokenStreamStartRaw
+        ? pairedTokenStreamEndRaw - pairedTokenStreamStartRaw
         : 0n;
-    if (isTokenStreamActive && isWethStreamActive) {
+    if (isTokenStreamActive && isPairedTokenStreamActive) {
         // When both streams are active, display the one that ends last
         displayStreamStartRaw =
-            wethStreamEndRaw > tokenStreamEndRaw ? wethStreamStartRaw : tokenStreamStartRaw;
+            pairedTokenStreamEndRaw > tokenStreamEndRaw ? pairedTokenStreamStartRaw : tokenStreamStartRaw;
         displayStreamEndRaw =
-            wethStreamEndRaw > tokenStreamEndRaw ? wethStreamEndRaw : tokenStreamEndRaw;
+            pairedTokenStreamEndRaw > tokenStreamEndRaw ? pairedTokenStreamEndRaw : tokenStreamEndRaw;
     }
     else if (isTokenStreamActive) {
         displayStreamStartRaw = tokenStreamStartRaw;
         displayStreamEndRaw = tokenStreamEndRaw;
     }
-    else if (isWethStreamActive) {
-        displayStreamStartRaw = wethStreamStartRaw;
-        displayStreamEndRaw = wethStreamEndRaw;
+    else if (isPairedTokenStreamActive) {
+        displayStreamStartRaw = pairedTokenStreamStartRaw;
+        displayStreamEndRaw = pairedTokenStreamEndRaw;
     }
-    else if (wethStreamDuration > tokenStreamDuration) {
+    else if (pairedTokenStreamDuration > tokenStreamDuration) {
         // No active streams: keep prior behaviour of showing the longer window
-        displayStreamStartRaw = wethStreamStartRaw;
-        displayStreamEndRaw = wethStreamEndRaw;
+        displayStreamStartRaw = pairedTokenStreamStartRaw;
+        displayStreamEndRaw = pairedTokenStreamEndRaw;
     }
     // Get pending fees from ClankerFeeLocker (staking recipient)
     const stakingPendingToken = pendingFeesResults?.[0]?.result ?? 0n;
-    const stakingPendingWeth = pendingFeesResults?.[1]?.result ?? 0n;
-    // Calculate WETH APR if available
-    let wethApr = null;
-    if (wethRewardRateRaw !== null &&
-        wethRewardRateRaw !== undefined &&
+    const stakingPendingPaired = pendingFeesResults?.[1]?.result ?? 0n;
+    // Calculate pairedToken APR if available
+    let pairedTokenApr = null;
+    if (pairedTokenRewardRateRaw !== null &&
+        pairedTokenRewardRateRaw !== undefined &&
         pricing &&
         totalStakedRaw > 0n) {
-        const wethUsd = parseFloat(pricing.wethUsd);
+        const pairedTokenUsd = parseFloat(pricing.pairedTokenUsd);
         const tokenUsd = parseFloat(pricing.tokenUsd);
         if (tokenUsd > 0) {
-            const wethPriceInTokens = wethUsd / tokenUsd;
+            const pairedTokenPriceInTokens = pairedTokenUsd / tokenUsd;
             const secondsPerYear = BigInt(365 * 24 * 60 * 60);
-            const annualWethRewards = wethRewardRateRaw * secondsPerYear;
+            const annualPairedRewards = pairedTokenRewardRateRaw * secondsPerYear;
             const priceScaleFactor = BigInt(1000000000000000000);
-            const wethPriceScaled = BigInt(Math.floor(wethPriceInTokens * Number(priceScaleFactor)));
-            const annualRewardsInUnderlying = (annualWethRewards * wethPriceScaled) / priceScaleFactor;
-            const aprBpsWeth = totalStakedRaw > 0n ? (annualRewardsInUnderlying * 10000n) / totalStakedRaw : 0n;
-            wethApr = {
-                raw: aprBpsWeth,
-                percentage: Number(aprBpsWeth) / 100,
+            const pairedTokenPriceScaled = BigInt(Math.floor(pairedTokenPriceInTokens * Number(priceScaleFactor)));
+            const annualRewardsInUnderlying = (annualPairedRewards * pairedTokenPriceScaled) / priceScaleFactor;
+            const aprBpsPairedToken = totalStakedRaw > 0n ? (annualRewardsInUnderlying * 10000n) / totalStakedRaw : 0n;
+            pairedTokenApr = {
+                raw: aprBpsPairedToken,
+                percentage: Number(aprBpsPairedToken) / 100,
             };
         }
     }
@@ -368,7 +322,7 @@ function parseStakingStats(results, pendingFeesResults, tokenDecimals, tokenUsdP
     // When fee splitter is NOT active: stakingPendingToken = staking's pending from ClankerFeeLocker
     // Note: feeSplitterPending is now local balance only (not from ClankerFeeLocker), so we don't add it
     const tokenPendingTotal = stakingPendingToken; // Already queried for correct recipient
-    const wethPendingTotal = stakingPendingWeth; // Already queried for correct recipient
+    const pairedTokenPendingTotal = stakingPendingPaired; // Already queried for correct recipient
     return {
         totalStaked: formatBalanceWithUsd(totalStakedRaw, tokenDecimals, tokenUsdPrice),
         apr: {
@@ -376,24 +330,24 @@ function parseStakingStats(results, pendingFeesResults, tokenDecimals, tokenUsdP
                 raw: aprBpsRaw,
                 percentage: Number(aprBpsRaw) / 100,
             },
-            weth: wethApr,
+            pairedToken: pairedTokenApr,
         },
         outstandingRewards: {
             staking: {
                 available: formatBalanceWithUsd(outstandingRewardsTokenAvailable, tokenDecimals, tokenUsdPrice),
                 pending: formatBalanceWithUsd(tokenPendingTotal, tokenDecimals, tokenUsdPrice),
             },
-            weth: outstandingRewardsWethAvailable !== null
+            pairedToken: outstandingRewardsPairedAvailable !== null
                 ? {
-                    available: formatBalanceWithUsd(outstandingRewardsWethAvailable, 18, wethUsdPrice),
-                    pending: formatBalanceWithUsd(wethPendingTotal, 18, wethUsdPrice),
+                    available: formatBalanceWithUsd(outstandingRewardsPairedAvailable, pairedTokenDecimals, pairedTokenUsdPrice),
+                    pending: formatBalanceWithUsd(pairedTokenPendingTotal, pairedTokenDecimals, pairedTokenUsdPrice),
                 }
                 : null,
         },
         rewardRates: {
             token: formatBalanceWithUsd(tokenRewardRateRaw, tokenDecimals, tokenUsdPrice),
-            weth: wethRewardRateRaw !== null && wethRewardRateRaw !== undefined
-                ? formatBalanceWithUsd(wethRewardRateRaw, 18, wethUsdPrice)
+            pairedToken: pairedTokenRewardRateRaw !== null && pairedTokenRewardRateRaw !== undefined
+                ? formatBalanceWithUsd(pairedTokenRewardRateRaw, pairedTokenDecimals, pairedTokenUsdPrice)
                 : null,
         },
         streamParams: {
@@ -404,80 +358,32 @@ function parseStakingStats(results, pendingFeesResults, tokenDecimals, tokenUsdP
         },
     };
 }
+// ============================================================================
+// Indexed Project Data
+// ============================================================================
 /**
- * Get multiple projects data using factory's paginated getProjects()
+ * Fetch project data from the indexer
+ * Returns null if the project is not found in the indexer
  */
-export async function getProjects({ publicClient, offset = 0, limit = 50, }) {
-    if (Object.values({ publicClient }).some((value) => !value)) {
-        throw new Error("Invalid projects params");
+export async function getIndexedProject(chainId, clankerToken) {
+    try {
+        const fields = getLevrProjectByIdFields(chainId, clankerToken);
+        const result = await query(fields);
+        // Cast to our explicit type since the generated types can be complex
+        return result.LevrProject_by_pk ?? null;
     }
-    const chainId = publicClient.chain?.id;
-    if (!chainId)
-        throw new Error("Chain ID not found on public client");
-    const factoryAddress = GET_FACTORY_ADDRESS(chainId);
-    if (!factoryAddress)
-        throw new Error("Factory address not found");
-    // Get projects from factory using paginated view function
-    const [projectsData, total] = await publicClient.readContract({
-        address: factoryAddress,
-        abi: LevrFactory_v1,
-        functionName: "getProjects",
-        args: [BigInt(offset), BigInt(limit)],
-    });
-    if (projectsData.length === 0) {
-        return {
-            projects: [],
-            total: Number(total),
-        };
+    catch {
+        return null;
     }
-    // Track contracts and their mapping per project for correct result parsing
-    const contractsPerProject = [];
-    // Build contract calls for all projects (token data + treasury balances)
-    const contracts = projectsData.flatMap((projectInfo) => {
-        const tokenContracts = getTokenContracts(projectInfo.clankerToken);
-        const treasuryContracts = getTreasuryContracts(projectInfo.clankerToken, projectInfo.project.treasury, projectInfo.project.staking, undefined);
-        contractsPerProject.push({
-            tokenCount: tokenContracts.length,
-            treasuryCount: treasuryContracts.length,
-        });
-        return [...tokenContracts, ...treasuryContracts];
-    });
-    const results = await publicClient.multicall({ contracts });
-    // Parse results into Project objects
-    const projects = [];
-    let currentOffset = 0;
-    for (let i = 0; i < projectsData.length; i++) {
-        const projectInfo = projectsData[i];
-        const tokenCount = contractsPerProject[i].tokenCount;
-        const treasuryCount = contractsPerProject[i].treasuryCount;
-        // Extract results for this project
-        const tokenResults = results.slice(currentOffset, currentOffset + tokenCount);
-        currentOffset += tokenCount;
-        const treasuryResults = results.slice(currentOffset, currentOffset + treasuryCount);
-        currentOffset += treasuryCount;
-        // Parse using our type-safe parsers
-        const tokenData = parseTokenData(tokenResults, projectInfo.clankerToken);
-        const treasuryStats = parseTreasuryStats(treasuryResults, tokenData.decimals, tokenData.totalSupply, null // No pricing for list view
-        );
-        projects.push({
-            chainId,
-            treasury: projectInfo.project.treasury,
-            governor: projectInfo.project.governor,
-            staking: projectInfo.project.staking,
-            stakedToken: projectInfo.project.stakedToken,
-            factory: factoryAddress,
-            token: tokenData,
-            treasuryStats,
-        });
-    }
-    return {
-        projects,
-        total: Number(total),
-    };
 }
+// ============================================================================
+// Static Project Functions
+// ============================================================================
 /**
  * Get static project data that doesn't change frequently
  * This includes contract addresses, token metadata, pool info, and fee receivers
+ *
+ * Uses indexed data for token and project data, only fetches via RPC what's not indexed
  */
 export async function getStaticProject({ publicClient, clankerToken, userAddress, }) {
     if (Object.values({ publicClient, clankerToken }).some((value) => !value)) {
@@ -489,39 +395,86 @@ export async function getStaticProject({ publicClient, clankerToken, userAddress
     const factoryAddress = GET_FACTORY_ADDRESS(chainId);
     if (!factoryAddress)
         throw new Error("Factory address not found");
-    // Get deployed fee splitter for this token (if exists)
-    const feeSplitterAddress = await getFeeSplitter({
-        publicClient,
-        clankerToken,
-        chainId,
-    });
-    // Build contract calls including tokenRewards and fee splitter static in the same multicall
+    // Fetch indexed data and fee splitter in parallel
+    const [indexedProject, feeSplitterAddress] = await Promise.all([
+        getIndexedProject(chainId, clankerToken),
+        getFeeSplitter({ publicClient, clankerToken, chainId }),
+    ]);
+    if (!indexedProject)
+        return null;
+    // Parse token data from indexed project
+    const indexedToken = indexedProject.clankerToken;
+    if (!indexedToken)
+        return null;
+    let parsedMetadata = null;
+    if (indexedToken.metadata && typeof indexedToken.metadata === "string") {
+        try {
+            parsedMetadata = JSON.parse(indexedToken.metadata);
+        }
+        catch {
+            // If parsing fails, leave as null
+        }
+    }
+    const tokenData = {
+        address: clankerToken,
+        decimals: indexedToken.decimals ?? 18,
+        name: indexedToken.name ?? "",
+        symbol: indexedToken.symbol ?? "",
+        totalSupply: indexedToken.totalSupply ? BigInt(indexedToken.totalSupply) : 0n,
+        metadata: parsedMetadata,
+        imageUrl: indexedToken.imageUrl ?? undefined,
+        originalAdmin: (indexedToken.originalAdmin ?? zeroAddress),
+        admin: (indexedToken.admin ?? zeroAddress),
+        context: indexedToken.context ?? "",
+    };
+    // Parse factory data from indexed project
+    const { treasury_id, governor_id, staking_id, stakedToken_id } = indexedProject;
+    const indexedFactory = treasury_id && governor_id && staking_id && stakedToken_id
+        ? {
+            treasury: treasury_id,
+            governor: governor_id,
+            staking: staking_id,
+            stakedToken: stakedToken_id,
+            forwarder: zeroAddress,
+        }
+        : null;
+    // Only fetch what's not in the indexer: forwarder, fee receivers, fee splitter
     const contracts = [
-        ...getTokenContracts(clankerToken),
-        ...getFactoryContracts(factoryAddress, clankerToken),
+        // Forwarder is not indexed
+        {
+            address: factoryAddress,
+            abi: LevrFactory_v1,
+            functionName: "trustedForwarder",
+        },
+        // Fee receivers from LP locker (not indexed)
         ...getFeeReceiverContracts(clankerToken, chainId),
+        // Fee splitter static data if available
         ...(feeSplitterAddress ? getFeeSplitterStaticContracts(clankerToken, feeSplitterAddress) : []),
     ];
     const multicallResults = await publicClient.multicall({ contracts });
-    // Calculate slice indices for each data group
-    const tokenCount = 5;
-    const factoryCount = 2;
-    const tokenRewardsCount = 1;
-    const feeSplitterStaticCount = feeSplitterAddress ? 3 : 0;
+    // Parse results
     let idx = 0;
-    const tokenResults = multicallResults.slice(idx, idx + tokenCount);
-    idx += tokenCount;
-    const factoryResults = multicallResults.slice(idx, idx + factoryCount);
-    idx += factoryCount;
+    // Forwarder
+    const forwarderResult = multicallResults[idx];
+    idx += 1;
+    const factoryData = indexedFactory
+        ? { ...indexedFactory, forwarder: forwarderResult.result ?? zeroAddress }
+        : {
+            treasury: zeroAddress,
+            governor: zeroAddress,
+            staking: zeroAddress,
+            stakedToken: zeroAddress,
+            forwarder: forwarderResult.result ?? zeroAddress,
+        };
+    // Fee receivers (tokenRewards)
     const tokenRewardsResult = multicallResults[idx];
-    idx += tokenRewardsCount;
+    idx += 1;
+    // Fee splitter static
+    const feeSplitterStaticCount = feeSplitterAddress ? 3 : 0;
     const feeSplitterStaticResults = feeSplitterAddress
         ? multicallResults.slice(idx, idx + feeSplitterStaticCount)
         : null;
     idx += feeSplitterStaticCount;
-    // Parse results using individual parsers
-    const tokenData = parseTokenData(tokenResults, clankerToken);
-    const factoryData = parseFactoryData(factoryResults);
     // Check if project exists
     const { treasury, governor, staking, stakedToken } = factoryData;
     const isRegistered = [treasury, governor, staking, stakedToken].every((a) => a !== zeroAddress);
@@ -531,10 +484,13 @@ export async function getStaticProject({ publicClient, clankerToken, userAddress
     if (tokenRewardsResult.status === "success") {
         const tokenRewards = tokenRewardsResult.result;
         const poolKey = tokenRewards.poolKey;
+        // Resolve paired token info from pool key and indexed data
+        const pairedToken = resolvePairedToken(poolKey, clankerToken, indexedToken.symbol, indexedToken.v4Pool, chainId);
         poolInfo = {
             poolKey,
             feeDisplay: poolKey.fee === 8388608 ? "Dynamic" : `${(poolKey.fee / 10000).toFixed(2)}%`,
             numPositions: tokenRewards.numPositions,
+            pairedToken,
         };
         const rewardSlotCount = tokenRewards.rewardRecipients?.length ??
             tokenRewards.rewardAdmins?.length ??
@@ -592,81 +548,55 @@ export async function getStaticProject({ publicClient, clankerToken, userAddress
 /**
  * Get project data for a clanker token
  * Requires staticProject data to avoid refetching static information
- * Fetches dynamic data including treasury, governance, staking stats, and pricing
+ * Fetches dynamic data including treasury, staking stats, and pricing
+ *
+ * Governance stats are fetched from the indexer (no RPC calls needed)
  */
-export async function getProject({ publicClient, staticProject, oraclePublicClient, }) {
+export async function getProject({ publicClient, staticProject, }) {
     if (Object.values({ publicClient, staticProject }).some((value) => !value)) {
         throw new Error("Invalid project params");
     }
     const chainId = publicClient.chain?.id;
     if (!chainId)
         throw new Error("Chain ID not found on public client");
-    const wethAddress = WETH(chainId)?.address;
+    // Get paired token info from static project if available
+    const pairedTokenInfo = staticProject.pool?.pairedToken;
+    const pairedTokenAddress = pairedTokenInfo?.address;
     const clankerToken = staticProject.token.address;
-    // Use fee splitter from staticProject (already fetched in getStaticProject)
     const feeSplitterAddress = staticProject.feeSplitter?.address;
-    const rewardTokens = wethAddress ? [clankerToken, wethAddress] : [clankerToken];
-    // Fetch pricing data if oracle client is provided and pool exists
-    let pricing;
-    if (oraclePublicClient && staticProject.pool) {
-        try {
-            const [wethUsdData, tokenUsdData] = await Promise.all([
-                getWethUsdPrice({ publicClient: oraclePublicClient }),
-                getUsdPrice({
-                    oraclePublicClient,
-                    quotePublicClient: publicClient,
-                    tokenAddress: clankerToken,
-                    tokenDecimals: staticProject.token.decimals,
-                    quoteFee: staticProject.pool.poolKey.fee,
-                    quoteTickSpacing: staticProject.pool.poolKey.tickSpacing,
-                    quoteHooks: staticProject.pool.poolKey.hooks,
-                }),
-            ]);
-            pricing = {
-                wethUsd: wethUsdData.priceUsd,
-                tokenUsd: tokenUsdData.priceUsd,
-            };
-        }
-        catch (error) {
-            // If pricing fails, continue without it (graceful degradation)
-            console.warn("Failed to fetch USD pricing:", error);
-        }
-    }
-    // Get current block timestamp for accurate stream status
-    const block = await publicClient.getBlock();
-    const blockTimestamp = block.timestamp;
-    // Get fee locker address to query pending fees
-    const feeLockerAddress = GET_FEE_LOCKER_ADDRESS(chainId);
+    const rewardTokens = pairedTokenAddress ? [clankerToken, pairedTokenAddress] : [clankerToken];
     // Determine fee recipient for pending fees query
-    // If fee splitter is active, query pending for fee splitter (it receives fees before distribution)
-    // If fee splitter is NOT active, query pending for staking (direct recipient)
+    const feeLockerAddress = GET_FEE_LOCKER_ADDRESS(chainId);
     const stakingFeeRecipient = feeSplitterAddress && staticProject.feeSplitter?.isActive
-        ? feeSplitterAddress // Fee splitter is the ClankerFeeLocker recipient
-        : staticProject.staking; // Staking is the direct ClankerFeeLocker recipient
-    // Fetch only dynamic data (treasury, governance, staking stats, pending fees, and fee splitter dynamic)
+        ? feeSplitterAddress
+        : staticProject.staking;
+    // Build contract calls (governance is fetched from indexer, not RPC)
     const contracts = [
-        ...getTreasuryContracts(clankerToken, staticProject.treasury, staticProject.staking, wethAddress),
-        ...getGovernanceContracts(staticProject.governor),
-        ...getStakingContracts(staticProject.staking, clankerToken, wethAddress),
+        ...getTreasuryContracts(clankerToken, staticProject.treasury, staticProject.staking, pairedTokenAddress),
+        ...getStakingContracts(staticProject.staking, clankerToken, pairedTokenAddress),
         ...(feeLockerAddress
-            ? getPendingFeesContracts(feeLockerAddress, stakingFeeRecipient, clankerToken, wethAddress)
+            ? getPendingFeesContracts(feeLockerAddress, stakingFeeRecipient, clankerToken, pairedTokenAddress)
             : []),
         ...(feeSplitterAddress && staticProject.feeSplitter?.isActive
             ? getFeeSplitterDynamicContracts(clankerToken, feeSplitterAddress, rewardTokens)
             : []),
     ];
-    const results = await publicClient.multicall({ contracts });
-    // Calculate slice indices for dynamic data
-    const treasuryCount = wethAddress ? 4 : 3; // treasury balance, staking balance, escrow balance, (optional weth balance)
-    const governanceCount = 3; // currentCycleId + 2 activeProposalCount calls
-    const stakingCount = wethAddress ? 8 : 5; // 5 base + 3 optional weth (including getTokenStreamInfo for weth)
-    const pendingFeesCount = feeLockerAddress ? (wethAddress ? 2 : 1) : 0; // Pending fees from ClankerFeeLocker
+    // Fetch all data in parallel: indexed governance, pricing, block, and RPC multicall
+    const [indexedProject, pricing, block, results] = await Promise.all([
+        getIndexedProject(chainId, clankerToken),
+        fetchPricing(publicClient, staticProject),
+        publicClient.getBlock(),
+        publicClient.multicall({ contracts }),
+    ]);
+    const blockTimestamp = block.timestamp;
+    // Calculate slice indices for multicall results
+    const treasuryCount = pairedTokenAddress ? 4 : 3;
+    const stakingCount = pairedTokenAddress ? 8 : 5;
+    const pendingFeesCount = feeLockerAddress ? (pairedTokenAddress ? 2 : 1) : 0;
     const feeSplitterDynamicCount = feeSplitterAddress && staticProject.feeSplitter?.isActive ? rewardTokens.length : 0;
     let idx = 0;
     const treasuryResults = results.slice(idx, idx + treasuryCount);
     idx += treasuryCount;
-    const governanceResults = results.slice(idx, idx + governanceCount);
-    idx += governanceCount;
     const stakingResults = results.slice(idx, idx + stakingCount);
     idx += stakingCount;
     const pendingFeesResults = pendingFeesCount > 0
@@ -674,31 +604,35 @@ export async function getProject({ publicClient, staticProject, oraclePublicClie
         : null;
     idx += pendingFeesCount;
     const feeSplitterDynamicResults = feeSplitterDynamicCount > 0 ? results.slice(idx, idx + feeSplitterDynamicCount) : null;
-    // Calculate USD values for stats if pricing is available
+    // Calculate USD values for stats
     const tokenUsdPrice = pricing ? parseFloat(pricing.tokenUsd) : null;
-    const wethUsdPrice = pricing ? parseFloat(pricing.wethUsd) : null;
-    // Parse fee splitter dynamic data first (needed for staking stats)
+    const pairedTokenUsdPrice = pricing ? parseFloat(pricing.pairedTokenUsd) : null;
+    // Parse fee splitter dynamic data
     let feeSplitter = staticProject.feeSplitter;
     let feeSplitterPendingFees;
     if (feeSplitterDynamicResults && staticProject.feeSplitter) {
-        const feeSplitterDynamic = parseFeeSplitterDynamic(feeSplitterDynamicResults, wethAddress);
-        feeSplitter = {
-            ...staticProject.feeSplitter,
-            ...feeSplitterDynamic,
-        };
-        // Extract pending fees to add to outstanding rewards
-        // When using fee splitter, fees in LP locker should show as "pending" in outstanding rewards
+        const feeSplitterDynamic = parseFeeSplitterDynamic(feeSplitterDynamicResults, pairedTokenAddress);
+        feeSplitter = { ...staticProject.feeSplitter, ...feeSplitterDynamic };
         if (staticProject.feeSplitter.isActive && feeSplitterDynamic.pendingFees) {
             feeSplitterPendingFees = {
                 token: feeSplitterDynamic.pendingFees.token,
-                weth: feeSplitterDynamic.pendingFees.weth ?? null,
+                pairedToken: feeSplitterDynamic.pendingFees.pairedToken ?? null,
             };
         }
     }
-    // Parse treasury and staking stats using individual parsers
-    const treasuryStats = parseTreasuryStats(treasuryResults, staticProject.token.decimals, staticProject.token.totalSupply, tokenUsdPrice, wethUsdPrice);
-    const stakingStats = parseStakingStats(stakingResults, pendingFeesResults, staticProject.token.decimals, tokenUsdPrice, wethUsdPrice, blockTimestamp, pricing, feeSplitterPendingFees);
-    const governanceStats = parseGovernanceData(governanceResults);
+    // Parse stats
+    const treasuryStats = parseTreasuryStats(treasuryResults, staticProject.token.decimals, staticProject.token.totalSupply, tokenUsdPrice, pairedTokenUsdPrice, pairedTokenInfo?.decimals ?? 18);
+    const stakingStats = parseStakingStats(stakingResults, pendingFeesResults, staticProject.token.decimals, tokenUsdPrice, pairedTokenUsdPrice, pairedTokenInfo?.decimals ?? 18, blockTimestamp, pricing, feeSplitterPendingFees);
+    // Use indexed governance data (no RPC calls needed)
+    const governanceStats = indexedProject
+        ? {
+            currentCycleId: BigInt(indexedProject.currentCycleId ?? "1"),
+            activeProposalCount: {
+                boost: BigInt(indexedProject.activeBoostProposals ?? "0"),
+                transfer: BigInt(indexedProject.activeTransferProposals ?? "0"),
+            },
+        }
+        : { currentCycleId: 1n, activeProposalCount: { boost: 0n, transfer: 0n } };
     return {
         chainId,
         ...staticProject,
@@ -710,4 +644,37 @@ export async function getProject({ publicClient, staticProject, oraclePublicClie
         blockTimestamp,
     };
 }
+// ============================================================================
+// Internal Helpers
+// ============================================================================
+async function fetchPricing(publicClient, staticProject) {
+    if (!staticProject.pool)
+        return undefined;
+    try {
+        const pairedToken = staticProject.pool.pairedToken;
+        const tokenUsdData = await getUsdPrice({
+            publicClient,
+            tokenAddress: staticProject.token.address,
+            tokenDecimals: staticProject.token.decimals,
+            pairedTokenAddress: pairedToken.address,
+            pairedTokenDecimals: pairedToken.decimals,
+            quoteFee: staticProject.pool.poolKey.fee,
+            quoteTickSpacing: staticProject.pool.poolKey.tickSpacing,
+            quoteHooks: staticProject.pool.poolKey.hooks,
+        });
+        // Get paired token USD price (WETH/WBNB = oracle, stablecoins = $1.00)
+        const pairedTokenUsdPrice = await getPairedTokenUsdPrice({
+            publicClient,
+            pairedTokenAddress: pairedToken.address,
+        });
+        return {
+            tokenUsd: tokenUsdData.priceUsd,
+            pairedTokenUsd: pairedTokenUsdPrice,
+        };
+    }
+    catch (error) {
+        console.warn("Failed to fetch USD pricing:", error);
+        return undefined;
+    }
+}
 //# sourceMappingURL=project.js.map