@gearbox-protocol/sdk 3.0.0-next.204 → 3.0.0-next.206

package/lib/redstone/api.js

@@ -3,8 +3,8 @@ 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 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;
@@ -23,10 +23,10 @@ class RedstoneApi {
             uniqueSignersCount,
         });
         const dataPayload = await wrapper.prepareRedstonePayload(true);
-        const { signedDataPackages, unsignedMetadata } = redstone_protocol_1.RedstonePayload.parse((0, ethers_1.getBytes)(`0x${dataPayload}`));
+        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, ethers_1.toUtf8String)(unsignedMetadata));
+            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;
@@ -37,7 +37,10 @@ class RedstoneApi {
                     throw new Error("Timestamps are not equal");
                 }
             });
-            return ethers_1.AbiCoder.defaultAbiCoder().encode(["uint256", "bytes"], [ts, (0, ethers_1.getBytes)(`0x${payload.toBytesHexWithout0xPrefix()}`)]);
+            return (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("uint256, bytes"), [
+                (0, sdk_gov_1.toBigInt)(ts),
+                `0x${payload.toBytesHexWithout0xPrefix()}`,
+            ]);
         });
         return result[0];
     };
@@ -112,20 +115,24 @@ class RedstoneApi {
             }
             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 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);
@@ -138,7 +145,7 @@ class RedstoneApi {
         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 { result: feedAddress, error: feedError } = addressResponse[index] || {};
             const feedAddressLc = feedAddress?.toLowerCase();
             const hasId = !feedError && typeof feedAddressLc === "string";
             if (hasId && dataFeedId && dataServiceId) {
@@ -168,28 +175,33 @@ class RedstoneApi {
     }
     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 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 && p.value?.trusted === false) {
-                acc.push([symbol, p.value.priceFeed]);
+            if (!p.error && typeof p.result === "object" && p.result[4] === false) {
+                const [priceFeed] = p.result;
+                acc.push([symbol, priceFeed]);
             }
             return acc;
         }, []);
@@ -197,38 +209,42 @@ class RedstoneApi {
         const reservePF = reserveFeedsUnsafe.reduce((acc, p, index) => {
             const symbol = allTokens[index][0];
             if (!p.error &&
-                typeof p.value === "string" &&
+                typeof p.result === "string" &&
                 notTrustedMainPFRecord[symbol]) {
-                acc.push([symbol, p.value]);
+                acc.push([symbol, p.result]);
             }
             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 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;
@@ -239,32 +255,36 @@ class RedstoneApi {
         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 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;
@@ -285,8 +305,8 @@ class RedstoneApi {
     };
     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 { 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) {
@@ -304,15 +324,15 @@ class RedstoneApi {
         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 { error: typeError, result: feedType } = typeResponse[index];
             const isRedstone = !typeError && Number(feedType) === sdk_gov_1.PriceFeedType.REDSTONE_ORACLE;
-            const { value: dataFeedId, error: idError } = idResponse[index];
+            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, ethers_1.toUtf8String)(dataFeedId)
+                    const id = (0, viem_1.bytesToString)((0, viem_1.hexToBytes)(dataFeedId))
                         .trim()
                         .replace(/\u0000/g, "");
                     const unsafeTicker = tickers[symbol];

package/lib/tokens/tokenData.d.ts

@@ -1,9 +1,10 @@
 import { NetworkType, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { TokenDataPayload } from "../payload/token";
 export declare class TokenData {
     readonly title: string;
     readonly symbol: SupportedToken;
-    readonly address: string;
+    readonly address: Address;
     readonly decimals: number;
     readonly icon: string;
     constructor(payload: TokenDataPayload, network?: NetworkType);

package/lib/types/CompositePriceFeed.d.ts

@@ -1,90 +1,182 @@
-import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
-import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener, TypedContractMethod } from "./common";
-export type PriceFeedParamsStruct = {
-    priceFeed: AddressLike;
-    stalenessPeriod: BigNumberish;
-};
-export type PriceFeedParamsStructOutput = [
-    priceFeed: string,
-    stalenessPeriod: bigint
-] & {
-    priceFeed: string;
-    stalenessPeriod: bigint;
-};
-export interface CompositePriceFeedInterface extends Interface {
-    getFunction(nameOrSignature: "decimals" | "description" | "latestRoundData" | "priceFeed0" | "priceFeed1" | "priceFeedType" | "skipCheck1" | "skipPriceCheck" | "stalenessPeriod0" | "stalenessPeriod1" | "targetFeedScale" | "version"): FunctionFragment;
-    encodeFunctionData(functionFragment: "decimals", values?: undefined): string;
-    encodeFunctionData(functionFragment: "description", values?: undefined): string;
-    encodeFunctionData(functionFragment: "latestRoundData", values?: undefined): string;
-    encodeFunctionData(functionFragment: "priceFeed0", values?: undefined): string;
-    encodeFunctionData(functionFragment: "priceFeed1", values?: undefined): string;
-    encodeFunctionData(functionFragment: "priceFeedType", values?: undefined): string;
-    encodeFunctionData(functionFragment: "skipCheck1", values?: undefined): string;
-    encodeFunctionData(functionFragment: "skipPriceCheck", values?: undefined): string;
-    encodeFunctionData(functionFragment: "stalenessPeriod0", values?: undefined): string;
-    encodeFunctionData(functionFragment: "stalenessPeriod1", values?: undefined): string;
-    encodeFunctionData(functionFragment: "targetFeedScale", values?: undefined): string;
-    encodeFunctionData(functionFragment: "version", values?: undefined): string;
-    decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "description", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "latestRoundData", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "priceFeed0", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "priceFeed1", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "priceFeedType", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "skipCheck1", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "skipPriceCheck", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "stalenessPeriod0", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "stalenessPeriod1", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "targetFeedScale", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
-}
-export interface CompositePriceFeed extends BaseContract {
-    connect(runner?: ContractRunner | null): CompositePriceFeed;
-    waitForDeployment(): Promise<this>;
-    interface: CompositePriceFeedInterface;
-    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
-    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
-    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
-    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
-    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
-    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
-    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
-    listeners(eventName?: string): Promise<Array<Listener>>;
-    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
-    decimals: TypedContractMethod<[], [bigint], "view">;
-    description: TypedContractMethod<[], [string], "view">;
-    latestRoundData: TypedContractMethod<[
-    ], [
-        [bigint, bigint, bigint, bigint, bigint] & {
-            answer: bigint;
-        }
-    ], "view">;
-    priceFeed0: TypedContractMethod<[], [string], "view">;
-    priceFeed1: TypedContractMethod<[], [string], "view">;
-    priceFeedType: TypedContractMethod<[], [bigint], "view">;
-    skipCheck1: TypedContractMethod<[], [boolean], "view">;
-    skipPriceCheck: TypedContractMethod<[], [boolean], "view">;
-    stalenessPeriod0: TypedContractMethod<[], [bigint], "view">;
-    stalenessPeriod1: TypedContractMethod<[], [bigint], "view">;
-    targetFeedScale: TypedContractMethod<[], [bigint], "view">;
-    version: TypedContractMethod<[], [bigint], "view">;
-    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
-    getFunction(nameOrSignature: "decimals"): TypedContractMethod<[], [bigint], "view">;
-    getFunction(nameOrSignature: "description"): TypedContractMethod<[], [string], "view">;
-    getFunction(nameOrSignature: "latestRoundData"): TypedContractMethod<[
-    ], [
-        [bigint, bigint, bigint, bigint, bigint] & {
-            answer: bigint;
-        }
-    ], "view">;
-    getFunction(nameOrSignature: "priceFeed0"): TypedContractMethod<[], [string], "view">;
-    getFunction(nameOrSignature: "priceFeed1"): TypedContractMethod<[], [string], "view">;
-    getFunction(nameOrSignature: "priceFeedType"): TypedContractMethod<[], [bigint], "view">;
-    getFunction(nameOrSignature: "skipCheck1"): TypedContractMethod<[], [boolean], "view">;
-    getFunction(nameOrSignature: "skipPriceCheck"): TypedContractMethod<[], [boolean], "view">;
-    getFunction(nameOrSignature: "stalenessPeriod0"): TypedContractMethod<[], [bigint], "view">;
-    getFunction(nameOrSignature: "stalenessPeriod1"): TypedContractMethod<[], [bigint], "view">;
-    getFunction(nameOrSignature: "targetFeedScale"): TypedContractMethod<[], [bigint], "view">;
-    getFunction(nameOrSignature: "version"): TypedContractMethod<[], [bigint], "view">;
-    filters: {};
-}
+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";
+}];