@gearbox-protocol/sdk 2.1.37 → 3.0.0-draft.1

package/lib/parsers/iParser.d.ts

@@ -1,9 +1,6 @@
-import { FunctionFragment } from "ethers/lib/utils";
+import { Address } from "viem";
+import { ParsedObject } from "./abstractParser";
 export interface IParser {
-    parse: (calldata: string) => string;
-    parseToObject?: (address: string, calldata: string) => {
-        address: string;
-        functionFragment: FunctionFragment;
-        args: any;
-    };
+    parse: (calldata: Address) => string;
+    parseToObject?: (address: Address, calldata: Address) => ParsedObject;
 }

package/lib/parsers/lidoAdapterParser.d.ts

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

package/lib/parsers/lidoAdapterParser.js

@@ -6,22 +6,23 @@ const abstractParser_1 = require("./abstractParser");
 class LidoAdapterParser extends abstractParser_1.AbstractParser {
     constructor(contract, isContract) {
         super(contract);
-        this.ifc = types_1.ILidoV1Adapter__factory.createInterface();
+        this.abi = types_1.iLidoV1AdapterAbi;
         if (!isContract)
             this.adapterName = "LidoV1Adapter";
     }
     parse(calldata) {
-        const { functionFragment, functionName } = this.parseSelector(calldata);
-        switch (functionFragment.name) {
+        const { operationName, functionData } = this.parseSelector(calldata);
+        switch (functionData.functionName) {
             case "submit": {
-                const [amount] = this.decodeFunctionData(functionFragment, calldata);
-                return `${functionName}(amount: ${this.formatBN(amount, "STETH")})`;
+                const [amount] = functionData.args || [];
+                return `${operationName}(amount: ${this.formatBN(amount, "STETH")})`;
             }
-            case "submitAll": {
-                return `${functionName}()`;
+            case "submitDiff": {
+                const [leftoverAmount] = functionData.args || [];
+                return `${operationName}(leftoverAmount: ${this.formatBN(leftoverAmount, "STETH")})`;
             }
             default:
-                return `${functionName}: Unknown operation ${functionFragment.name} with calldata ${calldata}`;
+                return this.reportUnknownFragment(this.adapterName || this.contract, operationName, calldata);
         }
     }
 }

package/lib/parsers/lidoSTETHParser.d.ts

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

package/lib/parsers/lidoSTETHParser.js

@@ -1,35 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LidoSTETHParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 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, formatter_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.IPriceOracleV2__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,46 +1,37 @@
-import { SupportedContract } from "../contracts/contracts";
-import { NetworkType } from "../core/chains";
-import { SupportedToken } from "../tokens/token";
-import { MultiCallStruct } from "../types/@gearbox-protocol/router/contracts/interfaces/IClosePathResolver";
+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("@ethersproject/abi").FunctionFragment;
-        args: any;
-    };
-    static getParseData(address: string): ParseData;
-    static parseMultiCall(calls: Array<MultiCallStruct>): Array<string>;
-    static parseToObjectMultiCall(calls: Array<MultiCallStruct>): {
-        address: string;
-        functionFragment: import("@ethersproject/abi").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): void;
+    static addCreditFacade(creditFacade: Address, underlying: SupportedToken, version: number): void;
     static addTokens(network: NetworkType): void;
-    static addOffchainOracleParser(address: string): void;
-    static addPriceOracle(address: string): void;
-    static addDataCompressor(address: string): void;
-    static addAddressProvider(address: string): void;
-    static addMulticall(address: string): void;
-    static addAirdropDistributor(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

@@ -1,27 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxParser = void 0;
-const adapters_1 = require("../contracts/adapters");
-const contracts_1 = require("../contracts/contracts");
-const token_1 = require("../tokens/token");
-const mappers_1 = require("../utils/mappers");
-const addressProviderParser_1 = require("./addressProviderParser");
-const airdropDistributorParser_1 = require("./airdropDistributorParser");
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+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");
 const creditFacadeParser_1 = require("./creditFacadeParser");
 const creditManagerParser_1 = require("./creditManagerParser");
 const curveAdapterParser_1 = require("./curveAdapterParser");
-const dataCompressorParser_1 = require("./dataCompressorParser");
 const ERC20Parser_1 = require("./ERC20Parser");
+const erc626AdapterParser_1 = require("./erc626AdapterParser");
 const lidoAdapterParser_1 = require("./lidoAdapterParser");
-const lidoOracleParser_1 = require("./lidoOracleParser");
 const lidoSTETHParser_1 = require("./lidoSTETHParser");
-const multicallParser_1 = require("./multicallParser");
-const offchainOracleParser_1 = require("./offchainOracleParser");
-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");
@@ -29,28 +25,44 @@ 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) {
-            const contract = contracts_1.contractsByAddress[a.contract.toLowerCase()];
-            if (contract && contracts_1.contractParams[contract]) {
-                TxParser.chooseContractParser(a.adapter, contract, contracts_1.contractParams[contract].type, false);
+            const contract = sdk_gov_1.contractsByAddress[a.contract.toLowerCase()];
+            if (contract && sdk_gov_1.contractParams[contract]) {
+                TxParser.chooseContractParser(a.adapter, contract, sdk_gov_1.contractParams[contract].type, false);
             }
             else {
                 console.error(`Unknown address: ${contract} at ${a.contract}`);
@@ -58,33 +70,29 @@ class TxParser {
         }
     }
     static addContracts(network) {
-        mappers_1.TypedObjectUtils.entries(contracts_1.contractParams).forEach(([contract, contractData]) => {
-            const address = contracts_1.contractsByNetwork[network][contract];
+        sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.contractParams).forEach(([contract, contractData]) => {
+            const address = sdk_gov_1.contractsByNetwork[network][contract];
             TxParser.chooseContractParser(address, contract, contractData.type, true);
-            if (contractData.type === adapters_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL) {
+            if (contractData.type === sdk_gov_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL) {
                 contractData.extraRewards.forEach(r => {
                     const extraAddress = r.poolAddress[network];
                     TxParser._addParser(extraAddress, new convextRewardPoolParser_1.ConvexRewardPoolParser(r.rewardToken));
                 });
             }
-            if (contractData.type === adapters_1.AdapterInterface.LIDO_V1) {
-                const extraAddress = contractData.oracle[network];
-                TxParser._addParser(extraAddress, new lidoOracleParser_1.LidoOracleParser());
-            }
         });
     }
-    static addCreditFacade(creditFacade, underlying) {
-        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying));
+    static addCreditFacade(creditFacade, underlying, version) {
+        TxParser._addParser(creditFacade, new creditFacadeParser_1.CreditFacadeParser(underlying, version));
     }
     static addTokens(network) {
-        mappers_1.TypedObjectUtils.entries(token_1.tokenDataByNetwork[network]).forEach(([s, t]) => {
+        sdk_gov_1.TypedObjectUtils.entries(sdk_gov_1.tokenDataByNetwork[network]).forEach(([s, t]) => {
             if (s === "STETH") {
                 TxParser._addParser(t, new lidoSTETHParser_1.LidoSTETHParser(s));
             }
             else {
-                const contract = contracts_1.contractsByAddress[t.toLowerCase()];
+                const contract = sdk_gov_1.contractsByAddress[t.toLowerCase()];
                 if (contract) {
-                    TxParser.chooseContractParser(t, contract, contracts_1.contractParams[contract].type, true);
+                    TxParser.chooseContractParser(t, contract, sdk_gov_1.contractParams[contract].type, true);
                 }
                 else {
                     TxParser._addParser(t, new ERC20Parser_1.ERC20Parser(s));
@@ -92,30 +100,12 @@ class TxParser {
             }
         });
     }
-    static addOffchainOracleParser(address) {
-        TxParser._addParser(address, new offchainOracleParser_1.OffchainOracleParserParser());
-    }
     static addPriceOracle(address) {
         TxParser._addParser(address, new priceOracleParser_1.PriceOracleParser());
     }
-    static addDataCompressor(address) {
-        TxParser._addParser(address, new dataCompressorParser_1.DataCompressorParser());
-    }
-    static addAddressProvider(address) {
-        TxParser._addParser(address, new addressProviderParser_1.AddressProviderParser());
-    }
-    static addMulticall(address) {
-        TxParser._addParser(address, new multicallParser_1.MulticallParser());
-    }
-    static addAirdropDistributor(address) {
-        TxParser._addParser(address, new airdropDistributorParser_1.AirdropDistributorParser());
-    }
     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)
@@ -124,7 +114,7 @@ class TxParser {
     }
     static chooseContractParser(address, contract, adapterType, isContract) {
         const addressLC = address.toLowerCase();
-        switch (adapters_1.AdapterInterface[adapterType]) {
+        switch (sdk_gov_1.AdapterInterface[adapterType]) {
             case "UNISWAP_V2_ROUTER":
                 TxParser._addParser(addressLC, new uniV2AdapterParser_1.UniswapV2AdapterParser(contract, isContract));
                 break;
@@ -142,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;
@@ -156,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 "../contracts/contracts";
+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

@@ -1,24 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniswapV2AdapterParser = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
 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, formatter_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);
         }
     }
 }