@gearbox-protocol/sdk 3.0.0-next.99 → 3.0.0-prevfour.2

package/contracts/SignUpRepository.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+struct SignupInfo {
+    address account;
+    bytes signature;
+}
+
+interface SignUpRepositoryEvents {
+    event NewSignatureAdded(uint8 indexed version, string text, bytes32 messageHash);
+
+    event Signature(address indexed account, uint8 indexed version, bytes signature);
+}
+
+contract SignUpRepository is SignUpRepositoryEvents, Ownable {
+    using Strings for uint256;
+
+    error IncorrectVersionException();
+
+    error IncorrectSignatureException();
+
+    bytes32 public messageHash;
+
+    uint8 public signatureVersion;
+
+    constructor() Ownable() {
+  
+   }
+
+    function updateLegalText(uint8 newVersion, string memory message) external onlyOwner {
+        if (newVersion <= signatureVersion) revert IncorrectVersionException();
+
+        signatureVersion = newVersion;
+        messageHash = prefixed(message);
+
+        emit NewSignatureAdded(newVersion, message, messageHash);
+    }
+
+    function addSignature(address account, bytes memory signature) external {
+        _addSignature(account, signature);
+    }
+
+    function addBatchSignatures(SignupInfo[] memory signatures) external {
+        uint256 len = signatures.length;
+        for (uint256 i; i < len; ++i) {
+            _addSignature(signatures[i].account, signatures[i].signature);
+        }
+    }
+
+    function _addSignature(address account, bytes memory signature) internal {
+        (uint8 v, bytes32 r, bytes32 s) = splitSignature(signature);
+
+        if (account != ecrecover(messageHash, v, r, s)) {
+            revert IncorrectSignatureException();
+        }
+
+        emit Signature(account, signatureVersion, signature);
+    }
+
+    /// signature methods.
+    function splitSignature(bytes memory sig) internal pure returns (uint8 v, bytes32 r, bytes32 s) {
+        require(sig.length == 65);
+
+        assembly {
+            // first 32 bytes, after the length prefix.
+            r := mload(add(sig, 32))
+            // second 32 bytes.
+            s := mload(add(sig, 64))
+            // final byte (first byte of the next 32 bytes).
+            v := byte(0, mload(add(sig, 96)))
+        }
+
+        return (v, r, s);
+    }
+
+    /// builds a prefixed hash to mimic the behavior of eth_sign.
+    function prefixed(string memory message) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encodePacked("\x19Ethereum Signed Message:\n", bytes(message).length.toString(), bytes(message))
+        );
+    }
+}

package/contracts/index.sol

@@ -4,8 +4,8 @@
 
 pragma solidity ^0.8.10;
 
-import {IDataCompressorV2_10} from "@gearbox-protocol/periphery-v3/contracts/interfaces/IDataCompressorV2_10.sol";
-import {IDataCompressorV3_00} from "@gearbox-protocol/periphery-v3/contracts/interfaces/IDataCompressorV3_00.sol";
+import {IDataCompressorV2_1} from "@gearbox-protocol/periphery-v3/contracts/interfaces/IDataCompressorV2_1.sol";
+import {IDataCompressorV3} from "@gearbox-protocol/periphery-v3/contracts/interfaces/IDataCompressorV3.sol";
 import {IAddressProviderV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IAddressProviderV3.sol";
 import {IContractsRegister} from "@gearbox-protocol/core-v2/contracts/interfaces/IContractsRegister.sol";
 import {IPoolV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPoolV3.sol";
@@ -61,6 +61,7 @@ import {IPriceOracleV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPr
 import {IPriceFeed} from "@gearbox-protocol/core-v2/contracts/interfaces/IPriceFeed.sol";
 import {ILPPriceFeed} from "@gearbox-protocol/oracles-v3/contracts/interfaces/ILPPriceFeed.sol";
 import {RedstonePriceFeed} from "@gearbox-protocol/oracles-v3/contracts/oracles/updatable/RedstonePriceFeed.sol";
+import {CompositePriceFeed} from "@gearbox-protocol/oracles-v3/contracts/oracles/CompositePriceFeed.sol";
 
 import {ICurveV1_2AssetsAdapter} from
     "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_2AssetsAdapter.sol";
@@ -71,7 +72,15 @@ import {ICurveV1_3AssetsAdapter} from
 import {ICurveV1_4AssetsAdapter} from
     "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_4AssetsAdapter.sol";
 
+import {IStakingRewardsAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/sky/IStakingRewardsAdapter.sol";
+    
+
+
+import {IMulticall3} from "@gearbox-protocol/router-v3/lib/forge-std/src/interfaces/IMulticall3.sol";
 import {IRouterV3} from "@gearbox-protocol/router-v3/contracts/interfaces/IRouterV3.sol";
 import {IRouter} from "@gearbox-protocol/router/contracts/interfaces/IRouter.sol";
 
 import {IFarmingPool} from "@1inch/farming/contracts/interfaces/IFarmingPool.sol";
+
+import {PartialLiquidationBotV3} from "@gearbox-protocol/bots-v3/contracts/bots/PartialLiquidationBotV3.sol";

package/lib/apy/curveAPY.d.ts

@@ -1,11 +1,58 @@
-import { CurveLPToken } from "@gearbox-protocol/sdk-gov/lib/tokens/curveLP";
-import { GearboxToken } from "@gearbox-protocol/sdk-gov/lib/tokens/gear";
-type CurveAPYTokens = CurveLPToken | GearboxToken;
+import { NetworkType, PartialRecord, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+interface CurvePoolData {
+    address: Address;
+    amplificationCoefficient: string;
+    assetType?: string;
+    assetTypeName: string;
+    coins: Array<{
+        address: Address;
+        decimals: string;
+        isBasePoolLpToken: boolean;
+        poolBalance: string;
+        symbol: string;
+        usdPrice: number;
+    }>;
+    coinsAddresses: Array<Address>;
+    decimals: Array<string>;
+    gaugeAddress: Address;
+    gaugeCrvApy: Array<number>;
+    gaugeRewards: Array<{
+        apy: number;
+        decimals: string;
+        gaugeAddress: Address;
+        name: string;
+        symbol: string;
+        tokenAddress: Address;
+        tokenPrice: number;
+    }>;
+    id: string;
+    implementation: string;
+    implementationAddress: Address;
+    isMetaPool: boolean;
+    lpTokenAddress: Address;
+    name: string;
+    poolUrls: {
+        deposit: Array<string>;
+        swap: Array<string>;
+        withdraw: Array<string>;
+    };
+    priceOracle: number;
+    symbol: string;
+    totalSupply: string;
+    usdTotal: number;
+    usdTotalExcludingBasePool: number;
+    virtualPrice: string;
+}
 interface CurveAPY {
-    base: bigint;
-    crv: bigint;
-    gauge: Array<[string, bigint]>;
+    base: number;
+    crv: number;
+    gauge: Array<[Address, number]>;
 }
-export type CurveAPYResult = Record<CurveAPYTokens, CurveAPY>;
-export declare function getCurveAPY(): Promise<CurveAPYResult | null>;
+export type CurveAPYResult = PartialRecord<Address, CurveAPY>;
+export declare function getCurveAPY(network: NetworkType, currentTokens: Record<SupportedToken, Address>): Promise<{
+    curveAPY: CurveAPYResult;
+    gearAPY: CurveAPY;
+}>;
+export declare function getCurveGearPool(): Promise<CurvePoolData | undefined>;
 export {};

package/lib/apy/curveAPY.js

@@ -3,85 +3,141 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCurveAPY = void 0;
+exports.getCurveGearPool = exports.getCurveAPY = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const axios_1 = __importDefault(require("axios"));
-const formatter_1 = require("../utils/formatter");
-const APY_DICTIONARY = {
-    "3Crv": "0",
-    FRAX3CRV: "34",
-    gusd3CRV: "19",
-    LUSD3CRV: "33",
-    crvPlain3andSUSD: "15",
-    steCRV: "14",
-    crvFRAX: "44",
-    GEAR: "factory-crypto-192",
-    OHMFRAXBP: "factory-crypto-158",
-    MIM_3LP3CRV: "40",
-    crvCRVETH: "crypto-3",
-    crvCVXETH: "crypto-4",
-    crvUSDTWBTCWETH: "factory-tricrypto-1",
-    LDOETH: "factory-crypto-204",
-    crvUSDUSDC: "factory-crvusd-0",
-    crvUSDUSDT: "factory-crvusd-1",
-    crvUSDFRAX: "factory-crvusd-4",
-    crvUSDETHCRV: "factory-tricrypto-4",
-    rETH_f: "factory-crypto-210", // 0x0f3159811670c117c372428D4E69AC32325e4D0F
+const GEAR_POOL = "0x5Be6C45e2d074fAa20700C49aDA3E88a1cc0025d".toLowerCase();
+const CURVE_CHAINS = {
+    Arbitrum: "arbitrum",
+    Mainnet: "ethereum",
+    Optimism: "optimism",
+    Base: "base",
 };
-const CRV_APY_RESPONSE_DECIMALS = 100;
-// const CRYPTO = "https://api.curve.fi/api/getPools/ethereum/crypto";
-// const FACTORY = "https://api.curve.fi/api/getPools/ethereum/factory";
-const CURVE_APY_URL = "https://www.convexfinance.com/api/curve-apys";
-const CURVE_MAIN_URL = "https://api.curve.fi/api/getPools/ethereum/main";
-const CURVE_FACTORY_CRYPTO_URL = "https://api.curve.fi/api/getPools/ethereum/factory-crypto";
-const CURVE_CRYPTO_URL = "https://api.curve.fi/api/getPools/ethereum/crypto";
-const CURVE_FACTORY_TRICRYPTO_URL = "https://api.curve.fi/api/getPools/ethereum/factory-tricrypto";
-const CURVE_FACTORY_CRVUSD_URL = "https://api.curve.fi/api/getPools/ethereum/factory-crvusd";
-async function getCurveAPY() {
-    try {
-        const [{ data: apyData }, ...restData] = await Promise.all([
-            axios_1.default.get(CURVE_APY_URL),
-            axios_1.default.get(CURVE_MAIN_URL),
-            axios_1.default.get(CURVE_FACTORY_CRYPTO_URL),
-            axios_1.default.get(CURVE_CRYPTO_URL),
-            axios_1.default.get(CURVE_FACTORY_TRICRYPTO_URL),
-            axios_1.default.get(CURVE_FACTORY_CRVUSD_URL),
+// const CRYPTO = "https://api.curve.fi/api/getPools/${CURVE_CHAINS[n]}/crypto";
+// const FACTORY = "https://api.curve.fi/api/getPools/${CURVE_CHAINS[n]}/factory";
+// const CURVE_APY_URL = "https://www.convexfinance.com/api/curve-apys";
+const getVolumesURL = (n) => `https://api.curve.fi/api/getVolumes/${CURVE_CHAINS[n]}`;
+const getMainURL = (n) => `https://api.curve.fi/api/getPools/${CURVE_CHAINS[n]}/main`;
+const getFactoryCryptoURL = (n) => `https://api.curve.fi/api/getPools/${CURVE_CHAINS[n]}/factory-crypto`;
+const getCryptoURL = (n) => `https://api.curve.fi/api/getPools/${CURVE_CHAINS[n]}/crypto`;
+const getFactoryTriCryptoURL = (n) => `https://api.curve.fi/api/getPools/${CURVE_CHAINS[n]}/factory-tricrypto`;
+const getFactoryCrvUsdURL = (n) => `https://api.curve.fi/api/getPools/${CURVE_CHAINS[n]}/factory-crvusd`;
+const getFactoryStableNgURL = (n) => `https://api.curve.fi/api/getPools/${CURVE_CHAINS[n]}/factory-stable-ng`;
+async function getCurveAPY(network, currentTokens) {
+    const { mainnetVolumes, mainnetFactoryPools, volumes, pools } = await getCurvePools(network);
+    const volumeByAddress = volumes.data.data.pools.reduce((acc, v) => {
+        acc[v.address.toLowerCase()] = v;
+        return acc;
+    }, {});
+    const poolDataByAddress = pools.reduce((acc, poolCategory) => {
+        const { poolData = [] } = poolCategory?.data?.data || {};
+        poolData.forEach(p => {
+            acc[p.lpTokenAddress.toLowerCase()] = p;
+        });
+        return acc;
+    }, {});
+    const curveAPY = sdk_gov_1.TypedObjectUtils.entries(currentTokens).reduce((acc, [, address]) => {
+        if (!poolDataByAddress[address])
+            return acc;
+        const pool = poolDataByAddress[address];
+        const volume = volumeByAddress[(pool?.address || "").toLowerCase()];
+        const baseAPY = volume?.latestDailyApyPcent || 0;
+        const maxCrv = Math.max(...(pool?.gaugeCrvApy || []), 0);
+        const extraRewards = (pool?.gaugeRewards || []).map(({ apy = 0, tokenAddress }) => [
+            tokenAddress.toLowerCase(),
+            curveAPYToBn(apy),
         ]);
-        const { apys } = apyData || {};
-        const poolDataByID = Object.fromEntries(restData
-            .map(resp => {
-            const { poolData = [] } = resp?.data?.data || {};
-            return poolData.map(p => [p.id, p]);
-        })
-            .flat(1));
-        const curveAPY = sdk_gov_1.TypedObjectUtils.entries(APY_DICTIONARY).reduce((acc, [curveSymbol, poolId]) => {
-            const { baseApy, crvApy } = apys[poolId] || {};
-            if (baseApy === undefined)
-                console.warn(`No base apy for: ${curveSymbol}, ${poolId}`);
-            const pool = poolDataByID[poolId];
-            const { gaugeRewards = [] } = pool || {};
-            if (pool === undefined)
-                console.warn(`No pool data for: ${curveSymbol}, ${poolId}`);
-            const extraRewards = gaugeRewards.map(({ apy = 0, symbol }) => [
-                symbol.toLowerCase(),
-                curveAPYToBn(apy),
+        acc[address] = {
+            base: curveAPYToBn(baseAPY),
+            crv: curveAPYToBn(maxCrv),
+            gauge: extraRewards,
+        };
+        return acc;
+    }, {});
+    const poolFactoryByAddress = (mainnetFactoryPools?.data?.data?.poolData || []).reduce((acc, p) => {
+        acc[p.lpTokenAddress.toLowerCase()] = p;
+        return acc;
+    }, {});
+    const mainnetVolumeByAddress = mainnetVolumes.data.data.pools.reduce((acc, v) => {
+        acc[v.address.toLowerCase()] = v;
+        return acc;
+    }, {});
+    const gearPool = poolFactoryByAddress[GEAR_POOL];
+    const gearVolume = mainnetVolumeByAddress[(gearPool?.address || "").toLowerCase()];
+    const gearAPY = {
+        base: curveAPYToBn(gearVolume?.latestDailyApyPcent || 0),
+        crv: curveAPYToBn(Math.max(...(gearPool?.gaugeCrvApy || []), 0)),
+        gauge: (gearPool?.gaugeRewards || []).map(({ apy = 0, tokenAddress }) => [
+            tokenAddress.toLowerCase(),
+            curveAPYToBn(apy),
+        ]),
+    };
+    return { curveAPY, gearAPY };
+}
+exports.getCurveAPY = getCurveAPY;
+async function getCurvePools(network) {
+    switch (network) {
+        case "Mainnet": {
+            const [volumes, mainnetFactoryPools, ...pools] = await Promise.all([
+                axios_1.default.get(getVolumesURL(network)),
+                axios_1.default.get(getFactoryCryptoURL(network)),
+                axios_1.default.get(getMainURL(network)),
+                axios_1.default.get(getCryptoURL(network)),
+                axios_1.default.get(getFactoryTriCryptoURL(network)),
+                axios_1.default.get(getFactoryCrvUsdURL(network)),
             ]);
-            const maxCrv = pool?.gaugeCrvApy?.length > 0 ? Math.max(...pool.gaugeCrvApy) : crvApy;
-            acc[curveSymbol] = {
-                base: curveAPYToBn(baseApy || 0),
-                crv: curveAPYToBn(maxCrv || 0),
-                gauge: extraRewards,
+            return {
+                mainnetVolumes: volumes,
+                mainnetFactoryPools,
+                volumes,
+                pools: [mainnetFactoryPools, ...pools],
             };
-            return acc;
-        }, {});
-        return curveAPY;
-    }
-    catch (e) {
-        console.error(e);
-        return null;
+        }
+        case "Arbitrum": {
+            const [mainnetVolumes, mainnetFactoryPools, volumes, ...pools] = await Promise.all([
+                axios_1.default.get(getVolumesURL("Mainnet")),
+                axios_1.default.get(getFactoryCryptoURL("Mainnet")),
+                axios_1.default.get(getVolumesURL(network)),
+                axios_1.default.get(getMainURL(network)),
+                axios_1.default.get(getFactoryStableNgURL(network)),
+            ]);
+            return {
+                mainnetVolumes,
+                mainnetFactoryPools,
+                volumes,
+                pools,
+            };
+        }
+        case "Optimism": {
+            const [mainnetVolumes, mainnetFactoryPools, volumes, ...pools] = await Promise.all([
+                axios_1.default.get(getVolumesURL("Mainnet")),
+                axios_1.default.get(getFactoryCryptoURL("Mainnet")),
+                axios_1.default.get(getVolumesURL(network)),
+                axios_1.default.get(getMainURL(network)),
+                axios_1.default.get(getFactoryStableNgURL(network)),
+            ]);
+            return {
+                mainnetVolumes,
+                mainnetFactoryPools,
+                volumes,
+                pools,
+            };
+        }
+        default:
+            throw new Error("Unknown network");
     }
 }
-exports.getCurveAPY = getCurveAPY;
 function curveAPYToBn(baseApy) {
-    return (0, formatter_1.toBN)((baseApy / CRV_APY_RESPONSE_DECIMALS).toString(), sdk_gov_1.WAD_DECIMALS_POW);
+    return Math.round(baseApy * Number(sdk_gov_1.PERCENTAGE_FACTOR));
+}
+async function getCurveGearPool() {
+    const resp = await axios_1.default.get(getFactoryCryptoURL("Mainnet"));
+    const { poolData = [] } = resp?.data?.data || {};
+    const poolDataByAddress = poolData.reduce((acc, p) => {
+        acc[p.lpTokenAddress.toLowerCase()] = p;
+        return acc;
+    }, {});
+    const gearPool = poolDataByAddress[GEAR_POOL];
+    return gearPool;
 }
+exports.getCurveGearPool = getCurveGearPool;

package/lib/apy/defiLamaAPY.d.ts

@@ -0,0 +1,4 @@
+import { NetworkType, PartialRecord, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { TokensWithAPY } from ".";
+export declare function getDefiLamaAPY(networkType: NetworkType, currentTokens: Record<SupportedToken, Address>): Promise<PartialRecord<TokensWithAPY, number>>;

package/lib/apy/defiLamaAPY.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefiLamaAPY = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const axios_1 = __importDefault(require("axios"));
+const endpoint_1 = require("../core/endpoint");
+async function getDefiLamaAPY(networkType, currentTokens) {
+    const currentNormal = NORMAL_TO_LAMA[networkType];
+    const idList = Object.values(currentNormal);
+    if (idList.length === 0)
+        return {};
+    const res = await axios_1.default.get(endpoint_1.GearboxBackendApi.getLlamaAPYUrl(idList));
+    const itemsRecord = res.data.data.reduce((acc, item) => {
+        acc[item.pool] = item;
+        return acc;
+    }, {});
+    const allAPY = Object.entries(currentNormal).reduce((acc, [symbol, pool]) => {
+        const { apy = 0 } = itemsRecord[pool] || {};
+        const token = currentTokens[symbol];
+        acc[token] = Math.round(apy * Number(sdk_gov_1.PERCENTAGE_FACTOR));
+        return acc;
+    }, {});
+    return allAPY;
+}
+exports.getDefiLamaAPY = getDefiLamaAPY;
+const NORMAL_TO_LAMA = {
+    Mainnet: {
+        sDAI: "c8a24fee-ec00-4f38-86c0-9f6daebc4225",
+        rETH: "d4b3c522-6127-4b89-bedf-83641cdcd2eb",
+        osETH: "4d01599c-69ae-41a3-bae1-5fab896f04c8",
+        auraB_rETH_STABLE_vault: "a4b5b995-99e7-4b8f-916d-8940b5627d70",
+        sUSDe: "66985a81-9c51-46ca-9977-42b4fe7bc6df",
+        stkcvxcrvFRAX: "bd072651-d99c-4154-aeae-51f12109c054",
+        stkcvxcrvUSDETHCRV: "654ac683-141b-42d3-b28d-b2f77eedd595",
+        stkcvxcrvUSDFRAX: "411af006-56b0-480a-9586-1071bccbd178",
+        stkcvxcrvUSDTWBTCWETH: "3be97c90-d4a8-42b3-a0d0-2906ae4e9d27",
+        stkcvxcrvUSDUSDC: "755fcec6-f4fd-4150-9184-60f099206694",
+        stkcvxcrvUSDUSDT: "a3ffd3fe-b21c-44eb-94d5-22c80057a600",
+    },
+    Optimism: { rETH: "d4b3c522-6127-4b89-bedf-83641cdcd2eb" },
+    Arbitrum: {
+        rETH: "d4b3c522-6127-4b89-bedf-83641cdcd2eb",
+        cbETH: "0f45d730-b279-4629-8e11-ccb5cc3038b4",
+        sfrxETH: "77020688-e1f9-443c-9388-e51ace15cc32",
+    },
+    Base: {},
+};
+// const CONVEX_TO_LAMA: Record<
+//   NetworkType,
+//   Record<ConvexStakedPhantomToken, string>
+// > = {
+//   Mainnet: {
+//     stkcvx3Crv: "7394f1bc-840a-4ff0-9e87-5e0ef932943a",
+//     stkcvxFRAX3CRV: "844a8a29-4653-42e6-b675-a6b43fac3678", // !!
+//     stkcvxgusd3CRV: "dc81639c-9391-4e56-96b9-76cfbcda61d4",
+//     stkcvxLUSD3CRV: "b61ef013-6391-4cdd-b057-b344ab852088", // !!
+//     stkcvxcrvPlain3andSUSD: "45f74ed5-5832-4d6d-8f2c-2929b6ac5e9c", // !!
+//     stkcvxsteCRV: "5ce23e7e-3800-4c9c-ad30-6db3db0515a1", // !!
+//     stkcvxcrvFRAX: "bd072651-d99c-4154-aeae-51f12109c054",
+//     stkcvxOHMFRAXBP: "42de7839-da37-4a99-8992-d6352177c4db", // !!
+//     stkcvxMIM_3LP3CRV: "8a20c472-142c-4442-b724-40f2183c073e",
+//     stkcvxcrvCRVETH: "disabled",
+//     stkcvxcrvCVXETH: "25d9dc49-3182-493a-bda4-0db53b25f457",
+//     stkcvxcrvUSDTWBTCWETH: "3be97c90-d4a8-42b3-a0d0-2906ae4e9d27",
+//     stkcvxLDOETH: "69361f05-1a95-4323-9b6f-44338ad22e98",
+//     stkcvxcrvUSDUSDC: "755fcec6-f4fd-4150-9184-60f099206694",
+//     stkcvxcrvUSDUSDT: "a3ffd3fe-b21c-44eb-94d5-22c80057a600",
+//     stkcvxcrvUSDFRAX: "411af006-56b0-480a-9586-1071bccbd178",
+//     stkcvxcrvUSDETHCRV: "654ac683-141b-42d3-b28d-b2f77eedd595",
+//   },
+//   Optimism: {} as any,
+//   Arbitrum: {} as any,
+// };

package/lib/apy/index.d.ts

@@ -1,10 +1,16 @@
 import { LPTokens, PartialRecord, SupportedToken } from "@gearbox-protocol/sdk-gov";
-export type AdditionalTokenWithAPY = Extract<SupportedToken, "STETH">;
-export declare const additionalTokensWIthAPY: Record<AdditionalTokenWithAPY, true>;
-export type TokensWithAPY = LPTokens | Extract<SupportedToken, "STETH">;
-export type LpTokensAPY = PartialRecord<TokensWithAPY, number>;
+import { Address } from "viem";
+type ExtraFarmTokens = Extract<SupportedToken, "STETH" | "rETH" | "osETH" | "cbETH" | "wstETH" | "weETH" | "ezETH" | "sfrxETH" | "USDe" | "rsETH" | "rswETH" | "pufETH" | "pzETH" | "rstETH" | "steakLRT" | "amphrETH" | "LBTC" | "Re7LRT">;
+type ExtraTokensWithAPY = Extract<ExtraFarmTokens, "STETH" | "rETH" | "osETH" | "cbETH" | "wstETH" | "sfrxETH" | "pzETH" | "ezETH" | "Re7LRT" | "rsETH" | "weETH" | "rswETH" | "rstETH" | "steakLRT" | "amphrETH" | "pufETH">;
+type LRTAndLSTTokens = Exclude<ExtraFarmTokens, "USDe">;
+export declare const isExtraFarmToken: (t: unknown) => t is ExtraFarmTokens;
+export declare const isLRT_LSTToken: (t: unknown) => t is LRTAndLSTTokens;
+export type TokensWithAPY = LPTokens | ExtraTokensWithAPY;
+export type TokensAPYList = PartialRecord<Address, number>;
 export declare const isTokenWithAPY: (t: unknown) => t is TokensWithAPY;
-export * from "./convexAPY";
+export type AllLPTokens = LPTokens | ExtraFarmTokens;
+export declare const isFarmToken: (t: unknown) => t is AllLPTokens;
 export * from "./curveAPY";
+export * from "./defiLamaAPY";
 export * from "./lidoAPY";
 export * from "./yearnAPY";

package/lib/apy/index.js

@@ -14,16 +14,76 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTokenWithAPY = exports.additionalTokensWIthAPY = void 0;
+exports.isFarmToken = exports.isTokenWithAPY = exports.isLRT_LSTToken = exports.isExtraFarmToken = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-exports.additionalTokensWIthAPY = {
+const EXTRA_FARM_TOKENS = {
     STETH: true,
+    rETH: true,
+    osETH: true,
+    cbETH: true,
+    wstETH: true,
+    weETH: true,
+    ezETH: true,
+    sfrxETH: true,
+    USDe: true,
+    rsETH: true,
+    rswETH: true,
+    pufETH: true,
+    pzETH: true,
+    rstETH: true,
+    steakLRT: true,
+    amphrETH: true,
+    LBTC: true,
+    Re7LRT: true,
+};
+const isExtraFarmToken = (t) => {
+    if (typeof t !== "string")
+        return false;
+    return !!EXTRA_FARM_TOKENS[t];
+};
+exports.isExtraFarmToken = isExtraFarmToken;
+const EXTRA_TOKENS_WITH_APY = {
+    STETH: true,
+    osETH: true,
+    rETH: true,
+    wstETH: true,
+    cbETH: true,
+    sfrxETH: true,
+    pzETH: true,
+    ezETH: true,
+    Re7LRT: true,
+    rsETH: true,
+    weETH: true,
+    rswETH: true,
+    rstETH: true,
+    steakLRT: true,
+    amphrETH: true,
+    pufETH: true,
+};
+const isExtraTokenWithAPY = (t) => {
+    if (typeof t !== "string")
+        return false;
+    return !!EXTRA_TOKENS_WITH_APY[t];
+};
+const { USDe, ...rest } = EXTRA_FARM_TOKENS;
+const LRT_LST = rest;
+const isLRT_LSTToken = (t) => {
+    if (typeof t !== "string")
+        return false;
+    return !!LRT_LST[t];
+};
+exports.isLRT_LSTToken = isLRT_LSTToken;
+const isTokenWithAPY = (t) => {
+    if (typeof t !== "string")
+        return false;
+    return (0, sdk_gov_1.isLPToken)(t) || isExtraTokenWithAPY(t);
 };
-const isTokenWithAPY = (t) => typeof t === "string" &&
-    (!!sdk_gov_1.lpTokens[t] ||
-        !!exports.additionalTokensWIthAPY[t]);
 exports.isTokenWithAPY = isTokenWithAPY;
-__exportStar(require("./convexAPY"), exports);
+const isFarmToken = (t) => {
+    return (0, sdk_gov_1.isLPToken)(t) || (0, exports.isExtraFarmToken)(t);
+};
+exports.isFarmToken = isFarmToken;
 __exportStar(require("./curveAPY"), exports);
+__exportStar(require("./defiLamaAPY"), exports);
 __exportStar(require("./lidoAPY"), exports);
 __exportStar(require("./yearnAPY"), exports);

package/lib/apy/lidoAPY.d.ts

@@ -1 +1,4 @@
-export declare function getLidoAPY(): Promise<bigint>;
+import { PartialRecord, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+export type LidoAPYResult = PartialRecord<Address, number>;
+export declare function getLidoAPY(currentTokens: Record<SupportedToken, Address>): Promise<LidoAPYResult>;

package/lib/apy/lidoAPY.js

@@ -6,17 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLidoAPY = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const axios_1 = __importDefault(require("axios"));
-const formatter_1 = require("../utils/formatter");
 const LIDO_URL = "https://eth-api.lido.fi/v1/protocol/steth/apr/sma";
-async function getLidoAPY() {
-    try {
-        const res = await axios_1.default.get(LIDO_URL);
-        const { smaApr = 0 } = res?.data?.data || {};
-        return (0, formatter_1.toBN)(String(smaApr), sdk_gov_1.WAD_DECIMALS_POW) / sdk_gov_1.PERCENTAGE_DECIMALS;
-    }
-    catch (e) {
-        console.error(e);
-        return 0n;
-    }
+async function getLidoAPY(currentTokens) {
+    const res = await axios_1.default.get(LIDO_URL);
+    const { smaApr = 0 } = res?.data?.data || {};
+    const r = Math.round(smaApr * Number(sdk_gov_1.PERCENTAGE_FACTOR));
+    return {
+        [currentTokens.STETH]: r,
+        [currentTokens.wstETH]: r,
+    };
 }
 exports.getLidoAPY = getLidoAPY;

package/lib/apy/yearnAPY.d.ts

@@ -1,3 +1,4 @@
-import { YearnLPToken } from "@gearbox-protocol/sdk-gov";
-export type YearnAPYResult = Record<YearnLPToken, bigint>;
-export declare function getYearnAPY(): Promise<YearnAPYResult | null>;
+import { NetworkType, PartialRecord, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+export type YearnAPYResult = PartialRecord<Address, number>;
+export declare function getYearnAPY(network: NetworkType, currentTokens: Record<SupportedToken, Address>): Promise<YearnAPYResult>;