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

package/lib/parsers/yearnAdapterParser.spec.js

@@ -2,35 +2,53 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
+const viem_1 = require("viem");
 const types_1 = require("../types");
 const yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
 describe("YearnV2AdapterParser test", () => {
     it("deposit / withdraw functions works well", () => {
-        let parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
-        const ifc = types_1.IYearnV2Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("depositDiff", [sdk_gov_1.WAD * 19000n]));
+        const parser = new yearnV2AdapterParser_1.YearnV2AdapterParser("YEARN_CURVE_STETH_VAULT", false);
+        let parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "depositDiff",
+            args: [sdk_gov_1.WAD * 19000n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].depositDiff(leftoverAmount: 19.00K [19000000000000000000000])", "Incorrect parse depositDiff");
-        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256)", [sdk_gov_1.WAD * 19000n]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "deposit",
+            args: [sdk_gov_1.WAD * 19000n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000])", "Incorrect parse deposit(amount)");
-        parsed = parser.parse(ifc.encodeFunctionData("deposit(uint256,address)", [
-            sdk_gov_1.WAD * 19000n,
-            sdk_gov_1.DUMB_ADDRESS,
-        ]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "deposit",
+            args: [sdk_gov_1.WAD * 19000n, sdk_gov_1.DUMB_ADDRESS],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].deposit(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS})`, "Incorrect parse deposit(amount,address)");
-        parsed = parser.parse(ifc.encodeFunctionData("withdrawDiff", [sdk_gov_1.WAD * 19000n]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "withdrawDiff",
+            args: [sdk_gov_1.WAD * 19000n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdrawDiff(leftoverAmount: 19.00K [19000000000000000000000])", "Incorrect parse withdrawDiff");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256)", [sdk_gov_1.WAD * 19000n]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "withdraw",
+            args: [sdk_gov_1.WAD * 19000n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000])", "Incorrect parse withdraw(amount)");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address)", [
-            sdk_gov_1.WAD * 19000n,
-            sdk_gov_1.DUMB_ADDRESS,
-        ]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "withdraw",
+            args: [sdk_gov_1.WAD * 19000n, sdk_gov_1.DUMB_ADDRESS],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS})`, "Incorrect parse withdraw(amount,address)");
-        parsed = parser.parse(ifc.encodeFunctionData("withdraw(uint256,address,uint256)", [
-            sdk_gov_1.WAD * 19000n,
-            sdk_gov_1.DUMB_ADDRESS,
-            555,
-        ]));
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iYearnV2AdapterAbi,
+            functionName: "withdraw",
+            args: [sdk_gov_1.WAD * 19000n, sdk_gov_1.DUMB_ADDRESS, 555n],
+        }));
         (0, chai_1.expect)(parsed).to.be.eq(`YearnV2Adapter[YEARN_CURVE_STETH_VAULT].withdraw(amount: 19.00K [19000000000000000000000], address: ${sdk_gov_1.DUMB_ADDRESS}, maxLoss: 555)`, "Incorrect parse withdraw(amount,address,uint256)");
     });
 });

package/lib/parsers/yearnV2AdapterParser.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 YearnV2AdapterParser extends AbstractParser implements IParser {
     constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
 }

package/lib/parsers/yearnV2AdapterParser.js

@@ -7,17 +7,17 @@ const abstractParser_1 = require("./abstractParser");
 class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IYearnV2Adapter__factory.createInterface();
+        this.abi = types_1.iYearnV2AdapterAbi;
         if (!isContract)
             this.adapterName = "YearnV2Adapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "deposit":
             case "withdraw":
             case "withdraw(uint256,address,uint256)": {
-                const [amount, address, maxLoss] = this.decodeFunctionData(functionFragment, calldata);
+                const [amount, address, maxLoss] = functionData.args || [];
                 const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
                 const amountStr = amount
                     ? `amount: ${this.formatBN(amount, yvSym)}`
@@ -27,13 +27,13 @@ class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
                 return `${functionName}(${amountStr}${addressStr}${maxLossStr})`;
             }
             case "depositDiff": {
-                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                const [leftoverAmount] = functionData.args || [];
                 const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
                 const leftoverAmountStr = this.formatBN(leftoverAmount, yvSym);
                 return `${functionName}(leftoverAmount: ${leftoverAmountStr})`;
             }
             case "withdrawDiff": {
-                const [leftoverAmount] = this.decodeFunctionData(functionFragment, calldata);
+                const [leftoverAmount] = functionData.args || [];
                 const yvSym = this.tokenSymbol(sdk_gov_1.contractsByNetwork.Mainnet[this.contract]);
                 const leftoverAmountStr = this.formatBN(leftoverAmount, yvSym);
                 return `${functionName}(leftoverAmount: ${leftoverAmountStr})`;
@@ -42,15 +42,15 @@ class YearnV2AdapterParser extends abstractParser_1.AbstractParser {
                 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})`;
             }
             default:
-                return this.reportUnknownFragment(functionName, functionFragment, calldata);
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/pathfinder/core.d.ts

@@ -1,18 +1,30 @@
-import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
-import { MultiCallStructOutput, RouterResultStructOutput, SwapTaskStruct } from "../types/IRouterV3";
+import { Address } from "viem";
 export declare enum SwapOperation {
     EXACT_INPUT = 0,
     EXACT_INPUT_ALL = 1,
     EXACT_OUTPUT = 2
 }
-export type MultiCall = ExcludeArrayProps<MultiCallStructOutput>;
-export type SwapTask = ExcludeArrayProps<SwapTaskStruct>;
-export type PathFinderResult = Omit<ExcludeArrayProps<RouterResultStructOutput>, "calls"> & {
-    calls: Array<MultiCall>;
-};
+export interface MultiCall {
+    target: Address;
+    callData: Address;
+}
+export interface SwapTask {
+    swapOperation: number;
+    creditAccount: Address;
+    tokenIn: Address;
+    tokenOut: Address;
+    connectors: Address[];
+    amount: bigint;
+    leftoverAmount: bigint;
+}
+export interface PathFinderResult {
+    amount: bigint;
+    minAmount: bigint;
+    calls: MultiCall[];
+}
 export interface PathFinderOpenStrategyResult extends PathFinderResult {
-    balances: Record<string, bigint>;
-    minBalances: Record<string, bigint>;
+    balances: Record<Address, bigint>;
+    minBalances: Record<Address, bigint>;
 }
 export interface PathFinderCloseResult extends PathFinderResult {
     underlyingBalance: bigint;

package/lib/pathfinder/pathOptions.d.ts

@@ -1,15 +1,16 @@
 import { BalancerLPToken, CurveLPToken, NetworkType } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { CaTokenBalance } from "../payload/creditAccount";
 export interface PathOption {
-    target: string;
+    target: Address;
     option: number;
     totalOptions: number;
 }
 export type PathOptionSerie = Array<PathOption>;
 export type BalanceInterface = Pick<CaTokenBalance, "balance">;
 export declare class PathOptionFactory {
-    static generatePathOptions(balances: Record<string, BalanceInterface>, loopsInTx: number, network: NetworkType): Array<PathOptionSerie>;
-    static getCurvePools(balances: Record<string, BalanceInterface>): Array<CurveLPToken>;
-    static getBalancerPools(balances: Record<string, BalanceInterface>): Array<BalancerLPToken>;
+    static generatePathOptions(balances: Record<Address, BalanceInterface>, loopsInTx: number, network: NetworkType): Array<PathOptionSerie>;
+    static getCurvePools(balances: Record<Address, BalanceInterface>): Array<CurveLPToken>;
+    static getBalancerPools(balances: Record<Address, BalanceInterface>): Array<BalancerLPToken>;
     static next(path: PathOptionSerie): PathOptionSerie;
 }

package/lib/pathfinder/pathfinder.d.ts

@@ -1,47 +1,46 @@
 import { NetworkType } from "@gearbox-protocol/sdk-gov";
-import { Provider, Signer } from "ethers";
+import { Address, GetContractReturnType, PublicClient } from "viem";
 import { Asset } from "../core/assets";
 import { CreditAccountData } from "../core/creditAccount";
 import { CreditManagerData } from "../core/creditManager";
-import { IRouterV3 } from "../types";
+import { iRouterV3Abi } from "../types";
 import { PathFinderCloseResult, PathFinderOpenStrategyResult, PathFinderResult, SwapOperation } from "./core";
 interface FindAllSwapsProps {
     creditAccount: CreditAccountData;
     swapOperation: SwapOperation;
-    tokenIn: string;
-    tokenOut: string;
+    tokenIn: Address;
+    tokenOut: Address;
     amount: bigint;
     leftoverAmount: bigint;
     slippage: number;
 }
 interface FindOneTokenPathProps {
     creditAccount: CreditAccountData;
-    tokenIn: string;
-    tokenOut: string;
+    tokenIn: Address;
+    tokenOut: Address;
     amount: bigint;
     slippage: number;
 }
 interface FindBestClosePathProps {
     creditAccount: CreditAccountData;
     creditManager: CreditManagerData;
-    expectedBalances: Record<string, Asset>;
-    leftoverBalances: Record<string, Asset>;
+    expectedBalances: Record<Address, Asset>;
+    leftoverBalances: Record<Address, Asset>;
     slippage: number;
-    noConcurrency?: boolean;
     network: NetworkType;
 }
 interface FindOpenStrategyPathProps {
     creditManager: CreditManagerData;
-    expectedBalances: Record<string, Asset>;
-    leftoverBalances: Record<string, Asset>;
-    target: string;
+    expectedBalances: Record<Address, Asset>;
+    leftoverBalances: Record<Address, Asset>;
+    target: Address;
     slippage: number;
 }
 export declare class PathFinder {
-    pathFinder: IRouterV3;
+    pathFinder: GetContractReturnType<typeof iRouterV3Abi, PublicClient>;
     network: NetworkType;
-    protected readonly _connectors: Array<string>;
-    constructor(address: string, provider: Signer | Provider, network?: NetworkType);
+    protected readonly _connectors: Array<Address>;
+    constructor(address: Address, provider: PublicClient, network?: NetworkType);
     findAllSwaps({ creditAccount, swapOperation, tokenIn, tokenOut, amount, leftoverAmount, slippage, }: FindAllSwapsProps): Promise<Array<PathFinderResult>>;
     findOneTokenPath({ creditAccount, tokenIn, tokenOut, amount, slippage, }: FindOneTokenPathProps): Promise<PathFinderResult>;
     /**
@@ -55,7 +54,7 @@ export declare class PathFinder {
      * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
      * @returns PathFinderOpenStrategyResult which
      */
-    findOpenStrategyPath({ creditManager: cm, expectedBalances, leftoverBalances, target, slippage, }: FindOpenStrategyPathProps): Promise<PathFinderOpenStrategyResult>;
+    findOpenStrategyPath({ creditManager: cm, expectedBalances, leftoverBalances, target: targetUntyped, slippage, }: FindOpenStrategyPathProps): Promise<PathFinderOpenStrategyResult>;
     /**
      * @dev Finds the path to swap / withdraw all assets from CreditAccount into underlying asset
      *   Can bu used for closing Credit Account and for liquidations as well.
@@ -65,9 +64,9 @@ export declare class PathFinder {
      *          - underlyingBalance - total balance of underlying token
      *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
      */
-    findBestClosePath({ creditAccount, creditManager: cm, expectedBalances, leftoverBalances, slippage, noConcurrency, network, }: FindBestClosePathProps): Promise<PathFinderCloseResult>;
+    findBestClosePath({ creditAccount, creditManager: cm, expectedBalances, leftoverBalances, slippage, network, }: FindBestClosePathProps): Promise<PathFinderCloseResult>;
     static compare(r1: PathFinderResult, r2: PathFinderResult): PathFinderResult;
-    getAvailableConnectors(availableList: Record<string, bigint> | Record<string, true>): string[];
-    static getAvailableConnectors(availableList: Record<string, bigint> | Record<string, true>, connectors: string[]): string[];
+    getAvailableConnectors(availableList: Record<Address, bigint> | Record<Address, true>): `0x${string}`[];
+    static getAvailableConnectors(availableList: Record<Address, bigint> | Record<Address, true>, connectors: Address[]): `0x${string}`[];
 }
 export {};

package/lib/pathfinder/pathfinder.js

@@ -2,16 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathFinder = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const viem_1 = require("viem");
 const types_1 = require("../types");
 const pathOptions_1 = require("./pathOptions");
-const MAX_GAS_PER_ROUTE = 200e6;
-const GAS_PER_BLOCK = 400e6;
+const MAX_GAS_PER_ROUTE = 200000000n;
+const GAS_PER_BLOCK = 400000000n;
 class PathFinder {
     pathFinder;
     network;
     _connectors;
     constructor(address, provider, network = "Mainnet") {
-        this.pathFinder = types_1.IRouterV3__factory.connect(address, provider);
+        this.pathFinder = (0, viem_1.getContract)({
+            address,
+            abi: types_1.iRouterV3Abi,
+            client: provider,
+        });
         this.network = network;
         this._connectors = (0, sdk_gov_1.getConnectors)(network);
     }
@@ -26,8 +31,8 @@ class PathFinder {
             amount,
             leftoverAmount,
         };
-        const results = await this.pathFinder.findAllSwaps.staticCall(swapTask, slippage, {
-            gasLimit: GAS_PER_BLOCK,
+        const { result: results } = await this.pathFinder.simulate.findAllSwaps([swapTask, BigInt(slippage)], {
+            gas: GAS_PER_BLOCK,
         });
         const unique = {};
         results.forEach(r => {
@@ -44,8 +49,15 @@ class PathFinder {
     }
     async findOneTokenPath({ creditAccount, tokenIn, tokenOut, amount, slippage, }) {
         const connectors = this.getAvailableConnectors(creditAccount.balances);
-        const result = await this.pathFinder.findOneTokenPath.staticCall(tokenIn, amount, tokenOut, creditAccount.addr, connectors, slippage, {
-            gasLimit: GAS_PER_BLOCK,
+        const { result } = await this.pathFinder.simulate.findOneTokenPath([
+            tokenIn,
+            amount,
+            tokenOut,
+            creditAccount.addr,
+            connectors,
+            BigInt(slippage),
+        ], {
+            gas: GAS_PER_BLOCK,
         });
         return {
             amount: result.amount,
@@ -64,7 +76,8 @@ class PathFinder {
      * @param slippage Slippage in PERCENTAGE_FORMAT (100% = 10_000) per operation
      * @returns PathFinderOpenStrategyResult which
      */
-    async findOpenStrategyPath({ creditManager: cm, expectedBalances, leftoverBalances, target, slippage, }) {
+    async findOpenStrategyPath({ creditManager: cm, expectedBalances, leftoverBalances, target: targetUntyped, slippage, }) {
+        const target = targetUntyped;
         const input = cm.collateralTokens.map(token => ({
             token,
             balance: expectedBalances[token]?.balance || 0n,
@@ -74,8 +87,8 @@ class PathFinder {
             balance: leftoverBalances[token]?.balance || 1n,
         }));
         const connectors = this.getAvailableConnectors(cm.supportedTokens);
-        const [outBalances, result] = await this.pathFinder.findOpenStrategyPath.staticCall(cm.address, input, leftover, target, connectors, slippage, {
-            gasLimit: GAS_PER_BLOCK,
+        const { result: [outBalances, result], } = await this.pathFinder.simulate.findOpenStrategyPath([cm.address, input, leftover, target, connectors, BigInt(slippage)], {
+            gas: GAS_PER_BLOCK,
         });
         const balancesAfter = outBalances.reduce((acc, b) => {
             acc[b.token.toLowerCase()] = b.balance;
@@ -104,9 +117,9 @@ class PathFinder {
      *          - underlyingBalance - total balance of underlying token
      *          - calls - list of calls which should be done to swap & unwrap everything to underlying token
      */
-    async findBestClosePath({ creditAccount, creditManager: cm, expectedBalances, leftoverBalances, slippage, noConcurrency = false, network, }) {
-        const loopsPerTx = Math.floor(GAS_PER_BLOCK / MAX_GAS_PER_ROUTE);
-        const pathOptions = pathOptions_1.PathOptionFactory.generatePathOptions(creditAccount.allBalances, loopsPerTx, network);
+    async findBestClosePath({ creditAccount, creditManager: cm, expectedBalances, leftoverBalances, slippage, network, }) {
+        const loopsPerTx = GAS_PER_BLOCK / MAX_GAS_PER_ROUTE;
+        const pathOptions = pathOptions_1.PathOptionFactory.generatePathOptions(creditAccount.allBalances, Number(loopsPerTx), network);
         const expected = cm.collateralTokens.map(token => {
             // When we pass expected balances explicitly, we need to mimic router behaviour by filtering out leftover tokens
             // for example, we can have stETH balance of 2, because 1 transforms to 2 because of rebasing
@@ -122,24 +135,22 @@ class PathFinder {
             balance: leftoverBalances[token]?.balance || 1n,
         }));
         const connectors = this.getAvailableConnectors(creditAccount.balances);
-        let results = [];
-        if (noConcurrency) {
-            for (const po of pathOptions) {
-                results.push(await this.pathFinder.findBestClosePath.staticCall(creditAccount.addr, expected, leftover, connectors, slippage, po, loopsPerTx, false, {
-                    gasLimit: GAS_PER_BLOCK,
-                }));
-            }
-        }
-        else {
-            const requests = pathOptions.map(po => this.pathFinder.findBestClosePath.staticCall(creditAccount.addr, expected, leftover, connectors, slippage, po, loopsPerTx, false, {
-                gasLimit: GAS_PER_BLOCK,
-            }));
-            results = await Promise.all(requests);
-        }
+        const results = await Promise.all(pathOptions.map(po => this.pathFinder.simulate.findBestClosePath([
+            creditAccount.addr,
+            expected,
+            leftover,
+            connectors,
+            BigInt(slippage),
+            po,
+            loopsPerTx,
+            false,
+        ], {
+            gas: GAS_PER_BLOCK,
+        })));
         const bestResult = results.reduce((best, pathFinderResult) => PathFinder.compare(best, {
-            calls: pathFinderResult.calls,
-            amount: pathFinderResult.amount,
-            minAmount: pathFinderResult.minAmount,
+            calls: pathFinderResult.result.calls,
+            amount: pathFinderResult.result.amount,
+            minAmount: pathFinderResult.result.minAmount,
         }), {
             amount: 0n,
             minAmount: 0n,
@@ -148,8 +159,7 @@ class PathFinder {
         return {
             ...bestResult,
             underlyingBalance: bestResult.minAmount +
-                creditAccount.allBalances[creditAccount.underlyingToken.toLowerCase()]
-                    .balance,
+                creditAccount.allBalances[creditAccount.underlyingToken.toLowerCase()].balance,
         };
     }
     static compare(r1, r2) {

package/lib/pathfinder/pathfinder.spec.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const chai_1 = require("chai");
-const ethers_1 = require("ethers");
+const viem_1 = require("viem");
 const pathfinder_1 = require("./pathfinder");
 describe("PathFinder test", () => {
     it("compare works correctly", () => {
@@ -20,7 +20,7 @@ describe("PathFinder test", () => {
         (0, chai_1.expect)(result).to.be.eql(r2);
     });
     it("has all expected connectors", () => {
-        const pf = new pathfinder_1.PathFinder("", new ethers_1.JsonRpcProvider(), "Mainnet");
+        const pf = new pathfinder_1.PathFinder("", (0, viem_1.createPublicClient)({ transport: (0, viem_1.http)("https://mainnet.infura.io/v3/") }), "Mainnet");
         const allowedTokens = {
             [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: true,
             [sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: true,
@@ -37,7 +37,7 @@ describe("PathFinder test", () => {
         ]);
     });
     it("has all expected connectors, when gew are disabled", () => {
-        const pf = new pathfinder_1.PathFinder("", new ethers_1.JsonRpcProvider(), "Mainnet");
+        const pf = new pathfinder_1.PathFinder("", (0, viem_1.createPublicClient)({ transport: (0, viem_1.http)("https://mainnet.infura.io/v3/") }), "Mainnet");
         const allowedTokens = {
             [sdk_gov_1.tokenDataByNetwork.Mainnet.WETH.toLowerCase()]: true,
             [sdk_gov_1.tokenDataByNetwork.Mainnet.DAI.toLowerCase()]: true,

package/lib/pathfinder/utils.d.ts

@@ -1,26 +1,25 @@
-import { Interface, Provider } from "ethers";
+import { Address, PublicClient } from "viem";
 import { MultiCall } from "./core";
 export interface FeeInfo {
     type: KnownFeeTypes;
     value: bigint;
 }
 type KnownFeeTypes = "curve" | "lido" | "uniswap_v2" | "uniswap_v3" | "balancer";
-export declare const BALANCER_VAULT_ABI: {
-    inputs: never[];
-    name: string;
-    outputs: {
-        internalType: string;
-        name: string;
-        type: string;
-    }[];
-    stateMutability: string;
-    type: string;
-}[];
-export declare const BALANCER_VAULT_INTERFACE: Interface;
-interface FindPathFeesProps {
+export declare const BALANCER_VAULT_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "getSwapFeePercentage";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export interface FindPathFeesProps {
     calls: Array<MultiCall>;
-    provider: Provider;
-    contractsByAdapter: Record<string, string>;
+    provider: PublicClient;
+    contractsByAdapter: Record<Address, Address>;
 }
 export declare class PathFinderUtils {
     static findPathFees({ calls, provider, contractsByAdapter, }: FindPathFeesProps): Promise<FeeInfo[]>;

package/lib/pathfinder/utils.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathFinderUtils = exports.BALANCER_VAULT_INTERFACE = exports.BALANCER_VAULT_ABI = void 0;
+exports.PathFinderUtils = exports.BALANCER_VAULT_ABI = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const ethers_1 = require("ethers");
 const balancerV2VaultParser_1 = require("../parsers/balancerV2VaultParser");
 const curveAdapterParser_1 = require("../parsers/curveAdapterParser");
 const lidoAdapterParser_1 = require("../parsers/lidoAdapterParser");
@@ -28,7 +27,6 @@ exports.BALANCER_VAULT_ABI = [
         type: "function",
     },
 ];
-exports.BALANCER_VAULT_INTERFACE = new ethers_1.Interface(exports.BALANCER_VAULT_ABI);
 class PathFinderUtils {
     static async findPathFees({ calls, provider, contractsByAdapter, }) {
         const pathObjects = txParser_1.TxParser.parseToObjectMultiCall(calls);
@@ -74,7 +72,11 @@ class PathFinderUtils {
             curve: [],
             balancer: [],
         });
-        const response = await (0, sdk_gov_1.safeMulticall)([...curve, ...balancer], provider);
+        const response = (await provider.multicall({
+            allowFailure: true,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [...curve, ...balancer],
+        }));
         const curveEnds = curve.length;
         const curveResponse = response.slice(0, curveEnds);
         const balancerEnds = balancer.length;
@@ -85,8 +87,8 @@ class PathFinderUtils {
         return fees;
     }
     static getUniswapV2Fee(callObject) {
-        const { name } = callObject.functionFragment;
-        switch (name) {
+        const { functionName } = callObject;
+        switch (functionName) {
             case "swapExactTokensForTokens":
             case "swapTokensForExactTokens":
             case "swapDiffTokensForTokens": {
@@ -101,13 +103,13 @@ class PathFinderUtils {
         }
     }
     static getUniswapV3Fee(callObject) {
-        const { name } = callObject.functionFragment;
-        switch (name) {
+        const { functionName, args } = callObject;
+        switch (functionName) {
             case "exactInputSingle":
             case "exactDiffInputSingle":
             case "exactOutputSingle": {
-                const { params } = callObject.args || {};
-                const { fee = 0 } = params || {};
+                const [first] = args;
+                const { fee = 0 } = first || {};
                 return {
                     type: "uniswap_v3",
                     value: (0, sdk_gov_1.toBigInt)(fee),
@@ -118,8 +120,8 @@ class PathFinderUtils {
         }
     }
     static getCurveFeeCall(callObject, contractsByAdapter) {
-        const { name } = callObject.functionFragment;
-        switch (name) {
+        const { functionName } = callObject;
+        switch (functionName) {
             case "exchange":
             case "exchange_underlying":
             case "exchange_diff":
@@ -129,8 +131,9 @@ class PathFinderUtils {
                 return contract
                     ? {
                         address: contract,
-                        interface: types_1.ICurvePool__factory.createInterface(),
-                        method: "fee()",
+                        abi: types_1.iCurvePoolAbi,
+                        functionName: "fee",
+                        args: [],
                     }
                     : null;
             }
@@ -138,25 +141,27 @@ class PathFinderUtils {
                 return null;
         }
     }
-    static getCurveFee({ value }) {
-        const feeOriginal = value || 0n;
+    static getCurveFee({ result }) {
+        const feeOriginal = result || 0n;
         return {
             type: "curve",
             value: (feeOriginal * sdk_gov_1.PERCENTAGE_FACTOR) / CURVE_FEE_DECIMALS,
         };
     }
     static getBalancerFeeCall(callObject) {
-        const { name } = callObject.functionFragment;
-        switch (name) {
+        const { functionName } = callObject;
+        switch (functionName) {
             case "swapDiff":
             case "swap": {
-                const { poolId = "" } = callObject.args?.[0] || {};
+                const [first] = callObject.args;
+                const { poolId = "" } = first || {};
                 const { address } = (0, balancerVault_1.splitPoolId)(poolId);
                 return address
                     ? {
-                        address,
-                        interface: exports.BALANCER_VAULT_INTERFACE,
-                        method: "getSwapFeePercentage()",
+                        address: address,
+                        abi: exports.BALANCER_VAULT_ABI,
+                        functionName: "getSwapFeePercentage",
+                        args: [],
                     }
                     : null;
             }
@@ -164,8 +169,8 @@ class PathFinderUtils {
                 return null;
         }
     }
-    static getBalancerFee({ value }) {
-        const feeOriginal = value || 0n;
+    static getBalancerFee({ result }) {
+        const feeOriginal = result || 0n;
         return {
             type: "balancer",
             value: (feeOriginal * sdk_gov_1.PERCENTAGE_FACTOR) / BALANCER_FEE_DECIMALS,

package/lib/payload/bot.d.ts

@@ -1,13 +1,13 @@
-import type { BigNumberish } from "ethers";
+import { Address } from "viem";
 export type BotBaseType = "liquidationProtection";
 export type LiquidationBotType = "deleverageBotPegged" | "deleverageBotLV" | "deleverageBotHV";
 export type BotDetailedType = LiquidationBotType;
 export interface BotDataPayload {
     baseType: BotBaseType;
     detailedType: BotDetailedType;
-    address: string;
-    minHealthFactor: BigNumberish;
-    maxHealthFactor: BigNumberish;
-    premiumScaleFactor: BigNumberish;
-    feeScaleFactor: BigNumberish;
+    address: Address;
+    minHealthFactor: number;
+    maxHealthFactor: number;
+    premiumScaleFactor: number;
+    feeScaleFactor: number;
 }