@gearbox-protocol/sdk 14.11.2 → 14.12.0-next.1

package/dist/esm/history/classifyMulticallOperations.js

@@ -8,12 +8,12 @@ import {
   TransferAlignmentError,
   UnknownAdapterError,
   WithdrawCollateralAlignmentError
-} from "./errors.js";
+} from "../preview/trace/index.js";
 function classifyMulticallOperations(input) {
   const {
     innerCalls,
-    executeResults,
-    protocolCalldatas,
+    executeTransfers,
+    adapterTraces,
     register,
     creditAccount,
     underlying,
@@ -28,20 +28,27 @@ function classifyMulticallOperations(input) {
     const contract = register.getContract(call.target);
     if (contract instanceof AbstractAdapterContract) {
       const idx = transferIdx++;
-      const executeResult = executeResults[idx];
-      if (!executeResult) {
-        throw new TransferAlignmentError(executeResults.length, transferIdx);
+      const transfers2 = executeTransfers[idx];
+      if (!transfers2) {
+        throw new TransferAlignmentError(executeTransfers.length, transferIdx);
       }
-      const { transfers: transfers2, targetContract: targetContract2 } = executeResult;
-      const protocolCalldata = protocolCalldatas[idx];
-      const partial = contract.parseAdapterOperation(
+      const protocol = contract.parseProtocolCall(adapterTraces[idx], strict);
+      const legacy = contract.classifyLegacyOperation(
         call,
-        transfers2,
-        creditAccount,
-        protocolCalldata,
-        strict
+        toNetTransfers(transfers2, creditAccount)
       );
-      if (partial) result.push({ ...partial, protocol: targetContract2 });
+      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
+      });
       continue;
     }
     if (contract !== void 0) {
@@ -60,23 +67,22 @@ function classifyMulticallOperations(input) {
       throw new UnknownAdapterError(call.target);
     }
     const unknownIdx = transferIdx++;
-    const unknownResult = executeResults[unknownIdx];
-    if (!unknownResult) {
-      throw new TransferAlignmentError(executeResults.length, transferIdx);
+    const transfers = executeTransfers[unknownIdx];
+    if (!transfers) {
+      throw new TransferAlignmentError(executeTransfers.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,
-      protocolFunctionName: call.functionName,
-      protocolArgs: 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,
       transfers,
       legacy: {
         operation: "Swap",
@@ -84,8 +90,8 @@ function classifyMulticallOperations(input) {
       }
     });
   }
-  if (transferIdx !== executeResults.length) {
-    throw new TransferAlignmentError(executeResults.length, transferIdx);
+  if (transferIdx !== executeTransfers.length) {
+    throw new TransferAlignmentError(executeTransfers.length, transferIdx);
   }
   if (withdrawCollateralEvents && withdrawCollateralEvents.length > 0 && withdrawIdx !== withdrawCollateralEvents.length) {
     throw new WithdrawCollateralAlignmentError(

package/dist/esm/history/index.js

@@ -1,4 +1,3 @@
-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,6 +1,5 @@
+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,
@@ -25,7 +24,7 @@ function parseCreditAccountTransaction(input) {
     strict
   );
   const {
-    executeResults,
+    executeTransfers,
     directTransfers,
     liquidationRemainingFunds,
     phantomTokens,
@@ -40,7 +39,7 @@ function parseCreditAccountTransaction(input) {
   };
   const facadeOps = assembleOperations({
     facadeCalls,
-    executeResults,
+    executeTransfers,
     register,
     underlying,
     liquidationRemainingFunds,

package/dist/esm/history/toLegacyOperation.js

@@ -24,7 +24,11 @@ function createLegacyVisitor(params) {
         blockNum: ctx.blockNumber,
         timestamp: ctx.timestamp,
         sessionId: params.sessionId,
-        protocol: op.protocol
+        // `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
       };
     },
     IncreaseBorrowedAmount(op, ctx) {

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

@@ -3,13 +3,16 @@ import {
   decodeFunctionData,
   zeroAddress
 } from "viem";
+import {
+  resolveProtocolCall
+} from "../../../common-utils/utils/trace.js";
 import {
   BaseContract,
   functionArgsToRecord,
   getFunctionSignature,
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
-import { swapFromTransfers, toNetTransfers } from "../transferHelpers.js";
+import { swapFromTransfers } from "../transferHelpers.js";
 class AbstractAdapterContract extends BaseContract {
   #targetContract;
   #creditManager;
@@ -50,45 +53,33 @@ class AbstractAdapterContract extends BaseContract {
     };
   }
   /**
-   * Builds an {@link AdapterOperation} from a parsed call and ordered transfer entries.
+   * Decodes the protocol-level call (target contract + function name + args)
+   * performed by this adapter, recovered from its adapter-level call trace.
    *
-   * Returns `PartialBy<AdapterOperation, "targetContract">` because the adapter
-   * may not have `targetContract` (adapters created without SDK do not have serializedParams)
+   * Both the `targetContract` and the protocol calldata are taken from the
+   * execution trace.
    *
-   * @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
-   */
-  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.
+   * 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`
    */
-  parseProtocolCall(calldata, strict) {
+  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;
     const selector = calldata.slice(0, 10);
     if (this.protocolAbi.length === 0) {
       if (strict) {
         throw new Error(`Protocol ABI is missing for selector ${selector}`);
       }
-      return {
-        protocolFunctionName: `unknown function ${selector}`,
-        protocolArgs: {}
-      };
+      return void 0;
     }
     try {
       const decoded = decodeFunctionData({
@@ -96,12 +87,12 @@ class AbstractAdapterContract extends BaseContract {
         data: calldata
       });
       const functionName = getFunctionSignature(this.protocolAbi, calldata);
-      const protocolArgs = functionArgsToRecord(
+      const functionArgs = functionArgsToRecord(
         this.protocolAbi,
         decoded.functionName,
         decoded.args
       );
-      return { protocolFunctionName: functionName, protocolArgs };
+      return { contract, functionName, functionArgs };
     } catch (e) {
       if (strict) {
         throw new Error(
@@ -109,10 +100,7 @@ class AbstractAdapterContract extends BaseContract {
           { cause: e }
         );
       }
-      return {
-        protocolFunctionName: `unknown function ${selector}`,
-        protocolArgs: {}
-      };
+      return void 0;
     }
   }
   /**
@@ -126,6 +114,8 @@ 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);

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

@@ -12,6 +12,15 @@ class AccountMigratorAdapterContract extends AbstractAdapterContract {
       `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;
+  }
 }
 export {
   AccountMigratorAdapterContract

package/dist/esm/preview/index.js

@@ -0,0 +1,4 @@
+export * from "./parse/index.js";
+export * from "./prerequisites/index.js";
+export * from "./simulate/index.js";
+export * from "./trace/index.js";

package/dist/esm/preview/package.json

@@ -0,0 +1 @@
+{"type": "module","sideEffects":false}

package/dist/esm/preview/parse/classifyInnerOperations.js

@@ -0,0 +1,68 @@
+import { AbstractAdapterContract } from "../../plugins/adapters/index.js";
+function classifyInnerOperations(calls, props) {
+  const { sdk, underlying } = props;
+  const result = [];
+  for (const call of calls) {
+    const contract = sdk.getContract(call.target);
+    if (contract instanceof AbstractAdapterContract || contract === void 0) {
+      result.push({
+        operation: "Execute",
+        adapter: call.target,
+        adapterType: call.contractType,
+        version: call.version,
+        label: call.label,
+        adapterFunctionName: call.functionName,
+        adapterArgs: call.rawArgs
+      });
+      continue;
+    }
+    const op = classifyFacadeInnerCall(call, underlying);
+    if (op) {
+      result.push(op);
+    }
+  }
+  return result;
+}
+function classifyFacadeInnerCall(call, underlying) {
+  const functionName = call.functionName.split("(")[0];
+  const { rawArgs } = call;
+  switch (functionName) {
+    case "increaseDebt":
+      return {
+        operation: "IncreaseBorrowedAmount",
+        token: underlying,
+        amount: rawArgs.amount
+      };
+    case "decreaseDebt":
+      return {
+        operation: "DecreaseBorrowedAmount",
+        token: underlying,
+        amount: rawArgs.amount
+      };
+    case "addCollateral":
+    case "addCollateralWithPermit":
+      return {
+        operation: "AddCollateral",
+        token: rawArgs.token,
+        amount: rawArgs.amount
+      };
+    case "withdrawCollateral":
+      return {
+        operation: "WithdrawCollateral",
+        token: rawArgs.token,
+        amount: rawArgs.amount,
+        to: rawArgs.to
+      };
+    case "updateQuota":
+      return {
+        operation: "UpdateQuota",
+        token: rawArgs.token,
+        change: rawArgs.quotaChange
+      };
+    default:
+      return null;
+  }
+}
+export {
+  classifyInnerOperations
+};

package/dist/esm/preview/parse/errors.js

@@ -0,0 +1,22 @@
+class UnsupportedTargetError extends Error {
+  target;
+  constructor(target) {
+    super(`unsupported transaction target: ${target}`);
+    this.name = "UnsupportedTargetError";
+    this.target = target;
+  }
+}
+class UnsupportedPoolFunctionError extends Error {
+  pool;
+  functionName;
+  constructor(pool, functionName) {
+    super(`unsupported pool function "${functionName}" on ${pool}`);
+    this.name = "UnsupportedPoolFunctionError";
+    this.pool = pool;
+    this.functionName = functionName;
+  }
+}
+export {
+  UnsupportedPoolFunctionError,
+  UnsupportedTargetError
+};

package/dist/esm/preview/parse/extractExpectedBalanceChanges.js

@@ -0,0 +1,24 @@
+function extractExpectedBalanceChanges(innerCalls) {
+  const calls = innerCalls.filter(
+    (call) => functionName(call) !== "onDemandPriceUpdates"
+  );
+  if (calls.length === 0) {
+    return void 0;
+  }
+  const first = calls[0];
+  const last = calls[calls.length - 1];
+  if (functionName(first) !== "storeExpectedBalances" || functionName(last) !== "compareBalances") {
+    return void 0;
+  }
+  const balanceDeltas = first.rawArgs.balanceDeltas;
+  if (!balanceDeltas) {
+    return void 0;
+  }
+  return balanceDeltas.map(({ token, amount }) => ({ token, delta: amount }));
+}
+function functionName(call) {
+  return call.functionName.split("(")[0];
+}
+export {
+  extractExpectedBalanceChanges
+};

package/dist/esm/preview/parse/index.js

@@ -0,0 +1,7 @@
+export * from "./classifyInnerOperations.js";
+export * from "./errors.js";
+export * from "./extractExpectedBalanceChanges.js";
+export * from "./parseFacadeOperationCalldata.js";
+export * from "./parseOperationCalldata.js";
+export * from "./parsePoolOperationCalldata.js";
+export * from "./types.js";

package/dist/esm/preview/parse/parseFacadeOperationCalldata.js

@@ -0,0 +1,91 @@
+import { isAddressEqual, zeroAddress } from "viem";
+import { classifyInnerOperations } from "./classifyInnerOperations.js";
+import { extractExpectedBalanceChanges } from "./extractExpectedBalanceChanges.js";
+function parseFacadeOperationCalldata(props) {
+  const { sdk, facade, calldata } = props;
+  const parsed = sdk.parseFunctionDataV2(facade.address, calldata);
+  const functionName = parsed.functionName.split("(")[0];
+  const { rawArgs } = parsed;
+  const suite = sdk.marketRegister.creditManagers.find(
+    (cm) => isAddressEqual(cm.creditFacade.address, facade.address)
+  );
+  if (!suite) {
+    throw new Error(`no credit suite found for facade ${facade.address}`);
+  }
+  const metadata = {
+    creditManager: suite.creditManager.address,
+    creditFacade: facade.address
+  };
+  const innerCalls = rawArgs.calls ?? [];
+  const multicall = classifyInnerOperations(innerCalls, {
+    sdk,
+    underlying: suite.underlying
+  });
+  const expectedBalanceChanges = extractExpectedBalanceChanges(innerCalls);
+  switch (functionName) {
+    case "multicall":
+      return {
+        ...metadata,
+        operation: "MultiCall",
+        creditAccount: rawArgs.creditAccount,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "botMulticall":
+      return {
+        ...metadata,
+        operation: "BotMulticall",
+        creditAccount: rawArgs.creditAccount,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "openCreditAccount":
+      return {
+        ...metadata,
+        operation: "OpenCreditAccount",
+        creditAccount: zeroAddress,
+        onBehalfOf: rawArgs.onBehalfOf,
+        referralCode: rawArgs.referralCode,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "closeCreditAccount":
+      return {
+        ...metadata,
+        operation: "CloseCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "liquidateCreditAccount":
+      return {
+        ...metadata,
+        operation: "LiquidateCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        to: rawArgs.to,
+        // `token` and `remainingFunds` are only emitted on-chain during
+        // liquidation, so they are not recoverable from raw calldata.
+        token: zeroAddress,
+        remainingFunds: 0n,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "partiallyLiquidateCreditAccount":
+      return {
+        ...metadata,
+        operation: "PartiallyLiquidateCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        token: rawArgs.token,
+        repaidAmount: rawArgs.repaidAmount,
+        minSeizedAmount: rawArgs.minSeizedAmount,
+        to: rawArgs.to
+      };
+    default:
+      throw new Error(
+        `unsupported credit facade function "${parsed.functionName}" on ${facade.address}`
+      );
+  }
+}
+export {
+  parseFacadeOperationCalldata
+};

package/dist/esm/preview/parse/parseOperationCalldata.js

@@ -0,0 +1,25 @@
+import {
+  CreditFacadeV310Contract,
+  PoolV310Contract
+} from "../../sdk/index.js";
+import { UnsupportedTargetError } from "./errors.js";
+import { parseFacadeOperationCalldata } from "./parseFacadeOperationCalldata.js";
+import { parsePoolOperationCalldata } from "./parsePoolOperationCalldata.js";
+function parseOperationCalldata(input) {
+  const { sdk, to, calldata } = input;
+  const contract = sdk.getContract(to);
+  if (contract instanceof PoolV310Contract) {
+    return parsePoolOperationCalldata({ sdk, pool: contract, calldata });
+  }
+  if (contract instanceof CreditFacadeV310Contract) {
+    return parseFacadeOperationCalldata({
+      sdk,
+      facade: contract,
+      calldata
+    });
+  }
+  throw new UnsupportedTargetError(to);
+}
+export {
+  parseOperationCalldata
+};

package/dist/esm/preview/parse/parsePoolOperationCalldata.js

@@ -0,0 +1,53 @@
+import { UnsupportedPoolFunctionError } from "./errors.js";
+function parsePoolOperationCalldata(props) {
+  const { sdk, pool, calldata } = props;
+  const parsed = sdk.parseFunctionDataV2(pool.address, calldata);
+  const functionName = parsed.functionName.split("(")[0];
+  const { rawArgs } = parsed;
+  const underlying = pool.underlying;
+  switch (functionName) {
+    case "deposit":
+    case "depositWithReferral":
+      return {
+        operation: "Deposit",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        assets: rawArgs.assets,
+        underlying,
+        referralCode: functionName === "depositWithReferral" ? rawArgs.referralCode : void 0
+      };
+    case "mint":
+    case "mintWithReferral":
+      return {
+        operation: "Mint",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        shares: rawArgs.shares,
+        underlying,
+        referralCode: functionName === "mintWithReferral" ? rawArgs.referralCode : void 0
+      };
+    case "withdraw":
+      return {
+        operation: "Withdraw",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        owner: rawArgs.owner,
+        assets: rawArgs.assets,
+        underlying
+      };
+    case "redeem":
+      return {
+        operation: "Redeem",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        owner: rawArgs.owner,
+        shares: rawArgs.shares,
+        underlying
+      };
+    default:
+      throw new UnsupportedPoolFunctionError(pool.address, parsed.functionName);
+  }
+}
+export {
+  parsePoolOperationCalldata
+};

package/dist/esm/preview/parse/types.js

@@ -0,0 +1,9 @@
+export * from "./types-adapters.js";
+export * from "./types-facades.js";
+export * from "./types-pools.js";
+function isPoolOperation(tx) {
+  return tx.operation === "Deposit" || tx.operation === "Mint" || tx.operation === "Withdraw" || tx.operation === "Redeem";
+}
+export {
+  isPoolOperation
+};

package/dist/esm/preview/prerequisites/AllowancePrerequisite.js

@@ -0,0 +1,57 @@
+import { erc20Abi } from "viem";
+import {
+  Prerequisite,
+  toPrerequisiteError
+} from "./Prerequisite.js";
+class AllowancePrerequisite extends Prerequisite {
+  _id;
+  _title;
+  _detail;
+  constructor(props) {
+    super();
+    this._id = props.id ?? `allowance:${props.token}:${props.owner}:${props.spender}`;
+    this._title = props.title ?? "Token approval";
+    this._detail = {
+      token: props.token,
+      owner: props.owner,
+      spender: props.spender,
+      required: props.required
+    };
+  }
+  get id() {
+    return this._id;
+  }
+  get kind() {
+    return "allowance";
+  }
+  get title() {
+    return this._title;
+  }
+  get detail() {
+    return this._detail;
+  }
+  calls() {
+    return [
+      {
+        address: this._detail.token,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [this._detail.owner, this._detail.spender]
+      }
+    ];
+  }
+  resolve(slice) {
+    const res = slice[0];
+    if (!res || res.status === "failure") {
+      return this.errorResult(toPrerequisiteError(res?.error));
+    }
+    const actual = res.result;
+    return this.satisfiedResult(actual >= this._detail.required, {
+      ...this._detail,
+      actual
+    });
+  }
+}
+export {
+  AllowancePrerequisite
+};