@gearbox-protocol/sdk 14.11.0-next.9 → 14.11.0

package/dist/cjs/plugins/adapters/contracts/AbstractAdapter.js

@@ -22,7 +22,6 @@ __export(AbstractAdapter_exports, {
 });
 module.exports = __toCommonJS(AbstractAdapter_exports);
 var import_viem = require("viem");
-var import_trace = require("../../../common-utils/utils/trace.js");
 var import_sdk = require("../../../sdk/index.js");
 var import_transferHelpers = require("../transferHelpers.js");
 class AbstractAdapterContract extends import_sdk.BaseContract {
@@ -65,33 +64,45 @@ class AbstractAdapterContract extends import_sdk.BaseContract {
     };
   }
   /**
-   * Decodes the protocol-level call (target contract + function name + args)
-   * performed by this adapter, recovered from its adapter-level call trace.
+   * Builds an {@link AdapterOperation} from a parsed call and ordered transfer entries.
    *
-   * Both the `targetContract` and the protocol calldata are taken from the
-   * execution trace.
+   * Returns `PartialBy<AdapterOperation, "targetContract">` because the adapter
+   * may not have `targetContract` (adapters created without SDK do not have serializedParams)
    *
-   * Returns `undefined` (in non-strict mode) when no external protocol call can
-   * be recovered, in strict mode throws instead.
-   *
-   * @param trace Adapter-level call trace (a direct child of the facade trace)
-   * @param strict When true, throws instead of returning `undefined`
+   * @param protocolCalldata Raw calldata of the actual CALL to targetContract, extracted from trace
+   * @param strict When true, throws if protocol ABI is missing or decode fails
    */
-  parseProtocolCall(trace, strict) {
-    const resolved = (0, import_trace.resolveProtocolCall)(trace);
-    if (!resolved) {
-      if (strict) {
-        throw new Error("no external protocol call found in adapter trace");
-      }
-      return void 0;
-    }
-    const { contract, calldata } = resolved;
+  parseAdapterOperation(parsed, transfers, creditAccount, protocolCalldata, strict) {
+    const netTransfers = (0, import_transferHelpers.toNetTransfers)(transfers, creditAccount);
+    const protocol = this.parseProtocolCall(protocolCalldata, strict);
+    return {
+      operation: "Execute",
+      adapter: this.address,
+      protocol: this.#targetContract,
+      adapterType: this.adapterType,
+      version: this.version,
+      label: parsed.label,
+      adapterFunctionName: parsed.functionName,
+      adapterArgs: parsed.rawArgs,
+      ...protocol,
+      transfers,
+      legacy: this.classifyLegacyOperation(parsed, netTransfers)
+    };
+  }
+  /**
+   * Decodes protocol-level function name and args from the raw calldata
+   * sent to targetContract.
+   */
+  parseProtocolCall(calldata, strict) {
     const selector = calldata.slice(0, 10);
     if (this.protocolAbi.length === 0) {
       if (strict) {
         throw new Error(`Protocol ABI is missing for selector ${selector}`);
       }
-      return void 0;
+      return {
+        protocolFunctionName: `unknown function ${selector}`,
+        protocolArgs: {}
+      };
     }
     try {
       const decoded = (0, import_viem.decodeFunctionData)({
@@ -99,12 +110,12 @@ class AbstractAdapterContract extends import_sdk.BaseContract {
         data: calldata
       });
       const functionName = (0, import_sdk.getFunctionSignature)(this.protocolAbi, calldata);
-      const functionArgs = (0, import_sdk.functionArgsToRecord)(
+      const protocolArgs = (0, import_sdk.functionArgsToRecord)(
         this.protocolAbi,
         decoded.functionName,
         decoded.args
       );
-      return { contract, functionName, functionArgs };
+      return { protocolFunctionName: functionName, protocolArgs };
     } catch (e) {
       if (strict) {
         throw new Error(
@@ -112,7 +123,10 @@ class AbstractAdapterContract extends import_sdk.BaseContract {
           { cause: e }
         );
       }
-      return void 0;
+      return {
+        protocolFunctionName: `unknown function ${selector}`,
+        protocolArgs: {}
+      };
     }
   }
   /**
@@ -126,8 +140,6 @@ class AbstractAdapterContract extends import_sdk.BaseContract {
    * Override in protocol-specific subclasses for richer classification.
    *
    * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/account_operation.go#L238-L264
-   *
-   * @deprecated Eventually will be gone, exists to produce output that legacy UI can display
    */
   classifyLegacyOperation(_parsed, transfers) {
     const swap = (0, import_transferHelpers.swapFromTransfers)(transfers);

package/dist/cjs/plugins/adapters/contracts/AccountMigratorAdapterContract.js

@@ -35,15 +35,6 @@ class AccountMigratorAdapterContract extends import_AbstractAdapter.AbstractAdap
       `classifyLegacyOperation is not supported for legacy adapter: ${this.contractType}`
     );
   }
-  /**
-   * The account-migrator adapter's `execute` targets the migrator bot, not an
-   * external protocol, so there is no protocol-level call to recover. Returning
-   * `undefined` keeps the `protocol` field aligned with its external-protocol
-   * semantics (see {@link TraceAdapterExt}).
-   */
-  parseProtocolCall(_trace, _strict) {
-    return void 0;
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/esm/common-utils/utils/index.js

@@ -5,5 +5,4 @@ export * from "./constants.js";
 export * from "./creditAccount/index.js";
 export * from "./price-math.js";
 export * from "./strategies/index.js";
-export * from "./trace.js";
 export * from "./validation/index.js";

package/dist/esm/dev/index.js

@@ -22,7 +22,6 @@ export * from "./replaceStorage.js";
 export * from "./resilientTransport.js";
 export * from "./transports.js";
 export * from "./types.js";
-export * from "./verifyTestnet.js";
 export {
   isRangeError,
   logSplitterTransport

package/dist/esm/dev/isOutOfSyncError.js

@@ -15,7 +15,9 @@ const OUT_OF_SYNC_PATTERNS = [
   // Optimism proxyd (code -32019) for future/non-existent blocks
   /block is out of range/i,
   // EIP-1474 standard (code -32001) when block/state is not available
-  /resource not found/i
+  /resource not found/i,
+  // DRPC when a requested block is ahead of the node's latest block
+  /greater than latest block/i
 ];
 function isOutOfSyncError(e) {
   if (e instanceof BaseError) {

package/dist/esm/history/assembleOperations.js

@@ -1,12 +1,10 @@
 import { AbstractAdapterContract } from "../plugins/adapters/index.js";
-import {
-  extractAdapterCallTraces
-} from "../preview/trace/index.js";
 import { classifyMulticallOperations } from "./classifyMulticallOperations.js";
+import { extractProtocolCalls } from "./extractProtocolCalls.js";
 function assembleOperations(input) {
   const {
     facadeCalls,
-    executeTransfers,
+    executeResults,
     register,
     underlying,
     liquidationRemainingFunds,
@@ -21,7 +19,7 @@ function assembleOperations(input) {
       return assemblePartialLiquidation(fc);
     }
     const count = countAdapterCalls(fc.innerCalls, register);
-    const sliced = executeTransfers.slice(executeOffset, executeOffset + count);
+    const sliced = executeResults.slice(executeOffset, executeOffset + count);
     executeOffset += count;
     const withdrawCount = countWithdrawCollateralCalls(fc.innerCalls);
     const slicedWithdrawEvents = withdrawCollateralEvents.slice(
@@ -29,11 +27,11 @@ function assembleOperations(input) {
       withdrawOffset + withdrawCount
     );
     withdrawOffset += withdrawCount;
-    const adapterTraces = extractAdapterCallTraces(fc.trace);
+    const protocolCalldatas = extractProtocolCalls(fc.trace, sliced);
     const multicall = classifyMulticallOperations({
       innerCalls: fc.innerCalls,
-      executeTransfers: sliced,
-      adapterTraces,
+      executeResults: sliced,
+      protocolCalldatas,
       register,
       creditAccount: fc.creditAccount,
       underlying,

package/dist/esm/history/classifyMulticallOperations.js

@@ -8,12 +8,12 @@ import {
   TransferAlignmentError,
   UnknownAdapterError,
   WithdrawCollateralAlignmentError
-} from "../preview/trace/index.js";
+} from "./errors.js";
 function classifyMulticallOperations(input) {
   const {
     innerCalls,
-    executeTransfers,
-    adapterTraces,
+    executeResults,
+    protocolCalldatas,
     register,
     creditAccount,
     underlying,
@@ -28,27 +28,20 @@ function classifyMulticallOperations(input) {
     const contract = register.getContract(call.target);
     if (contract instanceof AbstractAdapterContract) {
       const idx = transferIdx++;
-      const transfers2 = executeTransfers[idx];
-      if (!transfers2) {
-        throw new TransferAlignmentError(executeTransfers.length, transferIdx);
+      const executeResult = executeResults[idx];
+      if (!executeResult) {
+        throw new TransferAlignmentError(executeResults.length, transferIdx);
       }
-      const protocol = contract.parseProtocolCall(adapterTraces[idx], strict);
-      const legacy = contract.classifyLegacyOperation(
+      const { transfers: transfers2, targetContract: targetContract2 } = executeResult;
+      const protocolCalldata = protocolCalldatas[idx];
+      const partial = contract.parseAdapterOperation(
         call,
-        toNetTransfers(transfers2, creditAccount)
+        transfers2,
+        creditAccount,
+        protocolCalldata,
+        strict
       );
-      result.push({
-        operation: "Execute",
-        adapter: call.target,
-        adapterType: call.contractType,
-        version: call.version,
-        label: call.label,
-        adapterFunctionName: call.functionName,
-        adapterArgs: call.rawArgs,
-        protocol,
-        transfers: transfers2,
-        legacy
-      });
+      if (partial) result.push({ ...partial, protocol: targetContract2 });
       continue;
     }
     if (contract !== void 0) {
@@ -67,22 +60,23 @@ function classifyMulticallOperations(input) {
       throw new UnknownAdapterError(call.target);
     }
     const unknownIdx = transferIdx++;
-    const transfers = executeTransfers[unknownIdx];
-    if (!transfers) {
-      throw new TransferAlignmentError(executeTransfers.length, transferIdx);
+    const unknownResult = executeResults[unknownIdx];
+    if (!unknownResult) {
+      throw new TransferAlignmentError(executeResults.length, transferIdx);
     }
+    const { transfers, targetContract } = unknownResult;
     const netTransfers = toNetTransfers(transfers, creditAccount);
     result.push({
       operation: "Execute",
       adapter: call.target,
+      protocol: targetContract,
       adapterType: call.contractType,
       version: call.version,
       label: call.label,
       adapterFunctionName: call.functionName,
       adapterArgs: call.rawArgs,
-      // Unknown adapter (non-strict): we have no ABI to decode the protocol
-      // call, so `protocol` is left absent rather than filled with placeholders.
-      protocol: void 0,
+      protocolFunctionName: call.functionName,
+      protocolArgs: call.rawArgs,
       transfers,
       legacy: {
         operation: "Swap",
@@ -90,8 +84,8 @@ function classifyMulticallOperations(input) {
       }
     });
   }
-  if (transferIdx !== executeTransfers.length) {
-    throw new TransferAlignmentError(executeTransfers.length, transferIdx);
+  if (transferIdx !== executeResults.length) {
+    throw new TransferAlignmentError(executeResults.length, transferIdx);
   }
   if (withdrawCollateralEvents && withdrawCollateralEvents.length > 0 && withdrawIdx !== withdrawCollateralEvents.length) {
     throw new WithdrawCollateralAlignmentError(

package/dist/esm/{preview/trace → history}/errors.js

@@ -22,6 +22,28 @@ class WithdrawCollateralAlignmentError extends Error {
     this.name = "WithdrawCollateralAlignmentError";
   }
 }
+class ProtocolCallNotFoundError extends Error {
+  targetContract;
+  executeIndex;
+  constructor(targetContract, executeIndex) {
+    super(
+      `protocol call to ${targetContract} not found in trace for Execute #${executeIndex}`
+    );
+    this.name = "ProtocolCallNotFoundError";
+    this.targetContract = targetContract;
+    this.executeIndex = executeIndex;
+  }
+}
+class AdapterTraceAlignmentError extends Error {
+  constructor(expected, actual) {
+    super(`found ${actual} adapter traces for ${expected} execute events`);
+    this.expected = expected;
+    this.actual = actual;
+    this.name = "AdapterTracesAlignmentError";
+  }
+  expected;
+  actual;
+}
 class UnexpectedFacadeEventOrderError extends Error {
   constructor(e) {
     super(
@@ -41,6 +63,8 @@ class UnknownFacadeCallError extends Error {
   }
 }
 export {
+  AdapterTraceAlignmentError,
+  ProtocolCallNotFoundError,
   TransferAlignmentError,
   UnexpectedFacadeEventOrderError,
   UnknownAdapterError,

package/dist/esm/history/extractProtocolCalls.js

@@ -0,0 +1,32 @@
+import {
+  AdapterTraceAlignmentError,
+  ProtocolCallNotFoundError
+} from "./errors.js";
+import { findCallTo } from "./trace-utils.js";
+function extractProtocolCalls(facadeTrace, executeResults) {
+  if (executeResults.length === 0) {
+    return [];
+  }
+  const subtraces = facadeTrace.calls ?? [];
+  const result = [];
+  let subtraceIdx = 0;
+  for (let i = 0; i < executeResults.length; i++) {
+    const { targetContract } = executeResults[i];
+    let found;
+    while (subtraceIdx < subtraces.length && !found) {
+      found = findCallTo(subtraces[subtraceIdx], targetContract);
+      subtraceIdx++;
+    }
+    if (!found) {
+      throw new ProtocolCallNotFoundError(targetContract, i);
+    }
+    result.push(found.input);
+  }
+  if (result.length !== executeResults.length) {
+    throw new AdapterTraceAlignmentError(executeResults.length, result.length);
+  }
+  return result;
+}
+export {
+  extractProtocolCalls
+};

package/dist/esm/{preview/trace → history}/extractTransfers.js

@@ -3,14 +3,18 @@ import {
   isAddressEqual,
   parseEventLogs
 } from "viem";
-import { iCreditFacadeV310Abi } from "../../abi/310/generated.js";
-import { ierc20Abi } from "../../abi/iERC20.js";
-import { AddressMap } from "../../sdk/index.js";
+import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
+import { ierc20Abi } from "../abi/iERC20.js";
+import { AddressMap } from "../sdk/index.js";
 import { UnexpectedFacadeEventOrderError } from "./errors.js";
 function extractTransfers(logs, creditAccount, pool, creditFacade) {
   const ranges = buildOperationRanges(logs, creditFacade, creditAccount);
+  const hasLiquidation = logs.some((l) => {
+    const e = tryDecodeFacadeEvent(l, creditFacade);
+    return !!e && (e.eventName === "LiquidateCreditAccount" || e.eventName === "PartiallyLiquidateCreditAccount") && isAddressEqual(e.args.creditAccount, creditAccount);
+  });
   let currentEntries = [];
-  const executeTransfers = [];
+  const executeResults = [];
   const directTransfers = [];
   const phantomTokens = new AddressMap();
   const withdrawCollateralEvents = [];
@@ -19,17 +23,20 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
     const facadeEvent = tryDecodeFacadeEvent(log, creditFacade);
     if (facadeEvent) {
       if (isExecute(facadeEvent, creditAccount)) {
-        executeTransfers.push(currentEntries);
+        executeResults.push({
+          transfers: currentEntries,
+          targetContract: facadeEvent.args.targetContract
+        });
       } else if (isLiquidation(facadeEvent, creditAccount)) {
         liquidationRemainingFunds = facadeEvent.args.remainingFunds;
       } else if (isWithdrawPhantomToken(facadeEvent, creditAccount)) {
-        const phantomTransfers = executeTransfers.pop();
-        if (!phantomTransfers) {
+        const phantomExec = executeResults.pop();
+        if (!phantomExec) {
           throw new Error(
             `WithdrawPhantomToken without preceding Execute at logIndex ${facadeEvent.logIndex}`
           );
         }
-        const rawDeposit = phantomTransfers.find(
+        const rawDeposit = phantomExec.transfers.find(
           (t) => isAddressEqual(t.to, creditAccount)
         );
         if (!rawDeposit) {
@@ -63,12 +70,17 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
     if (isAddressEqual(from, creditAccount) || isAddressEqual(to, creditAccount)) {
       currentEntries.push({ token, amount: value, from, to });
     }
-    if (isAddressEqual(to, creditAccount) && !isInRange(log.logIndex, ranges)) {
-      directTransfers.push({ token, amount: value, from, to });
+    if (!hasLiquidation && !isInRange(log.logIndex, ranges) && (isAddressEqual(from, creditAccount) || isAddressEqual(to, creditAccount))) {
+      directTransfers.push({
+        token,
+        from,
+        to,
+        amount: value
+      });
     }
   }
   return {
-    executeTransfers,
+    executeResults,
     directTransfers,
     liquidationRemainingFunds,
     phantomTokens,

package/dist/esm/{preview/trace → history}/findFacadeCalls.js

@@ -2,11 +2,9 @@ import {
   decodeFunctionResult,
   isAddressEqual
 } from "viem";
-import { iCreditFacadeV310Abi } from "../../abi/310/generated.js";
-import {
-  collectTraces
-} from "../../common-utils/utils/trace.js";
+import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
 import { UnknownFacadeCallError } from "./errors.js";
+import { collectTraces } from "./trace-utils.js";
 const FACADE_CALL_TYPES = {
   multicall: "MultiCall",
   botMulticall: "BotMulticall",

package/dist/esm/history/index.js

@@ -1,3 +1,4 @@
+export * from "./inner-operations.js";
 export * from "./mapOperations.js";
 import { parseCreditAccountTransaction } from "./parseCreditAccountTransaction.js";
 export * from "./populateContractsRegister.js";

package/dist/esm/history/parseCreditAccountTransaction.js

@@ -1,5 +1,6 @@
-import { extractTransfers, findFacadeCalls } from "../preview/trace/index.js";
 import { assembleOperations } from "./assembleOperations.js";
+import { extractTransfers } from "./extractTransfers.js";
+import { findFacadeCalls } from "./findFacadeCalls.js";
 function parseCreditAccountTransaction(input) {
   const {
     trace,
@@ -24,7 +25,7 @@ function parseCreditAccountTransaction(input) {
     strict
   );
   const {
-    executeTransfers,
+    executeResults,
     directTransfers,
     liquidationRemainingFunds,
     phantomTokens,
@@ -39,7 +40,7 @@ function parseCreditAccountTransaction(input) {
   };
   const facadeOps = assembleOperations({
     facadeCalls,
-    executeTransfers,
+    executeResults,
     register,
     underlying,
     liquidationRemainingFunds,

package/dist/esm/history/toLegacyOperation.js

@@ -24,11 +24,7 @@ function createLegacyVisitor(params) {
         blockNum: ctx.blockNumber,
         timestamp: ctx.timestamp,
         sessionId: params.sessionId,
-        // `protocol` may be absent (migrator adapter, unknown adapter in
-        // non-strict mode, or undecodable calldata). The deprecated charts
-        // output still needs an address, so fall back to the on-chain adapter
-        // address, which is the closest meaningful value.
-        protocol: op.protocol?.contract ?? op.adapter
+        protocol: op.protocol
       };
     },
     IncreaseBorrowedAmount(op, ctx) {
@@ -84,7 +80,7 @@ function createLegacyVisitor(params) {
         token: op.token,
         amount: op.amount.toString(),
         from: op.from,
-        to: op.creditAccount
+        to: op.to
       };
     },
     MultiCall(op, multicall) {

package/dist/esm/history/trace-utils.js

@@ -0,0 +1,36 @@
+import { isAddressEqual } from "viem";
+function findCallTo(node, target) {
+  if (node.error) {
+    return void 0;
+  }
+  if (node.type === "CALL" && isAddressEqual(node.to, target)) {
+    return node;
+  }
+  if (node.calls) {
+    for (const child of node.calls) {
+      const found = findCallTo(child, target);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return void 0;
+}
+function collectTraces(node, target) {
+  const results = [];
+  if (node.error) {
+    return results;
+  }
+  if (node.type === "CALL" && isAddressEqual(node.to, target)) {
+    results.push(node);
+  } else if (node.calls) {
+    for (const child of node.calls) {
+      results.push(...collectTraces(child, target));
+    }
+  }
+  return results;
+}
+export {
+  collectTraces,
+  findCallTo
+};

package/dist/esm/permissionless/bindings/pricefeeds/curve-twap.js

@@ -4,12 +4,12 @@ const curveTwapPriceFeed = {
   constructorParams: [
     {
       label: "lowerBound ($)",
-      type: { type: "int256", decimals: 8 },
+      type: { type: "int256", decimals: 18 },
       defaultValue: "0"
     },
     {
       label: "upperBound ($)",
-      type: { type: "int256", decimals: 8 },
+      type: { type: "int256", decimals: 18 },
       defaultValue: "1"
     },
     {

package/dist/esm/plugins/adapters/contracts/AbstractAdapter.js

@@ -3,16 +3,13 @@ import {
   decodeFunctionData,
   zeroAddress
 } from "viem";
-import {
-  resolveProtocolCall
-} from "../../../common-utils/utils/trace.js";
 import {
   BaseContract,
   functionArgsToRecord,
   getFunctionSignature,
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
-import { swapFromTransfers } from "../transferHelpers.js";
+import { swapFromTransfers, toNetTransfers } from "../transferHelpers.js";
 class AbstractAdapterContract extends BaseContract {
   #targetContract;
   #creditManager;
@@ -53,33 +50,45 @@ class AbstractAdapterContract extends BaseContract {
     };
   }
   /**
-   * Decodes the protocol-level call (target contract + function name + args)
-   * performed by this adapter, recovered from its adapter-level call trace.
-   *
-   * Both the `targetContract` and the protocol calldata are taken from the
-   * execution trace.
+   * Builds an {@link AdapterOperation} from a parsed call and ordered transfer entries.
    *
-   * Returns `undefined` (in non-strict mode) when no external protocol call can
-   * be recovered, in strict mode throws instead.
+   * Returns `PartialBy<AdapterOperation, "targetContract">` because the adapter
+   * may not have `targetContract` (adapters created without SDK do not have serializedParams)
    *
-   * @param trace Adapter-level call trace (a direct child of the facade trace)
-   * @param strict When true, throws instead of returning `undefined`
+   * @param protocolCalldata Raw calldata of the actual CALL to targetContract, extracted from trace
+   * @param strict When true, throws if protocol ABI is missing or decode fails
    */
-  parseProtocolCall(trace, strict) {
-    const resolved = resolveProtocolCall(trace);
-    if (!resolved) {
-      if (strict) {
-        throw new Error("no external protocol call found in adapter trace");
-      }
-      return void 0;
-    }
-    const { contract, calldata } = resolved;
+  parseAdapterOperation(parsed, transfers, creditAccount, protocolCalldata, strict) {
+    const netTransfers = toNetTransfers(transfers, creditAccount);
+    const protocol = this.parseProtocolCall(protocolCalldata, strict);
+    return {
+      operation: "Execute",
+      adapter: this.address,
+      protocol: this.#targetContract,
+      adapterType: this.adapterType,
+      version: this.version,
+      label: parsed.label,
+      adapterFunctionName: parsed.functionName,
+      adapterArgs: parsed.rawArgs,
+      ...protocol,
+      transfers,
+      legacy: this.classifyLegacyOperation(parsed, netTransfers)
+    };
+  }
+  /**
+   * Decodes protocol-level function name and args from the raw calldata
+   * sent to targetContract.
+   */
+  parseProtocolCall(calldata, strict) {
     const selector = calldata.slice(0, 10);
     if (this.protocolAbi.length === 0) {
       if (strict) {
         throw new Error(`Protocol ABI is missing for selector ${selector}`);
       }
-      return void 0;
+      return {
+        protocolFunctionName: `unknown function ${selector}`,
+        protocolArgs: {}
+      };
     }
     try {
       const decoded = decodeFunctionData({
@@ -87,12 +96,12 @@ class AbstractAdapterContract extends BaseContract {
         data: calldata
       });
       const functionName = getFunctionSignature(this.protocolAbi, calldata);
-      const functionArgs = functionArgsToRecord(
+      const protocolArgs = functionArgsToRecord(
         this.protocolAbi,
         decoded.functionName,
         decoded.args
       );
-      return { contract, functionName, functionArgs };
+      return { protocolFunctionName: functionName, protocolArgs };
     } catch (e) {
       if (strict) {
         throw new Error(
@@ -100,7 +109,10 @@ class AbstractAdapterContract extends BaseContract {
           { cause: e }
         );
       }
-      return void 0;
+      return {
+        protocolFunctionName: `unknown function ${selector}`,
+        protocolArgs: {}
+      };
     }
   }
   /**
@@ -114,8 +126,6 @@ class AbstractAdapterContract extends BaseContract {
    * Override in protocol-specific subclasses for richer classification.
    *
    * @see https://github.com/Gearbox-protocol/charts_server/blob/master/core/account_operation.go#L238-L264
-   *
-   * @deprecated Eventually will be gone, exists to produce output that legacy UI can display
    */
   classifyLegacyOperation(_parsed, transfers) {
     const swap = swapFromTransfers(transfers);