@gearbox-protocol/sdk 3.0.0-next.205 → 3.0.0-next.207

package/lib/gearboxRewards/api.js

@@ -6,12 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GearboxRewardsApi = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const axios_1 = __importDefault(require("axios"));
-const ethers_1 = require("ethers");
+const viem_1 = require("viem");
 const types_1 = require("../types");
-const calls_1 = require("../utils/calls");
 const formatter_1 = require("../utils/formatter");
 const math_1 = require("../utils/math");
-const abi_1 = require("./abi");
 const merklAPI_1 = require("./merklAPI");
 const DEFAULT_POOLS_WITH_EXTRA_REWARDS = {
     Mainnet: ["sdcrvUSDV3"],
@@ -23,44 +21,51 @@ class GearboxRewardsApi {
     static async getLmRewardsInfo({ currentTokenData, provider, multicallAddress, poolsWithExtraRewards = DEFAULT_POOLS_WITH_EXTRA_REWARDS, network, reportError, }) {
         const poolTokens = sdk_gov_1.TypedObjectUtils.entries(currentTokenData).filter(([symbol]) => (0, sdk_gov_1.isDieselStakedToken)(symbol));
         const farmInfoCalls = poolTokens.map(([, address]) => ({
-            address: address,
-            interface: types_1.IFarmingPool__factory.createInterface(),
-            method: "farmInfo()",
-        }));
-        const rewardTokenCalls = poolTokens.map(([, address]) => ({
-            address: address,
-            interface: POOL_REWARD_INTERFACE,
-            method: "rewardsToken()",
+            address,
+            abi: types_1.iFarmingPoolAbi,
+            functionName: "farmInfo",
+            args: [],
         }));
         const farmSupplyCalls = poolTokens.map(([, address]) => ({
-            address: address,
-            interface: types_1.IFarmingPool__factory.createInterface(),
-            method: "totalSupply()",
-            params: [],
+            address,
+            abi: types_1.iFarmingPoolAbi,
+            functionName: "totalSupply",
+            args: [],
+        }));
+        const rewardTokenCalls = poolTokens.map(([, address]) => ({
+            address,
+            abi: POOL_REWARDS_ABI,
+            functionName: "rewardsToken",
+            args: [],
         }));
-        const blockTimestampCall = {
-            address: multicallAddress,
-            interface: abi_1.MULTICALL_EXTENDED_INTERFACE,
-            method: "getCurrentBlockTimestamp()",
-        };
         const tokenWithExtraRewards = poolsWithExtraRewards[network] || [];
         const chainId = sdk_gov_1.CHAINS[network];
         const [mc, ...extra] = await Promise.allSettled([
-            (0, sdk_gov_1.multicall)([
-                blockTimestampCall,
-                ...farmInfoCalls,
-                ...farmSupplyCalls,
-                ...rewardTokenCalls,
-            ], provider),
+            provider.multicall({
+                allowFailure: false,
+                multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+                contracts: [
+                    {
+                        address: multicallAddress,
+                        abi: types_1.iMulticall3Abi,
+                        functionName: "getCurrentBlockTimestamp",
+                        args: [],
+                    },
+                    ...farmInfoCalls,
+                    ...farmSupplyCalls,
+                    ...rewardTokenCalls,
+                ],
+            }),
             ...tokenWithExtraRewards.map(symbol => axios_1.default.get(merklAPI_1.MerkleXYZApi.getRewardsCampaignsUrl({
                 params: {
                     chainId,
-                    mainParameter: (0, ethers_1.getAddress)(currentTokenData[symbol]),
+                    mainParameter: (0, viem_1.getAddress)(currentTokenData[symbol]),
                 },
             }))),
         ]);
         const mcResponse = this.extractFulfilled(mc, reportError, "rewardsInfoMulticall") || [];
-        const [blockTimestamp = 0n, ...restMCResponse] = mcResponse;
+        const [ts = 0n, ...restMCResponse] = mcResponse;
+        const blockTimestamp = ts || 0n;
         const farmInfoCallsEnd = farmInfoCalls.length;
         const farmInfo = restMCResponse.slice(0, farmInfoCallsEnd);
         const farmSupplyCallsEnd = farmInfoCallsEnd + farmSupplyCalls.length;
@@ -99,8 +104,8 @@ class GearboxRewardsApi {
             const [symbol] = (0, sdk_gov_1.extractTokenData)(rewardTokens[i] || "");
             if (symbol) {
                 const baseReward = {
-                    duration: currentInfo.duration,
-                    finished: currentInfo.finished,
+                    duration: BigInt(currentInfo.duration),
+                    finished: BigInt(currentInfo.finished),
                     reward: currentInfo.reward,
                     balance: currentInfo.balance,
                     symbol: symbol,
@@ -126,9 +131,8 @@ class GearboxRewardsApi {
     static async getLmRewardsV2({ provider, account, currentTokenData, network, airdropDistributorAddress, }) {
         if (!airdropDistributorAddress)
             return { rewards: [] };
-        const distributor = types_1.IAirdropDistributor__factory.connect(airdropDistributorAddress, provider);
         const [claimedResp, merkleDataResp] = await Promise.all([
-            this.getClaimed({ distributor, account }),
+            this.getClaimed({ airdropDistributorAddress, provider, account }),
             this.getMerkle(provider, airdropDistributorAddress, network, account),
         ]);
         const amountOnContract = this.getAmountOnContract({
@@ -148,26 +152,29 @@ class GearboxRewardsApi {
     }
     static async getLmRewardsV3({ baseRewardPoolsInfo, currentTokenData, provider, account, network, reportError, }) {
         const poolTokens = Object.keys(baseRewardPoolsInfo);
-        const farmedCalls = poolTokens.map(address => ({
-            address: address,
-            interface: types_1.IFarmingPool__factory.createInterface(),
-            method: "farmed(address)",
-            params: [account],
-        }));
         const [gearboxLmResponse, merkleXYZLMResponse] = await Promise.allSettled([
-            (0, sdk_gov_1.multicall)(farmedCalls, provider),
+            provider.multicall({
+                allowFailure: false,
+                multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+                contracts: poolTokens.map(address => ({
+                    address: address,
+                    abi: types_1.iFarmingPoolAbi,
+                    functionName: "farmed",
+                    args: [account],
+                })),
+            }),
             axios_1.default.get(merklAPI_1.MerkleXYZApi.getUserRewardsUrl({
                 params: {
                     chainId: sdk_gov_1.CHAINS[network],
-                    user: (0, ethers_1.getAddress)(account),
+                    user: (0, viem_1.getAddress)(account),
                 },
             })),
         ]);
-        const gearboxLm = this.extractFulfilled(gearboxLmResponse, reportError, "v3Rewards") || [];
+        const gearboxLm = (this.extractFulfilled(gearboxLmResponse, reportError, "v3Rewards") || []);
         const merkleXYZLM = this.extractFulfilled(merkleXYZLMResponse, reportError, "merkleRewards")?.data;
         const PREFIX = "ERC20";
         const REWARD_KEYS_RECORD = poolTokens.reduce((acc, t) => {
-            const key = [PREFIX, (0, ethers_1.getAddress)(t)].join("_");
+            const key = [PREFIX, (0, viem_1.getAddress)(t)].join("_");
             acc[key] = t;
             return acc;
         }, {});
@@ -225,33 +232,61 @@ class GearboxRewardsApi {
     static async claimLmRewardsV2({ signer, account, provider, network, airdropDistributorAddress, }) {
         if (!airdropDistributorAddress)
             throw new Error(`V2 rewards are not supported on chain: ${network}`);
-        const distributor = types_1.IAirdropDistributor__factory.connect(airdropDistributorAddress, signer);
         const merkleData = await this.getMerkle(provider, airdropDistributorAddress, network, account);
         const rewardFromMerkle = merkleData?.claims[account];
         if (!rewardFromMerkle)
             throw new Error("No rewards found");
-        return (0, calls_1.makeTransactionCall)(distributor.claim, [
-            rewardFromMerkle.index,
+        const distributor = (0, viem_1.getContract)({
+            address: airdropDistributorAddress,
+            abi: types_1.iAirdropDistributorAbi,
+            client: signer,
+        });
+        return distributor.write.claim([
+            BigInt(rewardFromMerkle.index),
             account,
-            rewardFromMerkle.amount,
+            (0, sdk_gov_1.toBigInt)(rewardFromMerkle.amount),
             rewardFromMerkle.proof,
-        ], signer);
+        ], {
+            account: account,
+            chain: signer.chain,
+        });
     }
-    static async claimLmRewardsV3({ reward, signer }) {
-        const pool = types_1.IFarmingPool__factory.connect(reward.poolToken, signer);
-        return (0, calls_1.makeTransactionCall)(pool.claim, [], signer);
+    static async claimLmRewardsV3({ reward, signer, account, }) {
+        const pool = (0, viem_1.getContract)({
+            address: reward.poolToken,
+            abi: types_1.iFarmingPoolAbi,
+            client: signer,
+        });
+        return pool.write.claim({
+            account: account,
+            chain: signer.chain,
+        });
     }
     static async getMerkle(provider, distributorAddress, network, account) {
-        const distributor = types_1.IAirdropDistributor__factory.connect(distributorAddress, provider);
-        const root = await distributor.merkleRoot();
+        const distributor = (0, viem_1.getContract)({
+            address: distributorAddress,
+            abi: types_1.iAirdropDistributorAbi,
+            client: provider,
+        });
+        const root = await distributor.read.merkleRoot();
         const path = `${network}_${root.slice(2)}/${account.slice(2, 4)}`;
         const url = `https://am.gearbox.finance/${path.toLowerCase()}.json`;
         const result = await axios_1.default.get(url);
         return result.data;
     }
-    static async getClaimed({ distributor, account, }) {
-        const claimedRewardsResponse = await distributor.queryFilter(distributor.filters.Claimed(account, undefined, false));
-        const claimedRewards = (claimedRewardsResponse || []).reduce((acc, r) => acc + r.args.amount, 0n);
+    static async getClaimed({ provider, airdropDistributorAddress, account, }) {
+        const distributor = (0, viem_1.getContract)({
+            address: airdropDistributorAddress,
+            abi: types_1.iAirdropDistributorAbi,
+            client: provider,
+        });
+        const claimedRewardsResponse = await distributor.getEvents.Claimed({
+            account,
+            historic: false,
+        }, {
+            fromBlock: 0n,
+        });
+        const claimedRewards = (claimedRewardsResponse || []).reduce((acc, r) => acc + (r.args.amount || 0n), 0n);
         return claimedRewards;
     }
     static getAmountOnContract({ account, merkleData, }) {
@@ -276,4 +311,3 @@ const POOL_REWARDS_ABI = [
         type: "function",
     },
 ];
-const POOL_REWARD_INTERFACE = new ethers_1.Interface(POOL_REWARDS_ABI);

package/lib/gearboxRewards/apy.d.ts

@@ -1,4 +1,5 @@
 import { SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { PoolData } from "../core/pool";
 import { TokenData } from "../tokens/tokenData";
 import { FarmInfo } from "./api";
@@ -20,13 +21,13 @@ export interface PoolExtraRewardApy {
     apy: number;
 }
 interface GetPoolExtraAPY_V3Props {
-    stakedDieselToken: string | undefined;
+    stakedDieselToken: Address | undefined;
     pool: PoolData;
-    prices: Record<string, bigint>;
-    rewardPoolsInfo: Record<string, Array<FarmInfo>>;
-    rewardPoolsSupply: Record<string, bigint>;
-    tokensList: Record<string, TokenData>;
-    currentTokenData: Record<SupportedToken, string>;
+    prices: Record<Address, bigint>;
+    rewardPoolsInfo: Record<Address, Array<FarmInfo>>;
+    rewardPoolsSupply: Record<Address, bigint>;
+    tokensList: Record<Address, TokenData>;
+    currentTokenData: Record<SupportedToken, Address>;
     currentTimestamp: number;
 }
 export declare class GearboxRewardsApy {

package/lib/gearboxRewards/extraAPY.d.ts

@@ -1,17 +1,18 @@
 import { NetworkType, SupportedToken } from "@gearbox-protocol/sdk-gov";
+import { Address } from "viem";
 import { Asset } from "../core/assets";
 import { PoolData } from "../core/pool";
 import { TokenData } from "../tokens/tokenData";
 export interface GetPointsByPoolProps {
-    totalTokenBalances: Record<string, Asset>;
+    totalTokenBalances: Record<Address, Asset>;
     pools: Array<PoolData>;
-    currentTokenData: Record<SupportedToken, string>;
-    tokensList: Record<string, TokenData>;
+    currentTokenData: Record<SupportedToken, Address>;
+    tokensList: Record<Address, TokenData>;
     network: NetworkType;
 }
 export interface GetTotalTokensOnProtocolProps {
-    currentTokenData: Record<SupportedToken, string>;
-    tokensList: Record<string, TokenData>;
+    currentTokenData: Record<SupportedToken, Address>;
+    tokensList: Record<Address, TokenData>;
     chainId: number;
     network: NetworkType;
 }
@@ -24,9 +25,9 @@ interface PoolPointsInfo {
 export declare class GearboxRewardsExtraApy {
     static getTotalTokensOnProtocol({ currentTokenData, chainId, tokensList, network, }: GetTotalTokensOnProtocolProps): Promise<[SupportedToken, PromiseSettledResult<Asset>][]>;
     private static getTokenTotal;
-    static getPointsByPool({ totalTokenBalances, pools, tokensList, currentTokenData, network, }: GetPointsByPoolProps): Record<string, Asset[]>;
+    static getPointsByPool({ totalTokenBalances, pools, tokensList, currentTokenData, network, }: GetPointsByPoolProps): Record<`0x${string}`, Asset[]>;
     private static getPoolTokenPoints;
-    static getPoolPointsTip(network: NetworkType, pool: string, token: SupportedToken): PoolPointsInfo | undefined;
+    static getPoolPointsTip(network: NetworkType, pool: Address, token: SupportedToken): PoolPointsInfo | undefined;
     static getExtraLidoAPY: (supply: bigint, supplyPrice: bigint, rewardPrice: bigint, currentTimestamp: number) => number;
 }
 export {};

package/lib/gearboxRewards/merklAPI.d.ts

@@ -1,4 +1,4 @@
-import { BigNumberish } from "ethers";
+import { BigNumberish } from "../utils/formatter";
 interface UserOptions {
     params: {
         user: string;

package/lib/index.d.ts

@@ -6,7 +6,6 @@ export * from "./core/creditAccount";
 export * from "./core/creditManager";
 export * from "./core/creditSession";
 export * from "./core/endpoint";
-export * from "./core/errors";
 export * from "./core/eventOrTx";
 export * from "./core/events";
 export * from "./core/gauge";
@@ -31,7 +30,6 @@ export * from "./payload/token";
 export * from "./redstone";
 export * from "./tokens/tokenData";
 export * from "./types";
-export { callRepeater } from "./utils/calls";
 export * from "./utils/errors";
 export * from "./utils/formatter";
 export * from "./utils/loading";

package/lib/index.js

@@ -14,7 +14,6 @@ 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 });
-exports.callRepeater = void 0;
 __exportStar(require("./apy"), exports);
 __exportStar(require("./contracts/contractsRegister"), exports);
 __exportStar(require("./core/assets"), exports);
@@ -23,7 +22,6 @@ __exportStar(require("./core/creditAccount"), exports);
 __exportStar(require("./core/creditManager"), exports);
 __exportStar(require("./core/creditSession"), exports);
 __exportStar(require("./core/endpoint"), exports);
-__exportStar(require("./core/errors"), exports);
 __exportStar(require("./core/eventOrTx"), exports);
 __exportStar(require("./core/events"), exports);
 __exportStar(require("./core/gauge"), exports);
@@ -48,8 +46,6 @@ __exportStar(require("./payload/token"), exports);
 __exportStar(require("./redstone"), exports);
 __exportStar(require("./tokens/tokenData"), exports);
 __exportStar(require("./types"), exports);
-var calls_1 = require("./utils/calls");
-Object.defineProperty(exports, "callRepeater", { enumerable: true, get: function () { return calls_1.callRepeater; } });
 __exportStar(require("./utils/errors"), exports);
 __exportStar(require("./utils/formatter"), exports);
 __exportStar(require("./utils/loading"), exports);

package/lib/parsers/ERC20Parser.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 ERC20Parser extends AbstractParser implements IParser {
     constructor(symbol: SupportedToken);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
 }

package/lib/parsers/ERC20Parser.js

@@ -8,28 +8,28 @@ class ERC20Parser extends abstractParser_1.AbstractParser {
     constructor(symbol) {
         super(symbol);
         this.adapterName = "Token";
-        this.ifc = types_1.IERC20__factory.createInterface();
+        this.abi = types_1.ierc20Abi;
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             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 this.reportUnknownFragment(functionName, functionFragment, calldata);
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

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

package/lib/parsers/aaveV2LendingPoolAdapterParser.js

@@ -6,15 +6,15 @@ const abstractParser_1 = require("./abstractParser");
 class AaveV2LendingPoolAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IAaveV2_LendingPoolAdapter__factory.createInterface();
+        this.abi = types_1.iAaveV2LendingPoolAdapterAbi;
         if (!isContract)
             this.adapterName = "AaveV2_LendingPoolAdapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             default:
-                return this.reportUnknownFragment(functionName, functionFragment, calldata);
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

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

package/lib/parsers/aaveV2WrappedATokenAdapterParser.js

@@ -6,15 +6,15 @@ const abstractParser_1 = require("./abstractParser");
 class AaveV2WrappedATokenAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IAaveV2_WrappedATokenAdapter__factory.createInterface();
+        this.abi = types_1.iAaveV2WrappedATokenAdapterAbi;
         if (!isContract)
             this.adapterName = "AaveV2_WrappedATokenAdapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             default:
-                return this.reportUnknownFragment(functionName, functionFragment, calldata);
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

package/lib/parsers/abstractParser.d.ts

@@ -1,26 +1,30 @@
 import { SupportedToken, TickerToken } from "@gearbox-protocol/sdk-gov";
-import { BigNumberish, BytesLike, FunctionFragment, Interface, Result } from "ethers";
-interface ParseSelectorResult {
-    functionFragment: FunctionFragment;
-    functionName: string;
-}
+import { Abi, Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
 export interface ParsedObject {
-    address: string;
-    functionFragment: FunctionFragment;
-    args: Result;
+    address: Address;
+    functionName: string;
+    args: readonly any[];
 }
 export declare class AbstractParser {
     readonly contract: string;
-    protected ifc: Interface;
+    protected abi: Abi;
     adapterName: string;
     constructor(contract: string);
-    parseSelector(calldata: BytesLike): ParseSelectorResult;
-    decodeFunctionData(functionFragment: FunctionFragment | string, data: BytesLike): Result;
-    encodeFunctionResult(functionFragment: FunctionFragment | string, data: Array<any>): string;
-    tokenSymbol(address: string): SupportedToken;
-    tokenOrTickerSymbol(address: string): SupportedToken | TickerToken;
+    parseSelector(calldata: Address): {
+        functionData: {
+            args: Array<any> | undefined;
+            functionName: string;
+        };
+        functionName: string;
+    };
+    decodeFunctionData(data: Address): {
+        args: readonly unknown[] | undefined;
+        functionName: string;
+    };
+    tokenSymbol(address: Address): SupportedToken;
+    tokenOrTickerSymbol(address: Address): SupportedToken | TickerToken;
     formatBN(amount: BigNumberish, token: SupportedToken): string;
-    parseToObject(address: string, calldata: string): ParsedObject;
-    reportUnknownFragment(functionName: string, functionFragment: FunctionFragment, calldata: string): string;
+    parseToObject(address: Address, calldata: Address): ParsedObject;
+    reportUnknownFragment(parserName: string, functionName: string, calldata: string): string;
 }
-export {};

package/lib/parsers/abstractParser.js

@@ -2,27 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractParser = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const ethers_1 = require("ethers");
+const viem_1 = require("viem");
 class AbstractParser {
     contract;
-    ifc;
+    abi;
     adapterName;
     constructor(contract) {
         this.contract = contract;
         this.adapterName = "Contract";
     }
     parseSelector(calldata) {
-        const functionFragment = this.ifc.getFunction((0, ethers_1.dataSlice)(calldata, 0, 4));
-        if (!functionFragment)
+        const functionData = (0, viem_1.decodeFunctionData)({
+            abi: this.abi,
+            data: calldata,
+        });
+        if (!functionData.functionName)
             throw new Error("Function fragment not found");
-        const functionName = `${this.adapterName}[${this.contract}].${functionFragment?.name}`;
-        return { functionFragment, functionName };
-    }
-    decodeFunctionData(functionFragment, data) {
-        return this.ifc.decodeFunctionData(functionFragment, data);
+        const functionName = `${this.adapterName}[${this.contract}].${functionData.functionName}`;
+        return {
+            functionData: functionData,
+            functionName,
+        };
     }
-    encodeFunctionResult(functionFragment, data) {
-        return this.ifc.encodeFunctionResult(functionFragment, data);
+    decodeFunctionData(data) {
+        return (0, viem_1.decodeFunctionData)({
+            abi: this.abi,
+            data,
+        });
     }
     tokenSymbol(address) {
         const symbol = sdk_gov_1.tokenSymbolByAddress[address.toLowerCase()];
@@ -41,16 +47,15 @@ class AbstractParser {
         return `${(0, sdk_gov_1.formatBN)(amount, sdk_gov_1.decimals[token])} [${(0, sdk_gov_1.toBigInt)(amount).toString()}]`;
     }
     parseToObject(address, calldata) {
-        const { functionFragment } = this.parseSelector(calldata);
-        const args = this.decodeFunctionData(functionFragment, calldata);
+        const { functionName, functionData } = this.parseSelector(calldata);
         return {
             address,
-            functionFragment,
-            args,
+            functionName,
+            args: functionData.args || [],
         };
     }
-    reportUnknownFragment(functionName, functionFragment, calldata) {
-        return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+    reportUnknownFragment(parserName, functionName, calldata) {
+        return `${parserName}: Unknown operation ${functionName} with calldata ${calldata}`;
     }
 }
 exports.AbstractParser = AbstractParser;

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

package/lib/parsers/balancerV2VaultParser.js

@@ -6,28 +6,26 @@ const abstractParser_1 = require("./abstractParser");
 class BalancerV2VaultParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IBalancerV2VaultAdapter__factory.createInterface();
+        this.abi = types_1.iBalancerV2VaultAdapterAbi;
         if (!isContract)
             this.adapterName = "BalancerV2Vault";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { functionName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "batchSwap": {
                 return `${functionName}(undefined)`;
             }
             case "swapDiff": {
-                const d = this.decodeFunctionData(functionFragment, calldata);
-                const { assetIn = "", assetOut = "", leftoverAmount = 0, } = (d?.[0] || {});
+                const [{ leftoverAmount = 0, assetIn = "", assetOut = "" }] = functionData.args || [{}];
                 return `${functionName}(${this.tokenSymbol(assetIn)} => ${this.tokenSymbol(assetOut)} ${this.formatBN(leftoverAmount, this.tokenSymbol(assetIn))}}`;
             }
             case "swap": {
-                const d = this.decodeFunctionData(functionFragment, calldata);
-                const { assetIn = "", assetOut = "", amount = 0, } = (d?.[0] || {});
+                const [{ assetIn = "", assetOut = "", amount = 0 }] = functionData.args || [{}];
                 return `${functionName}(${this.tokenSymbol(assetIn)} => ${this.tokenSymbol(assetOut)} ${this.formatBN(amount, this.tokenSymbol(assetIn))}}`;
             }
             default:
-                return this.reportUnknownFragment(functionName, functionFragment, calldata);
+                return this.reportUnknownFragment(this.adapterName || this.contract, functionName, calldata);
         }
     }
 }

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