@gearbox-protocol/sdk 14.11.3 → 14.12.0-next.10

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/prerequisites/runPrerequisites.js

@@ -0,0 +1,47 @@
+async function verifyPrerequisites(prereqs, ctx) {
+  if (prereqs.length === 0) {
+    return [];
+  }
+  const ranges = [];
+  const calls = [];
+  for (const prereq of prereqs) {
+    const start = calls.length;
+    calls.push(...prereq.calls(ctx));
+    ranges.push({ start, end: calls.length });
+  }
+  let results;
+  try {
+    results = await ctx.sdk.client.multicall({
+      allowFailure: true,
+      contracts: calls,
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber: ctx.blockNumber
+    });
+  } catch (cause) {
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    return prereqs.map(
+      (prereq, i) => (
+        // Each prereq pairs its own kind with its detail, so the widened
+        // `resolve` return is safe to narrow back to the discriminated union.
+        prereq.resolve(
+          failureSlice(ranges[i].end - ranges[i].start, error)
+        )
+      )
+    );
+  }
+  return prereqs.map(
+    (prereq, i) => prereq.resolve(
+      results.slice(ranges[i].start, ranges[i].end)
+    )
+  );
+}
+function failureSlice(n, error) {
+  return Array.from({ length: n }, () => ({
+    status: "failure",
+    error
+  }));
+}
+export {
+  verifyPrerequisites
+};

package/dist/esm/preview/preview/applyInnerOperations.js

@@ -0,0 +1,110 @@
+import { AbstractAdapterContract } from "../../plugins/adapters/index.js";
+import {
+  AssetsMap,
+  MAX_UINT256,
+  MIN_INT96
+} from "../../sdk/index.js";
+function makeInnerOperationsState() {
+  return {
+    balances: new AssetsMap(),
+    debt: 0n,
+    totalDebt: 0n,
+    collateralAdded: new AssetsMap(),
+    collateralWithdrawn: new AssetsMap(),
+    quotaChanges: []
+  };
+}
+function applyInnerOperations(sdk, multicall, state) {
+  let inBracket = false;
+  let storeSeen = false;
+  for (const op of multicall) {
+    switch (op.operation) {
+      case "AddCollateral":
+        state.collateralAdded.inc(op.token, op.amount);
+        state.balances.inc(op.token, op.amount);
+        break;
+      case "WithdrawCollateral": {
+        const running = state.balances.get(op.token) ?? 0n;
+        const amount = op.amount === MAX_UINT256 ? running > 0n ? running : 0n : op.amount;
+        state.balances.dec(op.token, amount);
+        state.collateralWithdrawn.inc(op.token, amount);
+        break;
+      }
+      case "IncreaseBorrowedAmount":
+        state.debt += op.amount;
+        state.totalDebt += op.amount;
+        state.balances.inc(op.token, op.amount);
+        break;
+      case "DecreaseBorrowedAmount": {
+        const repaid = op.amount > state.totalDebt ? state.totalDebt : op.amount;
+        state.balances.dec(op.token, repaid);
+        state.totalDebt -= repaid;
+        if (state.debt > state.totalDebt) {
+          state.debt = state.totalDebt;
+        }
+        break;
+      }
+      case "UpdateQuota":
+        state.quotaChanges.push({ token: op.token, balance: op.change });
+        break;
+      case "StoreExpectedBalances":
+        if (storeSeen) {
+          throw new Error(
+            "malformed multicall: duplicate storeExpectedBalances call"
+          );
+        }
+        storeSeen = true;
+        inBracket = true;
+        for (const { token, balance } of op.deltas) {
+          state.balances.inc(token, balance);
+        }
+        break;
+      case "CompareBalances":
+        if (!inBracket) {
+          throw new Error(
+            "malformed multicall: compareBalances without a preceding storeExpectedBalances"
+          );
+        }
+        inBracket = false;
+        break;
+      case "Execute":
+        if (inBracket) {
+          const adapter = sdk.getContract(op.adapter);
+          if (!(adapter instanceof AbstractAdapterContract)) {
+            throw new Error(
+              `call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`
+            );
+          }
+          adapter.previewBalanceChanges(state.balances, op.calldata);
+        }
+        break;
+    }
+  }
+  if (inBracket) {
+    throw new Error(
+      "malformed multicall: storeExpectedBalances without a matching compareBalances"
+    );
+  }
+}
+function applyQuotaChanges(initialQuotas, changes) {
+  const final = initialQuotas.clone();
+  for (const { token, balance: change } of changes) {
+    if (change === MIN_INT96) {
+      final.upsert(token, 0n);
+    } else {
+      const next = (final.get(token) ?? 0n) + change;
+      final.upsert(token, next > 0n ? next : 0n);
+    }
+  }
+  const quotas = final.entries().filter(([, balance]) => balance > 0n).map(([token, balance]) => ({ token, balance }));
+  const quotasChange = final.entries().map(([token, balance]) => ({
+    token,
+    balance: balance - (initialQuotas.get(token) ?? 0n)
+  })).filter(({ balance }) => balance !== 0n);
+  return { quotas, quotasChange };
+}
+export {
+  applyInnerOperations,
+  applyQuotaChanges,
+  makeInnerOperationsState
+};

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

@@ -0,0 +1,27 @@
+class InvalidTransactionValueError extends Error {
+  /** Transaction `msg.value`. */
+  value;
+  /** Amount of wrapped native token added as collateral. */
+  wethCollateral;
+  constructor(value, wethCollateral) {
+    super(
+      `transaction value ${value} exceeds WETH collateral ${wethCollateral}`
+    );
+    this.name = "InvalidTransactionValueError";
+    this.value = value;
+    this.wethCollateral = wethCollateral;
+  }
+}
+class UnsupportedOperationError extends Error {
+  /** The parsed operation kind (the `operation` discriminant). */
+  operation;
+  constructor(operation) {
+    super(`operation "${operation}" is not supported by previewOperation`);
+    this.name = "UnsupportedOperationError";
+    this.operation = operation;
+  }
+}
+export {
+  InvalidTransactionValueError,
+  UnsupportedOperationError
+};

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

@@ -0,0 +1,5 @@
+export * from "./applyInnerOperations.js";
+export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewOperation.js";
+export * from "./types.js";

package/dist/esm/preview/preview/previewAdjustCreditAccount.js

@@ -0,0 +1,79 @@
+import {
+  AP_WETH_TOKEN,
+  AssetsMap,
+  NO_VERSION
+} from "../../sdk/index.js";
+import {
+  applyInnerOperations,
+  applyQuotaChanges,
+  makeInnerOperationsState
+} from "./applyInnerOperations.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+async function previewAdjustCreditAccount(input, operation, options) {
+  const { sdk, value = 0n } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  let ca = options?.creditAccount;
+  if (!ca) {
+    ca = await sdk.accounts.getCreditAccountData(
+      operation.creditAccount,
+      options?.blockNumber
+    );
+  }
+  if (!ca) {
+    throw new Error(`credit account ${operation.creditAccount} not found`);
+  }
+  const initialBalances = new AssetsMap();
+  const initialQuotas = new AssetsMap();
+  for (const t of ca.tokens) {
+    if (t.balance > 1n) {
+      initialBalances.upsert(t.token, t.balance);
+    }
+    if (t.quota > 1n) {
+      initialQuotas.upsert(t.token, t.quota);
+    }
+  }
+  const state = makeInnerOperationsState();
+  for (const [token, balance] of initialBalances.entries()) {
+    state.balances.upsert(token, balance);
+  }
+  state.debt = ca.debt;
+  state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+  applyInnerOperations(sdk, operation.multicall, state);
+  const collateralAdded = unwrapNativeCollateral(
+    state.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  const { quotas, quotasChange } = applyQuotaChanges(
+    initialQuotas,
+    state.quotaChanges
+  );
+  const assets = state.balances.toAssets(true);
+  const assetsChange = state.balances.entries().map(([token, balance]) => ({
+    token,
+    balance: balance - (initialBalances.get(token) ?? 0n)
+  })).filter(({ balance }) => balance !== 0n);
+  const totalValue = assets.reduce(
+    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
+    0n
+  );
+  return {
+    operation: "AdjustCreditAccount",
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    collateralWithdrawn: state.collateralWithdrawn.toAssets(),
+    totalValue,
+    debt: state.debt,
+    debtChange: state.debt - ca.debt,
+    quotas,
+    quotasChange,
+    assets,
+    assetsChange
+  };
+}
+export {
+  previewAdjustCreditAccount
+};

package/dist/esm/preview/preview/previewOpenCreditAccount.js

@@ -0,0 +1,51 @@
+import {
+  AP_WETH_TOKEN,
+  NO_VERSION
+} from "../../sdk/index.js";
+import {
+  applyInnerOperations,
+  makeInnerOperationsState
+} from "./applyInnerOperations.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+function previewOpenCreditAccount(input, operation) {
+  const { sdk, value = 0n } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const state = makeInnerOperationsState();
+  applyInnerOperations(sdk, operation.multicall, state);
+  let collateral = state.collateralAdded.toAssets();
+  const collateralValue = collateral.reduce(
+    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
+    0n
+  );
+  collateral = unwrapNativeCollateral(
+    collateral,
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  const assets = state.balances.entries().filter(([, balance]) => balance > 1n).map(([token, balance]) => ({ token, balance }));
+  return {
+    operation: operation.operation,
+    creditManager: operation.creditManager,
+    target: inferTargetAsset(operation.multicall, state.balances),
+    collateral,
+    collateralValue,
+    debt: state.debt,
+    // On opening, initial quotas are zero, so the raw changes are the quotas.
+    quotas: state.quotaChanges,
+    assets
+  };
+}
+function inferTargetAsset(multicall, balances) {
+  for (const op of multicall) {
+    if (op.operation === "UpdateQuota" && op.change > 0n) {
+      const balance = balances.get(op.token);
+      return balance ? { token: op.token, balance } : void 0;
+    }
+  }
+  return void 0;
+}
+export {
+  previewOpenCreditAccount
+};

package/dist/esm/preview/preview/previewOperation.js

@@ -0,0 +1,21 @@
+import { isPoolOperation, parseOperationCalldata } from "../parse/index.js";
+import { UnsupportedOperationError } from "./errors.js";
+import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
+import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
+import { previewPoolOperation } from "./previewPoolOperation.js";
+async function previewOperation(input, options) {
+  const operation = parseOperationCalldata(input);
+  if (isPoolOperation(operation)) {
+    return previewPoolOperation(input, operation, options);
+  }
+  if (operation.operation === "OpenCreditAccount" || operation.operation === "SecuritizeOpenCreditAccount") {
+    return previewOpenCreditAccount(input, operation);
+  }
+  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "SecuritizeMulticall") {
+    return previewAdjustCreditAccount(input, operation, options);
+  }
+  throw new UnsupportedOperationError(operation.operation);
+}
+export {
+  previewOperation
+};

package/dist/esm/preview/preview/previewPoolOperation.js

@@ -0,0 +1,53 @@
+import {
+  simulatePoolOperation
+} from "../simulate/index.js";
+async function previewPoolOperation(input, operation, options) {
+  const { sdk, to, calldata } = input;
+  const { tokenIn, tokenOut } = operation;
+  const sim = await simulatePoolOperation(
+    { sdk, operation, to, calldata },
+    options
+  );
+  if (sim.status === "success") {
+    return {
+      operation: operation.operation,
+      pool: operation.pool,
+      tokenIn: { token: tokenIn, balance: sim.amountIn },
+      tokenOut: { token: tokenOut, balance: sim.amountOut }
+    };
+  }
+  const { error } = sim;
+  switch (operation.operation) {
+    case "Deposit":
+      return {
+        operation: "Deposit",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, balance: operation.assets },
+        tokenOut: { token: tokenOut, error }
+      };
+    case "Mint":
+      return {
+        operation: "Mint",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, error },
+        tokenOut: { token: tokenOut, balance: operation.shares }
+      };
+    case "Withdraw":
+      return {
+        operation: "Withdraw",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, error },
+        tokenOut: { token: tokenOut, balance: operation.assets }
+      };
+    case "Redeem":
+      return {
+        operation: "Redeem",
+        pool: operation.pool,
+        tokenIn: { token: tokenIn, balance: operation.shares },
+        tokenOut: { token: tokenOut, error }
+      };
+  }
+}
+export {
+  previewPoolOperation
+};

package/dist/esm/preview/preview/unwrapNativeCollateral.js

@@ -0,0 +1,21 @@
+import { AssetsMap, NATIVE_ADDRESS } from "../../sdk/index.js";
+import { InvalidTransactionValueError } from "./errors.js";
+function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
+  if (nativeAmount === 0n) {
+    return collateral;
+  }
+  const balances = new AssetsMap(collateral);
+  const wethBalance = balances.get(wethToken) ?? 0n;
+  if (wethBalance < nativeAmount) {
+    throw new InvalidTransactionValueError(nativeAmount, wethBalance);
+  }
+  balances.upsert(
+    wethToken,
+    wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount
+  );
+  balances.inc(NATIVE_ADDRESS, nativeAmount);
+  return balances.toAssets();
+}
+export {
+  unwrapNativeCollateral
+};

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

@@ -0,0 +1,69 @@
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  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 decodeSimulationError(revert) {
+  const { error, data } = revert;
+  if (data && data !== "0x") {
+    try {
+      const decoded = decodeErrorResult({ abi: errorAbis, data });
+      return {
+        reason: formatDecodedError(decoded.errorName, decoded.args),
+        cause: error
+      };
+    } catch {
+    }
+  }
+  if (error instanceof BaseError) {
+    const reverted = error.walk(
+      (e) => e instanceof ContractFunctionRevertedError
+    );
+    if (reverted instanceof ContractFunctionRevertedError) {
+      return {
+        reason: reverted.data?.errorName ?? reverted.reason ?? reverted.shortMessage ?? "reverted",
+        cause: error
+      };
+    }
+    return { reason: error.shortMessage ?? error.name, cause: error };
+  }
+  if (error instanceof Error) {
+    return { reason: error.message, cause: error };
+  }
+  return { reason: "reverted", cause: error };
+}
+function formatDecodedError(errorName, args) {
+  if (!args || args.length === 0) {
+    return errorName;
+  }
+  return `${errorName}(${args.map((arg) => String(arg)).join(", ")})`;
+}
+export {
+  PreviewSimulationError,
+  asPreviewSimulationError,
+  decodeSimulationError
+};

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

@@ -0,0 +1,12 @@
+import { PreviewSimulationError } from "./errors.js";
+import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
+import { simulateOperation } from "./simulateOperation.js";
+import { simulatePoolOperation } from "./simulatePoolOperation.js";
+import { simulateRWAOperation } from "./simulateRWAOperation.js";
+export {
+  PreviewSimulationError,
+  simulateFacadeOperation,
+  simulateOperation,
+  simulatePoolOperation,
+  simulateRWAOperation
+};

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

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

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

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

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

@@ -0,0 +1,67 @@
+import { iPoolV310Abi } from "../../abi/310/generated.js";
+import { iZapperAbi } from "../../abi/iZapper.js";
+import { asPreviewSimulationError } from "./errors.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 };
+  }
+}
+function previewContract(operation) {
+  const { functionName, amount } = previewRead(operation);
+  if (operation.zapper) {
+    return {
+      address: operation.zapper,
+      abi: iZapperAbi,
+      functionName,
+      args: [amount]
+    };
+  }
+  return {
+    address: operation.pool,
+    abi: iPoolV310Abi,
+    functionName,
+    args: [amount]
+  };
+}
+function amountsInOut(operation, previewAmount) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { amountIn: operation.assets, amountOut: previewAmount };
+    case "Mint":
+      return { amountIn: previewAmount, amountOut: operation.shares };
+    case "Withdraw":
+      return { amountIn: previewAmount, amountOut: operation.assets };
+    case "Redeem":
+      return { amountIn: operation.shares, amountOut: previewAmount };
+  }
+}
+async function simulatePoolOperation(input, options = {}) {
+  const { sdk, operation } = input;
+  const { blockNumber, logger } = options;
+  try {
+    const previewAmount = await sdk.client.readContract({
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber,
+      ...previewContract(operation)
+    });
+    return {
+      status: "success",
+      ...amountsInOut(operation, previewAmount)
+    };
+  } catch (cause) {
+    const error = asPreviewSimulationError(cause, "multicall");
+    logger?.error(error, "pool operation simulation failed");
+    return { status: "failure", error };
+  }
+}
+export {
+  simulatePoolOperation
+};

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

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

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

@@ -22,28 +22,6 @@ 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(
@@ -63,8 +41,6 @@ class UnknownFacadeCallError extends Error {
   }
 }
 export {
-  AdapterTraceAlignmentError,
-  ProtocolCallNotFoundError,
   TransferAlignmentError,
   UnexpectedFacadeEventOrderError,
   UnknownAdapterError,