@gearbox-protocol/sdk 3.0.0-next.2 → 3.0.0-next.200

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/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,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;

package/lib/types/AddressProvider.d.ts

@@ -0,0 +1,201 @@
+import type { BaseContract, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "./common";
+export interface AddressProviderInterface extends Interface {
+    getFunction(nameOrSignature: "addresses" | "claimOwnership" | "getACL" | "getAccountFactory" | "getContractsRegister" | "getDataCompressor" | "getGearToken" | "getLeveragedActions" | "getPriceOracle" | "getTreasuryContract" | "getWETHGateway" | "getWethToken" | "owner" | "pendingOwner" | "renounceOwnership" | "setACL" | "setAccountFactory" | "setContractsRegister" | "setDataCompressor" | "setGearToken" | "setLeveragedActions" | "setPriceOracle" | "setTreasuryContract" | "setWETHGateway" | "setWethToken" | "transferOwnership" | "version"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "AddressSet" | "OwnershipTransferred"): EventFragment;
+    encodeFunctionData(functionFragment: "addresses", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "claimOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getACL", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getAccountFactory", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getContractsRegister", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getDataCompressor", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getGearToken", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getLeveragedActions", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getPriceOracle", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getTreasuryContract", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getWETHGateway", values?: undefined): string;
+    encodeFunctionData(functionFragment: "getWethToken", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pendingOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setACL", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setAccountFactory", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setContractsRegister", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setDataCompressor", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setGearToken", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setLeveragedActions", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setPriceOracle", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setTreasuryContract", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setWETHGateway", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "setWethToken", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "version", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "addresses", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "claimOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getACL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getAccountFactory", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getContractsRegister", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getDataCompressor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getGearToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getLeveragedActions", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getPriceOracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getTreasuryContract", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getWETHGateway", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getWethToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pendingOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setACL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setAccountFactory", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setContractsRegister", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setDataCompressor", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setGearToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setLeveragedActions", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setPriceOracle", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setTreasuryContract", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setWETHGateway", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setWethToken", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;
+}
+export declare namespace AddressSetEvent {
+    type InputTuple = [service: BytesLike, newAddress: AddressLike];
+    type OutputTuple = [service: string, newAddress: string];
+    interface OutputObject {
+        service: string;
+        newAddress: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export declare namespace OwnershipTransferredEvent {
+    type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+    type OutputTuple = [previousOwner: string, newOwner: string];
+    interface OutputObject {
+        previousOwner: string;
+        newOwner: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
+}
+export interface AddressProvider extends BaseContract {
+    connect(runner?: ContractRunner | null): AddressProvider;
+    waitForDeployment(): Promise<this>;
+    interface: AddressProviderInterface;
+    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>;
+    addresses: TypedContractMethod<[arg0: BytesLike], [string], "view">;
+    claimOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    getACL: TypedContractMethod<[], [string], "view">;
+    getAccountFactory: TypedContractMethod<[], [string], "view">;
+    getContractsRegister: TypedContractMethod<[], [string], "view">;
+    getDataCompressor: TypedContractMethod<[], [string], "view">;
+    getGearToken: TypedContractMethod<[], [string], "view">;
+    getLeveragedActions: TypedContractMethod<[], [string], "view">;
+    getPriceOracle: TypedContractMethod<[], [string], "view">;
+    getTreasuryContract: TypedContractMethod<[], [string], "view">;
+    getWETHGateway: TypedContractMethod<[], [string], "view">;
+    getWethToken: TypedContractMethod<[], [string], "view">;
+    owner: TypedContractMethod<[], [string], "view">;
+    pendingOwner: TypedContractMethod<[], [string], "view">;
+    renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+    setACL: TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    setAccountFactory: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setContractsRegister: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setDataCompressor: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setGearToken: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setLeveragedActions: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setPriceOracle: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setTreasuryContract: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setWETHGateway: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    setWethToken: TypedContractMethod<[
+        _address: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    transferOwnership: TypedContractMethod<[
+        newOwner: AddressLike
+    ], [
+        void
+    ], "nonpayable">;
+    version: TypedContractMethod<[], [bigint], "view">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "addresses"): TypedContractMethod<[arg0: BytesLike], [string], "view">;
+    getFunction(nameOrSignature: "claimOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "getACL"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getAccountFactory"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getContractsRegister"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getDataCompressor"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getGearToken"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getLeveragedActions"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getPriceOracle"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getTreasuryContract"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getWETHGateway"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "getWethToken"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "owner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "pendingOwner"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "renounceOwnership"): TypedContractMethod<[], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setACL"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setAccountFactory"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setContractsRegister"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setDataCompressor"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setGearToken"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setLeveragedActions"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setPriceOracle"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setTreasuryContract"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setWETHGateway"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "setWethToken"): TypedContractMethod<[_address: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "transferOwnership"): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+    getFunction(nameOrSignature: "version"): TypedContractMethod<[], [bigint], "view">;
+    getEvent(key: "AddressSet"): TypedContractEvent<AddressSetEvent.InputTuple, AddressSetEvent.OutputTuple, AddressSetEvent.OutputObject>;
+    getEvent(key: "OwnershipTransferred"): TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    filters: {
+        "AddressSet(bytes32,address)": TypedContractEvent<AddressSetEvent.InputTuple, AddressSetEvent.OutputTuple, AddressSetEvent.OutputObject>;
+        AddressSet: TypedContractEvent<AddressSetEvent.InputTuple, AddressSetEvent.OutputTuple, AddressSetEvent.OutputObject>;
+        "OwnershipTransferred(address,address)": TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+        OwnershipTransferred: TypedContractEvent<OwnershipTransferredEvent.InputTuple, OwnershipTransferredEvent.OutputTuple, OwnershipTransferredEvent.OutputObject>;
+    };
+}

package/lib/types/Balances.sol/BalanceOps.d.ts

@@ -0,0 +1,20 @@
+import type { BaseContract, FunctionFragment, Interface, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedListener } from "../common";
+export interface BalanceOpsInterface extends Interface {
+}
+export interface BalanceOps extends BaseContract {
+    connect(runner?: ContractRunner | null): BalanceOps;
+    waitForDeployment(): Promise<this>;
+    interface: BalanceOpsInterface;
+    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>;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    filters: {};
+}

package/lib/types/Balances.sol/index.d.ts

@@ -0,0 +1 @@
+export type { BalanceOps } from "./BalanceOps";