@gearbox-protocol/sdk 3.0.0-next.30 → 3.0.0-next.300

package/lib/payload/pool.d.ts

@@ -1,49 +1,115 @@
-import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
-import { BigNumberish } from "ethers";
-import { ZapperInfoStructOutput } from "../types/IDataCompressorV2_10";
-import { LinearModelStructOutput, PoolDataStructOutput } from "../types/IDataCompressorV3_00";
-export type PoolDataPayload = Omit<ExcludeArrayProps<PoolDataStructOutput>, "zappers"> & {
-    zappers: Array<PoolZapper>;
-    borrowAPY7D: number | undefined;
-};
-export type LinearModel = Omit<ExcludeArrayProps<LinearModelStructOutput>, "version"> & {
+import { Address } from "viem";
+export interface PoolDataPayload {
+    addr: Address;
+    underlying: Address;
+    dieselToken: Address;
+    symbol: string;
+    name: string;
+    baseInterestIndex: bigint;
+    availableLiquidity: bigint;
+    expectedLiquidity: bigint;
+    totalBorrowed: bigint;
+    totalDebtLimit: bigint;
+    totalAssets: bigint;
+    totalSupply: bigint;
+    supplyRate: bigint;
+    baseInterestRate: bigint;
+    dieselRate_RAY: bigint;
+    withdrawFee: bigint;
+    lastBaseInterestUpdate: bigint;
+    baseInterestIndexLU: bigint;
+    version: bigint;
+    poolQuotaKeeper: Address;
+    gauge: Address;
+    isPaused: boolean;
+    readonly lirm: {
+        interestModel: Address;
+        version: bigint;
+        U_1: number;
+        U_2: number;
+        R_base: number;
+        R_slope1: number;
+        R_slope2: number;
+        R_slope3: number;
+        isBorrowingMoreU2Forbidden: boolean;
+    };
+    quotas: readonly {
+        token: Address;
+        rate: number;
+        quotaIncreaseFee: number;
+        totalQuoted: bigint;
+        limit: bigint;
+        isActive: boolean;
+    }[];
+    zappers: readonly PoolZapper[];
+    creditManagerDebtParams: readonly {
+        creditManager: Address;
+        borrowed: bigint;
+        limit: bigint;
+        availableToBorrow: bigint;
+    }[];
+}
+export interface PoolDataExtraPayload {
+    stakedDieselToken: Array<Address>;
+    stakedDieselToken_old: Array<Address>;
+    supplyAPY7D: number | undefined;
+}
+export interface LinearModel {
+    interestModel: Address;
     version: number;
-};
-export type PoolZapper = ExcludeArrayProps<ZapperInfoStructOutput>;
+    U_1: bigint;
+    U_2: bigint;
+    R_base: bigint;
+    R_slope1: bigint;
+    R_slope2: bigint;
+    R_slope3: bigint;
+    isBorrowingMoreU2Forbidden: boolean;
+}
+export interface PoolZapper {
+    zapper: Address;
+    tokenIn: Address;
+    tokenOut: Address;
+}
 export interface ChartsPoolDataPayload {
-    addr: string;
-    dieselToken: string;
-    underlyingToken: string;
+    addr: Address;
+    dieselToken: Address;
+    underlyingToken: Address;
     isWETH: boolean;
-    borrowAPY_RAY: BigNumberish;
-    depositAPY_RAY: BigNumberish;
-    dieselRate_RAY: BigNumberish;
+    version: number;
+    name: string;
+    borrowAPY_RAY: string;
+    depositAPY_RAY: string;
+    dieselRate_RAY: string;
     lmAPY: number;
+    lmRewardAll: Array<{
+        apy: number;
+        token: Address;
+    }>;
     earned7D: number;
     earned7DInUSD: number;
-    availableLiquidity: BigNumberish;
-    availableLiquidityOld: BigNumberish;
+    availableLiquidity: string;
+    availableLiquidityOld: string;
     availableLiquidity10kBasis: number;
     availableLiquidityInUSD: number;
     expectedLiqWeekAgo: number;
-    expectedLiquidity: BigNumberish;
-    expectedLiquidityOld: BigNumberish;
+    expectedLiquidity: string;
+    expectedLiquidityOld: string;
     expectedLiquidity10kBasis: number;
     expectedLiquidityInUSD: number;
-    expectedLiquidityLimit: BigNumberish;
+    expectedLiquidityLimit: string;
     expectedLiquidityLimitInUSD: number;
     caLockedValue: number;
     caLockedValueOld: number;
     caLockedValue10kBasis: number;
     caLockedValueUSD: number;
-    totalBorrowed: BigNumberish;
-    totalBorrowedOld: BigNumberish;
+    totalBorrowed: string;
+    totalBorrowedOld: string;
     totalBorrowed10kBasis: number;
     totalBorrowedInUSD: number;
-    debtWithInterest: BigNumberish;
+    debtWithInterest: string;
     debtWithInterest10kBasis: number;
     debtWithInterestInUSD: number;
-    debtWithInterestOld: BigNumberish;
+    debtWithInterestOld: string;
     withdrawFee: number;
     addLiqCount: number;
     addedLiquidity: number;
@@ -75,30 +141,40 @@ export interface ChartsAggregatedPoolPayload extends ChartsAggregatedStats {
     pools: Array<ChartsPoolDataPayload>;
 }
 export interface UserPoolPayload {
-    pool: string;
+    pool: Address;
     dieselSym: string;
-    dieselToken: string;
-    underlyingToken: string;
-    liqValue: BigNumberish;
+    dieselToken: Address;
+    underlyingToken: Address;
+    liqValue: string;
     liqValueInUSD: number;
     dieselBalance: number;
-    dieselBalanceBI: BigNumberish;
-    lmRewards: BigNumberish;
+    dieselBalanceBI: string;
+    lmRewards: string;
     lmRewardsInUSD: number;
+    userRewards: Array<{
+        lmRewards: string;
+        lmRewardsInUSD: number;
+        pool: Address;
+        rewardToken: Address;
+    }>;
     liqPnlInNativeToken: number;
     liqPnlInUSD: number;
     addedLiq: number;
     addLiqCount: number;
     removeLiqCount: number;
     removedLiq: number;
-    depositAPY_RAY: BigNumberish;
+    depositAPY_RAY: string;
     lmAPY: number;
+    lmRewardAll: Array<{
+        apy: number;
+        token: Address;
+    }>;
 }
 export interface UserPoolAggregatedStatsPayload {
     totalLMRewards: number;
     totalLiqInUSD: number;
     totalLiqt7DInUSD: number;
     totalLiqt10kBasis: number;
-    user: string;
+    user: Address;
     pools: Array<UserPoolPayload>;
 }

package/lib/payload/token.d.ts

@@ -1,5 +1,8 @@
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 export interface TokenDataPayload {
-    addr: string;
-    symbol: string;
+    title?: string;
+    addr: Address;
+    symbol: SupportedToken;
     decimals: number;
 }

package/lib/redstone/api.d.ts

@@ -0,0 +1,42 @@
+import { NetworkType, SupportedToken, TickerInfo } from "@gearbox-protocol/sdk-gov";
+import { SignedDataPackage } from "@redstone-finance/protocol";
+import { Address, PublicClient } from "viem";
+export declare const DEFAULT_DATA_SERVICE_ID = "redstone-primary-prod";
+export declare const REDSTONE_SIGNERS_THRESHOLD: number;
+interface RedstonePriceFeedInfo {
+    tokenAddress: Address;
+    tickedTokenAddress: Address;
+    symbol: SupportedToken;
+    feedAddress: Address;
+    dataFeedId: string;
+    tickedDataFeedId: string;
+    dataServiceId: string;
+    reserve: boolean;
+    ticker?: TickerInfo;
+}
+export type RedstonePriceFeeds = Array<RedstonePriceFeedInfo>;
+export interface GetRedstoneFeedsProps {
+    provider: PublicClient;
+    currentTokenData: Record<SupportedToken, Address>;
+    priceOracleAddress: Address;
+    network: NetworkType;
+}
+export declare class RedstoneApi {
+    static getPricesBulk(feedsToUpdate: Array<RedstonePriceFeedInfo>): Promise<`0x${string}`[]>;
+    static getRedstonePayloadForManualUsage: (dataServiceId: string, dataFeeds: string, uniqueSignersCount: number) => Promise<`0x${string}`>;
+    static getDataPackagesBulk(feedsToUpdate: Array<RedstonePriceFeedInfo>): Promise<{
+        [k: string]: SignedDataPackage[];
+    }>;
+    private static getDataPackages;
+    private static splitResponse;
+    static getRedstonePriceFeeds: ({ priceOracleAddress, currentTokenData, provider, network, }: GetRedstoneFeedsProps) => Promise<{
+        main: RedstonePriceFeeds;
+        reserve: RedstonePriceFeeds;
+        allReserve: Record<`0x${string}`, `0x${string}`[]>;
+        allMain_Root: Record<`0x${string}`, `0x${string}`>;
+    }>;
+    private static unwrapSecondStage;
+    private static unwrapThirdStage;
+    private static getRedstonePF_Onchain;
+}
+export {};

package/lib/redstone/api.js

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedstoneApi = exports.REDSTONE_SIGNERS_THRESHOLD = exports.DEFAULT_DATA_SERVICE_ID = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const evm_connector_1 = require("@redstone-finance/evm-connector");
+const redstone_protocol_1 = require("redstone-protocol");
+const viem_1 = require("viem");
+const types_1 = require("../types");
+exports.DEFAULT_DATA_SERVICE_ID = "redstone-primary-prod";
+exports.REDSTONE_SIGNERS_THRESHOLD = sdk_gov_1.REDSTONE_SIGNERS.signersThreshold;
+const REDSTONE_DICTIONARY = {
+    STETH: "stETH",
+};
+class RedstoneApi {
+    static async getPricesBulk(feedsToUpdate) {
+        const pricesOnDemand = await Promise.all(feedsToUpdate.map(f => this.getRedstonePayloadForManualUsage(f.dataServiceId, f.tickedDataFeedId, exports.REDSTONE_SIGNERS_THRESHOLD)));
+        return pricesOnDemand;
+    }
+    static getRedstonePayloadForManualUsage = async (dataServiceId, dataFeeds, uniqueSignersCount) => {
+        const wrapper = new evm_connector_1.DataServiceWrapper({
+            dataServiceId,
+            dataPackagesIds: [dataFeeds],
+            uniqueSignersCount,
+        });
+        const dataPayload = await wrapper.prepareRedstonePayload(true);
+        const { signedDataPackages, unsignedMetadata } = redstone_protocol_1.RedstonePayload.parse((0, viem_1.hexToBytes)(`0x${dataPayload}`));
+        const dataPackagesList = this.splitResponse(signedDataPackages, uniqueSignersCount);
+        const result = dataPackagesList.map(list => {
+            const payload = new redstone_protocol_1.RedstonePayload(list, (0, viem_1.bytesToString)(unsignedMetadata));
+            let ts = 0;
+            list.forEach(p => {
+                const newTimestamp = p.dataPackage.timestampMilliseconds / 1000;
+                if (ts === 0) {
+                    ts = newTimestamp;
+                }
+                else if (ts !== newTimestamp) {
+                    throw new Error("Timestamps are not equal");
+                }
+            });
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("uint256, bytes"), [
+                (0, sdk_gov_1.toBigInt)(ts),
+                `0x${payload.toBytesHexWithout0xPrefix()}`,
+            ]);
+        });
+        return result[0];
+    };
+    static async getDataPackagesBulk(feedsToUpdate) {
+        const feedsByServiceId = feedsToUpdate.reduce((acc, f) => {
+            const { dataServiceId = exports.DEFAULT_DATA_SERVICE_ID } = f;
+            if (!acc[dataServiceId])
+                acc[dataServiceId] = [];
+            acc[dataServiceId].push(f);
+            return acc;
+        }, {});
+        const groupedFeedsList = Object.values(feedsByServiceId);
+        const response = await Promise.all(groupedFeedsList.map(gr => this.getDataPackages(gr[0].dataServiceId || exports.DEFAULT_DATA_SERVICE_ID, gr.map(f => f.tickedDataFeedId), exports.REDSTONE_SIGNERS_THRESHOLD)));
+        const respList = groupedFeedsList.reduce((acc, gr, i) => {
+            const groupResponse = response[i];
+            gr.forEach((feed, j) => {
+                const start = j * exports.REDSTONE_SIGNERS_THRESHOLD;
+                const end = (j + 1) * exports.REDSTONE_SIGNERS_THRESHOLD;
+                const feedPackages = groupResponse.slice(start, end);
+                if (feedPackages.length !== exports.REDSTONE_SIGNERS_THRESHOLD) {
+                    throw new Error(`Redstone price packages response length mismatch: expected: ${exports.REDSTONE_SIGNERS_THRESHOLD}, got: ${feedPackages.length}`);
+                }
+                acc.push([feed.tokenAddress, feedPackages]);
+            });
+            return acc;
+        }, []);
+        if (respList.length !== feedsToUpdate.length) {
+            throw new Error(`Redstone price packages response length mismatch: expected: ${feedsToUpdate.length}, got: ${respList.length}`);
+        }
+        const respRecord = Object.fromEntries(respList);
+        return respRecord;
+    }
+    static getDataPackages = async (dataServiceId, dataFeeds, uniqueSignersCount) => {
+        const wrapper = new evm_connector_1.DataServiceWrapper({
+            dataServiceId: dataServiceId,
+            dataPackagesIds: dataFeeds,
+            uniqueSignersCount: uniqueSignersCount,
+        });
+        const dataPayload = await wrapper.getDataPackagesForPayload();
+        return dataPayload;
+    };
+    static splitResponse = (arr, size) => {
+        const chunks = [];
+        for (let i = 0; i < arr.length; i += size) {
+            const chunk = arr.slice(i, i + size);
+            chunks.push(chunk);
+        }
+        return chunks;
+    };
+    static getRedstonePriceFeeds = async ({ priceOracleAddress, currentTokenData, provider, network, }) => {
+        const allTokens = sdk_gov_1.TypedObjectUtils.entries(currentTokenData);
+        // 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: [
+                ...allTokens.map(([, a]) => ({
+                    address: priceOracleAddress,
+                    abi: types_1.iPriceOracleV3Abi,
+                    functionName: "priceFeedParams",
+                    args: [a],
+                })),
+                ...allTokens.map(([symbol]) => ({
+                    address: priceOracleAddress,
+                    abi: types_1.iPriceOracleV3Abi,
+                    functionName: "priceFeedsRaw",
+                    args: [currentTokenData[symbol], true],
+                })),
+            ],
+        }));
+        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;
+                acc.push([symbol, priceFeed]);
+            }
+            return acc;
+        }, []);
+        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" &&
+                st1_NotTrustedMainPFRecord[symbol]) {
+                acc.push([symbol, p.result]);
+            }
+            return acc;
+        }, []);
+        // 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: [
+                ...st1_NotTrustedMainPF.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...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: [],
+                })),
+                ...st2_NotTrustedMainPF.map(([, address]) => ({
+                    address,
+                    abi: types_1.compositePriceFeedAbi,
+                    functionName: "priceFeed1",
+                    args: [],
+                })),
+                ...st2_ReservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...st2_ReservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.compositePriceFeedAbi,
+                    functionName: "priceFeed0",
+                    args: [],
+                })),
+                ...st2_ReservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.compositePriceFeedAbi,
+                    functionName: "priceFeed1",
+                    args: [],
+                })),
+            ],
+        }));
+        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: [
+                ...st3_NotTrustedMainPF.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...st3_NotTrustedMainPF.map(([, address]) => ({
+                    address,
+                    abi: types_1.redstonePriceFeedAbi,
+                    functionName: "dataFeedId",
+                    args: [],
+                })),
+                ...st3_ReservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...st3_ReservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.redstonePriceFeedAbi,
+                    functionName: "dataFeedId",
+                    args: [],
+                })),
+            ],
+        }));
+        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(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);
+        const allReserve = st3_ReservePF.reduce((acc, [s, pf]) => {
+            const token = currentTokenData[s];
+            if (!acc[token])
+                acc[token] = [];
+            acc[token].push(pf);
+            return acc;
+        }, {});
+        const allMain_Root = st1_MainFeedsUnsafe.reduce((acc, p, index) => {
+            const token = allTokens[index][1];
+            if (!p.error && typeof p.result === "object" && p.result[4] === false) {
+                const [priceFeed] = p.result;
+                acc[token] = priceFeed;
+            }
+            return acc;
+        }, {});
+        return {
+            main: mainPFData,
+            reserve: reservePFData,
+            allReserve,
+            allMain_Root,
+        };
+    };
+    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 isRedstone = !typeError && Number(feedType) === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE;
+            const hasFeed = !feedError && typeof feed === "string";
+            if (isRedstone) {
+                acc.push([symbol, baseAddress]);
+            }
+            else if (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];
+            const { error: feed1Error, result: feed1 } = priceFeed1Response[index];
+            const isRedstone = !typeError && Number(feedType) === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE;
+            const hasFeed0 = !feed0Error && typeof feed0 === "string";
+            const hasFeed1 = !feed1Error && typeof feed1 === "string";
+            if (isRedstone) {
+                acc.push([symbol, baseAddress]);
+            }
+            else if (hasFeed0 || hasFeed1) {
+                if (hasFeed0) {
+                    acc.push([symbol, feed0]);
+                }
+                if (hasFeed1) {
+                    acc.push([symbol, feed1]);
+                }
+            }
+            else {
+                acc.push([symbol, baseAddress]);
+            }
+            return acc;
+        }, []);
+        return result;
+    }
+    static getRedstonePF_Onchain(feeds, typeResponse, idResponse, getFeedInfo, currentTokenData, reserve, network) {
+        const tickers = sdk_gov_1.tickerInfoTokensByNetwork[network];
+        const r = feeds.reduce((acc, [symbol, feedAddress], index) => {
+            const feedAddressLc = feedAddress.toLowerCase();
+            const { error: typeError, result: feedType } = typeResponse[index];
+            const isRedstone = !typeError && Number(feedType) === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE;
+            const { result: dataFeedId, error: idError } = idResponse[index];
+            const hasId = !idError && typeof dataFeedId === "string";
+            if (isRedstone) {
+                if (hasId) {
+                    const feedData = getFeedInfo(symbol);
+                    const dataServiceId = feedData?.dataServiceId;
+                    const id = (0, viem_1.bytesToString)((0, viem_1.hexToBytes)(dataFeedId))
+                        .trim()
+                        .replace(/\u0000/g, "");
+                    const unsafeTicker = tickers[symbol];
+                    const ticker = unsafeTicker?.find(t => t.priceFeed.toLowerCase() === feedAddressLc);
+                    const tokenAddress = currentTokenData[symbol];
+                    const defaultDataId = REDSTONE_DICTIONARY[id] || id;
+                    acc.push({
+                        tickedTokenAddress: (ticker?.address || tokenAddress).toLowerCase(),
+                        tokenAddress: tokenAddress,
+                        symbol,
+                        feedAddress: feedAddressLc,
+                        dataFeedId: defaultDataId,
+                        tickedDataFeedId: ticker?.dataId || defaultDataId,
+                        dataServiceId: dataServiceId || exports.DEFAULT_DATA_SERVICE_ID,
+                        reserve: ticker ? ticker.reserve : reserve,
+                        ticker,
+                    });
+                }
+                else {
+                    throw new Error(`Redstone price feed ${symbol}) has no dataFeedId: ${feedAddressLc}`);
+                }
+            }
+            return acc;
+        }, []);
+        return r;
+    }
+}
+exports.RedstoneApi = RedstoneApi;

package/lib/redstone/index.d.ts

@@ -0,0 +1 @@
+export * from "./api";

package/lib/redstone/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./api"), exports);

package/lib/tokens/tokenData.d.ts

@@ -1,10 +1,12 @@
+import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { TokenDataPayload } from "../payload/token";
 export declare class TokenData {
-    readonly id: string;
-    readonly symbol: string;
-    readonly address: string;
+    readonly title: string;
+    readonly symbol: SupportedToken;
+    readonly address: Address;
     readonly decimals: number;
-    readonly icon?: string;
-    constructor(payload: TokenDataPayload, symbolReplacements?: Record<string, string>);
+    readonly icon: string;
+    constructor(payload: TokenDataPayload);
     compareBySymbol(b: TokenData): number;
 }