@gearbox-protocol/sdk 3.0.0-next.24 → 3.0.0-next.241

package/lib/gearboxRewards/merklAPI.d.ts

@@ -0,0 +1,43 @@
+import { BigNumberish } from "../utils/formatter";
+interface UserOptions {
+    params: {
+        user: string;
+        chainId: number;
+        mainParameter?: string;
+        rewardToken?: string;
+    };
+}
+export interface MerkleXYZUserRewards {
+    accumulated: BigNumberish;
+    decimals: number;
+    reasons: Record<string, {
+        accumulated: BigNumberish;
+        unclaimed: BigNumberish;
+    }>;
+    symbol: string;
+    unclaimed: BigNumberish;
+}
+export type MerkleXYZUserRewardsResponse = Record<string, MerkleXYZUserRewards>;
+interface CampaignsOptions {
+    params: {
+        chainId: number;
+        mainParameter?: string;
+        rewardToken?: string;
+    };
+}
+interface Campaign {
+    amountDecimal: string;
+    campaignId: string;
+    campaignType: number;
+    endTimestamp: number;
+    rewardToken: string;
+    rewardTokenSymbol: string;
+    startTimestamp: number;
+}
+export type MerkleXYZRewardsCampaignsResponse = Array<Campaign>;
+export declare class MerkleXYZApi {
+    static domain: string;
+    static getUserRewardsUrl: (options: UserOptions) => string;
+    static getRewardsCampaignsUrl: (options: CampaignsOptions) => string;
+}
+export {};

package/lib/gearboxRewards/merklAPI.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleXYZApi = void 0;
+const endpoint_1 = require("../core/endpoint");
+// https://api.merkl.xyz/v3/campaignsForMainParameter?chainId=1&mainParameter=0xE2037090f896A858E3168B978668F22026AC52e7
+class MerkleXYZApi {
+    static domain = "https://api.merkl.xyz/v3";
+    static getUserRewardsUrl = (options) => endpoint_1.URLApi.getRelativeUrl([this.domain, "userRewards"].join("/"), options);
+    static getRewardsCampaignsUrl = (options) => endpoint_1.URLApi.getRelativeUrl([this.domain, "campaignsForMainParameter"].join("/"), options);
+}
+exports.MerkleXYZApi = MerkleXYZApi;

package/lib/index.d.ts

@@ -1,27 +1,34 @@
 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";
+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";
@@ -29,8 +36,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,31 +14,37 @@ 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);
+__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);
@@ -46,9 +52,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;
+}

package/lib/parsers/compoundV2CTokenAdapterParser.js

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

package/lib/parsers/convexBaseRewardPoolAdapterParser.d.ts

@@ -1,9 +1,10 @@
 import { SupportedContract } 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 ConvexBaseRewardPoolAdapterParser extends AbstractParser implements IParser {
     constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
     formatAmount(amount: BigNumberish): string;
 }

package/lib/parsers/convexBaseRewardPoolAdapterParser.js

@@ -7,35 +7,39 @@ const abstractParser_1 = require("./abstractParser");
 class ConvexBaseRewardPoolAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface();
+        this.abi = types_1.iConvexV1BaseRewardPoolAdapterAbi;
         if (!isContract)
             this.adapterName = "ConvexV1BaseRewardPoolAdapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
-            case "stake":
-            case "stakeAll": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
-                const amountStr = amount ? `amount: ${this.formatAmount(amount)}` : "";
-                return `${functionName}(${amountStr})`;
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "stake": {
+                const [amount] = functionData.args || [];
+                return `${operationName}(amount: ${this.formatAmount(amount)})`;
+            }
+            case "stakeDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${operationName}(leftoverAmount: ${this.formatAmount(leftoverAmount)})`;
             }
             case "withdraw":
             case "withdrawAndUnwrap": {
-                const [amount, claim] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(amount: ${this.formatAmount(amount)}, claim: ${claim})`;
+                const [amount, claim] = functionData.args || [];
+                return `${operationName}(amount: ${this.formatAmount(amount)}, claim: ${claim})`;
             }
-            case "withdrawAll":
-            case "withdrawAllAndUnwrap": {
-                const [claim] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(claim: ${claim})`;
+            case "withdrawDiff":
+            case "withdrawDiffAndUnwrap": {
+                const [leftoverAmount, claim] = functionData.args || [];
+                return `${operationName}(leftoverAmount: ${this.formatAmount(leftoverAmount)}, claim: ${claim})`;
             }
             case "rewardRate":
-                return `${functionName}()`;
+                return `${operationName}()`;
             case "totalSupply":
-                return `${functionName}()`;
+                return `${operationName}()`;
+            case "getReward":
+                return `${operationName}()`;
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
         }
     }
     formatAmount(amount) {

package/lib/parsers/convexBoosterAdapterParser.d.ts

@@ -1,10 +1,10 @@
-import { SupportedContract } from "@gearbox-protocol/sdk-gov";
-import { BigNumberish } from "ethers";
+import { Address, SupportedContract } from "@gearbox-protocol/sdk-gov";
+import { BigNumberish } from "../utils/formatter";
 import { AbstractParser } from "./abstractParser";
 import { IParser } from "./iParser";
 export declare class ConvexBoosterAdapterParser extends AbstractParser implements IParser {
     constructor(contract: SupportedContract, isContract: boolean);
-    parse(calldata: string): string;
+    parse(calldata: Address): string;
     formatAmount(amount: BigNumberish, pid: number): string;
     formatPid(pid: number): string;
 }

package/lib/parsers/convexBoosterAdapterParser.js

@@ -7,31 +7,31 @@ const abstractParser_1 = require("./abstractParser");
 class ConvexBoosterAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IConvexV1BoosterAdapter__factory.createInterface();
+        this.abi = types_1.iConvexV1BoosterAdapterAbi;
         if (!isContract)
             this.adapterName = "ConvexV1BoosterAdapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "deposit": {
-                const [pid, amount, stake] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(pid: ${this.formatPid(pid)}, amount: ${this.formatAmount(amount, pid)}, stake: ${stake})`;
+                const [pid, amount, stake] = functionData.args || [];
+                return `${operationName}(pid: ${this.formatPid(pid)}, amount: ${this.formatAmount(amount, pid)}, stake: ${stake})`;
             }
-            case "depositAll": {
-                const [pid, stake] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(pid: ${this.formatPid(pid)}, stake: ${stake})`;
+            case "depositDiff": {
+                const [pid, leftoverAmount, stake] = functionData.args || [];
+                return `${operationName}(pid: ${this.formatPid(pid)}, leftoverAmount: ${this.formatAmount(leftoverAmount, pid)}, stake: ${stake})`;
             }
             case "withdraw": {
-                const [pid, amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(pid: ${this.formatPid(pid)}, amount: ${this.formatAmount(amount, pid)})`;
+                const [pid, amount] = functionData.args || [];
+                return `${operationName}(pid: ${this.formatPid(pid)}, amount: ${this.formatAmount(amount, pid)})`;
             }
-            case "withdrawAll": {
-                const [pid] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(pid: ${this.formatPid(pid)})`;
+            case "withdrawDiff": {
+                const [pid, leftoverAmount] = functionData.args || [];
+                return `${operationName}(pid: ${this.formatPid(pid)}, leftoverAmount: ${this.formatAmount(leftoverAmount, pid)})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
         }
     }
     formatAmount(amount, pid) {

package/lib/parsers/convextRewardPoolParser.d.ts

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

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 { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "rewardRate":
-                return `${functionName}()`;
+                return `${operationName}()`;
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
         }
     }
 }