@gearbox-protocol/sdk 3.0.0-next.2 → 3.0.0-next.200

package/contracts/IAirdropDistributor.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+struct DistributionData {
+    address account;
+    uint8 campaignId;
+    uint256 amount;
+}
+
+struct ClaimedData {
+    address account;
+    uint256 amount;
+}
+
+interface IAirdropDistributorEvents {
+    /// @dev Emits when a user claims tokens
+    event Claimed(
+        address indexed account,
+        uint256 amount,
+        bool indexed historic
+    );
+
+    /// @dev Emits when the owner replaces the merkle root
+    event RootUpdated(bytes32 oldRoot, bytes32 indexed newRoot);
+
+    /// @dev Emitted from a special function after updating the root to index allocations
+    event TokenAllocated(
+        address indexed account,
+        uint8 indexed campaignId,
+        uint256 amount
+    );
+}
+
+interface IAirdropDistributor is IAirdropDistributorEvents {
+    /// @dev Returns the token distributed by this contract.
+    function token() external view returns (IERC20);
+
+    /// @dev Returns the current merkle root containing total claimable balances
+    function merkleRoot() external view returns (bytes32);
+
+    /// @dev Returns the total amount of token claimed by the user
+    function claimed(address user) external view returns (uint256);
+
+    // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.
+    /// @dev Claims the given amount of the token for the account. Reverts if the inputs are not a leaf in the tree
+    ///      or the total claimed amount for the account is more than the leaf amount.
+    function claim(
+        uint256 index,
+        address account,
+        uint256 totalAmount,
+        bytes32[] calldata merkleProof
+    ) external;
+}

package/contracts/IDegenDistributor.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.0;
+
+interface IDegenDistributorEvents {
+    /// @dev Emits when a user claims tokens
+    event Claimed(address indexed account, uint256 amount);
+
+    /// @dev Emits when the owner replaces the merkle root
+    event RootUpdated(bytes32 oldRoot, bytes32 indexed newRoot);
+}
+
+interface IDegenDistributor is IDegenDistributorEvents {
+    // Returns the merkle root of the merkle tree containing account balances available to claim.
+    function merkleRoot() external view returns (bytes32);
+
+    /// @dev Returns the total amount of token claimed by the user
+    function claimed(address user) external view returns (uint256);
+
+    // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.
+    /// @dev Claims the remaining unclaimed amount of the token for the account. Reverts if the inputs are not a leaf in the tree
+    ///      or the total claimed amount for the account is more than the leaf amount.
+    function claim(
+        uint256 index,
+        address account,
+        uint256 totalAmount,
+        bytes32[] calldata merkleProof
+    ) external;
+}

package/contracts/IOffchainOracle.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: BUSL-1.1
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2021
+pragma solidity ^0.8.10;
+
+interface IOffchainOracle {
+    function getRate(
+        address srcToken,
+        address dstToken,
+        bool useWrappers
+    ) external view returns (uint256 weightedRate);
+
+    function getRateToEth(address srcToken, bool useSrcWrappers)
+        external
+        view
+        returns (uint256 weightedRate);
+}

package/contracts/IWETHGateway.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Holdings, 2022
+pragma solidity ^0.8.10;
+
+interface IWETHGateway {
+    /// @dev Converts ETH to WETH and add liqudity to the pool
+    /// @param pool Address of PoolService contract to add liquidity to. This pool must have WETH as an underlying.
+    /// @param onBehalfOf The address that will receive the diesel token.
+    /// @param referralCode Code used to log the transaction facilitator, for potential rewards. 0 if non-applicable.
+    function addLiquidityETH(
+        address pool,
+        address onBehalfOf,
+        uint16 referralCode
+    ) external payable;
+
+    /// @dev Removes liquidity from the pool and converts WETH to ETH
+    ///       - burns lp's diesel (LP) tokens
+    ///       - unwraps WETH to ETH and sends to the LP
+    /// @param pool Address of PoolService contract to withdraw liquidity from. This pool must have WETH as an underlying.
+    /// @param amount Amount of Diesel tokens to send.
+    /// @param to Address to transfer ETH to.
+    function removeLiquidityETH(
+        address pool,
+        uint256 amount,
+        address payable to
+    ) external;
+
+    /// @dev Converts WETH to ETH, and sends to the passed address
+    /// @param to Address to send ETH to
+    /// @param amount Amount of WETH to unwrap
+    function unwrapWETH(address to, uint256 amount) external;
+}

package/contracts/IwstETHGateway.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+interface IwstETHGateWay {
+    error NonRegisterPoolException();
+
+    /**
+     * @dev Adds stETH liquidity to wstETH pool
+     * - transfers the underlying to the pool
+     * - mints Diesel (LP) tokens to onBehalfOf
+     * @param amount Amount of tokens to be deposited
+     * @param onBehalfOf The address that will receive the dToken
+     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
+     *   0 if the action is executed directly by the user, without a facilitator.
+     */
+    function addLiquidity(uint256 amount, address onBehalfOf, uint256 referralCode) external;
+
+    /// @dev Removes liquidity from pool
+    ///  - burns LP's Diesel (LP) tokens
+    ///  - returns the equivalent amount of underlying to 'to'
+    /// @param amount Amount of Diesel tokens to burn
+    /// @param to Address to transfer the underlying to
+    function removeLiquidity(uint256 amount, address to) external returns (uint256 amountGet);
+}

package/contracts/index.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: UNLICENSED
+// Gearbox Protocol. Generalized leverage for DeFi protocols
+// (c) Gearbox Foundation, 2023.
+
+pragma solidity ^0.8.10;
+
+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";
+import {ILinearInterestRateModelV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ILinearInterestRateModelV3.sol";
+import {IPoolQuotaKeeperV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPoolQuotaKeeperV3.sol";
+import {IGaugeV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IGaugeV3.sol";
+import {ICreditFacadeV3} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3.sol";
+import {IPoolService} from "@gearbox-protocol/core-v2/contracts/interfaces/IPoolService.sol";
+import {ICreditFacadeV2} from "@gearbox-protocol/core-v2/contracts/interfaces/ICreditFacadeV2.sol";
+import {ICreditConfiguratorV2} from "@gearbox-protocol/core-v2/contracts/interfaces/ICreditConfiguratorV2.sol";
+import {IERC20ZapperDeposits} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/zappers/IERC20ZapperDeposits.sol";
+import {IETHZapperDeposits} from "@gearbox-protocol/integrations-v3/contracts/interfaces/zappers/IETHZapperDeposits.sol";
+import {IZapper} from "@gearbox-protocol/integrations-v3/contracts/interfaces/zappers/IZapper.sol";
+import {IZapperRegister} from "@gearbox-protocol/periphery-v3/contracts/interfaces/IZapperRegister.sol";
+import {IDegenNFTV2} from "@gearbox-protocol/core-v2/contracts/interfaces/IDegenNFTV2.sol";
+import {IBotListV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IBotListV3.sol";
+
+import {IGearStakingV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IGearStakingV3.sol";
+import {IControllerTimelockV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IControllerTimelockV3.sol";
+
+// Adapters
+import {IAaveV2_LendingPoolAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/aave/IAaveV2_LendingPoolAdapter.sol";
+import {IAaveV2_WrappedATokenAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/aave/IAaveV2_WrappedATokenAdapter.sol";
+import {IBalancerV2VaultAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/balancer/IBalancerV2VaultAdapter.sol";
+import {ICompoundV2_CTokenAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/compound/ICompoundV2_CTokenAdapter.sol";
+import {ILidoV1Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/lido/ILidoV1Adapter.sol";
+import {IBaseRewardPool} from "@gearbox-protocol/integrations-v3/contracts/integrations/convex/IBaseRewardPool.sol";
+import {IConvexToken} from "@gearbox-protocol/integrations-v3/contracts/integrations/convex/IConvexToken.sol";
+import {ICurvePool} from "@gearbox-protocol/integrations-v3/contracts/integrations/curve/ICurvePool.sol";
+import {IConvexV1BaseRewardPoolAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/convex/IConvexV1BaseRewardPoolAdapter.sol";
+import {IConvexV1BoosterAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/convex/IConvexV1BoosterAdapter.sol";
+import {IERC4626Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/erc4626/IERC4626Adapter.sol";
+
+import {IInterestRateModel} from "@gearbox-protocol/core-v2/contracts/interfaces/IInterestRateModel.sol";
+import {IUniswapV2Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/uniswap/IUniswapV2Adapter.sol";
+import {IUniswapV3Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/uniswap/IUniswapV3Adapter.sol";
+import {IYVault} from "@gearbox-protocol/integrations-v3/contracts/integrations/yearn/IYVault.sol";
+import {IYearnV2Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/yearn/IYearnV2Adapter.sol";
+
+import {IwstETHV1Adapter} from "@gearbox-protocol/integrations-v3/contracts/interfaces/lido/IwstETHV1Adapter.sol";
+import {IstETH} from "@gearbox-protocol/integrations-v3/contracts/integrations/lido/IstETH.sol";
+import {IwstETH} from "@gearbox-protocol/integrations-v3/contracts/integrations/lido/IwstETH.sol";
+import {IPriceOracleBase} from "@gearbox-protocol/core-v2/contracts/interfaces/IPriceOracleBase.sol";
+import {IPriceOracleV2} from "@gearbox-protocol/core-v2/contracts/interfaces/IPriceOracle.sol";
+import {IPriceOracleV3} from "@gearbox-protocol/core-v3/contracts/interfaces/IPriceOracleV3.sol";
+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";
+
+import {ICurveV1_3AssetsAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_3AssetsAdapter.sol";
+
+import {ICurveV1_4AssetsAdapter} from
+    "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_4AssetsAdapter.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/auraAPY.d.ts

@@ -0,0 +1 @@
+export declare function getAURAMintAmount(amount: bigint, totalSupply: bigint, multiplier: bigint): bigint;

package/lib/apy/auraAPY.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAURAMintAmount = void 0;
+const CVX_MAX_SUPPLY = 50000000000000000000000000n;
+const CVX_REDUCTION_PER_CLIFF = 100000000000000000000000n;
+const CVX_TOTAL_CLIFFS = 500n;
+const INITIAL_SUPPLY = 5n * 10n ** 25n;
+const INITIAL_CLIFFS = 700n;
+function getAURAMintAmount(amount, totalSupply, multiplier) {
+    if (totalSupply <= 0n)
+        return 0n;
+    const effectiveAmount = (amount * multiplier) / 10000n;
+    const emissionMinted = totalSupply - INITIAL_SUPPLY;
+    const cliff = emissionMinted / CVX_REDUCTION_PER_CLIFF;
+    if (cliff < CVX_TOTAL_CLIFFS) {
+        const reduction = INITIAL_CLIFFS + ((CVX_TOTAL_CLIFFS - cliff) * 5n) / 2n;
+        const mintedAmount = (effectiveAmount * reduction) / CVX_TOTAL_CLIFFS;
+        const amountTillMax = CVX_MAX_SUPPLY - emissionMinted;
+        return mintedAmount > amountTillMax ? amountTillMax : mintedAmount;
+    }
+    return 0n;
+}
+exports.getAURAMintAmount = getAURAMintAmount;

package/lib/apy/auraAbi.d.ts

@@ -0,0 +1,17 @@
+import { Interface } from "ethers";
+export declare const AURA_BOOSTER_ABI: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+export declare const AURA_BOOSTER_INTERFACE: Interface;

package/lib/apy/auraAbi.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AURA_BOOSTER_INTERFACE = exports.AURA_BOOSTER_ABI = void 0;
+const ethers_1 = require("ethers");
+exports.AURA_BOOSTER_ABI = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "input",
+                type: "address",
+            },
+        ],
+        name: "getRewardMultipliers",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "multiplier",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+exports.AURA_BOOSTER_INTERFACE = new ethers_1.Interface(exports.AURA_BOOSTER_ABI);

package/lib/apy/convexAPY.d.ts

@@ -1,16 +1,18 @@
 import { ConvexPoolContract, ConvexPoolParams, CurveGEARPoolParams, CurveParams, CurveSteCRVPoolParams, MCall, NetworkType } from "@gearbox-protocol/sdk-gov";
 import { CurveLPToken } from "@gearbox-protocol/sdk-gov/lib/tokens/curveLP";
 import { SupportedToken } from "@gearbox-protocol/sdk-gov/lib/tokens/token";
-import { BigNumber } from "ethers";
+import { BigNumberish } from "ethers";
 import { CurveAPYResult } from "./curveAPY";
 type GetTokenPriceCallback = (tokenAddress: string, currency?: string) => bigint;
 export interface GetConvexAPYBulkProps {
     getTokenPrice: GetTokenPriceCallback;
-    curveAPY: CurveAPYResult;
+    curveAPY: CurveAPYResult | undefined;
     generated: GetConvexAPYBulkCallsReturns;
-    response: Array<BigNumber>;
+    response: Array<BigNumberish>;
+    network: NetworkType;
+    currentTimestamp: number;
 }
-export declare function getConvexAPYBulk(props: GetConvexAPYBulkProps): bigint[];
+export declare function getConvexAPYBulk(props: GetConvexAPYBulkProps): number[];
 interface PoolInfo {
     cvxPool: ConvexPoolParams;
     cvxPoolAddress: string;
@@ -25,11 +27,11 @@ type CrvParams = CurveParams | CurveSteCRVPoolParams | CurveGEARPoolParams;
 type GetConvexAPYBulkCallsReturns = ReturnType<typeof getConvexAPYBulkCalls>;
 export interface GetConvexAPYBulkCallsProps {
     pools: Array<ConvexPoolContract>;
-    networkType: NetworkType;
+    network: NetworkType;
 }
-export declare function getConvexAPYBulkCalls({ pools, networkType, }: GetConvexAPYBulkCallsProps): {
+export declare function getConvexAPYBulkCalls({ pools, network, }: GetConvexAPYBulkCallsProps): {
     poolsInfo: PoolInfo[];
-    calls: [MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/curve/ICurvePool").ICurvePoolInterface>, MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IConvexToken").IConvexTokenInterface>, ...(MCall<import("../types/@gearbox-protocol/integrations-v2/contracts/integrations/convex/IBaseRewardPool").IBaseRewardPoolInterface> | MCall<any>)[]][];
+    calls: [MCall<import("../types/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/IBaseRewardPool").IBaseRewardPoolInterface>, MCall<import("../types/ICurvePool").ICurvePoolInterface>, MCall<import("../types/IConvexToken").IConvexTokenInterface>, ...(MCall<import("../types/IBaseRewardPool").IBaseRewardPoolInterface> | MCall<any>)[]][];
 };
 export interface CalculateConvexAPYProps {
     cvxPoolRate: bigint;
@@ -42,7 +44,8 @@ export interface CalculateConvexAPYProps {
     crvLpPrice: Array<bigint>;
     info: PoolInfo;
     getTokenPrice: GetTokenPriceCallback;
-    curveAPY: CurveAPYResult;
+    curveAPY: CurveAPYResult | undefined;
+    currentTimestamp: number;
 }
 export declare function getCVXMintAmount(crvAmount: bigint, cvxTokenSupply: bigint): bigint;
 export {};

package/lib/apy/convexAPY.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCVXMintAmount = exports.getConvexAPYBulkCalls = exports.getConvexAPYBulk = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const token_1 = require("@gearbox-protocol/sdk-gov/lib/tokens/token");
-const utils_1 = require("ethers/lib/utils");
+const ethers_1 = require("ethers");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 const V2_POOLS = { 20: true };
 function getConvexAPYBulk(props) {
+    if (props.network !== "Mainnet") {
+        return [];
+    }
     const { poolsInfo, calls } = props.generated;
     const [parsedResponse] = calls.reduce(([acc, start], call) => {
         const end = start + call.length;
@@ -24,29 +26,30 @@ function getConvexAPYBulk(props) {
         const lpPriceEnd = extraFinishEnd + crvLpPriceList.length;
         const crvLpPrice = rest.slice(extraFinishEnd, lpPriceEnd);
         const apy = calculateConvexAPY({
-            cvxPoolRewardsFinish: (0, formatter_1.toBigInt)(cvxPoolRewardsFinish),
-            cvxPoolRate: (0, formatter_1.toBigInt)(cvxPoolRate),
-            cvxPoolSupply: (0, formatter_1.toBigInt)(cvxPoolSupply),
-            crvVPrice: (0, formatter_1.toBigInt)(crvVPrice),
-            cvxTokenSupply: (0, formatter_1.toBigInt)(cvxTokenSupply),
-            cvxExtraRewards: cvxExtraRewards.map(v => (0, formatter_1.toBigInt)(v)),
-            cvxExtraRewardsFinish: cvxExtraRewardsFinish.map(v => (0, formatter_1.toBigInt)(v)),
-            crvLpPrice: crvLpPrice.map(v => (0, formatter_1.toBigInt)(v)),
+            cvxPoolRewardsFinish: (0, sdk_gov_1.toBigInt)(cvxPoolRewardsFinish || 0n),
+            cvxPoolRate: (0, sdk_gov_1.toBigInt)(cvxPoolRate || 0n),
+            cvxPoolSupply: (0, sdk_gov_1.toBigInt)(cvxPoolSupply || 0n),
+            crvVPrice: (0, sdk_gov_1.toBigInt)(crvVPrice || 0n),
+            cvxTokenSupply: (0, sdk_gov_1.toBigInt)(cvxTokenSupply || 0n),
+            cvxExtraRewards: cvxExtraRewards.map(v => (0, sdk_gov_1.toBigInt)(v || 0n)),
+            cvxExtraRewardsFinish: cvxExtraRewardsFinish.map(v => (0, sdk_gov_1.toBigInt)(v || 0n)),
+            crvLpPrice: crvLpPrice.map(v => (0, sdk_gov_1.toBigInt)(v || 0n)),
             info: poolsInfo[i],
             getTokenPrice: props.getTokenPrice,
             curveAPY: props.curveAPY,
+            currentTimestamp: props.currentTimestamp,
         });
         return apy;
     });
     return apyList;
 }
 exports.getConvexAPYBulk = getConvexAPYBulk;
-function getPoolInfo({ pool, networkType }) {
-    const tokenList = token_1.tokenDataByNetwork[networkType];
-    const contractsList = sdk_gov_1.contractsByNetwork[networkType];
+function getPoolInfo({ pool, network }) {
+    const tokenList = token_1.tokenDataByNetwork[network];
+    const contractsList = sdk_gov_1.contractsByNetwork[network];
     const poolParams = sdk_gov_1.contractParams[pool];
     const basePoolAddress = contractsList[pool];
-    const extraPoolAddresses = poolParams.extraRewards.map(d => d.poolAddress[networkType]);
+    const extraPoolAddresses = poolParams.extraRewards.map(d => d.poolAddress[network]);
     const stakedTokenParams = token_1.supportedTokens[poolParams.stakedToken];
     const { underlying } = stakedTokenParams;
     const crvParams = token_1.supportedTokens[underlying];
@@ -66,8 +69,11 @@ function getPoolInfo({ pool, networkType }) {
         tokenList,
     };
 }
-function getConvexAPYBulkCalls({ pools, networkType, }) {
-    const poolsInfo = pools.map(pool => getPoolInfo({ networkType, pool }));
+function getConvexAPYBulkCalls({ pools, network, }) {
+    if (network !== "Mainnet") {
+        return { poolsInfo: [], calls: [] };
+    }
+    const poolsInfo = pools.map(pool => getPoolInfo({ network, pool }));
     const calls = poolsInfo.map(info => getPoolDataCalls(info));
     return { poolsInfo, calls };
 }
@@ -113,7 +119,7 @@ function getPoolDataCalls(props) {
             ? [
                 {
                     address: props.crvPoolAddress,
-                    interface: new utils_1.Interface([
+                    interface: new ethers_1.Interface([
                         "function lp_price() view returns (uint256)",
                     ]),
                     method: "lp_price()",
@@ -135,7 +141,6 @@ const CURRENCY_LIST = {
 };
 function calculateConvexAPY(props) {
     const { tokenList, cvxPool, crvToken, cvxExtraPools } = props.info;
-    const currentTimestamp = getTimestampInSeconds();
     const currencySymbol = CURRENCY_LIST[cvxPool.stakedToken];
     const currency = currencySymbol && tokenList[currencySymbol || ""];
     const cvxPrice = props.getTokenPrice(tokenList.CVX, currency);
@@ -143,10 +148,12 @@ function calculateConvexAPY(props) {
     const crvPerSecond = props.cvxPoolRate;
     const vPrice = getVirtualPrice(props);
     const virtualSupply = (props.cvxPoolSupply * vPrice) / sdk_gov_1.WAD;
+    if (!virtualSupply)
+        return 0;
     const crvPerUnderlying = (crvPerSecond * sdk_gov_1.WAD) / virtualSupply;
     const crvPerYear = crvPerUnderlying * BigInt(sdk_gov_1.SECONDS_PER_YEAR);
     const cvxPerYear = getCVXMintAmount(crvPerYear, props.cvxTokenSupply);
-    const baseFinished = props.cvxPoolRewardsFinish <= currentTimestamp;
+    const baseFinished = props.cvxPoolRewardsFinish <= props.currentTimestamp;
     const crvAPY = baseFinished ? 0n : (crvPerYear * crvPrice) / sdk_gov_1.PRICE_DECIMALS;
     const cvxAPY = baseFinished ? 0n : (cvxPerYear * cvxPrice) / sdk_gov_1.PRICE_DECIMALS;
     const extraAPRs = cvxExtraPools.map((_, index) => {
@@ -157,15 +164,15 @@ function calculateConvexAPY(props) {
         const perYear = perUnderlying * BigInt(sdk_gov_1.SECONDS_PER_YEAR);
         const extraPrice = props.getTokenPrice(tokenList[extraRewardSymbol], currency);
         const extraAPY = (perYear * extraPrice) / sdk_gov_1.PRICE_DECIMALS;
-        const finished = extraFinished <= currentTimestamp;
+        const finished = extraFinished <= props.currentTimestamp;
         return finished ? 0n : extraAPY;
     });
     const extraAPYTotal = extraAPRs.reduce((acc, apy) => acc + apy, 0n);
-    const baseApyWAD = props.curveAPY[crvToken].base;
-    return baseApyWAD + crvAPY + cvxAPY + extraAPYTotal;
-}
-function getTimestampInSeconds() {
-    return Math.floor(Date.now() / 1000);
+    const baseApy = props.curveAPY?.[crvToken]?.base || 0;
+    const apyTotal = crvAPY + cvxAPY + extraAPYTotal;
+    const apyTotalInPercent = apyTotal * sdk_gov_1.PERCENTAGE_DECIMALS * sdk_gov_1.PERCENTAGE_FACTOR;
+    const r = baseApy + Math.round(Number((apyTotalInPercent * 10n) / sdk_gov_1.WAD) / 10);
+    return r;
 }
 function getCVXMintAmount(crvAmount, cvxTokenSupply) {
     const currentCliff = cvxTokenSupply / CVX_REDUCTION_PER_CLIFF;

package/lib/apy/curveAPY.d.ts

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