@gearbox-protocol/sdk 3.0.0-next.30 → 3.0.0-next.300

package/lib/gearboxRewards/extraAPY.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GearboxRewardsExtraApy = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const axios_1 = __importDefault(require("axios"));
+const endpoint_1 = require("../core/endpoint");
+const formatter_1 = require("../utils/formatter");
+const math_1 = require("../utils/math");
+class GearboxRewardsExtraApy {
+    static async getTotalTokensOnProtocol({ tokensToCheck, tokensList, network, }) {
+        const list = [...new Set(tokensToCheck)];
+        const res = await Promise.allSettled(list.map(t => this.getTokenTotal(t, network, tokensList)));
+        return res.map((r, i) => [
+            list[i],
+            r,
+        ]);
+    }
+    static async getTokenTotal(token, network, tokensList) {
+        const chainId = sdk_gov_1.CHAINS[network];
+        const url = endpoint_1.GearboxBackendApi.getChartsUrl("getBalanceAt", chainId, {
+            params: {
+                asset: token,
+            },
+        });
+        const result = await axios_1.default.get(url);
+        const balance = result.data.result.reduce((sum, r) => r.effective_balance + sum, 0);
+        const { decimals = 18 } = tokensList[token] || {};
+        return { token, balance: (0, formatter_1.toBN)(String(balance), decimals) };
+    }
+    static getPointsByPool({ poolRewards, totalTokenBalances, pools, tokensList, }) {
+        const r = pools.reduce((acc, p) => {
+            const pointsInfo = Object.values(poolRewards[p.address] || {});
+            const poolPointsList = pointsInfo.reduce((acc, pointsInfo) => {
+                const { address: tokenAddress } = tokensList[pointsInfo.token];
+                const tokenBalance = totalTokenBalances[tokenAddress || ""];
+                const points = this.getPoolTokenPoints(tokenBalance, p, tokensList, pointsInfo);
+                if (points !== null) {
+                    acc.push({ balance: points, token: tokenBalance.token });
+                }
+                return acc;
+            }, []);
+            acc[p.address] = poolPointsList;
+            return acc;
+        }, {});
+        return r;
+    }
+    static getPoolTokenPoints(tokenBalanceInPool, pool, tokensList, pointsInfo) {
+        if (!tokenBalanceInPool)
+            return null;
+        if (pool.expectedLiquidity <= 0)
+            return 0n;
+        const { decimals = 18 } = tokensList[tokenBalanceInPool.token] || {};
+        const targetFactor = 10n ** BigInt(decimals);
+        const { decimals: underlyingDecimals = 18 } = tokensList[pool.underlyingToken] || {};
+        const underlyingFactor = 10n ** BigInt(underlyingDecimals);
+        const defaultPoints = (pointsInfo.amount * targetFactor) / sdk_gov_1.PERCENTAGE_FACTOR;
+        const points = pointsInfo.estimation === "absolute"
+            ? defaultPoints
+            : (tokenBalanceInPool.balance * defaultPoints) /
+                ((pool.expectedLiquidity * targetFactor) / underlyingFactor);
+        return math_1.BigIntMath.min(points, defaultPoints);
+    }
+    static getPoolPointsTip(poolRewards, pool, token) {
+        const p = poolRewards[pool]?.[token];
+        return p;
+    }
+}
+exports.GearboxRewardsExtraApy = GearboxRewardsExtraApy;

package/lib/gearboxRewards/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./api";
+export * from "./apy";
+export * from "./extraAPY";

package/lib/gearboxRewards/index.js

@@ -0,0 +1,19 @@
+"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);
+__exportStar(require("./apy"), exports);
+__exportStar(require("./extraAPY"), exports);

package/lib/gearboxRewards/merklAPI.d.ts

@@ -0,0 +1,138 @@
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
+interface UserOptions {
+    params: {
+        user: string;
+        chainId: number;
+    };
+}
+export interface MerkleXYZUserRewardsV4 {
+    chain: MerkleXYZChain;
+    rewards: Array<{
+        root: Address;
+        recipient: Address;
+        amount: BigNumberish;
+        claimed: BigNumberish;
+        pending: BigNumberish;
+        proofs: Array<Address>;
+        token: {
+            address: Address;
+            chainId: number;
+            symbol: string;
+            decimals: number;
+        };
+        breakdowns: Array<{
+            reason: string;
+            amount: BigNumberish;
+            claimed: BigNumberish;
+            pending: BigNumberish;
+            campaignId: Address;
+        }>;
+    }>;
+}
+export type MerkleXYZUserRewardsV4Response = Array<MerkleXYZUserRewardsV4>;
+interface MerkleXYZChain {
+    id: number;
+    name: string;
+    icon: string;
+}
+interface MerkleXYZToken {
+    id: string;
+    name: string;
+    chainId: number;
+    address: Address;
+    decimals: number;
+    icon: string;
+    verified: boolean;
+    isTest: boolean;
+    price: number | null;
+    symbol: string;
+}
+export interface MerklXYZV4Campaign {
+    chainId: number;
+    type: string;
+    identifier: Address;
+    name: string;
+    status: "LIVE" | "PAST";
+    action: "LEND" | "BORROW";
+    tvl: number;
+    apr: number;
+    dailyRewards: number;
+    tags: Array<string>;
+    id: string;
+    tokens: Array<MerkleXYZToken>;
+    chain: MerkleXYZChain;
+    aprRecord: {
+        cumulated: number;
+        timestamp: string;
+        breakdowns: Array<{
+            id: number;
+            identifier: Address;
+            type: "CAMPAIGN";
+            value: number;
+            aprRecordId: string;
+        }>;
+    };
+    tvlRecord: {
+        id: string;
+        total: number;
+        timestamp: string;
+        breakdowns: [];
+    };
+    rewardsRecord: {
+        id: string;
+        total: number;
+        timestamp: string;
+        breakdowns: Array<{
+            token: MerkleXYZToken;
+            amount: string;
+            id: number;
+            value: number;
+            campaignId: string;
+            dailyRewardsRecordid: string;
+        }>;
+    };
+}
+export type MerkleXYZV4CampaignsResponse = Array<MerklXYZV4Campaign>;
+export interface MerklXYZV4RewardCampaign {
+    id: string;
+    computeChainId: number;
+    distributionChainId: number;
+    campaignId: Address;
+    rewardTokenId: string;
+    amount: string;
+    opportunityId: string;
+    startTimestamp: string;
+    endTimestamp: string;
+    creatorAddress: Address;
+    params: {
+        url: string;
+        duration: number;
+        blacklist: Array<Address>;
+        whitelist: Array<Address>;
+        forwarders: Array<Address>;
+        targetToken: Address;
+        symbolRewardToken: string;
+        symbolTargetToken: string;
+        decimalsRewardToken: number;
+        decimalsTargetToken: number;
+    };
+    chain: MerkleXYZChain;
+    rewardToken: MerkleXYZToken;
+    distributionChain: MerkleXYZChain;
+    campaignStatus: {
+        campaignId: string;
+        computedUntil: string;
+        processingStarted: string;
+        status: "SUCCESS";
+        error: string;
+        details: string;
+    };
+}
+export type MerkleXYZV4RewardCampaignResponse = Array<MerklXYZV4RewardCampaign>;
+export declare class MerkleXYZApi {
+    static getUserRewardsUrl: (options: UserOptions) => string;
+    static getGearboxCampaignsUrl: () => string;
+    static getGearboxRewardCampaignUrl: (campaignId: Address) => string;
+}
+export {};

package/lib/gearboxRewards/merklAPI.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleXYZApi = void 0;
+// https://api.merkl.xyz/v3/campaignsForMainParameter?chainId=1&mainParameter=0xE2037090f896A858E3168B978668F22026AC52e7
+class MerkleXYZApi {
+    static getUserRewardsUrl = (options) => `https://api.merkl.xyz/v4/users/${options.params.user}/rewards?chainId=${options.params.chainId}`;
+    static getGearboxCampaignsUrl = () => "https://api.merkl.xyz/v4/opportunities?name=gearbox";
+    static getGearboxRewardCampaignUrl = (campaignId) => `https://api.merkl.xyz/v4/campaigns?campaignId=${campaignId}`;
+}
+exports.MerkleXYZApi = MerkleXYZApi;

package/lib/index.d.ts

@@ -1,22 +1,25 @@
 export * from "./apy";
 export * from "./contracts/contractsRegister";
 export * from "./core/assets";
+export * from "./core/bot";
 export * from "./core/creditAccount";
 export * from "./core/creditManager";
 export * from "./core/creditSession";
-export * from "./core/errors";
+export * from "./core/endpoint";
 export * from "./core/eventOrTx";
-export * from "./core/events";
 export * from "./core/gauge";
+export * from "./core/gaugeMath";
 export * from "./core/pool";
+export * from "./core/protocols";
 export * from "./core/rewardClaimer";
 export * from "./core/strategy";
 export * from "./core/tokenDistributor";
 export * from "./core/trade";
 export * from "./core/transactions";
+export * from "./gearboxRewards";
 export * from "./parsers/txParser";
-export * from "./pathfinder/core";
-export * from "./pathfinder/pathfinder";
+export * from "./pathfinder";
+export * from "./payload/bot";
 export * from "./payload/creditAccount";
 export * from "./payload/creditManager";
 export * from "./payload/creditSession";
@@ -24,6 +27,7 @@ export * from "./payload/gauge";
 export * from "./payload/graphPayload";
 export * from "./payload/pool";
 export * from "./payload/token";
+export * from "./redstone";
 export * from "./tokens/tokenData";
 export * from "./types";
 export * from "./utils/errors";
@@ -31,8 +35,6 @@ export * from "./utils/formatter";
 export * from "./utils/loading";
 export * from "./utils/math";
 export * from "./utils/price";
-export { callRepeater } from "./utils/repeater";
+export * from "./utils/types";
 export * from "./utils/validate";
-export * from "./watchers/creditAccountWatcher";
-export * from "./watchers/creditManagerWatcher";
 export * from "@gearbox-protocol/sdk-gov";

package/lib/index.js

@@ -14,26 +14,28 @@ 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);
+__exportStar(require("./core/bot"), exports);
 __exportStar(require("./core/creditAccount"), exports);
 __exportStar(require("./core/creditManager"), exports);
 __exportStar(require("./core/creditSession"), exports);
-__exportStar(require("./core/errors"), exports);
+__exportStar(require("./core/endpoint"), exports);
 __exportStar(require("./core/eventOrTx"), exports);
-__exportStar(require("./core/events"), exports);
 __exportStar(require("./core/gauge"), exports);
+__exportStar(require("./core/gaugeMath"), exports);
 __exportStar(require("./core/pool"), exports);
+__exportStar(require("./core/protocols"), exports);
 __exportStar(require("./core/rewardClaimer"), exports);
 __exportStar(require("./core/strategy"), exports);
 __exportStar(require("./core/tokenDistributor"), exports);
 __exportStar(require("./core/trade"), exports);
 __exportStar(require("./core/transactions"), exports);
+__exportStar(require("./gearboxRewards"), exports);
 __exportStar(require("./parsers/txParser"), exports);
-__exportStar(require("./pathfinder/core"), exports);
-__exportStar(require("./pathfinder/pathfinder"), exports);
+__exportStar(require("./pathfinder"), exports);
+__exportStar(require("./payload/bot"), exports);
 __exportStar(require("./payload/creditAccount"), exports);
 __exportStar(require("./payload/creditManager"), exports);
 __exportStar(require("./payload/creditSession"), exports);
@@ -41,6 +43,7 @@ __exportStar(require("./payload/gauge"), exports);
 __exportStar(require("./payload/graphPayload"), exports);
 __exportStar(require("./payload/pool"), exports);
 __exportStar(require("./payload/token"), exports);
+__exportStar(require("./redstone"), exports);
 __exportStar(require("./tokens/tokenData"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils/errors"), exports);
@@ -48,9 +51,6 @@ __exportStar(require("./utils/formatter"), exports);
 __exportStar(require("./utils/loading"), exports);
 __exportStar(require("./utils/math"), exports);
 __exportStar(require("./utils/price"), exports);
-var repeater_1 = require("./utils/repeater");
-Object.defineProperty(exports, "callRepeater", { enumerable: true, get: function () { return repeater_1.callRepeater; } });
+__exportStar(require("./utils/types"), exports);
 __exportStar(require("./utils/validate"), exports);
-__exportStar(require("./watchers/creditAccountWatcher"), exports);
-__exportStar(require("./watchers/creditManagerWatcher"), exports);
 __exportStar(require("@gearbox-protocol/sdk-gov"), 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 { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "totalSupply": {
-                return `${functionName}()`;
+                return `${operationName}()`;
             }
             case "balanceOf": {
-                const [address] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${address})`;
+                const [address] = functionData.args || [];
+                return `${operationName}(${address})`;
             }
             case "allowance": {
-                const [account, to] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(account: ${account}, to: ${to})`;
+                const [account, to] = functionData.args || [];
+                return `${operationName}(account: ${account}, to: ${to})`;
             }
             case "approve": {
-                const [spender, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(${spender}, [${(0, sdk_gov_1.toBigInt)(amount).toString()}])`;
+                const [spender, amount] = functionData.args || [];
+                return `${operationName}(${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, operationName, calldata);
         }
     }
 }

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

package/lib/parsers/aaveV2LendingPoolAdapterParser.js

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

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

package/lib/parsers/aaveV2WrappedATokenAdapterParser.js

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

package/lib/parsers/abstractParser.d.ts

@@ -1,24 +1,30 @@
-import { FunctionFragment, Result } from "@ethersproject/abi";
-import { SupportedToken } from "@gearbox-protocol/sdk-gov";
-import { BigNumberish, BytesLike, utils } from "ethers";
-interface ParseSelectorResult {
-    functionFragment: FunctionFragment;
+import { SupportedToken, TickerToken } from "@gearbox-protocol/sdk-gov";
+import { Abi, Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
+export interface ParsedObject {
+    address: Address;
     functionName: string;
+    args: readonly any[];
 }
 export declare class AbstractParser {
     readonly contract: string;
-    protected ifc: utils.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;
-    formatBN(amount: BigNumberish, token: SupportedToken): string;
-    parseToObject(address: string, calldata: string): {
-        address: string;
-        functionFragment: FunctionFragment;
-        args: Result;
+    parseSelector(calldata: Address): {
+        functionData: {
+            args: Array<any> | undefined;
+            functionName: string;
+        };
+        operationName: 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: Address, calldata: Address): ParsedObject;
+    reportUnknownFragment(parserName: string, functionName: string, calldata: string): string;
 }
-export {};

package/lib/parsers/abstractParser.js

@@ -2,25 +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(ethers_1.utils.hexDataSlice(calldata, 0, 4));
-        const functionName = `${this.adapterName}[${this.contract}].${functionFragment.name}`;
-        return { functionFragment, functionName };
-    }
-    decodeFunctionData(functionFragment, data) {
-        return this.ifc.decodeFunctionData(functionFragment, data);
+        const functionData = (0, viem_1.decodeFunctionData)({
+            abi: this.abi,
+            data: calldata,
+        });
+        if (!functionData.functionName)
+            throw new Error("Function fragment not found");
+        const operationName = `${this.adapterName}[${this.contract}].${functionData.functionName}`;
+        return {
+            functionData: functionData,
+            operationName,
+        };
     }
-    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()];
@@ -28,17 +36,26 @@ class AbstractParser {
             throw new Error(`Unknown token: ${address}`);
         return symbol;
     }
+    tokenOrTickerSymbol(address) {
+        const symbol = (0, sdk_gov_1.getTokenSymbolOrTicker)(address);
+        if (!symbol) {
+            throw new Error(`Unknown token or ticker: ${address}`);
+        }
+        return symbol;
+    }
     formatBN(amount, token) {
         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 { functionData } = this.parseSelector(calldata);
         return {
             address,
-            functionFragment,
-            args,
+            functionName: functionData.functionName,
+            args: functionData.args || [],
         };
     }
+    reportUnknownFragment(parserName, functionName, calldata) {
+        return `${parserName}: Unknown operation ${functionName} with calldata ${calldata}`;
+    }
 }
 exports.AbstractParser = AbstractParser;

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

package/lib/parsers/balancerV2VaultParser.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalancerV2VaultParser = void 0;
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class BalancerV2VaultParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iBalancerV2VaultAdapterAbi;
+        if (!isContract)
+            this.adapterName = "BalancerV2Vault";
+    }
+    parse(calldata) {
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "batchSwap": {
+                return `${operationName}(undefined)`;
+            }
+            case "swapDiff": {
+                const [{ leftoverAmount = 0, assetIn = "", assetOut = "" }] = functionData.args || [{}];
+                return `${operationName}(${this.tokenSymbol(assetIn)} => ${this.tokenSymbol(assetOut)} ${this.formatBN(leftoverAmount, this.tokenSymbol(assetIn))}}`;
+            }
+            case "swap": {
+                const [{ assetIn = "", assetOut = "", amount = 0 }] = functionData.args || [{}];
+                return `${operationName}(${this.tokenSymbol(assetIn)} => ${this.tokenSymbol(assetOut)} ${this.formatBN(amount, this.tokenSymbol(assetIn))}}`;
+            }
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
+        }
+    }
+}
+exports.BalancerV2VaultParser = BalancerV2VaultParser;

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