@gearbox-protocol/sdk 14.11.0-next.6 → 14.11.0-next.7

package/dist/cjs/preview/simulate/simulatePoolOperation.js

@@ -21,72 +21,37 @@ __export(simulatePoolOperation_exports, {
   simulatePoolOperation: () => simulatePoolOperation
 });
 module.exports = __toCommonJS(simulatePoolOperation_exports);
-var import_viem = require("viem");
-var import_actions = require("viem/actions");
-var import_iERC20 = require("../../abi/iERC20.js");
-var import_decodeSimulationError = require("./decodeSimulationError.js");
-var import_extractERC20Transfers = require("./extractERC20Transfers.js");
-async function simulatePoolOperation(input) {
-  const { sdk, operation, to, calldata, wallet, blockNumber } = input;
-  const { underlying, pool } = operation;
-  const receiverIsWallet = (0, import_viem.isAddressEqual)(operation.receiver, wallet);
-  const holders = receiverIsWallet ? [wallet] : [wallet, operation.receiver];
-  const tokens = [underlying, pool];
-  const balanceOf = (token, holder) => ({
-    to: token,
-    abi: import_iERC20.ierc20Abi,
-    functionName: "balanceOf",
-    args: [holder]
-  });
-  const balanceCalls = holders.flatMap(
-    (holder) => tokens.map((token) => balanceOf(token, holder))
+var import_errors = require("./errors.js");
+var import_simulatePoolOpMulticall = require("./simulatePoolOpMulticall.js");
+var import_simulatePoolOpV1 = require("./simulatePoolOpV1.js");
+async function simulatePoolOperation(input, options = {}) {
+  const { logger, useSimulateV1 } = options;
+  logger?.debug(
+    { wallet: input.wallet, to: input.to },
+    "simulating pool operation"
   );
-  const { results } = await (0, import_actions.simulateCalls)(sdk.client, {
-    account: wallet,
-    // `undefined` lets viem simulate at `latest`; `blockNumber` is only set for
-    // testnet forks pinned to a specific block.
-    blockNumber,
-    calls: [...balanceCalls, { to, data: calldata }, ...balanceCalls]
-  });
-  const sim = results;
-  const txIndex = balanceCalls.length;
-  const afterOffset = txIndex + 1;
-  const txResult = sim[txIndex];
-  if (!txResult || txResult.status === "failure") {
-    return {
-      status: "failure",
-      error: (0, import_decodeSimulationError.decodeSimulationError)({
-        error: txResult?.error,
-        data: txResult?.data
-      })
-    };
+  const [v1, multicall] = await Promise.allSettled([
+    useSimulateV1 ? (0, import_simulatePoolOpV1.simulatePoolOpV1)(input, options) : void 0,
+    (0, import_simulatePoolOpMulticall.simulatePoolOpMulticall)(input, options)
+  ]);
+  if (v1.status === "fulfilled" && v1.value) {
+    return { status: "success", ...v1.value };
   }
-  const balanceChanges = [];
-  for (const [holderIndex, address] of holders.entries()) {
-    const changes = [];
-    for (const [tokenIndex, token] of tokens.entries()) {
-      const slot = holderIndex * tokens.length + tokenIndex;
-      const before = readBalance(sim[slot]);
-      const after = readBalance(sim[afterOffset + slot]);
-      const delta = after - before;
-      const magnitude = delta >= 0n ? delta : -delta;
-      if (magnitude > 1n) {
-        changes.push({ token, before, after, delta });
-      }
-    }
-    if (changes.length > 0) {
-      balanceChanges.push({ address, changes });
+  if (multicall.status === "fulfilled") {
+    if (v1.status === "rejected") {
+      logger?.debug(
+        (0, import_errors.asPreviewSimulationError)(v1.reason, "eth_simulateV1"),
+        "eth_simulateV1 flow failed; falling back to multicall result"
+      );
     }
+    return { status: "success", ...multicall.value };
   }
-  return {
-    status: "success",
-    transfers: (0, import_extractERC20Transfers.extractERC20Transfers)(txResult.logs ?? [], holders),
-    balanceChanges,
-    gasUsed: txResult.gasUsed
-  };
-}
-function readBalance(result) {
-  return result?.status === "success" ? result.result : 0n;
+  const error = (0, import_errors.combinePreviewSimulationErrors)(
+    v1.status === "rejected" ? (0, import_errors.asPreviewSimulationError)(v1.reason, "eth_simulateV1") : void 0,
+    (0, import_errors.asPreviewSimulationError)(multicall.reason, "multicall")
+  );
+  logger?.error(error, "pool operation simulation failed");
+  return { status: "failure", error };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -14,9 +14,26 @@ function parsePoolOperationCalldata(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,9 +42,7 @@ function parsePoolOperationCalldata(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);

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

@@ -2,7 +2,7 @@ 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/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,6 +1,12 @@
-export * from "./decodeSimulationError.js";
-export * from "./extractERC20Transfers.js";
-export * from "./simulateFacadeOperation.js";
-export * from "./simulateOperation.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
+};

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

@@ -1,4 +1,4 @@
-async function simulateFacadeOperation(_input) {
+async function simulateFacadeOperation(_input, _options) {
   throw new Error("not yet implemented");
 }
 export {

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

@@ -1,12 +1,12 @@
 import { isPoolOperation } from "../parse/index.js";
 import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
-async function simulateOperation(input) {
+async function simulateOperation(input, options) {
   const { operation } = input;
   if (isPoolOperation(operation)) {
-    return simulatePoolOperation({ ...input, operation });
+    return simulatePoolOperation({ ...input, operation }, options);
   }
-  return simulateFacadeOperation({ ...input, operation });
+  return simulateFacadeOperation({ ...input, operation }, options);
 }
 export {
   simulateOperation

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

@@ -0,0 +1,130 @@
+import { iPoolV310Abi } from "../../abi/310/generated.js";
+import { ierc20Abi } from "../../abi/iERC20.js";
+import { AddressMap } from "../../sdk/index.js";
+import { decodeSimulationError, PreviewSimulationError } from "./errors.js";
+import { watchedHolders } from "./holders.js";
+function previewRead(operation) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { functionName: "previewDeposit", amount: operation.assets };
+    case "Mint":
+      return { functionName: "previewMint", amount: operation.shares };
+    case "Withdraw":
+      return { functionName: "previewWithdraw", amount: operation.assets };
+    case "Redeem":
+      return { functionName: "previewRedeem", amount: operation.shares };
+  }
+}
+async function simulatePoolOpMulticall(input, options = {}) {
+  const { sdk, operation, wallet } = input;
+  const { blockNumber } = options;
+  const { underlying, pool } = operation;
+  const holders = watchedHolders(operation, wallet);
+  const tokens = [underlying, pool];
+  const balanceCalls = holders.flatMap(
+    (holder) => tokens.map((token) => ({ holder, token }))
+  );
+  const balanceContracts = balanceCalls.map(
+    ({ holder, token }) => ({
+      address: token,
+      abi: ierc20Abi,
+      functionName: "balanceOf",
+      args: [holder]
+    })
+  );
+  const { functionName, amount } = previewRead(operation);
+  const previewContract = {
+    address: pool,
+    abi: iPoolV310Abi,
+    functionName,
+    args: [amount]
+  };
+  let results;
+  try {
+    results = await sdk.client.multicall({
+      allowFailure: false,
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber,
+      contracts: [...balanceContracts, previewContract]
+    });
+  } catch (cause) {
+    throw new PreviewSimulationError([
+      {
+        source: "multicall",
+        detail: decodeSimulationError({
+          error: cause instanceof Error ? cause : new Error(String(cause))
+        })
+      }
+    ]);
+  }
+  const previewAmount = results[balanceContracts.length];
+  const balances = new AddressMap();
+  for (const [i, { holder, token }] of balanceCalls.entries()) {
+    const tokenBalances = balances.get(holder) ?? new AddressMap();
+    tokenBalances.upsert(token, results[i]);
+    balances.upsert(holder, tokenBalances);
+  }
+  const before = (token, holder) => balances.get(holder)?.get(token) ?? 0n;
+  return {
+    balanceChanges: computePoolOpBalanceChanges(
+      operation,
+      wallet,
+      previewAmount,
+      before
+    ),
+    transfers: void 0
+  };
+}
+function balanceLegs(operation, wallet, previewAmount) {
+  const { underlying, pool, receiver } = operation;
+  switch (operation.operation) {
+    case "Deposit":
+      return [
+        { address: wallet, token: underlying, delta: -operation.assets },
+        { address: receiver, token: pool, delta: previewAmount }
+      ];
+    case "Mint":
+      return [
+        { address: wallet, token: underlying, delta: -previewAmount },
+        { address: receiver, token: pool, delta: operation.shares }
+      ];
+    case "Withdraw":
+      return [
+        { address: operation.owner, token: pool, delta: -previewAmount },
+        { address: receiver, token: underlying, delta: operation.assets }
+      ];
+    case "Redeem":
+      return [
+        { address: operation.owner, token: pool, delta: -operation.shares },
+        { address: receiver, token: underlying, delta: previewAmount }
+      ];
+  }
+}
+function computePoolOpBalanceChanges(operation, wallet, previewAmount, before) {
+  const byAddress = new AddressMap();
+  for (const { address, token, delta } of balanceLegs(
+    operation,
+    wallet,
+    previewAmount
+  )) {
+    const beforeBalance = before(token, address);
+    const change = {
+      token,
+      before: beforeBalance,
+      after: beforeBalance + delta,
+      delta
+    };
+    const existing = byAddress.get(address);
+    if (existing) {
+      existing.changes.push(change);
+    } else {
+      byAddress.upsert(address, { address, changes: [change] });
+    }
+  }
+  return byAddress.values();
+}
+export {
+  computePoolOpBalanceChanges,
+  simulatePoolOpMulticall
+};

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

@@ -0,0 +1,82 @@
+import { simulateCalls } from "viem/actions";
+import { ierc20Abi } from "../../abi/iERC20.js";
+import { decodeSimulationError, PreviewSimulationError } from "./errors.js";
+import { extractERC20Transfers } from "./extractERC20Transfers.js";
+import { watchedHolders } from "./holders.js";
+async function simulatePoolOpV1(input, options = {}) {
+  const { sdk, operation, to, calldata, wallet } = input;
+  const { blockNumber } = options;
+  const { underlying, pool } = operation;
+  const holders = watchedHolders(operation, wallet);
+  const tokens = [underlying, pool];
+  const balanceOf = (token, holder) => ({
+    to: token,
+    abi: ierc20Abi,
+    functionName: "balanceOf",
+    args: [holder]
+  });
+  const balanceCalls = holders.flatMap(
+    (holder) => tokens.map((token) => balanceOf(token, holder))
+  );
+  let results;
+  try {
+    ({ results } = await simulateCalls(sdk.client, {
+      account: wallet,
+      // `undefined` lets viem simulate at `latest`; `blockNumber` is only set
+      // for testnet forks pinned to a specific block.
+      blockNumber,
+      calls: [...balanceCalls, { to, data: calldata }, ...balanceCalls]
+    }));
+  } catch (cause) {
+    throw new PreviewSimulationError([
+      {
+        source: "eth_simulateV1",
+        detail: decodeSimulationError({
+          error: cause instanceof Error ? cause : new Error(String(cause))
+        })
+      }
+    ]);
+  }
+  const sim = results;
+  const txIndex = balanceCalls.length;
+  const afterOffset = txIndex + 1;
+  const txResult = sim[txIndex];
+  if (!txResult || txResult.status === "failure") {
+    throw new PreviewSimulationError([
+      {
+        source: "eth_simulateV1",
+        detail: decodeSimulationError({
+          error: txResult?.error,
+          data: txResult?.data
+        })
+      }
+    ]);
+  }
+  const balanceChanges = [];
+  for (const [holderIndex, address] of holders.entries()) {
+    const changes = [];
+    for (const [tokenIndex, token] of tokens.entries()) {
+      const slot = holderIndex * tokens.length + tokenIndex;
+      const before = readBalance(sim[slot]);
+      const after = readBalance(sim[afterOffset + slot]);
+      const delta = after - before;
+      const magnitude = delta >= 0n ? delta : -delta;
+      if (magnitude > 1n) {
+        changes.push({ token, before, after, delta });
+      }
+    }
+    if (changes.length > 0) {
+      balanceChanges.push({ address, changes });
+    }
+  }
+  return {
+    transfers: extractERC20Transfers(txResult.logs ?? [], holders),
+    balanceChanges
+  };
+}
+function readBalance(result) {
+  return result?.status === "success" ? result.result : 0n;
+}
+export {
+  simulatePoolOpV1
+};

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

@@ -1,69 +1,37 @@
-import { isAddressEqual } from "viem";
-import { simulateCalls } from "viem/actions";
-import { ierc20Abi } from "../../abi/iERC20.js";
-import { decodeSimulationError } from "./decodeSimulationError.js";
-import { extractERC20Transfers } from "./extractERC20Transfers.js";
-async function simulatePoolOperation(input) {
-  const { sdk, operation, to, calldata, wallet, blockNumber } = input;
-  const { underlying, pool } = operation;
-  const receiverIsWallet = isAddressEqual(operation.receiver, wallet);
-  const holders = receiverIsWallet ? [wallet] : [wallet, operation.receiver];
-  const tokens = [underlying, pool];
-  const balanceOf = (token, holder) => ({
-    to: token,
-    abi: ierc20Abi,
-    functionName: "balanceOf",
-    args: [holder]
-  });
-  const balanceCalls = holders.flatMap(
-    (holder) => tokens.map((token) => balanceOf(token, holder))
+import {
+  asPreviewSimulationError,
+  combinePreviewSimulationErrors
+} from "./errors.js";
+import { simulatePoolOpMulticall } from "./simulatePoolOpMulticall.js";
+import { simulatePoolOpV1 } from "./simulatePoolOpV1.js";
+async function simulatePoolOperation(input, options = {}) {
+  const { logger, useSimulateV1 } = options;
+  logger?.debug(
+    { wallet: input.wallet, to: input.to },
+    "simulating pool operation"
   );
-  const { results } = await simulateCalls(sdk.client, {
-    account: wallet,
-    // `undefined` lets viem simulate at `latest`; `blockNumber` is only set for
-    // testnet forks pinned to a specific block.
-    blockNumber,
-    calls: [...balanceCalls, { to, data: calldata }, ...balanceCalls]
-  });
-  const sim = results;
-  const txIndex = balanceCalls.length;
-  const afterOffset = txIndex + 1;
-  const txResult = sim[txIndex];
-  if (!txResult || txResult.status === "failure") {
-    return {
-      status: "failure",
-      error: decodeSimulationError({
-        error: txResult?.error,
-        data: txResult?.data
-      })
-    };
+  const [v1, multicall] = await Promise.allSettled([
+    useSimulateV1 ? simulatePoolOpV1(input, options) : void 0,
+    simulatePoolOpMulticall(input, options)
+  ]);
+  if (v1.status === "fulfilled" && v1.value) {
+    return { status: "success", ...v1.value };
   }
-  const balanceChanges = [];
-  for (const [holderIndex, address] of holders.entries()) {
-    const changes = [];
-    for (const [tokenIndex, token] of tokens.entries()) {
-      const slot = holderIndex * tokens.length + tokenIndex;
-      const before = readBalance(sim[slot]);
-      const after = readBalance(sim[afterOffset + slot]);
-      const delta = after - before;
-      const magnitude = delta >= 0n ? delta : -delta;
-      if (magnitude > 1n) {
-        changes.push({ token, before, after, delta });
-      }
-    }
-    if (changes.length > 0) {
-      balanceChanges.push({ address, changes });
+  if (multicall.status === "fulfilled") {
+    if (v1.status === "rejected") {
+      logger?.debug(
+        asPreviewSimulationError(v1.reason, "eth_simulateV1"),
+        "eth_simulateV1 flow failed; falling back to multicall result"
+      );
     }
+    return { status: "success", ...multicall.value };
   }
-  return {
-    status: "success",
-    transfers: extractERC20Transfers(txResult.logs ?? [], holders),
-    balanceChanges,
-    gasUsed: txResult.gasUsed
-  };
-}
-function readBalance(result) {
-  return result?.status === "success" ? result.result : 0n;
+  const error = combinePreviewSimulationErrors(
+    v1.status === "rejected" ? asPreviewSimulationError(v1.reason, "eth_simulateV1") : void 0,
+    asPreviewSimulationError(multicall.reason, "multicall")
+  );
+  logger?.error(error, "pool operation simulation failed");
+  return { status: "failure", error };
 }
 export {
   simulatePoolOperation

package/dist/types/preview/parse/parsePoolOperationCalldata.d.ts

@@ -8,8 +8,10 @@ export interface ParsePoolOperationCalldataProps {
     calldata: Hex;
 }
 /**
- * Decodes ERC4626 `deposit`/`depositWithReferral`/`redeem` calldata on a
- * Gearbox pool into a {@link PoolOperation}. Any other selector throws
+ * Decodes ERC4626 pool calldata into a {@link PoolOperation}. Supports every
+ * deposit/mint/withdraw/redeem variant of `IPoolV3` (and the `IERC4626` base it
+ * extends): `deposit`/`depositWithReferral`, `mint`/`mintWithReferral`,
+ * `withdraw` and `redeem`. Any other selector throws
  * {@link UnsupportedPoolFunctionError}.
  */
 export declare function parsePoolOperationCalldata(props: ParsePoolOperationCalldataProps): PoolOperation;