@gearbox-protocol/sdk 14.11.0-next.1 → 14.11.0-next.10

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

@@ -1,3 +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/parse/classifyInnerOperations.js

@@ -1,56 +1,25 @@
-import { zeroAddress } from "viem";
-import {
-  AbstractAdapterContract
-} from "../../plugins/adapters/index.js";
+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) {
+    if (contract instanceof AbstractAdapterContract || contract === void 0) {
       result.push({
         operation: "Execute",
         adapter: call.target,
-        protocol: contract.targetContract,
         adapterType: call.contractType,
         version: call.version,
         label: call.label,
         adapterFunctionName: call.functionName,
-        adapterArgs: call.rawArgs,
-        // TODO: mirror the adapter call into the protocol fields for now. The
-        // real protocol-level call (adapter -> target contract) only exists in
-        // the execution call trace, which is not available from raw calldata.
-        // Recovering the actual protocol function/args requires a call trace.
-        protocolFunctionName: call.functionName,
-        protocolArgs: call.rawArgs,
-        transfers: [],
-        legacy: mockLegacyOperation()
+        adapterArgs: call.rawArgs
       });
       continue;
     }
-    if (contract !== void 0) {
-      const op = classifyFacadeInnerCall(call, underlying);
-      if (op) result.push(op);
-      continue;
+    const op = classifyFacadeInnerCall(call, underlying);
+    if (op) {
+      result.push(op);
     }
-    result.push({
-      operation: "Execute",
-      adapter: call.target,
-      protocol: call.target,
-      adapterType: call.contractType,
-      version: call.version,
-      label: call.label,
-      adapterFunctionName: call.functionName,
-      adapterArgs: call.rawArgs,
-      // TODO: mirror the adapter call into the protocol fields for now. The
-      // real protocol-level call (adapter -> target contract) only exists in
-      // the execution call trace, which is not available from raw calldata.
-      // Recovering the actual protocol function/args requires a call trace.
-      protocolFunctionName: call.functionName,
-      protocolArgs: call.rawArgs,
-      transfers: [],
-      legacy: mockLegacyOperation()
-    });
   }
   return result;
 }
@@ -94,15 +63,6 @@ function classifyFacadeInnerCall(call, underlying) {
       return null;
   }
 }
-function mockLegacyOperation() {
-  return {
-    operation: "Swap",
-    from: zeroAddress,
-    fromAmount: "0",
-    to: zeroAddress,
-    toAmount: "0"
-  };
-}
 export {
   classifyInnerOperations
 };

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

@@ -1,6 +1,7 @@
 export * from "./classifyInnerOperations.js";
 export * from "./errors.js";
-export * from "./parseCreditFacadeOperation.js";
-export * from "./parsePoolOperation.js";
-export * from "./parseTransaction.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/{parseCreditFacadeOperation.js → parseFacadeOperationCalldata.js}

@@ -1,10 +1,7 @@
-import {
-  isAddressEqual,
-  zeroAddress,
-  zeroHash
-} from "viem";
+import { isAddressEqual, zeroAddress } from "viem";
 import { classifyInnerOperations } from "./classifyInnerOperations.js";
-function parseCreditFacadeOperation(props) {
+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];
@@ -17,30 +14,30 @@ function parseCreditFacadeOperation(props) {
   }
   const metadata = {
     creditManager: suite.creditManager.address,
-    creditFacade: facade.address,
-    blockNumber: Number(sdk.currentBlock),
-    txHash: zeroHash,
-    timestamp: 0
+    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
+        multicall,
+        expectedBalanceChanges
       };
     case "botMulticall":
       return {
         ...metadata,
         operation: "BotMulticall",
         creditAccount: rawArgs.creditAccount,
-        multicall
+        multicall,
+        expectedBalanceChanges
       };
     case "openCreditAccount":
       return {
@@ -49,14 +46,16 @@ function parseCreditFacadeOperation(props) {
         creditAccount: zeroAddress,
         onBehalfOf: rawArgs.onBehalfOf,
         referralCode: rawArgs.referralCode,
-        multicall
+        multicall,
+        expectedBalanceChanges
       };
     case "closeCreditAccount":
       return {
         ...metadata,
         operation: "CloseCreditAccount",
         creditAccount: rawArgs.creditAccount,
-        multicall
+        multicall,
+        expectedBalanceChanges
       };
     case "liquidateCreditAccount":
       return {
@@ -68,7 +67,8 @@ function parseCreditFacadeOperation(props) {
         // liquidation, so they are not recoverable from raw calldata.
         token: zeroAddress,
         remainingFunds: 0n,
-        multicall
+        multicall,
+        expectedBalanceChanges
       };
     case "partiallyLiquidateCreditAccount":
       return {
@@ -87,5 +87,5 @@ function parseCreditFacadeOperation(props) {
   }
 }
 export {
-  parseCreditFacadeOperation
+  parseFacadeOperationCalldata
 };

package/dist/esm/preview/parse/{parseTransaction.js → parseOperationCalldata.js}

@@ -3,16 +3,16 @@ import {
   PoolV310Contract
 } from "../../sdk/index.js";
 import { UnsupportedTargetError } from "./errors.js";
-import { parseCreditFacadeOperation } from "./parseCreditFacadeOperation.js";
-import { parsePoolOperation } from "./parsePoolOperation.js";
-function parseTransaction(input) {
+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 parsePoolOperation({ sdk, pool: contract, calldata });
+    return parsePoolOperationCalldata({ sdk, pool: contract, calldata });
   }
   if (contract instanceof CreditFacadeV310Contract) {
-    return parseCreditFacadeOperation({
+    return parseFacadeOperationCalldata({
       sdk,
       facade: contract,
       calldata
@@ -21,5 +21,5 @@ function parseTransaction(input) {
   throw new UnsupportedTargetError(to);
 }
 export {
-  parseTransaction
+  parseOperationCalldata
 };

package/dist/esm/preview/parse/{parsePoolOperation.js → parsePoolOperationCalldata.js}

@@ -1,5 +1,5 @@
 import { UnsupportedPoolFunctionError } from "./errors.js";
-function parsePoolOperation(props) {
+function parsePoolOperationCalldata(props) {
   const { sdk, pool, calldata } = props;
   const parsed = sdk.parseFunctionDataV2(pool.address, calldata);
   const functionName = parsed.functionName.split("(")[0];
@@ -14,9 +14,26 @@ function parsePoolOperation(props) {
         receiver: rawArgs.receiver,
         assets: rawArgs.assets,
         underlying,
-        referralCode: functionName === "depositWithReferral" ? rawArgs.referralCode : void 0,
-        // Calldata-only parse: transfers are recovered later by simulation.
-        transfers: []
+        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 {
@@ -25,14 +42,12 @@ function parsePoolOperation(props) {
         receiver: rawArgs.receiver,
         owner: rawArgs.owner,
         shares: rawArgs.shares,
-        underlying,
-        // Calldata-only parse: transfers are recovered later by simulation.
-        transfers: []
+        underlying
       };
     default:
       throw new UnsupportedPoolFunctionError(pool.address, parsed.functionName);
   }
 }
 export {
-  parsePoolOperation
+  parsePoolOperationCalldata
 };

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

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

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

@@ -4,6 +4,12 @@ import { BalancePrerequisite } from "./BalancePrerequisite.js";
 function buildPrerequisites(tx, ctx) {
   const { wallet } = ctx;
   switch (tx.operation) {
+    // Deposit and Mint both pull the underlying from the caller into the pool;
+    // they only differ in which side (assets vs shares) the caller specifies.
+    // The exact underlying amount for Mint is resolved by the pool, so we can
+    // only require an allowance/balance against the known specified amount —
+    // here we approximate Mint by its shares amount (a lower bound on assets is
+    // not knowable from calldata alone).
     case "Deposit":
       return [
         new AllowancePrerequisite({
@@ -20,6 +26,24 @@ function buildPrerequisites(tx, ctx) {
           title: "Sufficient token balance"
         })
       ];
+    case "Mint":
+      return [
+        new AllowancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          spender: tx.pool,
+          required: tx.shares,
+          title: "Token approved to pool"
+        }),
+        new BalancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          required: tx.shares,
+          title: "Sufficient token balance"
+        })
+      ];
+    // Redeem and Withdraw both burn LP shares from `owner`; they only differ in
+    // which side (shares vs assets) the caller specifies.
     case "Redeem": {
       const prereqs = [
         new BalancePrerequisite({
@@ -42,6 +66,28 @@ function buildPrerequisites(tx, ctx) {
       }
       return prereqs;
     }
+    case "Withdraw": {
+      const prereqs = [
+        new BalancePrerequisite({
+          token: tx.pool,
+          owner: tx.owner,
+          required: tx.assets,
+          title: "Sufficient LP token balance"
+        })
+      ];
+      if (!isAddressEqual(tx.owner, wallet)) {
+        prereqs.push(
+          new AllowancePrerequisite({
+            token: tx.pool,
+            owner: tx.owner,
+            spender: wallet,
+            required: tx.assets,
+            title: "LP token approved to caller"
+          })
+        );
+      }
+      return prereqs;
+    }
     case "MultiCall":
     case "BotMulticall":
     case "OpenCreditAccount":

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

@@ -2,5 +2,6 @@ export * from "./AllowancePrerequisite.js";
 export * from "./BalancePrerequisite.js";
 export * from "./buildPrerequisites.js";
 export * from "./Prerequisite.js";
+export * from "./prepareAction.js";
 export * from "./runPrerequisites.js";
 export * from "./types.js";

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

@@ -0,0 +1,23 @@
+import { encodeFunctionData, erc20Abi } from "viem";
+function preparePrerequisiteAction(result) {
+  if (result.kind === "allowance" && result.satisfied === false) {
+    const { token, spender, required } = result.detail;
+    return {
+      kind: "allowance",
+      to: token,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [spender, required]
+      })
+    };
+  }
+  return null;
+}
+function isActionablePrerequisite(result) {
+  return preparePrerequisiteAction(result) !== null;
+}
+export {
+  isActionablePrerequisite,
+  preparePrerequisiteAction
+};

package/dist/esm/preview/simulate/constants.js

@@ -0,0 +1,4 @@
+const ETH_SIMULATE_V1_NETWORKS = /* @__PURE__ */ new Set(["Mainnet", "Plasma", "Somnia"]);
+export {
+  ETH_SIMULATE_V1_NETWORKS
+};

package/dist/esm/preview/simulate/{decodeSimulationError.js → errors.js}

@@ -4,6 +4,34 @@ import {
   decodeErrorResult
 } from "viem";
 import { errorAbis } from "../../abi/errors.js";
+class PreviewSimulationError extends BaseError {
+  name = "PreviewSimulationError";
+  /** Per-flow decoded failures behind this error. */
+  failures;
+  constructor(failures) {
+    const shortMessage = failures.length <= 1 ? failures[0]?.detail.reason ?? "simulation failed" : "all simulation flows failed";
+    const cause = failures.find((f) => f.detail.cause instanceof Error)?.detail.cause;
+    super(shortMessage, {
+      metaMessages: failures.map((f) => `[${f.source}] ${f.detail.reason}`),
+      cause
+    });
+    this.failures = failures;
+  }
+}
+function asPreviewSimulationError(reason, source) {
+  if (reason instanceof PreviewSimulationError) {
+    return reason;
+  }
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  return new PreviewSimulationError([
+    { source, detail: decodeSimulationError({ error }) }
+  ]);
+}
+function combinePreviewSimulationErrors(...errors) {
+  return new PreviewSimulationError(
+    errors.filter((e) => e).flatMap((e) => e?.failures ?? [])
+  );
+}
 function decodeSimulationError(revert) {
   const { error, data } = revert;
   if (data && data !== "0x") {
@@ -40,5 +68,8 @@ function formatDecodedError(errorName, args) {
   return `${errorName}(${args.map((arg) => String(arg)).join(", ")})`;
 }
 export {
+  PreviewSimulationError,
+  asPreviewSimulationError,
+  combinePreviewSimulationErrors,
   decodeSimulationError
 };

package/dist/esm/preview/simulate/holders.js

@@ -0,0 +1,21 @@
+import { AddressSet } from "../../sdk/index.js";
+function sourceHolder(operation, wallet) {
+  switch (operation.operation) {
+    case "Deposit":
+    case "Mint":
+      return wallet;
+    case "Withdraw":
+    case "Redeem":
+      return operation.owner;
+  }
+}
+function watchedHolders(operation, wallet) {
+  const holders = new AddressSet([
+    sourceHolder(operation, wallet),
+    operation.receiver
+  ]);
+  return holders.asArray();
+}
+export {
+  watchedHolders
+};

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

@@ -1,4 +1,12 @@
-export * from "./decodeSimulationError.js";
-export * from "./extractERC20Transfers.js";
-export * from "./simulatePoolOperation.js";
-export * from "./types.js";
+import { ETH_SIMULATE_V1_NETWORKS } from "./constants.js";
+import { PreviewSimulationError } from "./errors.js";
+import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
+import { simulateOperation } from "./simulateOperation.js";
+import { simulatePoolOperation } from "./simulatePoolOperation.js";
+export {
+  ETH_SIMULATE_V1_NETWORKS,
+  PreviewSimulationError,
+  simulateFacadeOperation,
+  simulateOperation,
+  simulatePoolOperation
+};