@gearbox-protocol/sdk 3.0.0-next.246 → 3.0.0-next.248

package/contracts/index.sol

@@ -62,6 +62,8 @@ import {IPriceFeed} from "@gearbox-protocol/core-v2/contracts/interfaces/IPriceF
 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 {PendleTWAPPTPriceFeed} from "@gearbox-protocol/oracles-v3/contracts/oracles/pendle/PendleTWAPPTPriceFeed.sol";
+
 
 import {ICurveV1_2AssetsAdapter} from
     "@gearbox-protocol/integrations-v3/contracts/interfaces/curve/ICurveV1_2AssetsAdapter.sol";
@@ -74,6 +76,8 @@ import {ICurveV1_4AssetsAdapter} from
 
 import {IStakingRewardsAdapter} from
     "@gearbox-protocol/integrations-v3/contracts/interfaces/sky/IStakingRewardsAdapter.sol";
+
+    
     
 
 

package/lib/core/creditAccount.d.ts

@@ -17,12 +17,14 @@ export interface CalcOverallAPYProps {
     debt: bigint | undefined;
     baseRateWithFee: number;
     underlyingToken: Address;
+    tokensList: Record<Address, TokenData>;
 }
 export interface CalcMaxLendingDebtProps {
     assets: Array<Asset>;
     prices: Record<Address, bigint>;
     liquidationThresholds: Record<Address, bigint>;
     underlyingToken: Address;
+    tokensList: Record<Address, TokenData>;
     targetHF?: bigint;
 }
 export interface CalcHealthFactorProps {
@@ -33,6 +35,7 @@ export interface CalcHealthFactorProps {
     liquidationThresholds: Record<Address, bigint>;
     underlyingToken: Address;
     debt: bigint;
+    tokensList: Record<Address, TokenData>;
 }
 export interface CalcDefaultQuotaProps {
     amount: bigint;
@@ -83,6 +86,7 @@ interface LiquidationPriceProps {
     underlyingToken: Address;
     targetToken: Address;
     assets: Record<Address, Asset>;
+    tokensList: Record<Address, TokenData>;
 }
 export interface TimeToLiquidationProps {
     totalBorrowRate_debt: bigint;
@@ -126,11 +130,11 @@ export declare class CreditAccountData {
     isQuoted(token: Address): boolean;
     isTokenEnabled(token: Address): boolean;
     static calcMaxDebtIncrease(healthFactor: number, debt: bigint, underlyingLT: number, minHf?: number): bigint;
-    static calcMaxLendingDebt({ assets, liquidationThresholds, underlyingToken, prices, targetHF, }: CalcMaxLendingDebtProps): bigint;
-    static calcOverallAPY({ caAssets, lpAPY, prices, quotas, quotaRates, feeInterest, totalValue, debt, baseRateWithFee, underlyingToken, }: CalcOverallAPYProps): bigint | undefined;
+    static calcMaxLendingDebt({ assets, liquidationThresholds, underlyingToken, prices, tokensList, targetHF, }: CalcMaxLendingDebtProps): bigint;
+    static calcOverallAPY({ caAssets, lpAPY, prices, quotas, quotaRates, feeInterest, totalValue, debt, baseRateWithFee, underlyingToken, tokensList, }: CalcOverallAPYProps): bigint | undefined;
     hash(): string;
     static hash(creditManager: Address, borrower: Address): string;
-    static calcHealthFactor({ assets, quotas, quotasInfo, liquidationThresholds, underlyingToken, debt, prices, }: CalcHealthFactorProps): number;
+    static calcHealthFactor({ assets, quotas, quotasInfo, liquidationThresholds, underlyingToken, debt, prices, tokensList, }: CalcHealthFactorProps): number;
     static roundUpQuota(quotaChange: bigint): bigint;
     static calcRecommendedQuota({ amount, debt, lt, quotaReserve, }: CalcRecommendedQuotaProps): bigint;
     static calcDefaultQuota({ amount, lt, quotaReserve }: CalcDefaultQuotaProps): bigint;
@@ -138,7 +142,7 @@ export declare class CreditAccountData {
     private static getSingleQuotaChange;
     static calcQuotaBorrowRate({ quotas, quotaRates }: CalcQuotaBorrowRateProps): bigint;
     static calcRelativeBaseBorrowRate({ debt, baseRateWithFee, assetAmountInUnderlying, }: CalcRelativeBaseBorrowRateProps): bigint;
-    static liquidationPrice({ liquidationThresholds, debt, underlyingToken, targetToken, assets, }: LiquidationPriceProps): bigint;
+    static liquidationPrice({ liquidationThresholds, debt, underlyingToken, targetToken, assets, tokensList, }: LiquidationPriceProps): bigint;
     /**
      * Calculates the time remaining until liquidation for a credit account.
      * @returns The time remaining until liquidation in milliseconds.

package/lib/core/creditAccount.js

@@ -155,9 +155,9 @@ class CreditAccountData {
         const result = (debt * BigInt(healthFactor - minHf)) / BigInt(minHf - underlyingLT);
         return math_1.BigIntMath.max(0n, result);
     }
-    static calcMaxLendingDebt({ assets, liquidationThresholds, underlyingToken, prices, targetHF = sdk_gov_1.PERCENTAGE_FACTOR, }) {
+    static calcMaxLendingDebt({ assets, liquidationThresholds, underlyingToken, prices, tokensList, targetHF = sdk_gov_1.PERCENTAGE_FACTOR, }) {
         const assetsLTMoney = assets.reduce((acc, { token: tokenAddress, balance: amount }) => {
-            const [, tokenDecimals] = (0, sdk_gov_1.extractTokenData)(tokenAddress);
+            const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
             const lt = liquidationThresholds[tokenAddress] || 0n;
             const price = prices[tokenAddress] || 0n;
             const tokenMoney = price_1.PriceUtils.calcTotalPrice(price, amount, tokenDecimals);
@@ -165,7 +165,7 @@ class CreditAccountData {
             return acc + tokenLtMoney;
         }, 0n);
         const underlyingPrice = prices[underlyingToken] || 0n;
-        const [, underlyingDecimals = 18] = (0, sdk_gov_1.extractTokenData)(underlyingToken);
+        const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
         // HF = TWV / D => D = TWV / HF; D = amount * price
         // Debt_max = sum(LT_i * Asset_i * price_i) / (price_underlying * HF)
         const max = underlyingPrice > 0
@@ -176,26 +176,24 @@ class CreditAccountData {
             : 0n;
         return max;
     }
-    static calcOverallAPY({ caAssets, lpAPY, prices, quotas, quotaRates, feeInterest, totalValue, debt, baseRateWithFee, underlyingToken, }) {
+    static calcOverallAPY({ caAssets, lpAPY, prices, quotas, quotaRates, feeInterest, totalValue, debt, baseRateWithFee, underlyingToken, tokensList, }) {
         if (!lpAPY ||
             !totalValue ||
             totalValue <= 0n ||
             !debt ||
             totalValue <= debt)
             return undefined;
-        const underlyingTokenAddressLC = underlyingToken.toLowerCase();
-        const underlyingTokenSymbol = sdk_gov_1.tokenSymbolByAddress[underlyingTokenAddressLC] || "";
+        const underlyingTokenSymbol = sdk_gov_1.tokenSymbolByAddress[underlyingToken] || "";
         const underlyingTokenDecimals = sdk_gov_1.decimals[underlyingTokenSymbol] || 18;
-        const underlyingPrice = prices[underlyingTokenAddressLC];
+        const underlyingPrice = prices[underlyingToken];
         const assetAPYMoney = caAssets.reduce((acc, { token: tokenAddress, balance: amount }) => {
-            const tokenAddressLC = tokenAddress.toLowerCase();
-            const [symbol = "", tokenDecimals] = (0, sdk_gov_1.extractTokenData)(tokenAddressLC);
+            const { symbol = "", decimals: tokenDecimals = 18 } = tokensList[tokenAddress] || {};
             const apy = lpAPY[symbol] || 0;
-            const price = prices[tokenAddressLC] || 0n;
+            const price = prices[tokenAddress] || 0n;
             const money = price_1.PriceUtils.calcTotalPrice(price, amount, tokenDecimals);
             const apyMoney = money * BigInt(apy);
-            const { rate: quotaAPY = 0n, isActive = false } = quotaRates?.[tokenAddressLC] || {};
-            const { balance: quotaBalance = 0n } = quotas[tokenAddressLC] || {};
+            const { rate: quotaAPY = 0n, isActive = false } = quotaRates?.[tokenAddress] || {};
+            const { balance: quotaBalance = 0n } = quotas[tokenAddress] || {};
             const quotaAmount = isActive ? quotaBalance : 0n;
             const quotaMoney = price_1.PriceUtils.calcTotalPrice(underlyingPrice || 0n, quotaAmount, underlyingTokenDecimals);
             const quotaRate = (quotaAPY * (BigInt(feeInterest) + sdk_gov_1.PERCENTAGE_FACTOR)) /
@@ -218,13 +216,13 @@ class CreditAccountData {
     static hash(creditManager, borrower) {
         return `${creditManager.toLowerCase()}:${borrower.toLowerCase()}`;
     }
-    static calcHealthFactor({ assets, quotas, quotasInfo, liquidationThresholds, underlyingToken, debt, prices, }) {
+    static calcHealthFactor({ assets, quotas, quotasInfo, liquidationThresholds, underlyingToken, debt, prices, tokensList, }) {
         if (debt === 0n)
             return MAX_UINT16;
-        const [, underlyingDecimals] = (0, sdk_gov_1.extractTokenData)(underlyingToken);
+        const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
         const underlyingPrice = prices[underlyingToken] || 0n;
         const assetMoney = assets.reduce((acc, { token: tokenAddress, balance: amount }) => {
-            const [, tokenDecimals] = (0, sdk_gov_1.extractTokenData)(tokenAddress);
+            const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
             const lt = liquidationThresholds[tokenAddress] || 0n;
             const price = prices[tokenAddress] || 0n;
             const tokenMoney = price_1.PriceUtils.calcTotalPrice(price, amount, tokenDecimals);
@@ -369,19 +367,17 @@ class CreditAccountData {
     static calcRelativeBaseBorrowRate({ debt, baseRateWithFee, assetAmountInUnderlying, }) {
         return debt * BigInt(baseRateWithFee) * assetAmountInUnderlying;
     }
-    static liquidationPrice({ liquidationThresholds, debt, underlyingToken, targetToken, assets, }) {
-        const underlyingTokenLC = underlyingToken.toLowerCase();
-        const [, underlyingDecimals = 18] = (0, sdk_gov_1.extractTokenData)(underlyingTokenLC);
-        const { balance: underlyingBalance = 0n } = assets[underlyingTokenLC] || {};
+    static liquidationPrice({ liquidationThresholds, debt, underlyingToken, targetToken, assets, tokensList, }) {
+        const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
+        const { balance: underlyingBalance = 0n } = assets[underlyingToken] || {};
         // effectiveDebt = Debt - underlyingBalance*LTunderlying
-        const ltUnderlying = liquidationThresholds[underlyingTokenLC] || 0n;
+        const ltUnderlying = liquidationThresholds[underlyingToken] || 0n;
         const effectiveDebt = ((debt - (underlyingBalance * ltUnderlying) / sdk_gov_1.PERCENTAGE_FACTOR) * sdk_gov_1.WAD) /
             10n ** BigInt(underlyingDecimals);
-        const targetTokenLC = targetToken.toLowerCase();
-        const [, targetDecimals = 18] = (0, sdk_gov_1.extractTokenData)(targetTokenLC);
-        const { balance: targetBalance = 0n } = assets[targetTokenLC] || {};
+        const targetDecimals = tokensList[targetToken]?.decimals || 18;
+        const { balance: targetBalance = 0n } = assets[targetToken] || {};
         const effectiveTargetBalance = (targetBalance * sdk_gov_1.WAD) / 10n ** BigInt(targetDecimals);
-        const lpLT = liquidationThresholds[targetTokenLC] || 0n;
+        const lpLT = liquidationThresholds[targetToken] || 0n;
         if (targetBalance <= 0n || lpLT <= 0n)
             return 0n;
         // priceTarget = effectiveDebt / (lpLT*targetBalance)

package/lib/core/creditAccount.spec.js

@@ -2,10 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
+const tokenData_1 = require("../tokens/tokenData");
 const formatter_1 = require("../utils/formatter");
 const price_1 = require("../utils/price");
 const assets_1 = require("./assets");
 const creditAccount_1 = require("./creditAccount");
+const tokensFiltered = sdk_gov_1.TypedObjectUtils.fromEntries(sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.tokenDataByNetwork.Mainnet).filter(([_, address]) => !!address && address !== sdk_gov_1.NOT_DEPLOYED));
+const tokenDataList = sdk_gov_1.TypedObjectUtils.fromEntries(sdk_gov_1.TypedObjectUtils.entries(tokensFiltered).map(([tokenSymbol, addr]) => {
+    const data = sdk_gov_1.supportedTokens[tokenSymbol];
+    return [
+        addr.toLowerCase(),
+        new tokenData_1.TokenData({
+            ...data,
+            addr,
+            decimals: sdk_gov_1.decimals[tokenSymbol],
+        }),
+    ];
+}));
 const prices = {
     [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: (0, formatter_1.toBN)("1738.11830000", sdk_gov_1.PRICE_DECIMALS_POW),
     [sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: (0, formatter_1.toBN)("0.99941103", sdk_gov_1.PRICE_DECIMALS_POW),
@@ -82,6 +95,7 @@ describe("CreditAccount CreditAccountData.calcOverallAPY test", () => {
             feeInterest: 0,
             lpAPY,
             prices,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(-69484n);
     });
@@ -97,6 +111,7 @@ describe("CreditAccount CreditAccountData.calcOverallAPY test", () => {
             feeInterest: 0,
             lpAPY,
             prices,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(144919n);
     });
@@ -112,6 +127,7 @@ describe("CreditAccount CreditAccountData.calcOverallAPY test", () => {
             feeInterest: 0,
             lpAPY: undefined,
             prices,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(undefined);
     });
@@ -127,6 +143,7 @@ describe("CreditAccount CreditAccountData.calcOverallAPY test", () => {
             feeInterest: 0,
             lpAPY,
             prices,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(undefined);
     });
@@ -142,6 +159,7 @@ describe("CreditAccount CreditAccountData.calcOverallAPY test", () => {
             feeInterest: 0,
             lpAPY,
             prices,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(undefined);
     });
@@ -157,6 +175,7 @@ describe("CreditAccount CreditAccountData.calcOverallAPY test", () => {
             feeInterest: 0,
             lpAPY,
             prices,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(undefined);
     });
@@ -172,6 +191,7 @@ describe("CreditAccount CreditAccountData.calcOverallAPY test", () => {
             feeInterest: 0,
             lpAPY,
             prices,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(-18680n);
     });
@@ -192,6 +212,7 @@ describe("CreditAccount CreditAccountData.calcOverallAPY test", () => {
             feeInterest: 0,
             lpAPY,
             prices,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(144919n);
     });
@@ -240,6 +261,7 @@ describe("CreditAccount calcMaxLendingDebt test", () => {
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.USDC.toLowerCase()]: 1n,
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: 1000n,
             },
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq((0, formatter_1.toBN)("850", sdk_gov_1.decimals.USDC));
     });
@@ -261,6 +283,7 @@ describe("CreditAccount calcMaxLendingDebt test", () => {
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: 1n,
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: 1000n,
             },
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(0n);
     });
@@ -278,6 +301,7 @@ describe("CreditAccount calcMaxLendingDebt test", () => {
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: 1n,
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.USDC.toLowerCase()]: 1n,
             },
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq((0, formatter_1.toBN)("930", sdk_gov_1.decimals.USDC));
     });
@@ -300,6 +324,7 @@ describe("CreditAccount calcMaxLendingDebt test", () => {
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.USDC.toLowerCase()]: 1n,
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: 1000n,
             },
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq((0, formatter_1.toBN)("1780", sdk_gov_1.decimals.USDC));
     });
@@ -323,6 +348,7 @@ describe("CreditAccount calcMaxLendingDebt test", () => {
                 [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: 1000n,
             },
             targetHF: 12500n,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq((0, formatter_1.toBN)("1424", sdk_gov_1.decimals.USDC));
     });
@@ -364,6 +390,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds,
             underlyingToken: defaultCA.underlyingToken,
             debt: defaultCA.debt,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(defaultCA.healthFactor);
     });
@@ -376,6 +403,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds: {},
             underlyingToken: "",
             debt: 0n,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(65535);
     });
@@ -393,6 +421,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds,
             underlyingToken: defaultCA.underlyingToken,
             debt: defaultCA.debt,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(11188);
     });
@@ -413,6 +442,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds,
             underlyingToken: defaultCA.underlyingToken,
             debt: defaultCA.debt - amountDecrease,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(10308);
     });
@@ -433,6 +463,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds,
             underlyingToken: defaultCA.underlyingToken,
             debt: defaultCA.debt + amountIncrease,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(10137);
     });
@@ -458,6 +489,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds,
             underlyingToken: defaultCA.underlyingToken,
             debt: defaultCA.debt,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(9444);
     });
@@ -470,6 +502,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds,
             underlyingToken: defaultCA.underlyingToken,
             debt: defaultCA.debt,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(defaultCA.healthFactor);
     });
@@ -487,6 +520,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds,
             underlyingToken: defaultCA.underlyingToken,
             debt: defaultCA.debt,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(9300);
     });
@@ -503,6 +537,7 @@ describe("CreditAccount calcHealthFactor test", () => {
             liquidationThresholds,
             underlyingToken: defaultCA.underlyingToken,
             debt: defaultCA.debt,
+            tokensList: tokenDataList,
         });
         (0, chai_1.expect)(result).to.be.eq(9300);
     });

package/lib/gearboxRewards/api.d.ts

@@ -1,5 +1,6 @@
 import { NetworkType, SupportedToken } from "@gearbox-protocol/sdk-gov";
 import { Address, PublicClient, WalletClient } from "viem";
+import { TokenData } from "../tokens/tokenData";
 export interface GearboxExtraMerkleLmReward {
     poolToken: Address;
     rewardToken: Address;
@@ -39,6 +40,7 @@ type PoolsWithExtraRewardsList = Record<NetworkType, Array<SupportedToken>>;
 type ReportHandler = (e: unknown, description?: string) => void;
 export interface GetLmRewardsInfoProps {
     currentTokenData: Record<SupportedToken, Address>;
+    tokensList: Record<Address, TokenData>;
     provider: PublicClient;
     multicallAddress: Address;
     poolsWithExtraRewards?: PoolsWithExtraRewardsList;
@@ -67,7 +69,7 @@ export interface ClaimLmRewardsV3Props {
     signer: WalletClient;
 }
 export declare class GearboxRewardsApi {
-    static getLmRewardsInfo({ currentTokenData, provider, multicallAddress, poolsWithExtraRewards, network, reportError, }: GetLmRewardsInfoProps): Promise<{
+    static getLmRewardsInfo({ currentTokenData, provider, multicallAddress, tokensList, poolsWithExtraRewards, network, reportError, }: GetLmRewardsInfoProps): Promise<{
         rewardPoolsInfo: Record<string, FarmInfo[]>;
         baseRewardPoolsInfo: Record<string, FarmInfo>;
         extraRewardPoolsInfo: Record<string, FarmInfo[]>;

package/lib/gearboxRewards/api.js

@@ -19,7 +19,7 @@ const DEFAULT_POOLS_WITH_EXTRA_REWARDS = {
     Base: [],
 };
 class GearboxRewardsApi {
-    static async getLmRewardsInfo({ currentTokenData, provider, multicallAddress, poolsWithExtraRewards = DEFAULT_POOLS_WITH_EXTRA_REWARDS, network, reportError, }) {
+    static async getLmRewardsInfo({ currentTokenData, provider, multicallAddress, tokensList, poolsWithExtraRewards = DEFAULT_POOLS_WITH_EXTRA_REWARDS, network, reportError, }) {
         const poolTokens = sdk_gov_1.TypedObjectUtils.entries(currentTokenData).filter(([symbol]) => (0, sdk_gov_1.isDieselStakedToken)(symbol));
         const farmInfoCalls = poolTokens.map(([, address]) => ({
             address,
@@ -88,15 +88,15 @@ class GearboxRewardsApi {
                 const finished = (0, sdk_gov_1.toBigInt)(d.endTimestamp || 0);
                 if (blockTimestamp >= started && blockTimestamp <= finished) {
                     const rewardTokenLc = (d.rewardToken || "").toLowerCase();
-                    const [rewardSymbol, decimals = 18] = (0, sdk_gov_1.extractTokenData)(rewardTokenLc);
-                    const reward = (0, formatter_1.toBN)(d.amountDecimal, decimals);
-                    if (rewardSymbol && reward > 0) {
+                    const rewardTokenData = tokensList[rewardTokenLc];
+                    const reward = (0, formatter_1.toBN)(d.amountDecimal, rewardTokenData?.decimals || 18);
+                    if (rewardTokenData && reward > 0) {
                         infos.push({
                             duration: (0, sdk_gov_1.toBigInt)(d.endTimestamp - d.startTimestamp),
                             finished,
                             reward,
                             balance: 0n,
-                            symbol: rewardSymbol,
+                            symbol: rewardTokenData.symbol,
                         });
                     }
                 }
@@ -109,14 +109,15 @@ class GearboxRewardsApi {
         }, {});
         const rewardPoolsInfo = poolTokens.reduce((acc, [, address], i) => {
             const currentInfo = farmInfo[i];
-            const [symbol] = (0, sdk_gov_1.extractTokenData)(rewardTokens[i] || "");
-            if (symbol) {
+            const poolBaseRewardTokenLc = (rewardTokens[i] || "").toLowerCase();
+            const tokenData = tokensList[poolBaseRewardTokenLc];
+            if (tokenData) {
                 const baseReward = {
                     duration: BigInt(currentInfo.duration),
                     finished: BigInt(currentInfo.finished),
                     reward: currentInfo.reward,
                     balance: currentInfo.balance,
-                    symbol: symbol,
+                    symbol: tokenData.symbol,
                 };
                 const extra = extraRewards[address] || [];
                 acc.base[address] = baseReward;

package/lib/redstone/api.d.ts

@@ -34,7 +34,8 @@ export declare class RedstoneApi {
         reserve: RedstonePriceFeeds;
         allReserve: Record<`0x${string}`, `0x${string}`>;
     }>;
-    private static getPriceFeedsOfInterest_Onchain;
+    private static unwrapSecondStage;
+    private static unwrapThirdStage;
     private static getRedstonePF_Onchain;
 }
 export {};

package/lib/redstone/api.js

@@ -92,7 +92,8 @@ class RedstoneApi {
     };
     static getRedstonePriceFeeds = async ({ priceOracleAddress, currentTokenData, provider, network, }) => {
         const allTokens = sdk_gov_1.TypedObjectUtils.entries(currentTokenData);
-        const feeds = (await provider.multicall({
+        // STAGE 1: get direct price feeds and reserve price feeds
+        const st1_response = (await provider.multicall({
             allowFailure: true,
             multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
             contracts: [
@@ -110,11 +111,11 @@ class RedstoneApi {
                 })),
             ],
         }));
-        const mainFeedsEnd = allTokens.length;
-        const mainFeedsUnsafe = feeds.slice(0, mainFeedsEnd);
-        const reserveFeedsEnd = mainFeedsEnd + allTokens.length;
-        const reserveFeedsUnsafe = feeds.slice(mainFeedsEnd, reserveFeedsEnd);
-        const notTrustedMainPF = mainFeedsUnsafe.reduce((acc, p, index) => {
+        const st1_MainFeedsEnd = allTokens.length;
+        const st1_MainFeedsUnsafe = st1_response.slice(0, st1_MainFeedsEnd);
+        const st1_ReserveFeedsEnd = st1_MainFeedsEnd + allTokens.length;
+        const st1_ReserveFeedsUnsafe = st1_response.slice(st1_MainFeedsEnd, st1_ReserveFeedsEnd);
+        const st1_NotTrustedMainPF = st1_MainFeedsUnsafe.reduce((acc, p, index) => {
             const symbol = allTokens[index][0];
             if (!p.error && typeof p.result === "object" && p.result[4] === false) {
                 const [priceFeed] = p.result;
@@ -122,51 +123,93 @@ class RedstoneApi {
             }
             return acc;
         }, []);
-        const notTrustedMainPFRecord = sdk_gov_1.TypedObjectUtils.fromEntries(notTrustedMainPF);
-        const reservePF = reserveFeedsUnsafe.reduce((acc, p, index) => {
+        const st1_NotTrustedMainPFRecord = sdk_gov_1.TypedObjectUtils.fromEntries(st1_NotTrustedMainPF);
+        const st1_ReservePF = st1_ReserveFeedsUnsafe.reduce((acc, p, index) => {
             const symbol = allTokens[index][0];
             if (!p.error &&
                 typeof p.result === "string" &&
-                notTrustedMainPFRecord[symbol]) {
+                st1_NotTrustedMainPFRecord[symbol]) {
                 acc.push([symbol, p.result]);
             }
             return acc;
         }, []);
-        const typeResponse = (await provider.multicall({
+        // STAGE 2: get price feeds and their types. If type is Pendle TWAP, get the underlying price feeds for the next stage
+        const st2_response = (await provider.multicall({
             allowFailure: true,
             multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
             contracts: [
-                ...notTrustedMainPF.map(([, address]) => ({
+                ...st1_NotTrustedMainPF.map(([, address]) => ({
                     address,
                     abi: types_1.iPriceFeedAbi,
                     functionName: "priceFeedType",
                     args: [],
                 })),
-                ...notTrustedMainPF.map(([, address]) => ({
+                ...st1_NotTrustedMainPF.map(([, address]) => ({
+                    address,
+                    abi: types_1.pendleTwapptPriceFeedAbi,
+                    functionName: "priceFeed",
+                    args: [],
+                })),
+                ...st1_ReservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...st1_ReservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.pendleTwapptPriceFeedAbi,
+                    functionName: "priceFeed",
+                    args: [],
+                })),
+            ],
+        }));
+        const st2_MainFeedsTypeEnd = st1_NotTrustedMainPF.length;
+        const st2_MainFeedsTypeUnsafe = st2_response.slice(0, st2_MainFeedsTypeEnd);
+        const st2_MainFeedsEnd = st2_MainFeedsTypeEnd + st1_NotTrustedMainPF.length;
+        const st2_MainFeedsUnsafe = st2_response.slice(st2_MainFeedsTypeEnd, st2_MainFeedsEnd);
+        const st2_ReserveFeedsTypeEnd = st2_MainFeedsEnd + st1_ReservePF.length;
+        const st2_ReserveFeedsTypeUnsafe = st2_response.slice(st2_MainFeedsEnd, st2_ReserveFeedsTypeEnd);
+        const st2_ReserveFeedsEnd = st2_ReserveFeedsTypeEnd + st1_ReservePF.length;
+        const st2_ReserveFeedsUnsafe = st2_response.slice(st2_ReserveFeedsTypeEnd, st2_ReserveFeedsEnd);
+        const st2_NotTrustedMainPF = this.unwrapSecondStage(st1_NotTrustedMainPF, st2_MainFeedsTypeUnsafe, st2_MainFeedsUnsafe);
+        const st2_ReservePF = this.unwrapSecondStage(st1_ReservePF, st2_ReserveFeedsTypeUnsafe, st2_ReserveFeedsUnsafe);
+        // STAGE 3: get price feeds and their types. If types is composite, get the underlying price feeds
+        const st3_response = (await provider.multicall({
+            allowFailure: true,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [
+                ...st2_NotTrustedMainPF.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...st2_NotTrustedMainPF.map(([, address]) => ({
                     address,
                     abi: types_1.compositePriceFeedAbi,
                     functionName: "priceFeed0",
                     args: [],
                 })),
-                ...notTrustedMainPF.map(([, address]) => ({
+                ...st2_NotTrustedMainPF.map(([, address]) => ({
                     address,
                     abi: types_1.compositePriceFeedAbi,
                     functionName: "priceFeed1",
                     args: [],
                 })),
-                ...reservePF.map(([, address]) => ({
+                ...st2_ReservePF.map(([, address]) => ({
                     address,
                     abi: types_1.iPriceFeedAbi,
                     functionName: "priceFeedType",
                     args: [],
                 })),
-                ...reservePF.map(([, address]) => ({
+                ...st2_ReservePF.map(([, address]) => ({
                     address,
                     abi: types_1.compositePriceFeedAbi,
                     functionName: "priceFeed0",
                     args: [],
                 })),
-                ...reservePF.map(([, address]) => ({
+                ...st2_ReservePF.map(([, address]) => ({
                     address,
                     abi: types_1.compositePriceFeedAbi,
                     functionName: "priceFeed1",
@@ -174,43 +217,44 @@ class RedstoneApi {
                 })),
             ],
         }));
-        const mainFeedsTypeEnd = notTrustedMainPF.length;
-        const mainFeedsTypeUnsafe = typeResponse.slice(0, mainFeedsTypeEnd);
-        const mainPriceFeed0End = mainFeedsTypeEnd + notTrustedMainPF.length;
-        const mainPriceFeed0Unsafe = typeResponse.slice(mainFeedsTypeEnd, mainPriceFeed0End);
-        const mainPriceFeed1End = mainPriceFeed0End + notTrustedMainPF.length;
-        const mainPriceFeed1Unsafe = typeResponse.slice(mainPriceFeed0End, mainPriceFeed1End);
-        const reserveFeedsTypeEnd = mainPriceFeed1End + reservePF.length;
-        const reserveFeedsTypeUnsafe = typeResponse.slice(mainPriceFeed1End, reserveFeedsTypeEnd);
-        const reservePriceFeed0End = reserveFeedsTypeEnd + reservePF.length;
-        const reservePriceFeed0Unsafe = typeResponse.slice(reserveFeedsTypeEnd, reservePriceFeed0End);
-        const reservePriceFeed1End = reservePriceFeed0End + reservePF.length;
-        const reservePriceFeed1Unsafe = typeResponse.slice(reservePriceFeed0End, reservePriceFeed1End);
-        const realNotTrustedMainPriceFeeds = this.getPriceFeedsOfInterest_Onchain(notTrustedMainPF, mainFeedsTypeUnsafe, mainPriceFeed0Unsafe, mainPriceFeed1Unsafe);
-        const realReservePriceFeeds = this.getPriceFeedsOfInterest_Onchain(reservePF, reserveFeedsTypeUnsafe, reservePriceFeed0Unsafe, reservePriceFeed1Unsafe);
-        const response = (await provider.multicall({
+        const st3_MainFeedsTypeEnd = st2_NotTrustedMainPF.length;
+        const st3_MainFeedsTypeUnsafe = st3_response.slice(0, st3_MainFeedsTypeEnd);
+        const st3_MainPriceFeed0End = st3_MainFeedsTypeEnd + st2_NotTrustedMainPF.length;
+        const st3_MainPriceFeed0Unsafe = st3_response.slice(st3_MainFeedsTypeEnd, st3_MainPriceFeed0End);
+        const st3_MainPriceFeed1End = st3_MainPriceFeed0End + st2_NotTrustedMainPF.length;
+        const st3_MainPriceFeed1Unsafe = st3_response.slice(st3_MainPriceFeed0End, st3_MainPriceFeed1End);
+        const st3_ReserveFeedsTypeEnd = st3_MainPriceFeed1End + st2_ReservePF.length;
+        const st3_ReserveFeedsTypeUnsafe = st3_response.slice(st3_MainPriceFeed1End, st3_ReserveFeedsTypeEnd);
+        const st3_ReservePriceFeed0End = st3_ReserveFeedsTypeEnd + st2_ReservePF.length;
+        const st3_ReservePriceFeed0Unsafe = st3_response.slice(st3_ReserveFeedsTypeEnd, st3_ReservePriceFeed0End);
+        const st3_ReservePriceFeed1End = st3_ReservePriceFeed0End + st2_ReservePF.length;
+        const st3_ReservePriceFeed1Unsafe = st3_response.slice(st3_ReservePriceFeed0End, st3_ReservePriceFeed1End);
+        const st3_NotTrustedMainPF = this.unwrapThirdStage(st2_NotTrustedMainPF, st3_MainFeedsTypeUnsafe, st3_MainPriceFeed0Unsafe, st3_MainPriceFeed1Unsafe);
+        const st3_ReservePF = this.unwrapThirdStage(st2_ReservePF, st3_ReserveFeedsTypeUnsafe, st3_ReservePriceFeed0Unsafe, st3_ReservePriceFeed1Unsafe);
+        // STAGE 4: get price feed types and data feed ids for unwrapped price feeds
+        const st4_response = (await provider.multicall({
             allowFailure: true,
             multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
             contracts: [
-                ...realNotTrustedMainPriceFeeds.map(([, address]) => ({
+                ...st3_NotTrustedMainPF.map(([, address]) => ({
                     address,
                     abi: types_1.iPriceFeedAbi,
                     functionName: "priceFeedType",
                     args: [],
                 })),
-                ...realNotTrustedMainPriceFeeds.map(([, address]) => ({
+                ...st3_NotTrustedMainPF.map(([, address]) => ({
                     address,
                     abi: types_1.redstonePriceFeedAbi,
                     functionName: "dataFeedId",
                     args: [],
                 })),
-                ...realReservePriceFeeds.map(([, address]) => ({
+                ...st3_ReservePF.map(([, address]) => ({
                     address,
                     abi: types_1.iPriceFeedAbi,
                     functionName: "priceFeedType",
                     args: [],
                 })),
-                ...realReservePriceFeeds.map(([, address]) => ({
+                ...st3_ReservePF.map(([, address]) => ({
                     address,
                     abi: types_1.redstonePriceFeedAbi,
                     functionName: "dataFeedId",
@@ -218,25 +262,42 @@ class RedstoneApi {
                 })),
             ],
         }));
-        const mainTypeEnd = realNotTrustedMainPriceFeeds.length;
-        const mainTypeType = response.slice(0, mainTypeEnd);
-        const mainFeedIdEnd = mainTypeEnd + realNotTrustedMainPriceFeeds.length;
-        const mainFeedId = response.slice(mainTypeEnd, mainFeedIdEnd);
-        const reserveTypeEnd = mainFeedIdEnd + realReservePriceFeeds.length;
-        const reserveType = response.slice(mainFeedIdEnd, reserveTypeEnd);
-        const reserveFeedIdEnd = reserveTypeEnd + realReservePriceFeeds.length;
-        const reserveFeedId = response.slice(reserveTypeEnd, reserveFeedIdEnd);
+        const st4_MainTypeEnd = st3_NotTrustedMainPF.length;
+        const st4_MainTypeType = st4_response.slice(0, st4_MainTypeEnd);
+        const st4_MainFeedIdEnd = st4_MainTypeEnd + st3_NotTrustedMainPF.length;
+        const st4_MainFeedId = st4_response.slice(st4_MainTypeEnd, st4_MainFeedIdEnd);
+        const st4_ReserveTypeEnd = st4_MainFeedIdEnd + st3_ReservePF.length;
+        const st4_ReserveType = st4_response.slice(st4_MainFeedIdEnd, st4_ReserveTypeEnd);
+        const st4_ReserveFeedIdEnd = st4_ReserveTypeEnd + st3_ReservePF.length;
+        const st4_ReserveFeedId = st4_response.slice(st4_ReserveTypeEnd, st4_ReserveFeedIdEnd);
         const getMain = (symbol) => (0, sdk_gov_1.getPriceFeedsByToken)(symbol, network)?.Main;
         const getReserve = (symbol) => (0, sdk_gov_1.getPriceFeedsByToken)(symbol, network)?.Reserve;
-        const mainPFData = this.getRedstonePF_Onchain(realNotTrustedMainPriceFeeds, mainTypeType, mainFeedId, getMain, currentTokenData, false, network);
-        const reservePFData = this.getRedstonePF_Onchain(realReservePriceFeeds, reserveType, reserveFeedId, getReserve, currentTokenData, true, network);
+        const mainPFData = this.getRedstonePF_Onchain(st3_NotTrustedMainPF, st4_MainTypeType, st4_MainFeedId, getMain, currentTokenData, false, network);
+        const reservePFData = this.getRedstonePF_Onchain(st3_ReservePF, st4_ReserveType, st4_ReserveFeedId, getReserve, currentTokenData, true, network);
         return {
             main: mainPFData,
             reserve: reservePFData,
-            allReserve: sdk_gov_1.TypedObjectUtils.fromEntries(reservePF.map(([s, a]) => [currentTokenData[s], a])),
+            allReserve: sdk_gov_1.TypedObjectUtils.fromEntries(st3_ReservePF.map(([s, a]) => [currentTokenData[s], a])),
         };
     };
-    static getPriceFeedsOfInterest_Onchain(priceFeeds, feedsTypeResponse, priceFeed0Response, priceFeed1Response) {
+    static unwrapSecondStage(priceFeeds, feedsTypeResponse, priceFeedResponse) {
+        const result = priceFeeds.reduce((acc, [symbol, baseAddress], index) => {
+            const { error: typeError, result: feedType } = feedsTypeResponse[index];
+            const { error: feedError, result: feed } = priceFeedResponse[index];
+            const isPendle = !typeError &&
+                Number(feedType) === sdk_gov_1.PriceFeedType.PENDLE_PT_TWAP_ORACLE;
+            const hasFeed = !feedError && typeof feed === "string";
+            if (isPendle && hasFeed) {
+                acc.push([symbol, feed]);
+            }
+            else {
+                acc.push([symbol, baseAddress]);
+            }
+            return acc;
+        }, []);
+        return result;
+    }
+    static unwrapThirdStage(priceFeeds, feedsTypeResponse, priceFeed0Response, priceFeed1Response) {
         const result = priceFeeds.reduce((acc, [symbol, baseAddress], index) => {
             const { error: typeError, result: feedType } = feedsTypeResponse[index];
             const { error: feed0Error, result: feed0 } = priceFeed0Response[index];

package/lib/types/IPendleMarket.d.ts

@@ -0,0 +1,43 @@
+export declare const iPendleMarketAbi: readonly [{
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "expiry";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "secondsAgos";
+        readonly internalType: "uint32[]";
+        readonly type: "uint32[]";
+    }];
+    readonly name: "observe";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint216[]";
+        readonly type: "uint216[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "readTokens";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}];

package/lib/types/IPendleMarket.js

@@ -0,0 +1,35 @@
+"use strict";
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// IPendleMarket
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iPendleMarketAbi = void 0;
+exports.iPendleMarketAbi = [
+    {
+        type: "function",
+        inputs: [],
+        name: "expiry",
+        outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "secondsAgos", internalType: "uint32[]", type: "uint32[]" },
+        ],
+        name: "observe",
+        outputs: [{ name: "", internalType: "uint216[]", type: "uint216[]" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "readTokens",
+        outputs: [
+            { name: "", internalType: "address", type: "address" },
+            { name: "", internalType: "address", type: "address" },
+            { name: "", internalType: "address", type: "address" },
+        ],
+        stateMutability: "view",
+    },
+];

package/lib/types/IPendleSY.d.ts

@@ -0,0 +1,11 @@
+export declare const iPendleSyAbi: readonly [{
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "exchangeRate";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}];

package/lib/types/IPendleSY.js

@@ -0,0 +1,15 @@
+"use strict";
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// IPendleSY
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iPendleSyAbi = void 0;
+exports.iPendleSyAbi = [
+    {
+        type: "function",
+        inputs: [],
+        name: "exchangeRate",
+        outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+];

package/lib/types/IPendleYT.d.ts

@@ -0,0 +1,31 @@
+export declare const iPendleYtAbi: readonly [{
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "doCacheIndexSameBlock";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "pyIndexLastUpdatedBlock";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "pyIndexStored";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}];

package/lib/types/IPendleYT.js

@@ -0,0 +1,29 @@
+"use strict";
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// IPendleYT
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iPendleYtAbi = void 0;
+exports.iPendleYtAbi = [
+    {
+        type: "function",
+        inputs: [],
+        name: "doCacheIndexSameBlock",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "pyIndexLastUpdatedBlock",
+        outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "pyIndexStored",
+        outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+];

package/lib/types/PendleTWAPPTPriceFeed.d.ts

@@ -0,0 +1,201 @@
+export declare const pendleTwapptPriceFeedAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "_market";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "_priceFeed";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "_stalenessPeriod";
+        readonly internalType: "uint32";
+        readonly type: "uint32";
+    }, {
+        readonly name: "_twapWindow";
+        readonly internalType: "uint32";
+        readonly type: "uint32";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint8";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "description";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "string";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "expiry";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "latestRoundData";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint80";
+        readonly type: "uint80";
+    }, {
+        readonly name: "";
+        readonly internalType: "int256";
+        readonly type: "int256";
+    }, {
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "";
+        readonly internalType: "uint80";
+        readonly type: "uint80";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "market";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "priceFeed";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "priceFeedType";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "enum PriceFeedType";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "skipCheck";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "skipPriceCheck";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "stalenessPeriod";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint32";
+        readonly type: "uint32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "sy";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "twapWindow";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint32";
+        readonly type: "uint32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "version";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "yt";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly name: "AddressIsNotContractException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "IncorrectParameterException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "IncorrectPriceException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "IncorrectPriceFeedException";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "StalePriceException";
+}];

package/lib/types/PendleTWAPPTPriceFeed.js

@@ -0,0 +1,131 @@
+"use strict";
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// PendleTWAPPTPriceFeed
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pendleTwapptPriceFeedAbi = void 0;
+exports.pendleTwapptPriceFeedAbi = [
+    {
+        type: "constructor",
+        inputs: [
+            { name: "_market", internalType: "address", type: "address" },
+            { name: "_priceFeed", internalType: "address", type: "address" },
+            { name: "_stalenessPeriod", internalType: "uint32", type: "uint32" },
+            { name: "_twapWindow", internalType: "uint32", type: "uint32" },
+        ],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "decimals",
+        outputs: [{ name: "", internalType: "uint8", type: "uint8" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "description",
+        outputs: [{ name: "", internalType: "string", type: "string" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "expiry",
+        outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "latestRoundData",
+        outputs: [
+            { name: "", internalType: "uint80", type: "uint80" },
+            { name: "", internalType: "int256", type: "int256" },
+            { name: "", internalType: "uint256", type: "uint256" },
+            { name: "", internalType: "uint256", type: "uint256" },
+            { name: "", internalType: "uint80", type: "uint80" },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "market",
+        outputs: [{ name: "", internalType: "address", type: "address" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "priceFeed",
+        outputs: [{ name: "", internalType: "address", type: "address" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "priceFeedType",
+        outputs: [{ name: "", internalType: "enum PriceFeedType", type: "uint8" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "skipCheck",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "skipPriceCheck",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "stalenessPeriod",
+        outputs: [{ name: "", internalType: "uint32", type: "uint32" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "sy",
+        outputs: [{ name: "", internalType: "address", type: "address" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "twapWindow",
+        outputs: [{ name: "", internalType: "uint32", type: "uint32" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "version",
+        outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "yt",
+        outputs: [{ name: "", internalType: "address", type: "address" }],
+        stateMutability: "view",
+    },
+    {
+        type: "error",
+        inputs: [{ name: "", internalType: "address", type: "address" }],
+        name: "AddressIsNotContractException",
+    },
+    { type: "error", inputs: [], name: "IncorrectParameterException" },
+    { type: "error", inputs: [], name: "IncorrectPriceException" },
+    { type: "error", inputs: [], name: "IncorrectPriceFeedException" },
+    { type: "error", inputs: [], name: "StalePriceException" },
+];

package/lib/types/index.d.ts

@@ -34,6 +34,9 @@ export * from "./ILidoV1Adapter";
 export * from "./IMulticall3";
 export * from "./IOffchainOracle";
 export * from "./IPartialLiquidationBotV3";
+export * from "./IPendleMarket";
+export * from "./IPendleSY";
+export * from "./IPendleYT";
 export * from "./IPoolV3";
 export * from "./IPriceFeed";
 export * from "./IPriceOracleBase";
@@ -48,5 +51,6 @@ export * from "./IwstETH";
 export * from "./IwstETHV1Adapter";
 export * from "./IYearnV2Adapter";
 export * from "./IZapper";
+export * from "./PendleTWAPPTPriceFeed";
 export * from "./RedstonePriceFeed";
 export * from "./SignUpRepository";

package/lib/types/index.js

@@ -50,6 +50,9 @@ __exportStar(require("./ILidoV1Adapter"), exports);
 __exportStar(require("./IMulticall3"), exports);
 __exportStar(require("./IOffchainOracle"), exports);
 __exportStar(require("./IPartialLiquidationBotV3"), exports);
+__exportStar(require("./IPendleMarket"), exports);
+__exportStar(require("./IPendleSY"), exports);
+__exportStar(require("./IPendleYT"), exports);
 __exportStar(require("./IPoolV3"), exports);
 __exportStar(require("./IPriceFeed"), exports);
 __exportStar(require("./IPriceOracleBase"), exports);
@@ -64,5 +67,6 @@ __exportStar(require("./IwstETH"), exports);
 __exportStar(require("./IwstETHV1Adapter"), exports);
 __exportStar(require("./IYearnV2Adapter"), exports);
 __exportStar(require("./IZapper"), exports);
+__exportStar(require("./PendleTWAPPTPriceFeed"), exports);
 __exportStar(require("./RedstonePriceFeed"), exports);
 __exportStar(require("./SignUpRepository"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "3.0.0-next.246",
+  "version": "3.0.0-next.248",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -28,8 +28,7 @@
     "test": "npx mocha -r ts-node/register -r dotenv/config 'src/**/*.spec.ts'"
   },
   "dependencies": {
-    "@gearbox-protocol/bots-v3": "^1.5.1",
-    "@gearbox-protocol/sdk-gov": "^2.25.6",
+    "@gearbox-protocol/sdk-gov": "^2.26.1",
     "@wagmi/cli": "^2.1.13",
     "axios": "^1.2.6",
     "decimal.js-light": "^2.5.1",
@@ -49,7 +48,8 @@
     "@gearbox-protocol/periphery-v3": "^1.6.1",
     "@gearbox-protocol/prettier-config": "^1.4.1",
     "@gearbox-protocol/router": "^1.5.5",
-    "@gearbox-protocol/router-v3": "^1.36.1",
+    "@gearbox-protocol/bots-v3": "^1.5.1",
+    "@gearbox-protocol/router-v3": "^1.37.0",
     "@openzeppelin/contracts": "^4.9.3",
     "@redstone-finance/evm-connector": "^0.5.4",
     "@types/chai": "^4.3.3",