set up logic for NERI calc

Author: vidvidvid

frontend/app/src/contracts.ts

@@ -163,6 +163,7 @@ export const CONTRACT_ADDRESSES = {
   WETH: CONTRACT_WETH,
   YUSND: CONTRACT_YUSND,
   ShellToken: CONTRACT_SHELL_TOKEN,
+  NeriToken: "0x0000000000000000000000000000000000000000", // TODO: Replace with actual NERI token address
   GoSlowNft: "0x6da3c02293c96dfa5747b1739ebb492619222a8a",
 
   strategies: {

frontend/app/src/screens/ClaimScreen/ClaimScreen.tsx

@@ -8,7 +8,7 @@ import { a, useSpring, useTrail } from "@react-spring/web";
 import { Button, VFlex, ShellpointIcon, TokenIcon } from "@liquity2/uikit";
 import { useState, useMemo, useEffect } from "react";
 import { useBalance } from "@/src/wagmi-utils";
-import { useShellActivitiesOfHolders, useWeightedActivitySnapshots, usePrivacyPoolSnapshots } from "@/src/shell-hooks";
+import { useShellActivitiesOfHolders, useWeightedActivitySnapshots, usePrivacyPoolSnapshots, useTotalShells, useNeriTotalSupply, calculateNeriAllocation } from "@/src/shell-hooks";
 import { CONTRACT_ADDRESSES } from "@/src/contracts";
 import { getAddress, isAddress, isAddressEqual } from "viem";
 import { getEnsAddress, normalize } from "viem/ens";
@@ -149,6 +149,19 @@ export function ClaimScreen() {
   // Fetch privacy pool snapshots (GoSlow NFT)
   const { data: privacyPoolSnapshots } = usePrivacyPoolSnapshots(lookupAddress);
 
+  // Fetch total shells for NERI calculation
+  const { data: totalShells } = useTotalShells();
+
+  // Fetch NERI total supply from contract
+  const { data: neriTotalSupply } = useNeriTotalSupply();
+
+  // Calculate NERI allocation based on user's shell balance, total shells, and NERI supply
+  const neriAllocation = useMemo(() => {
+    if (!shellBalance || !totalShells || totalShells === 0n || !neriTotalSupply) return 0n;
+    const userShells = shellBalance[0];
+    return calculateNeriAllocation(userShells, totalShells, neriTotalSupply);
+  }, [shellBalance, totalShells, neriTotalSupply]);
+
   // Get aggregated stats from weighted snapshots
   const activityStats = useMemo(() => {
     if (!weightedSnapshots || weightedSnapshots.length === 0) return null;
@@ -241,10 +254,10 @@ export function ClaimScreen() {
     config: { mass: 1, tension: 80, friction: 30 },
   });
 
-  // NERI amount animation (proportional to shells - placeholder conversion)
+  // NERI amount animation
   const neriAmountSpring = useSpring({
     from: { number: 0 },
-    to: { number: revealed && shellBalance ? Number(format(shellBalance, 0).replace(/,/g, '')) * 0.1 : 0 },
+    to: { number: revealed && neriAllocation ? Number(neriAllocation / 10n ** 18n) : 0 },
     delay: revealed ? 400 : 0,
     config: { mass: 1, tension: 80, friction: 30 },
   });

frontend/app/src/shell-hooks.ts

@@ -17,6 +17,12 @@ import { UniswapV4PositionManager } from "./abi/UniswapV4PositionManager";
 import { Abi } from "abitype";
 import { isAddressEqual, zeroAddress } from "viem";
 
+
+// NERI Airdrop Configuration
+export const NERI_CONFIG = {
+  SHELL_ALLOCATION_PERCENT: 10,
+};
+
 type Options = {
   refetchInterval?: number;
 };
@@ -196,4 +202,63 @@ export function usePrivacyPoolSnapshots(
     enabled: Boolean(user),
     ...prepareOptions(options),
   });
+}
+
+// Get total shells across all holders
+export function useTotalShells(options?: Options) {
+  const { data: allBalances, ...rest } = useShellBalances(options);
+
+  const totalShells = allBalances?.reduce((sum, balance) => {
+    return sum + BigInt(balance.balance);
+  }, 0n) ?? 0n;
+
+  return {
+    data: totalShells,
+    ...rest,
+  };
+}
+
+// Hook to get NERI total supply from contract
+export function useNeriTotalSupply(options?: Options) {
+  const config = useWagmiConfig();
+
+  return useQuery({
+    queryKey: ["NeriTotalSupply"],
+    queryFn: async () => {
+      const result = await readContracts(config, {
+        allowFailure: false,
+        contracts: [{
+          address: CONTRACT_ADDRESSES.NeriToken as `0x${string}`,
+          abi: [{
+            name: "totalSupply",
+            type: "function",
+            stateMutability: "view",
+            inputs: [],
+            outputs: [{ type: "uint256" }],
+          }] as const,
+          functionName: "totalSupply",
+          args: [],
+        }],
+      });
+      return result[0] as bigint;
+    },
+    // Don't fetch if NERI token address is not set (zero address)
+    enabled: CONTRACT_ADDRESSES.NeriToken !== "0x0000000000000000000000000000000000000000",
+    ...prepareOptions(options),
+  });
+}
+
+// Calculate NERI amount for a given shell balance
+export function calculateNeriAllocation(
+  userShells: bigint,
+  totalShells: bigint,
+  neriTotalSupply: bigint
+): bigint {
+  if (totalShells === 0n || neriTotalSupply === 0n) return 0n;
+
+  // NERI allocated to shell holders = neriTotalSupply * SHELL_ALLOCATION_PERCENT / 100
+  const neriForShells = neriTotalSupply * BigInt(NERI_CONFIG.SHELL_ALLOCATION_PERCENT) / 100n;
+
+  // User's NERI = (userShells / totalShells) * neriForShells
+  return (userShells * neriForShells) / totalShells;
 }