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

package/lib/parsers/lidoSTETHParser.js

@@ -7,29 +7,29 @@ const abstractParser_1 = require("./abstractParser");
 class LidoSTETHParser extends abstractParser_1.AbstractParser {
     constructor(symbol) {
         super(`LIDO_${symbol}`);
-        this.ifc = types_1.IstETH__factory.createInterface();
+        this.abi = types_1.istEthAbi;
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "getFee":
             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/priceOracleParser.d.ts

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

package/lib/parsers/priceOracleParser.js

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

package/lib/parsers/stakingRewardsAdapterParser.d.ts

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

package/lib/parsers/stakingRewardsAdapterParser.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingRewardsAdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const types_1 = require("../types");
+const abstractParser_1 = require("./abstractParser");
+class StakingRewardsAdapterParser extends abstractParser_1.AbstractParser {
+    constructor(contract, isContract) {
+        super(contract);
+        this.abi = types_1.iStakingRewardsAdapterAbi;
+        if (!isContract)
+            this.adapterName = "StakingRewardsAdapter";
+    }
+    parse(calldata) {
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
+            case "withdraw": {
+                const [amount] = functionData.args || [];
+                return `${operationName}(amount: ${this.formatAmount(amount)}`;
+            }
+            case "withdrawDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${operationName}(leftoverAmount: ${this.formatAmount(leftoverAmount)}`;
+            }
+            case "getReward":
+                return `${operationName}()`;
+            default:
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
+        }
+    }
+    formatAmount(amount) {
+        return this.formatBN(amount, sdk_gov_1.contractParams[this.contract].stakedToken);
+    }
+}
+exports.StakingRewardsAdapterParser = StakingRewardsAdapterParser;

package/lib/parsers/txParser.d.ts

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

package/lib/parsers/txParser.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxParser = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const addressProviderParser_1 = require("./addressProviderParser");
+const aaveV2LendingPoolAdapterParser_1 = require("./aaveV2LendingPoolAdapterParser");
+const aaveV2WrappedATokenAdapterParser_1 = require("./aaveV2WrappedATokenAdapterParser");
+const balancerV2VaultParser_1 = require("./balancerV2VaultParser");
+const compoundV2CTokenAdapterParser_1 = require("./compoundV2CTokenAdapterParser");
 const convexBaseRewardPoolAdapterParser_1 = require("./convexBaseRewardPoolAdapterParser");
 const convexBoosterAdapterParser_1 = require("./convexBoosterAdapterParser");
 const convextRewardPoolParser_1 = require("./convextRewardPoolParser");
@@ -10,10 +13,11 @@ const creditFacadeParser_1 = require("./creditFacadeParser");
 const creditManagerParser_1 = require("./creditManagerParser");
 const curveAdapterParser_1 = require("./curveAdapterParser");
 const ERC20Parser_1 = require("./ERC20Parser");
+const erc626AdapterParser_1 = require("./erc626AdapterParser");
 const lidoAdapterParser_1 = require("./lidoAdapterParser");
 const lidoSTETHParser_1 = require("./lidoSTETHParser");
-const poolParser_1 = require("./poolParser");
 const priceOracleParser_1 = require("./priceOracleParser");
+const stakingRewardsAdapterParser_1 = require("./stakingRewardsAdapterParser");
 const uniV2AdapterParser_1 = require("./uniV2AdapterParser");
 const uniV3AdapterParser_1 = require("./uniV3AdapterParser");
 const wstETHAdapterParser_1 = require("./wstETHAdapterParser");
@@ -21,22 +25,38 @@ const yearnV2AdapterParser_1 = require("./yearnV2AdapterParser");
 class TxParser {
     static parsers = {};
     static parse(address, calldata) {
-        const parser = TxParser.getParser(address);
-        return parser.parse(calldata);
+        let parser;
+        try {
+            parser = TxParser.getParser(address);
+            const callStr = parser.parse(calldata);
+            return callStr;
+        }
+        catch (e) {
+            console.error(`Error while parsing ${address}`, parser, e);
+            return null;
+        }
     }
     static parseToObject(address, calldata) {
-        const parser = TxParser.getParser(address);
-        return parser.parseToObject(address, calldata);
+        let parser;
+        try {
+            parser = TxParser.getParser(address);
+            const callObject = parser.parseToObject(address, calldata);
+            return { callObject, parser };
+        }
+        catch (e) {
+            console.error(`Error while parsing ${address}`, parser, e);
+            return null;
+        }
     }
     static getParseData(address) {
         const parser = TxParser.getParser(address);
         return { contract: parser.contract, adapterName: parser.adapterName };
     }
     static parseMultiCall(calls) {
-        return calls.map(call => TxParser.parse(call.target, call.callData.toString()));
+        return calls.map(call => TxParser.parse(call.target, call.callData));
     }
     static parseToObjectMultiCall(calls) {
-        return calls.map(call => TxParser.parseToObject(call.target, call.callData.toString()));
+        return calls.map(call => TxParser.parseToObject(call.target, call.callData));
     }
     static addAdapters(adapters) {
         for (let a of adapters) {
@@ -83,15 +103,9 @@ class TxParser {
     static addPriceOracle(address) {
         TxParser._addParser(address, new priceOracleParser_1.PriceOracleParser());
     }
-    static addAddressProvider(address) {
-        TxParser._addParser(address, new addressProviderParser_1.AddressProviderParser());
-    }
     static addCreditManager(address, version) {
         TxParser._addParser(address, new creditManagerParser_1.CreditManagerParser(version));
     }
-    static addPool(address, version) {
-        TxParser._addParser(address, new poolParser_1.PoolParser(version));
-    }
     static getParser(address) {
         const parser = TxParser.parsers[address.toLowerCase()];
         if (!parser)
@@ -118,6 +132,9 @@ class TxParser {
             case "YEARN_V2":
                 TxParser._addParser(addressLC, new yearnV2AdapterParser_1.YearnV2AdapterParser(contract, isContract));
                 break;
+            case "STAKING_REWARDS":
+                TxParser._addParser(addressLC, new stakingRewardsAdapterParser_1.StakingRewardsAdapterParser(contract, isContract));
+                break;
             case "CONVEX_V1_BASE_REWARD_POOL":
                 TxParser._addParser(addressLC, new convexBaseRewardPoolAdapterParser_1.ConvexBaseRewardPoolAdapterParser(contract, isContract));
                 break;
@@ -132,6 +149,22 @@ class TxParser {
             case "LIDO_WSTETH_V1":
                 TxParser._addParser(addressLC, new wstETHAdapterParser_1.WstETHAdapterParser(contract, isContract));
                 break;
+            case "AAVE_V2_LENDING_POOL":
+                TxParser._addParser(addressLC, new aaveV2LendingPoolAdapterParser_1.AaveV2LendingPoolAdapterParser(contract, isContract));
+                break;
+            case "AAVE_V2_WRAPPED_ATOKEN":
+                TxParser._addParser(addressLC, new aaveV2WrappedATokenAdapterParser_1.AaveV2WrappedATokenAdapterParser(contract, isContract));
+                break;
+            case "BALANCER_VAULT":
+                TxParser._addParser(addressLC, new balancerV2VaultParser_1.BalancerV2VaultParser(contract, isContract));
+                break;
+            case "COMPOUND_V2_CERC20":
+            case "COMPOUND_V2_CETHER":
+                TxParser._addParser(addressLC, new compoundV2CTokenAdapterParser_1.CompoundV2CTokenAdapterParser(contract, isContract));
+                break;
+            case "ERC4626_VAULT":
+                TxParser._addParser(addressLC, new erc626AdapterParser_1.ERC4626AdapterParser(contract, isContract));
+                break;
         }
     }
     static _addParser(address, parser) {

package/lib/parsers/uniV2AdapterParser.d.ts

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

package/lib/parsers/uniV2AdapterParser.js

@@ -7,18 +7,15 @@ const abstractParser_1 = require("./abstractParser");
 class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IUniswapV2Adapter__factory.createInterface();
+        this.abi = types_1.iUniswapV2AdapterAbi;
         if (!isContract)
             this.adapterName = "UniswapV2Adapter";
     }
     parse(calldata) {
-        return this._parse(calldata);
-    }
-    _parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "swapExactTokensForTokens": {
-                const [amountIn, amountOutMin, path] = this.decodeFunctionData(functionFragment, calldata);
+                const [amountIn, amountOutMin, path] = functionData.args || [];
                 const pathStr = path
                     .map(r => this.tokenSymbol(r))
                     .join(" => ");
@@ -26,10 +23,10 @@ class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
                 const tokenOut = this.tokenSymbol(path[path.length - 1]);
                 const amountInStr = this.formatBN(amountIn, tokenIn);
                 const amountOutStr = this.formatBN(amountOutMin, tokenOut);
-                return `${functionName}(amountIn: ${amountInStr}, amountOutMin: ${amountOutStr}, path: [${pathStr}])`;
+                return `${operationName}(amountIn: ${amountInStr}, amountOutMin: ${amountOutStr}, path: [${pathStr}])`;
             }
             case "swapTokensForExactTokens": {
-                const [amountOut, amountInMax, path] = this.decodeFunctionData(functionFragment, calldata);
+                const [amountOut, amountInMax, path] = functionData.args || [];
                 const pathStr = path
                     .map(r => this.tokenSymbol(r))
                     .join(" => ");
@@ -37,16 +34,17 @@ class UniswapV2AdapterParser extends abstractParser_1.AbstractParser {
                 const tokenOut = this.tokenSymbol(path[path.length - 1]);
                 const amountOutStr = this.formatBN(amountOut, tokenIn);
                 const amountInMaxStr = this.formatBN(amountInMax, tokenOut);
-                return `${functionName}(amountOut: ${amountOutStr}, amountInMax: ${amountInMaxStr}, path: [${pathStr}])`;
+                return `${operationName}(amountOut: ${amountOutStr}, amountInMax: ${amountInMaxStr}, path: [${pathStr}])`;
             }
-            case "swapAllTokensForTokens": {
-                const [rateMinRAY, path] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}, path: [${path
+            case "swapDiffTokensForTokens": {
+                const [leftoverAmount, rateMinRAY, path] = functionData.args || [];
+                const tokenIn = this.tokenSymbol(path[0]);
+                return `${operationName}(leftoverAmount: ${this.formatBN(leftoverAmount, tokenIn)}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)}, path: [${path
                     .map(r => this.tokenSymbol(r))
                     .join(" => ")}])`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
         }
     }
 }

package/lib/parsers/uniV2AdapterParser.spec.js

@@ -2,45 +2,58 @@
 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 uniV2AdapterParser_1 = require("./uniV2AdapterParser");
 describe("UniswapV2AdapterParser test", () => {
     it("swap functions works well", () => {
         let parser = new uniV2AdapterParser_1.UniswapV2AdapterParser("UNISWAP_V2_ROUTER", false);
-        const ifc = types_1.IUniswapV2Adapter__factory.createInterface();
-        let parsed = parser.parse(ifc.encodeFunctionData("swapExactTokensForTokens", [
-            sdk_gov_1.WAD * 180000n,
-            BigInt(1e6) * 45n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.WETH,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+        let parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV2AdapterAbi,
+            functionName: "swapExactTokensForTokens",
+            args: [
+                sdk_gov_1.WAD * 180000n,
+                BigInt(1e6) * 45n,
+                [
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.WETH,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                ],
+                sdk_gov_1.DUMB_ADDRESS,
+                45000n,
             ],
-            sdk_gov_1.DUMB_ADDRESS,
-            45000,
-        ]));
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapExactTokensForTokens(amountIn: 180.00K [180000000000000000000000], amountOutMin: 45.00 [45000000], path: [DAI => WETH => USDC])", "Incorrect parse swapExactTokensForTokens");
-        parsed = parser.parse(ifc.encodeFunctionData("swapTokensForExactTokens", [
-            BigInt(1e6) * 234500n,
-            sdk_gov_1.WAD * 17700n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV2AdapterAbi,
+            functionName: "swapTokensForExactTokens",
+            args: [
+                BigInt(1e6) * 234500n,
+                sdk_gov_1.WAD * 17700n,
+                [
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
+                ],
+                sdk_gov_1.DUMB_ADDRESS,
+                45033n,
             ],
-            sdk_gov_1.DUMB_ADDRESS,
-            45033,
-        ]));
+        }));
         (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapTokensForExactTokens(amountOut: 234.50K [234500000000], amountInMax: 17.70K [17700000000000000000000], path: [USDC => DAI => FRAX])", "Incorrect parse swapTokensForExactTokens");
-        parsed = parser.parse(ifc.encodeFunctionData("swapAllTokensForTokens", [
-            sdk_gov_1.RAY * 3240n,
-            [
-                sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
-                sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
+        parsed = parser.parse((0, viem_1.encodeFunctionData)({
+            abi: types_1.iUniswapV2AdapterAbi,
+            functionName: "swapDiffTokensForTokens",
+            args: [
+                BigInt(1e6) * 234500n,
+                sdk_gov_1.RAY * 3240n,
+                [
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.USDC,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.DAI,
+                    sdk_gov_1.tokenDataByNetwork.Mainnet.FRAX,
+                ],
+                45033n,
             ],
-            45033,
-        ]));
-        (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapAllTokensForTokens(rate: 3.24K, path: [USDC => DAI => FRAX])", "Incorrect parse swapAllTokensForTokens");
+        }));
+        (0, chai_1.expect)(parsed).to.be.eq("UniswapV2Adapter[UNISWAP_V2_ROUTER].swapDiffTokensForTokens(leftoverAmount: 234.50K [234500000000], rate: 3.24K, path: [USDC => DAI => FRAX])", "Incorrect parse swapDiffTokensForTokens");
     });
 });

package/lib/parsers/uniV3AdapterParser.d.ts

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

package/lib/parsers/uniV3AdapterParser.js

@@ -7,56 +7,64 @@ const abstractParser_1 = require("./abstractParser");
 class UniswapV3AdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.IUniswapV3Adapter__factory.createInterface();
+        this.abi = types_1.iUniswapV3AdapterAbi;
         if (!isContract)
             this.adapterName = "UniswapV3Adapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "exactInputSingle": {
-                const [[tokenIn, tokenOut, fee, , , amountIn, amountOutMinimum]] = this.decodeFunctionData(functionFragment, calldata);
+                const [{ tokenIn, tokenOut, fee, amountIn, amountOutMinimum }] = functionData.args || [{}];
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
                 const amountInStr = this.formatBN(amountIn, tokenIn);
                 const amountOutMinimumStr = this.formatBN(amountOutMinimum, tokenOut);
-                return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
+                return `${operationName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
-            case "exactAllInputSingle": {
-                const { params: { tokenIn, tokenOut, fee, rateMinRAY }, } = this.decodeFunctionData(functionFragment, calldata);
+            case "exactDiffInputSingle": {
+                const [{ tokenIn, tokenOut, fee, leftoverAmount, rateMinRAY }] = functionData.args || [{}];
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
-                return `${functionName}(rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
+                const leftoverAmountStr = this.formatBN(leftoverAmount, tokenIn);
+                return `${operationName}(leftoverAmount: ${leftoverAmountStr}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             case "exactInput": {
-                const { params: { amountIn, amountOutMinimum, path }, } = this.decodeFunctionData(functionFragment, calldata);
+                const [{ path, amountIn, amountOutMinimum }] = functionData.args || [
+                    {},
+                ];
                 const pathStr = this.trackInputPath(path);
                 const amountInStr = this.formatBN(amountIn, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
                 const amountOutMinimumStr = this.formatBN(amountOutMinimum, this.tokenSymbol(`0x${path.slice(-40, path.length)}`));
-                return `${functionName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${pathStr}`;
+                return `${operationName}(amountIn: ${amountInStr}, amountOutMinimum: ${amountOutMinimumStr},  path: ${pathStr}`;
             }
-            case "exactAllInput": {
-                const { params: { rateMinRAY, path }, } = this.decodeFunctionData(functionFragment, calldata);
+            case "exactDiffInput": {
+                const [{ path, leftoverAmount, rateMinRAY }] = functionData.args || [
+                    {},
+                ];
+                const leftoverAmountStr = this.formatBN(leftoverAmount, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
                 const pathStr = this.trackInputPath(path);
-                return `${functionName}(rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
+                return `${operationName}(leftoverAmount: ${leftoverAmountStr}, rate: ${(0, sdk_gov_1.formatBN)(rateMinRAY, 27)},  path: ${pathStr}`;
             }
             case "exactOutput": {
-                const { params: { amountInMaximum, amountOut, path }, } = this.decodeFunctionData(functionFragment, calldata);
+                const [{ path, amountOut, amountInMaximum }] = functionData.args || [
+                    {},
+                ];
                 const pathStr = this.trackOutputPath(path);
                 const amountInMaximumStr = this.formatBN(amountInMaximum, this.tokenSymbol(`0x${path.slice(-40, path.length)}`));
                 const amountOutStr = this.formatBN(amountOut, this.tokenSymbol(`0x${path.replace("0x", "").slice(0, 40)}`));
-                return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${pathStr}`;
+                return `${operationName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${pathStr}`;
             }
             case "exactOutputSingle": {
-                const [[tokenIn, tokenOut, fee, , , amountOut, amountInMaximum]] = this.decodeFunctionData(functionFragment, calldata);
+                const [{ tokenIn, tokenOut, fee, amountOut, amountInMaximum }] = functionData.args || [{}];
                 const tokenInSym = this.tokenSymbol(tokenIn);
                 const tokenOutSym = this.tokenSymbol(tokenOut);
                 const amountInMaximumStr = this.formatBN(amountInMaximum, tokenInSym);
                 const amountOutStr = this.formatBN(amountOut, tokenOutSym);
-                return `${functionName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
+                return `${operationName}(amountInMaximum: ${amountInMaximumStr}, amountOut: ${amountOutStr},  path: ${tokenInSym} ==(fee: ${fee})==> ${tokenOutSym})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
         }
     }
     trackInputPath(path) {