@gearbox-protocol/sdk 3.0.0-next.21 → 3.0.0-next.211

package/lib/parsers/convextRewardPoolParser.js

@@ -6,15 +6,15 @@ const abstractParser_1 = require("./abstractParser");
 class ConvexRewardPoolParser extends abstractParser_1.AbstractParser {
     constructor(token) {
         super(`ConvexRewardPool_${token}`);
-        this.ifc = types_1.IBaseRewardPool__factory.createInterface();
+        this.abi = types_1.iBaseRewardPoolAbi;
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "rewardRate":
                 return `${functionName}()`;
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/creditFacadeParser.d.ts

@@ -1,10 +1,11 @@
 import { SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { BigNumberish } from "ethers";
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class CreditFacadeParser extends AbstractParser implements IParser {
     version: number;
     constructor(token: SupportedToken, version: number);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
     formatAmount(amount: BigNumberish): string;
 }

package/lib/parsers/creditFacadeParser.js

@@ -8,47 +8,73 @@ class CreditFacadeParser extends abstractParser_1.AbstractParser {
     constructor(token, version) {
         super(token);
         this.version = version;
-        this.ifc =
-            version === 300
-                ? types_1.ICreditFacadeV3Multicall__factory.createInterface()
-                : types_1.ICreditFacadeV2Extended__factory.createInterface();
+        this.abi =
+            version >= 300 ? types_1.iCreditFacadeV3MulticallAbi : types_1.iCreditFacadeV2ExtendedAbi;
         this.adapterName = "CreditFacade";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "addCollateral": {
-                const r = this.decodeFunctionData(functionFragment, calldata);
+                const r = functionData.args || [];
                 const token = r[0];
                 const amount = r[1];
-                return `${functionName}(token: ${this.tokenSymbol(token)}, amount: ${this.formatAmount(amount)})`;
+                return `${functionName}(token: ${this.tokenSymbol(token)}, amount: ${this.formatBN(amount, this.tokenSymbol(token))})`;
             }
             case "increaseDebt":
             case "decreaseDebt": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount] = functionData.args || [];
                 return `${functionName}(amount: ${this.formatAmount(amount)})`;
             }
             case "enableToken":
             case "disableToken": {
-                const [address] = this.decodeFunctionData(functionFragment, calldata);
+                const [address] = functionData.args || [];
                 return `${functionName}(token: ${this.tokenSymbol(address)})`;
             }
             case "updateQuota": {
-                const [address, quotaUpdate, minQuota] = this.decodeFunctionData(functionFragment, calldata);
+                const [address, quotaUpdate, minQuota] = functionData.args || [];
                 return `${functionName}(token: ${this.tokenSymbol(address)}, quotaUpdate: ${this.formatAmount(quotaUpdate)}, minQuota: ${this.formatAmount(minQuota)})`;
             }
             case "revertIfReceivedLessThan": {
-                const [balances] = this.decodeFunctionData(functionFragment, calldata);
+                const [balances] = functionData.args || [];
                 const balancesStr = balances
                     .map(b => {
+                    const balance = "balance" in b ? b.balance : b.amount;
                     const symbol = this.tokenSymbol(b.token);
-                    return `${symbol}: ${this.formatBN(b.balance, symbol)}`;
+                    return `${symbol}: ${this.formatBN(balance, symbol)}`;
                 })
                     .join(", ");
                 return `${functionName}(${balancesStr})`;
             }
+            case "withdrawCollateral": {
+                const [token, amount, to] = functionData.args || [];
+                return `${functionName}(token: ${this.tokenSymbol(token)}, withdraw: ${this.formatBN(amount, this.tokenSymbol(token))}, to: ${to})`;
+            }
+            case "addCollateralWithPermit": {
+                const [tokenAddress, amount, deadline, v, r, s] = functionData.args || [];
+                return `${functionName}(token: ${this.tokenSymbol(tokenAddress)}, amount: ${this.formatBN(amount, this.tokenSymbol(tokenAddress))}, ${[deadline, v, r, s].join(", ")})`;
+            }
+            case "compareBalances": {
+                return `${functionName}()`;
+            }
+            case "setFullCheckParams": {
+                const [collateralHints, minHealthFactor] = functionData.args || [];
+                return `${functionName}(token: ${collateralHints
+                    .map((a) => this.formatAmount(a))
+                    .join(", ")}, minHealthFactor: ${minHealthFactor})`;
+            }
+            case "storeExpectedBalances": {
+                const [balanceDeltas] = functionData.args || [];
+                return `${functionName}(balanceDeltas: ${balanceDeltas
+                    .map((b) => `${this.tokenSymbol(b.token)}: ${this.formatBN(b.amount, this.tokenSymbol(b.token))}`)
+                    .join(", ")})`;
+            }
+            case "onDemandPriceUpdate": {
+                const [token, reserve, data] = functionData.args || [];
+                return `${functionName}(token: ${this.tokenOrTickerSymbol(token)}, reserve: ${reserve}, data: ${data})`;
+            }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
     formatAmount(amount) {

package/lib/parsers/creditManagerParser.d.ts

@@ -1,6 +1,7 @@
+import { Address } from "viem";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class CreditManagerParser extends AbstractParser implements IParser {
     constructor(version: number);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
 }

package/lib/parsers/creditManagerParser.js

@@ -6,19 +6,16 @@ const abstractParser_1 = require("./abstractParser");
 class CreditManagerParser extends abstractParser_1.AbstractParser {
     constructor(version) {
         super(`CreditManager_V${version}`);
-        this.ifc =
-            version === 2
-                ? types_1.ICreditManagerV2__factory.createInterface()
-                : types_1.ICreditManagerV3__factory.createInterface();
+        this.abi = version === 2 ? types_1.iCreditManagerV2Abi : types_1.iCreditManagerV3Abi;
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "creditConfigurator": {
                 return `${functionName}()`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/curveAdapterParser.d.ts

@@ -1,11 +1,12 @@
 import { SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { BigNumberish } from "ethers";
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class CurveAdapterParser extends AbstractParser implements IParser {
     protected lpToken: SupportedToken;
     constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
     getTokenByIndex(index: number): SupportedToken;
     getUnderlyingTokenByIndex(index: number): SupportedToken;
     convertAmounts(amounts: Array<BigNumberish>): string;

package/lib/parsers/curveAdapterParser.js

@@ -12,15 +12,15 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
         const nCoins = sdk_gov_1.contractParams[contract].tokens.length;
         switch (nCoins) {
             case 2:
-                this.ifc = types_1.ICurveV1_2AssetsAdapter__factory.createInterface();
+                this.abi = types_1.iCurveV1_2AssetsAdapterAbi;
                 contractName = `Curve2AssetsAdapter`;
                 break;
             case 3:
-                this.ifc = types_1.ICurveV1_3AssetsAdapter__factory.createInterface();
+                this.abi = types_1.iCurveV1_3AssetsAdapterAbi;
                 contractName = `Curve3AssetsAdapter`;
                 break;
             case 4:
-                this.ifc = types_1.ICurveV1_4AssetsAdapter__factory.createInterface();
+                this.abi = types_1.iCurveV1_4AssetsAdapterAbi;
                 contractName = `Curve4AssetsAdapter`;
                 break;
             default:
@@ -31,54 +31,54 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
             this.adapterName = contractName;
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "exchange":
             case "exchange_underlying": {
-                const [i, j, dx, min_dy] = this.decodeFunctionData(functionFragment, calldata);
-                const iSym = functionFragment.name === "exchange_underlying"
+                const [i, j, dx, min_dy] = functionData.args || [];
+                const iSym = functionData.functionName === "exchange_underlying"
                     ? this.getUnderlyingTokenByIndex(i)
                     : this.getTokenByIndex(i);
-                const jSym = functionFragment.name === "exchange_underlying"
+                const jSym = functionData.functionName === "exchange_underlying"
                     ? this.getUnderlyingTokenByIndex(j)
                     : this.getTokenByIndex(j);
                 return `${functionName}(i ,j: ${iSym} => ${jSym}, dx: ${this.formatBN(dx, iSym)}, min_dy: ${this.formatBN(min_dy, jSym)})`;
             }
-            case "exchange_all":
-            case "exchange_all_underlying": {
-                const [i, j, rateMinRAY] = this.decodeFunctionData(functionFragment, calldata);
-                const iSym = functionFragment.name === "exchange_all_underlying"
+            case "exchange_diff":
+            case "exchange_diff_underlying": {
+                const [i, j, leftoverAmount, rateMinRAY] = functionData.args || [];
+                const iSym = functionData.functionName === "exchange_diff_underlying"
                     ? this.getUnderlyingTokenByIndex(i)
                     : this.getTokenByIndex(i);
-                const jSym = functionFragment.name === "exchange_all_underlying"
+                const jSym = functionData.functionName === "exchange_diff_underlying"
                     ? this.getUnderlyingTokenByIndex(j)
                     : this.getTokenByIndex(j);
-                return `${functionName}(i: ${iSym}, j: ${jSym}, rateMinRAY: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}`;
+                return `${functionName}(i: ${iSym}, j: ${jSym}, leftoverAmount: ${this.formatBN(leftoverAmount, iSym)}, rateMinRAY: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}`;
             }
             case "add_liquidity_one_coin": {
-                const [amount, i, minAmount] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount, i, minAmount] = functionData.args || [];
                 const iSym = this.getTokenByIndex(i);
                 return `${functionName}(amount: ${this.formatBN(amount, iSym)}, i: ${iSym}, minAmount: ${this.formatBN(minAmount, this.lpToken)})`;
             }
-            case "add_all_liquidity_one_coin":
-            case "remove_all_liquidity_one_coin": {
-                const [i, rateMinRAY] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(i: ${this.getTokenByIndex(i)}, rateMinRAY: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)})`;
+            case "add_diff_liquidity_one_coin":
+            case "remove_diff_liquidity_one_coin": {
+                const [leftoverAmount, i, rateMinRAY] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, i)}, i: ${this.getTokenByIndex(i)}, rateMinRAY: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)})`;
             }
             case "add_liquidity": {
-                const [amounts, minAmount] = this.decodeFunctionData(functionFragment, calldata);
+                const [amounts, minAmount] = functionData.args || [];
                 return `${functionName}(amounts: [${this.convertAmounts(amounts)}], minAmount: ${this.formatBN(minAmount, this.lpToken)})`;
             }
             case "remove_liquidity": {
-                const [amount, min_amounts] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount, min_amounts] = functionData.args || [];
                 return `${functionName}(amount: ${this.formatBN(amount, this.lpToken)}, min_amounts: [${this.convertAmounts(min_amounts)}])`;
             }
             case "remove_liquidity_imbalance": {
-                const [amounts, maxBurnAmount] = this.decodeFunctionData(functionFragment, calldata);
+                const [amounts, maxBurnAmount] = functionData.args || [];
                 return `${functionName}(amounts: [${this.convertAmounts(amounts)}], max_burn_amount: ${this.formatBN(maxBurnAmount, this.lpToken)})`;
             }
             case "remove_liquidity_one_coin": {
-                const [amount, i, min_amount] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount, i, min_amount] = functionData.args || [];
                 const iSym = this.getTokenByIndex(i);
                 return `${functionName}(amount: ${this.formatBN(amount, this.lpToken)},i: ${iSym}, min_amount: ${this.formatBN(min_amount, iSym)})`;
             }
@@ -86,22 +86,22 @@ class CurveAdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}()`;
             }
             case "balances": {
-                const [i] = this.decodeFunctionData(functionFragment, calldata);
+                const [i] = functionData.args || [];
                 return `${functionName}(${this.getTokenByIndex(i)})`;
             }
             case "balanceOf": {
-                const [address] = this.decodeFunctionData(functionFragment, calldata);
+                const [address] = functionData.args || [];
                 return `${functionName}(${address})`;
             }
             case "get_virtual_price": {
                 return `${functionName}()`;
             }
             case "allowance": {
-                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
+                const [account, to] = functionData.args || [];
                 return `${functionName}(account: ${account}, to: ${to})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
     getTokenByIndex(index) {

package/lib/parsers/erc626AdapterParser.d.ts

@@ -0,0 +1,8 @@
+import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
+import { AbstractParser } from "./abstractParser";
+import { IParser } from "./iParser";
+export declare class ERC4626AdapterParser extends AbstractParser implements IParser {
+    constructor(contract: SupportedContract, isContract: boolean);
+    parse(calldata: Address): string;
+}

package/lib/parsers/erc626AdapterParser.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC4626AdapterParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class ERC4626AdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.ierc4626AdapterAbi;
+        if (!isContract)
+            this.adapterName = "ERC4626Adapter";
+    }
+    parse(calldata) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
+        }
+    }
+}
+exports.ERC4626AdapterParser = ERC4626AdapterParser;

package/lib/parsers/iParser.d.ts

@@ -1,9 +1,6 @@
-import { FunctionFragment } from "ethers/lib/utils";
+import { Address } from "viem";
+import { ParsedObject } from "./abstractParser";
 export interface IParser {
-    parse: (calldata: string) => string;
-    parseToObject?: (address: string, calldata: string) => {
-        address: string;
-        functionFragment: FunctionFragment;
-        args: any;
-    };
+    parse: (calldata: Address) => string;
+    parseToObject?: (address: Address, calldata: Address) => ParsedObject;
 }

package/lib/parsers/lidoAdapterParser.d.ts

@@ -1,7 +1,8 @@
 import { SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class LidoAdapterParser extends AbstractParser implements IParser {
     constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
 }

package/lib/parsers/lidoAdapterParser.js

@@ -6,22 +6,23 @@ const abstractParser_1 = require("./abstractParser");
 class LidoAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.ILidoV1Adapter__factory.createInterface();
+        this.abi = types_1.iLidoV1AdapterAbi;
         if (!isContract)
             this.adapterName = "LidoV1Adapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "submit": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount] = functionData.args || [];
                 return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
             }
-            case "submitAll": {
-                return `${functionName}()`;
+            case "submitDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${functionName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/lidoSTETHParser.d.ts

@@ -1,7 +1,8 @@
 import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class LidoSTETHParser extends AbstractParser implements IParser {
     constructor(symbol: SupportedToken);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
 }

package/lib/parsers/lidoSTETHParser.js

@@ -7,29 +7,29 @@ const abstractParser_1 = require("./abstractParser");
 class LidoSTETHParser extends abstractParser_1.AbstractParser {
     constructor(symbol) {
         super(`LIDO_${symbol}`);
-        this.ifc = types_1.IstETH__factory.createInterface();
+        this.abi = types_1.istEthAbi;
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "getFee":
             case "totalSupply": {
                 return `${functionName}()`;
             }
             case "balanceOf": {
-                const [address] = this.decodeFunctionData(functionFragment, calldata);
+                const [address] = functionData.args || [];
                 return `${functionName}(${address})`;
             }
             case "allowance": {
-                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
+                const [account, to] = functionData.args || [];
                 return `${functionName}(account: ${account}, to: ${to})`;
             }
             case "approve": {
-                const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
+                const [spender, amount] = functionData.args || [];
                 return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/priceOracleParser.d.ts

@@ -1,6 +1,7 @@
+import { Address } from "viem";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class PriceOracleParser extends AbstractParser implements IParser {
     constructor();
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
 }

package/lib/parsers/priceOracleParser.js

@@ -6,17 +6,17 @@ const abstractParser_1 = require("./abstractParser");
 class PriceOracleParser extends abstractParser_1.AbstractParser {
     constructor() {
         super("PriceOracle");
-        this.ifc = types_1.IPriceOracleBase__factory.createInterface();
+        this.abi = types_1.iPriceOracleBaseAbi;
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "getPrice": {
-                const [token] = this.decodeFunctionData(functionFragment, calldata);
+                const [token] = functionData.args || [];
                 return `${functionName}(${this.tokenSymbol(token)})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/txParser.d.ts

@@ -1,40 +1,37 @@
 import { NetworkType, SupportedContract, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { MultiCall } from "../pathfinder/core";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export interface AdapterForParser {
-    adapter: string;
-    contract: string;
+    adapter: Address;
+    contract: Address;
 }
 interface ParseData {
     contract: string;
     adapterName: string;
 }
 export declare class TxParser {
-    protected static parsers: Record<string, IParser & AbstractParser>;
-    static parse(address: string, calldata: string): string;
-    static parseToObject(address: string, calldata: string): {
-        address: string;
-        functionFragment: import("ethers/lib/utils").FunctionFragment;
-        args: any;
-    };
-    static getParseData(address: string): ParseData;
-    static parseMultiCall(calls: Array<MultiCall>): Array<string>;
-    static parseToObjectMultiCall(calls: Array<MultiCall>): {
-        address: string;
-        functionFragment: import("ethers/lib/utils").FunctionFragment;
-        args: any;
-    }[];
+    protected static parsers: Record<Address, IParser & AbstractParser>;
+    static parse(address: Address, calldata: Address): string | null;
+    static parseToObject(address: Address, calldata: Address): {
+        callObject: import("./abstractParser").ParsedObject;
+        parser: IParser & AbstractParser;
+    } | null;
+    static getParseData(address: Address): ParseData;
+    static parseMultiCall(calls: Array<MultiCall>): (string | null)[];
+    static parseToObjectMultiCall(calls: Array<MultiCall>): ({
+        callObject: import("./abstractParser").ParsedObject;
+        parser: IParser & AbstractParser;
+    } | null)[];
     static addAdapters(adapters: Array<AdapterForParser>): void;
     static addContracts(network: NetworkType): void;
-    static addCreditFacade(creditFacade: string, underlying: SupportedToken, version: number): void;
+    static addCreditFacade(creditFacade: Address, underlying: SupportedToken, version: number): void;
     static addTokens(network: NetworkType): void;
-    static addPriceOracle(address: string): void;
-    static addAddressProvider(address: string): void;
-    static addCreditManager(address: string, version: number): void;
-    static addPool(address: string, version: number): void;
-    static getParser(address: string): IParser & AbstractParser;
-    protected static chooseContractParser(address: string, contract: SupportedContract, adapterType: number, isContract: boolean): void;
-    protected static _addParser(address: string, parser: IParser & AbstractParser): void;
+    static addPriceOracle(address: Address): void;
+    static addCreditManager(address: Address, version: number): void;
+    static getParser(address: Address): IParser & AbstractParser;
+    protected static chooseContractParser(address: Address, contract: SupportedContract, adapterType: number, isContract: boolean): void;
+    protected static _addParser(address: Address, parser: IParser & AbstractParser): void;
 }
 export {};