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

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

@@ -0,0 +1,56 @@
+import { erc20Abi } from "viem";
+import {
+  Prerequisite,
+  toPrerequisiteError
+} from "./Prerequisite.js";
+class BalancePrerequisite extends Prerequisite {
+  _id;
+  _title;
+  _detail;
+  constructor(props) {
+    super();
+    this._id = props.id ?? `balance:${props.token}:${props.owner}`;
+    this._title = props.title ?? "Sufficient balance";
+    this._detail = {
+      token: props.token,
+      owner: props.owner,
+      required: props.required
+    };
+  }
+  get id() {
+    return this._id;
+  }
+  get kind() {
+    return "balance";
+  }
+  get title() {
+    return this._title;
+  }
+  get detail() {
+    return this._detail;
+  }
+  calls() {
+    return [
+      {
+        address: this._detail.token,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [this._detail.owner]
+      }
+    ];
+  }
+  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 {
+  BalancePrerequisite
+};

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

@@ -0,0 +1,63 @@
+import {
+  BaseError,
+  ContractFunctionRevertedError
+} from "viem";
+function toPrerequisiteError(cause) {
+  if (cause instanceof BaseError) {
+    const reverted = cause.walk(
+      (e) => e instanceof ContractFunctionRevertedError
+    );
+    if (reverted instanceof ContractFunctionRevertedError) {
+      return {
+        reason: reverted.data?.errorName ?? reverted.shortMessage ?? "reverted",
+        cause
+      };
+    }
+    return { reason: cause.shortMessage ?? cause.name, cause };
+  }
+  if (cause instanceof Error) {
+    return { reason: cause.message, cause };
+  }
+  return { reason: "unknown error", cause };
+}
+class Prerequisite {
+  /**
+   * Verifies this prerequisite on its own using an `allowFailure` multicall.
+   * Prefer `verifyPrerequisites` to batch several checks into one round-trip.
+   */
+  async verify(ctx) {
+    const calls = this.calls(ctx);
+    const 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
+    });
+    return this.resolve(results);
+  }
+  /** Builds a successful result; `detail` carries the on-chain `actual`. */
+  satisfiedResult(satisfied, detail) {
+    return {
+      id: this.id,
+      kind: this.kind,
+      title: this.title,
+      detail,
+      satisfied
+    };
+  }
+  /** Builds a failed result from a decoded read error. */
+  errorResult(error) {
+    return {
+      id: this.id,
+      kind: this.kind,
+      title: this.title,
+      detail: this.detail,
+      error
+    };
+  }
+}
+export {
+  Prerequisite,
+  toPrerequisiteError
+};

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

@@ -0,0 +1,163 @@
+import { isAddressEqual } from "viem";
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+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({
+          token: tx.underlying,
+          owner: wallet,
+          spender: tx.pool,
+          required: tx.assets,
+          title: "Token approved to pool"
+        }),
+        new BalancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          required: tx.assets,
+          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({
+          token: tx.pool,
+          owner: tx.owner,
+          required: tx.shares,
+          title: "Sufficient LP token balance"
+        })
+      ];
+      if (!isAddressEqual(tx.owner, wallet)) {
+        prereqs.push(
+          new AllowancePrerequisite({
+            token: tx.pool,
+            owner: tx.owner,
+            spender: wallet,
+            required: tx.shares,
+            title: "LP token approved to caller"
+          })
+        );
+      }
+      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":
+    case "CloseCreditAccount":
+    case "LiquidateCreditAccount":
+      return collateralPrerequisites(tx.multicall, tx.creditManager, wallet);
+    case "PartiallyLiquidateCreditAccount": {
+      const underlying = underlyingOf(ctx.sdk, tx.creditManager);
+      if (!underlying || tx.repaidAmount === 0n) {
+        return [];
+      }
+      return [
+        new AllowancePrerequisite({
+          token: underlying,
+          owner: wallet,
+          spender: tx.creditManager,
+          required: tx.repaidAmount,
+          title: "Underlying approved to credit manager"
+        }),
+        new BalancePrerequisite({
+          token: underlying,
+          owner: wallet,
+          required: tx.repaidAmount,
+          title: "Sufficient underlying balance"
+        })
+      ];
+    }
+    default:
+      return [];
+  }
+}
+function collateralPrerequisites(multicall, creditManager, wallet) {
+  const required = /* @__PURE__ */ new Map();
+  for (const op of multicall) {
+    if (op.operation !== "AddCollateral" || op.amount === 0n) {
+      continue;
+    }
+    const key = op.token.toLowerCase();
+    const existing = required.get(key);
+    required.set(key, {
+      token: op.token,
+      amount: (existing?.amount ?? 0n) + op.amount
+    });
+  }
+  const prereqs = [];
+  for (const { token, amount } of required.values()) {
+    prereqs.push(
+      new AllowancePrerequisite({
+        token,
+        owner: wallet,
+        spender: creditManager,
+        required: amount,
+        title: "Collateral approved to credit manager"
+      }),
+      new BalancePrerequisite({
+        token,
+        owner: wallet,
+        required: amount,
+        title: "Sufficient collateral balance"
+      })
+    );
+  }
+  return prereqs;
+}
+function underlyingOf(sdk, creditManager) {
+  const suite = sdk.marketRegister.creditManagers.find(
+    (cm) => isAddressEqual(cm.creditManager.address, creditManager)
+  );
+  return suite?.underlying;
+}
+export {
+  buildPrerequisites
+};

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

@@ -0,0 +1,7 @@
+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/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/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/errors.js

@@ -0,0 +1,75 @@
+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 combinePreviewSimulationErrors(...errors) {
+  return new PreviewSimulationError(
+    errors.filter((e) => e).flatMap((e) => e?.failures ?? [])
+  );
+}
+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,
+  combinePreviewSimulationErrors,
+  decodeSimulationError
+};

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

@@ -0,0 +1,23 @@
+import { isAddressEqual, parseEventLogs } from "viem";
+import { ierc20Abi } from "../../abi/iERC20.js";
+function extractERC20Transfers(logs, watch) {
+  const parsed = parseEventLogs({
+    abi: ierc20Abi,
+    eventName: "Transfer",
+    logs
+  });
+  const transfers = [];
+  for (const log of parsed) {
+    const { from, to, value } = log.args;
+    const involved = watch.some(
+      (address) => isAddressEqual(from, address) || isAddressEqual(to, address)
+    );
+    if (involved) {
+      transfers.push({ token: log.address, amount: value, from, to });
+    }
+  }
+  return transfers;
+}
+export {
+  extractERC20Transfers
+};

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

@@ -0,0 +1,12 @@
+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

@@ -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,13 @@
+import { isPoolOperation } from "../parse/index.js";
+import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
+import { simulatePoolOperation } from "./simulatePoolOperation.js";
+async function simulateOperation(input, options) {
+  const { operation } = input;
+  if (isPoolOperation(operation)) {
+    return simulatePoolOperation({ ...input, operation }, options);
+  }
+  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
+};