add Ekubo Vault, etc

.env.sample

@@ -17,3 +17,11 @@ CRON_SECRET=
 # Note: Not everything is supported on sepolia
 # Default: mainnet
 NEXT_PUBLIC_NETWORK=mainnet
+
+# To enable API caching
+VK_REDIS_KV_URL=
+VK_REDIS_KV_REST_API_READ_ONLY_TOKEN=
+VK_REDIS_REDIS_URL=
+VK_REDIS_KV_REST_API_TOKEN=
+VK_REDIS_KV_REST_API_URL=
+VK_REDIS_PREFIX="strkfarm::beta"

package.json

@@ -34,10 +34,11 @@
     "@prisma/client": "5.18.0",
     "@starknet-react/chains": "3.0.0",
     "@starknet-react/core": "3.0.1",
-    "@strkfarm/sdk": "^1.0.28",
+    "@strkfarm/sdk": "^1.0.35",
     "@tanstack/query-core": "5.28.0",
     "@types/mixpanel-browser": "2.49.0",
     "@types/mustache": "4.2.5",
+    "@upstash/redis": "^1.34.7",
     "@vercel/analytics": "1.2.2",
     "@vercel/speed-insights": "1.0.12",
     "@xyflow/react": "^12.4.4",
@@ -53,6 +54,7 @@
     "graphql": "16.9.0",
     "jotai": "2.6.4",
     "jotai-tanstack-query": "0.8.5",
+    "lodash.debounce": "^4.0.8",
     "mixpanel": "^0.18.0",
     "mixpanel-browser": "2.49.0",
     "mustache": "4.2.0",
@@ -75,6 +77,7 @@
     "wonka": "6.3.4"
   },
   "devDependencies": {
+    "@types/lodash.debounce": "^4.0.9",
     "@types/node": "20",
     "@types/react": "18",
     "@types/react-dom": "18",

src/app/api/lib.ts

@@ -0,0 +1,151 @@
+import { STRKFarmStrategyAPIResult } from '@/store/strkfarm.atoms';
+import { Redis } from '@upstash/redis';
+import { Contract, RpcProvider, uint256 } from 'starknet';
+
+const kvRedis = new Redis({
+  url: process.env.VK_REDIS_KV_REST_API_URL,
+  token: process.env.VK_REDIS_KV_REST_API_TOKEN,
+});
+
+export async function getDataFromRedis(
+  key: string,
+  url: string,
+  revalidate: number,
+) {
+  if (url.includes('no_cache=true')) {
+    // force no cache
+    return null;
+  }
+  const cacheData: any = await kvRedis.get(key);
+  if (
+    cacheData &&
+    new Date().getTime() - new Date(cacheData.lastUpdated).getTime() <
+      revalidate * 1000
+  ) {
+    console.log(`Cache hit for ${key}`);
+    return cacheData;
+  }
+
+  return null;
+}
+
+export default kvRedis;
+
+export const getRewardsInfo = async (
+  strategies: Pick<STRKFarmStrategyAPIResult, 'id' | 'tvlUsd' | 'contract'>[],
+) => {
+  const funder =
+    '0x02D6cf6182259ee62A001EfC67e62C1fbc0dF109D2AA4163EB70D6d1074F0173';
+  const allowedStrats = [
+    {
+      id: 'vesu_fusion_eth',
+      // ! consider exchange rate of vToken
+      maxRewardsPerDay: 0.047, // in token units
+      maxAPY: 200, // in percent
+      underlyingTokenName: 'ETH',
+      decimals: 18,
+      rewardToken:
+        '0x021fe2ca1b7e731e4a5ef7df2881356070c5d72db4b2d19f9195f6b641f75df0',
+    },
+  ];
+
+  const provider = new RpcProvider({
+    nodeUrl: process.env.RPC_URL!,
+  });
+
+  const rewardsInfo: {
+    id: string;
+    reward: number;
+    tvlUsd: number;
+    rewardAPY: number;
+    rewardDecimals: number;
+    maxRewardsPerDay: number;
+    rewardToken: string;
+    funder: string;
+    receiver: string;
+  }[] = [];
+  for (const strat of strategies) {
+    const stratId = strat.id;
+    const stratAllowed = allowedStrats.find(
+      (allowedStrat) => allowedStrat.id === stratId,
+    );
+    if (stratAllowed) {
+      // Fetch the price of the underlying token
+      const priceResponse = await fetch(
+        `${process.env.HOSTNAME}/api/price/${stratAllowed.underlyingTokenName}`,
+      );
+      const priceData = await priceResponse.json();
+      // consider token price of vToken
+      const clsVToken = await provider.getClassAt(stratAllowed.rewardToken);
+      const tokenContractVToken = new Contract(
+        clsVToken.abi,
+        stratAllowed.rewardToken,
+        provider,
+      );
+      const shareValue = await tokenContractVToken.call('convert_to_assets', [
+        uint256.bnToUint256((1e18).toString()),
+      ]);
+      console.log(`shareValue::${stratId}::${shareValue}`);
+      const tokenPrice =
+        (priceData.price *
+          Number(
+            (BigInt(shareValue.toString()) * BigInt(10000)) /
+              BigInt((1e18).toString()),
+          )) /
+        10000;
+      console.log(
+        `RewardCalc::${stratId}::tokenPrice::${tokenPrice}, underlyingTokenPrice::${priceData.price}`,
+      );
+
+      const tvlUsd = strat.tvlUsd;
+      console.log(`RewardCalc::${stratId}::tvlUsd::${tvlUsd}`);
+
+      // Calculate the hourly reward based on TVL and token price
+      const rewardBasedOnTVL =
+        (tvlUsd * stratAllowed.maxAPY) / (100 * 365 * 24 * tokenPrice);
+      console.log(
+        `RewardCalc::${stratId}::ewardBasedOnTVL::${rewardBasedOnTVL}`,
+      );
+      console.log(`RewardCalc::${stratId}::tvl::${tvlUsd}`);
+
+      // Ensure the reward does not exceed max rewards per day
+      let finalReward = Math.min(
+        rewardBasedOnTVL,
+        stratAllowed.maxRewardsPerDay / 24,
+      );
+      console.log(`RewardCalc::${stratId}::finalReward::${finalReward}`);
+
+      // if less bal available, use the available balance
+      const rewardToken = stratAllowed.rewardToken;
+      const cls = await provider.getClassAt(rewardToken);
+      const tokenContract = new Contract(cls.abi, rewardToken, provider);
+      const available = await tokenContract.balanceOf(funder);
+      const availableBal =
+        Number(
+          BigInt(available.toString()) /
+            BigInt(10 ** (stratAllowed.decimals - 4)),
+        ) / 10000;
+      console.log(
+        `RewardCalc::${stratId}::availableBal::${availableBal.toString()}`,
+      );
+
+      finalReward = Math.min(finalReward, availableBal);
+      console.log(`RewardCalc::${stratId}::finalReward::${finalReward}`);
+
+      // Calculate the reward APY
+      rewardsInfo.push({
+        id: stratId,
+        reward: finalReward,
+        rewardDecimals: stratAllowed.decimals,
+        tvlUsd,
+        rewardAPY: ((finalReward * 24 * 365) / (tvlUsd / tokenPrice)) * 100,
+        maxRewardsPerDay: stratAllowed.maxRewardsPerDay,
+        rewardToken: stratAllowed.rewardToken,
+        funder,
+        receiver: strat.contract[0].address,
+      });
+    }
+  }
+
+  return rewardsInfo;
+};

src/app/api/price/[name]/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server';
 import { getMainnetConfig, PricerRedis } from '@strkfarm/sdk';
 
 export const revalidate = 300; // 5 mins
+export const dynamic = 'force-dynamic';
 
 // only meant for backend calls
 async function initRedis() {

src/app/api/raffle/_route.ts

@@ -0,0 +1,157 @@
+// import { NextResponse } from 'next/server';
+
+// import { db } from '@/db';
+// import { getStrategies } from '@/store/strategies.atoms';
+// import { standariseAddress } from '@/utils';
+
+// export async function POST(req: Request) {
+//   const { address, type } = await req.json();
+
+//   if (!address || !type) {
+//     return NextResponse.json({
+//       success: false,
+//       message: 'address not found',
+//       user: null,
+//     });
+//   }
+
+//   if (!type || !['SHARED_ON_X', 'ACTIVE_DEPOSITS', 'REGISTER'].includes(type)) {
+//     return NextResponse.json({
+//       success: false,
+//       message: 'Invalid type',
+//     });
+//   }
+
+//   // standardised address
+//   let parsedAddress = address;
+//   try {
+//     parsedAddress = standariseAddress(address);
+//   } catch (e) {
+//     throw new Error('Invalid address');
+//   }
+
+//   const user = await db.user.findFirst({
+//     where: {
+//       address: parsedAddress,
+//     },
+//   });
+
+//   if (!user) {
+//     return NextResponse.json({
+//       success: false,
+//       message: 'User not found',
+//       user: null,
+//     });
+//   }
+
+//   if (type === 'REGISTER') {
+//     const raffleUser = await db.raffle.findFirst({
+//       where: {
+//         userId: user.id,
+//       },
+//     });
+
+//     if (raffleUser) {
+//       return NextResponse.json({
+//         success: false,
+//         message: 'User already registered',
+//         user: raffleUser,
+//       });
+//     }
+
+//     const createdUser = await db.raffle.create({
+//       data: {
+//         isRaffleParticipant: true,
+//         User: {
+//           connect: {
+//             address: parsedAddress,
+//           },
+//         },
+//       },
+//     });
+
+//     return NextResponse.json({
+//       success: true,
+//       message: 'User registered for raffle successfully',
+//       user: createdUser,
+//     });
+//   }
+
+//   const raffleUser = await db.raffle.findFirst({
+//     where: {
+//       userId: user.id,
+//       isRaffleParticipant: true,
+//     },
+//   });
+
+//   if (!raffleUser) {
+//     return NextResponse.json({
+//       success: false,
+//       message: 'Registered user not found',
+//       user: null,
+//     });
+//   }
+
+//   if (type === 'SHARED_ON_X') {
+//     const updatedUser = await db.raffle.update({
+//       where: {
+//         raffleId: raffleUser.raffleId,
+//       },
+//       data: {
+//         sharedOnX: true,
+//       },
+//     });
+
+//     return NextResponse.json({
+//       success: true,
+//       message: 'Shared on X successfully',
+//       user: updatedUser,
+//     });
+//   }
+
+//   if (type === 'ACTIVE_DEPOSITS') {
+//     const strategies = getStrategies();
+
+//     const values = strategies.map(async (strategy) => {
+//       const balanceInfo = await strategy.getUserTVL(parsedAddress);
+//       return {
+//         id: strategy.id,
+//         usdValue: balanceInfo.usdValue,
+//         tokenInfo: {
+//           name: balanceInfo.tokenInfo.name,
+//           symbol: balanceInfo.tokenInfo.name,
+//           logo: balanceInfo.tokenInfo.logo,
+//           decimals: balanceInfo.tokenInfo.decimals,
+//           displayDecimals: balanceInfo.tokenInfo.displayDecimals,
+//         },
+//         amount: balanceInfo.amount.toEtherStr(),
+//       };
+//     });
+
+//     const result = await Promise.all(values);
+//     const sum = result.reduce((acc, item) => acc + item.usdValue, 0);
+
+//     if (sum > 10) {
+//       const createdUser = await db.raffle.update({
+//         where: {
+//           raffleId: raffleUser.raffleId,
+//         },
+//         data: {
+//           activeDeposits: true,
+//         },
+//       });
+
+//       return NextResponse.json({
+//         success: true,
+//         message: 'Active deposits found',
+//         user: createdUser,
+//       });
+//     }
+
+//     return NextResponse.json({
+//       success: false,
+//       message: 'No active deposits found',
+//       user: null,
+//     });
+//   }
+// }