@gearbox-protocol/sdk 3.0.0-next.23 → 3.0.0-next.230

package/lib/redstone/api.js

@@ -0,0 +1,365 @@
+"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,
+            dataFeeds: [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,
+            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 provider.multicall({
+            allowFailure: true,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [
+                ...mainRedstone.map(([symbol]) => ({
+                    address: priceOracleAddress,
+                    abi: types_1.iPriceOracleV3Abi,
+                    functionName: "priceFeedsRaw",
+                    args: [currentTokenData[symbol], false],
+                })),
+                ...reserveRedstone.map(([symbol]) => ({
+                    address: priceOracleAddress,
+                    abi: types_1.iPriceOracleV3Abi,
+                    functionName: "priceFeedsRaw",
+                    args: [currentTokenData[symbol], true],
+                })),
+            ],
+        }));
+        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 { result: 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 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 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 && typeof p.result === "object" && p.result[4] === false) {
+                const [priceFeed] = p.result;
+                acc.push([symbol, 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.result === "string" &&
+                notTrustedMainPFRecord[symbol]) {
+                acc.push([symbol, p.result]);
+            }
+            return acc;
+        }, []);
+        const typeResponse = (await provider.multicall({
+            allowFailure: true,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [
+                ...notTrustedMainPF.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...notTrustedMainPF.map(([, address]) => ({
+                    address,
+                    abi: types_1.compositePriceFeedAbi,
+                    functionName: "priceFeed0",
+                    args: [],
+                })),
+                ...reservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...reservePF.map(([, address]) => ({
+                    address,
+                    abi: types_1.compositePriceFeedAbi,
+                    functionName: "priceFeed0",
+                    args: [],
+                })),
+            ],
+        }));
+        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 provider.multicall({
+            allowFailure: true,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [
+                ...realNotTrustedMainPriceFeeds.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...realNotTrustedMainPriceFeeds.map(([, address]) => ({
+                    address,
+                    abi: types_1.redstonePriceFeedAbi,
+                    functionName: "dataFeedId",
+                    args: [],
+                })),
+                ...realReservePriceFeeds.map(([, address]) => ({
+                    address,
+                    abi: types_1.iPriceFeedAbi,
+                    functionName: "priceFeedType",
+                    args: [],
+                })),
+                ...realReservePriceFeeds.map(([, address]) => ({
+                    address,
+                    abi: types_1.redstonePriceFeedAbi,
+                    functionName: "dataFeedId",
+                    args: [],
+                })),
+            ],
+        }));
+        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,
+            allReserve: sdk_gov_1.TypedObjectUtils.fromEntries(reservePF.map(([s, a]) => [currentTokenData[s], a])),
+        };
+    };
+    static getPriceFeedsOfInterest_Onchain(priceFeeds, feedsTypeResponse, priceFeed0Response) {
+        const result = priceFeeds.reduce((acc, [symbol, baseAddress], index) => {
+            const { error: typeError, result: feedType } = feedsTypeResponse[index];
+            const { error: feed0Error, result: 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, 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?.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,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,26 @@
 "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",
+};
 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";
+}];