@gearbox-protocol/sdk 3.0.0-next.27 → 3.0.0-next.271

package/lib/redstone/api.d.ts

@@ -0,0 +1,41 @@
+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}`[]>;
+    }>;
+    private static unwrapSecondStage;
+    private static unwrapThirdStage;
+    private static getRedstonePF_Onchain;
+}
+export {};

package/lib/redstone/api.js

@@ -0,0 +1,375 @@
+"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 DataServiceWrapper_1 = require("@redstone-finance/evm-connector/dist/src/wrappers/DataServiceWrapper");
+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 DataServiceWrapper_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 DataServiceWrapper_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;
+        }, {});
+        return {
+            main: mainPFData,
+            reserve: reservePFData,
+            allReserve,
+        };
+    };
+    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;
 }

package/lib/tokens/tokenData.js

@@ -1,19 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenData = void 0;
-const config_1 = require("../config");
+const endpoint_1 = require("../core/endpoint");
+const ALIASES = {
+    USDC_e: "USDC.e",
+    dUSDC_eV3: "dUSDC.eV3",
+    sdUSDC_eV3: "sdUSDC.eV3",
+    sdWETHV3_OLD: "sdWETHV3 Old",
+    PT_rsETH_26SEP2024: "p.rsETH(26.09.24)",
+    PT_sUSDe_26DEC2024: "p.sUSDe(26.12.24)",
+    PT_eETH_26DEC2024: "p.eETH(26.12.24)",
+    PT_ezETH_26DEC2024: "p.ezETH(26.12.24)",
+    PT_eBTC_26DEC2024: "p.eBTC(26.12.24)",
+    PT_LBTC_27MAR2025: "p.LBTC(27.03.25)",
+    PT_cornLBTC_26DEC2024: "p.c.LBTC(26.12.24)",
+    PT_corn_eBTC_27MAR2025: "p.c.eBTC(27.03.25)",
+    PT_corn_pumpBTC_26DEC2024: "p.c.pumpBTC(26.12.24)",
+    PT_sUSDe_27MAR2025: "p.sUSDe(27.03.25)",
+};
 class TokenData {
-    id;
+    title;
     symbol;
     address;
     decimals;
     icon;
-    constructor(payload, symbolReplacements = {}) {
-        this.id = payload.addr.toLowerCase();
+    constructor(payload) {
+        const symbol = payload.symbol;
+        this.title = ALIASES[symbol] || payload.title || symbol;
         this.address = payload.addr.toLowerCase();
-        this.symbol = symbolReplacements[payload.symbol] || payload.symbol;
+        this.symbol = symbol;
         this.decimals = payload.decimals;
-        this.icon = `${config_1.STATIC_TOKEN}${payload.symbol?.toLowerCase()}.svg`;
+        this.icon = `${endpoint_1.GearboxBackendApi.getStaticTokenUrl()}${symbol.toLowerCase()}.svg`;
     }
     compareBySymbol(b) {
         return this.symbol > b.symbol ? 1 : -1;

package/lib/types/CompositePriceFeed.d.ts

@@ -0,0 +1,182 @@
+export declare const compositePriceFeedAbi: readonly [{
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "priceFeeds";
+        readonly internalType: "struct PriceFeedParams[2]";
+        readonly type: "tuple[2]";
+        readonly components: readonly [{
+            readonly name: "priceFeed";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "stalenessPeriod";
+            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: "latestRoundData";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint80";
+        readonly type: "uint80";
+    }, {
+        readonly name: "answer";
+        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: "priceFeed0";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "priceFeed1";
+    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: "skipCheck1";
+    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: "stalenessPeriod0";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint32";
+        readonly type: "uint32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "stalenessPeriod1";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint32";
+        readonly type: "uint32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "targetFeedScale";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "int256";
+        readonly type: "int256";
+    }];
+    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: "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";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "ZeroAddressException";
+}];