@gearbox-protocol/sdk 3.0.0-next.19 → 3.0.0-next.191

package/lib/redstone/api.js

@@ -0,0 +1,344 @@
+"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 ethers_1 = require("ethers");
+const redstone_protocol_1 = require("redstone-protocol");
+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,
+            dataFeeds: [dataFeeds],
+            uniqueSignersCount,
+        });
+        const dataPayload = await wrapper.prepareRedstonePayload(true);
+        const { signedDataPackages, unsignedMetadata } = redstone_protocol_1.RedstonePayload.parse((0, ethers_1.getBytes)(`0x${dataPayload}`));
+        const dataPackagesList = this.splitResponse(signedDataPackages, uniqueSignersCount);
+        const result = dataPackagesList.map(list => {
+            const payload = new redstone_protocol_1.RedstonePayload(list, (0, ethers_1.toUtf8String)(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 ethers_1.AbiCoder.defaultAbiCoder().encode(["uint256", "bytes"], [ts, (0, ethers_1.getBytes)(`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,
+            dataFeeds: 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 getRedstonePriceFeedsSDK = async ({ priceOracleAddress, currentTokenData, provider, network, }) => {
+        const allTokens = sdk_gov_1.TypedObjectUtils.entries(currentTokenData);
+        const { main: mainRedstone, reserve: reserveRedstone } = allTokens.reduce((acc, [t]) => {
+            const { Main, Reserve } = (0, sdk_gov_1.getPriceFeedsByToken)(t, network) || {};
+            const notTrusted = Main?.trusted === false;
+            const reserveRedstone = Reserve?.type === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE;
+            if (notTrusted && reserveRedstone) {
+                acc.reserve.push([t, Reserve]);
+            }
+            if (notTrusted &&
+                Reserve?.type === sdk_gov_1.PriceFeedType.COMPOSITE_ORACLE &&
+                typeof Reserve.targetToBasePriceFeed !== "string" &&
+                Reserve.targetToBasePriceFeed.type === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE) {
+                acc.reserve.push([t, Reserve.targetToBasePriceFeed]);
+            }
+            if (Main?.type === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE) {
+                acc.main.push([t, Main]);
+            }
+            if (Main?.type === sdk_gov_1.PriceFeedType.COMPOSITE_ORACLE &&
+                typeof Main.targetToBasePriceFeed !== "string" &&
+                Main.targetToBasePriceFeed.type === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE) {
+                acc.main.push([t, Main.targetToBasePriceFeed]);
+            }
+            return acc;
+        }, { main: [], reserve: [] });
+        const priceFeedsResp = await (0, sdk_gov_1.safeMulticall)([
+            ...mainRedstone.map(([symbol]) => ({
+                address: priceOracleAddress,
+                interface: types_1.IPriceOracleV3__factory.createInterface(),
+                method: "priceFeedsRaw(address,bool)",
+                params: [currentTokenData[symbol], false],
+            })),
+            ...reserveRedstone.map(([symbol]) => ({
+                address: priceOracleAddress,
+                interface: types_1.IPriceOracleV3__factory.createInterface(),
+                method: "priceFeedsRaw(address,bool)",
+                params: [currentTokenData[symbol], true],
+            })),
+        ], provider);
+        const mainPFEnd = mainRedstone.length;
+        const mainPFAddresses = priceFeedsResp.slice(0, mainPFEnd);
+        const mainPFData = this.getRedstonePF_SDK(mainRedstone, mainPFAddresses, currentTokenData, false, network);
+        const reservePFEnd = mainPFEnd + reserveRedstone.length;
+        const reservePFAddresses = priceFeedsResp.slice(mainPFEnd, reservePFEnd);
+        const reservePFData = this.getRedstonePF_SDK(reserveRedstone, reservePFAddresses, currentTokenData, true, network);
+        return { main: mainPFData, reserve: reservePFData };
+    };
+    static getRedstonePF_SDK(sdkPF, addressResponse, currentTokenData, reserve, network) {
+        const tickers = sdk_gov_1.tickerInfoTokensByNetwork[network];
+        const r = sdkPF.reduce((acc, [symbol, feedData], index) => {
+            const { dataId: dataFeedId, dataServiceId } = feedData || {};
+            const { value: feedAddress, error: feedError } = addressResponse[index] || {};
+            const feedAddressLc = feedAddress?.toLowerCase();
+            const hasId = !feedError && typeof feedAddressLc === "string";
+            if (hasId && dataFeedId && dataServiceId) {
+                const unsafeTicker = tickers[symbol];
+                const ticker = unsafeTicker?.priceFeed.toLowerCase() === feedAddressLc
+                    ? unsafeTicker
+                    : undefined;
+                const tokenAddress = currentTokenData[symbol];
+                acc.push({
+                    tickedTokenAddress: (ticker?.address || tokenAddress).toLowerCase(),
+                    tokenAddress,
+                    symbol,
+                    feedAddress: feedAddressLc,
+                    dataFeedId: dataFeedId,
+                    tickedDataFeedId: ticker?.dataId || dataFeedId,
+                    dataServiceId,
+                    reserve,
+                    ticker,
+                });
+            }
+            else {
+                throw new Error(`Redstone price feed (${symbol}) is missing one or more fields. feed: ${feedAddressLc}, dataFeedId: ${dataFeedId}, dataServiceId: ${dataServiceId}`);
+            }
+            return acc;
+        }, []);
+        return r;
+    }
+    static getRedstonePriceFeeds = async ({ priceOracleAddress, currentTokenData, provider, network, }) => {
+        const allTokens = sdk_gov_1.TypedObjectUtils.entries(currentTokenData);
+        const feeds = await (0, sdk_gov_1.safeMulticall)([
+            ...allTokens.map(([, a]) => ({
+                address: priceOracleAddress,
+                interface: types_1.IPriceOracleV3__factory.createInterface(),
+                method: "priceFeedParams(address)",
+                params: [a],
+            })),
+            ...allTokens.map(([symbol]) => ({
+                address: priceOracleAddress,
+                interface: types_1.IPriceOracleV3__factory.createInterface(),
+                method: "priceFeedsRaw(address,bool)",
+                params: [currentTokenData[symbol], true],
+            })),
+        ], provider);
+        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 symbol = allTokens[index][0];
+            if (!p.error && p.value?.trusted === false) {
+                acc.push([symbol, p.value.priceFeed]);
+            }
+            return acc;
+        }, []);
+        const notTrustedMainPFRecord = sdk_gov_1.TypedObjectUtils.fromEntries(notTrustedMainPF);
+        const reservePF = reserveFeedsUnsafe.reduce((acc, p, index) => {
+            const symbol = allTokens[index][0];
+            if (!p.error &&
+                typeof p.value === "string" &&
+                notTrustedMainPFRecord[symbol]) {
+                acc.push([symbol, p.value]);
+            }
+            return acc;
+        }, []);
+        const typeResponse = await (0, sdk_gov_1.safeMulticall)([
+            ...notTrustedMainPF.map(([, address]) => ({
+                address,
+                interface: types_1.IPriceFeed__factory.createInterface(),
+                method: "priceFeedType()",
+                params: [],
+            })),
+            ...notTrustedMainPF.map(([, address]) => ({
+                address,
+                interface: types_1.CompositePriceFeed__factory.createInterface(),
+                method: "priceFeed0()",
+                params: [],
+            })),
+            ...reservePF.map(([, address]) => ({
+                address,
+                interface: types_1.IPriceFeed__factory.createInterface(),
+                method: "priceFeedType()",
+                params: [],
+            })),
+            ...reservePF.map(([, address]) => ({
+                address,
+                interface: types_1.CompositePriceFeed__factory.createInterface(),
+                method: "priceFeed0()",
+                params: [],
+            })),
+        ], provider);
+        const mainFeedsTypeEnd = notTrustedMainPF.length;
+        const mainFeedsTypeUnsafe = typeResponse.slice(0, mainFeedsTypeEnd);
+        const mainPriceFeed0End = mainFeedsTypeEnd + notTrustedMainPF.length;
+        const mainPriceFeed0Unsafe = typeResponse.slice(mainFeedsTypeEnd, mainPriceFeed0End);
+        const reserveFeedsTypeEnd = mainPriceFeed0End + reservePF.length;
+        const reserveFeedsTypeUnsafe = typeResponse.slice(mainPriceFeed0End, reserveFeedsTypeEnd);
+        const reservePriceFeed0End = reserveFeedsTypeEnd + reservePF.length;
+        const reservePriceFeed0Unsafe = typeResponse.slice(reserveFeedsTypeEnd, reservePriceFeed0End);
+        const realNotTrustedMainPriceFeeds = this.getPriceFeedsOfInterest_Onchain(notTrustedMainPF, mainFeedsTypeUnsafe, mainPriceFeed0Unsafe);
+        const realReservePriceFeeds = this.getPriceFeedsOfInterest_Onchain(reservePF, reserveFeedsTypeUnsafe, reservePriceFeed0Unsafe);
+        const response = await (0, sdk_gov_1.safeMulticall)([
+            ...realNotTrustedMainPriceFeeds.map(([, address]) => ({
+                address,
+                interface: types_1.IPriceFeed__factory.createInterface(),
+                method: "priceFeedType()",
+                params: [],
+            })),
+            ...realNotTrustedMainPriceFeeds.map(([, address]) => ({
+                address,
+                interface: types_1.RedstonePriceFeed__factory.createInterface(),
+                method: "dataFeedId()",
+                params: [],
+            })),
+            ...realReservePriceFeeds.map(([, address]) => ({
+                address,
+                interface: types_1.IPriceFeed__factory.createInterface(),
+                method: "priceFeedType()",
+                params: [],
+            })),
+            ...realReservePriceFeeds.map(([, address]) => ({
+                address,
+                interface: types_1.RedstonePriceFeed__factory.createInterface(),
+                method: "dataFeedId()",
+                params: [],
+            })),
+        ], provider);
+        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 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);
+        return {
+            main: mainPFData,
+            reserve: reservePFData,
+        };
+    };
+    static getPriceFeedsOfInterest_Onchain(priceFeeds, feedsTypeResponse, priceFeed0Response) {
+        const result = priceFeeds.reduce((acc, [symbol, baseAddress], index) => {
+            const { error: typeError, value: feedType } = feedsTypeResponse[index];
+            const { error: feed0Error, value: feed0 } = priceFeed0Response[index];
+            const isRedstone = !typeError && Number(feedType) === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE;
+            const isComposite = !typeError && Number(feedType) === sdk_gov_1.PriceFeedType.COMPOSITE_ORACLE;
+            if (isRedstone) {
+                acc.push([symbol, baseAddress]);
+            }
+            const hasFeed0 = !feed0Error && typeof feed0 === "string";
+            if (isComposite && hasFeed0) {
+                acc.push([symbol, feed0]);
+            }
+            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, value: feedType } = typeResponse[index];
+            const isRedstone = !typeError && Number(feedType) === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE;
+            const { value: 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, ethers_1.toUtf8String)(dataFeedId)
+                        .trim()
+                        .replace(/\u0000/g, "");
+                    const unsafeTicker = tickers[symbol];
+                    const ticker = unsafeTicker?.priceFeed.toLowerCase() === feedAddressLc
+                        ? unsafeTicker
+                        : undefined;
+                    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,
+                    });
+                }
+                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/{core/pool → redstone}/index.js

@@ -14,4 +14,4 @@ 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("./data"), exports);
+__exportStar(require("./api"), exports);

package/lib/tokens/tokenData.d.ts

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

package/lib/tokens/tokenData.js

@@ -2,18 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenData = void 0;
 const config_1 = require("../config");
+const ALIASES = {
+    USDC_e: "USDC.e",
+};
+const NETWROK_DEPENDENT_ALIASES = {
+    Mainnet: {},
+    Optimism: {
+        dUSDCV3: "dUSDC.eV3",
+        sdUSDCV3: "sdUSDC.eV3",
+    },
+    Arbitrum: {
+        dUSDCV3: "dUSDC.eV3",
+        sdUSDCV3: "sdUSDC.eV3",
+    },
+    Base: {},
+};
 class TokenData {
-    id;
+    title;
     symbol;
     address;
     decimals;
     icon;
-    constructor(payload, symbolReplacements = {}) {
-        this.id = payload.addr.toLowerCase();
+    constructor(payload, network) {
+        const symbol = payload.symbol;
+        const networkAlias = network
+            ? NETWROK_DEPENDENT_ALIASES[network][symbol]
+            : undefined;
+        this.title = networkAlias || 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 = `${config_1.STATIC_TOKEN}${symbol.toLowerCase()}.svg`;
     }
     compareBySymbol(b) {
         return this.symbol > b.symbol ? 1 : -1;