@gearbox-protocol/sdk 14.10.7 → 14.11.0-next.2

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

@@ -0,0 +1,108 @@
+import { zeroAddress } from "viem";
+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) {
+      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()
+      });
+      continue;
+    }
+    if (contract !== void 0) {
+      const op = classifyFacadeInnerCall(call, underlying);
+      if (op) result.push(op);
+      continue;
+    }
+    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;
+}
+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;
+  }
+}
+function mockLegacyOperation() {
+  return {
+    operation: "Swap",
+    from: zeroAddress,
+    fromAmount: "0",
+    to: zeroAddress,
+    toAmount: "0"
+  };
+}
+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/index.js

@@ -0,0 +1,6 @@
+export * from "./classifyInnerOperations.js";
+export * from "./errors.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,
+  zeroHash
+} from "viem";
+import { classifyInnerOperations } from "./classifyInnerOperations.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,
+    blockNumber: Number(sdk.currentBlock),
+    txHash: zeroHash,
+    timestamp: 0
+  };
+  const innerCalls = rawArgs.calls ?? [];
+  const multicall = classifyInnerOperations(innerCalls, {
+    sdk,
+    underlying: suite.underlying
+  });
+  switch (functionName) {
+    case "multicall":
+      return {
+        ...metadata,
+        operation: "MultiCall",
+        creditAccount: rawArgs.creditAccount,
+        multicall
+      };
+    case "botMulticall":
+      return {
+        ...metadata,
+        operation: "BotMulticall",
+        creditAccount: rawArgs.creditAccount,
+        multicall
+      };
+    case "openCreditAccount":
+      return {
+        ...metadata,
+        operation: "OpenCreditAccount",
+        creditAccount: zeroAddress,
+        onBehalfOf: rawArgs.onBehalfOf,
+        referralCode: rawArgs.referralCode,
+        multicall
+      };
+    case "closeCreditAccount":
+      return {
+        ...metadata,
+        operation: "CloseCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        multicall
+      };
+    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
+      };
+    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,38 @@
+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,
+        // Calldata-only parse: transfers are recovered later by simulation.
+        transfers: []
+      };
+    case "redeem":
+      return {
+        operation: "Redeem",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        owner: rawArgs.owner,
+        shares: rawArgs.shares,
+        underlying,
+        // Calldata-only parse: transfers are recovered later by simulation.
+        transfers: []
+      };
+    default:
+      throw new UnsupportedPoolFunctionError(pool.address, parsed.functionName);
+  }
+}
+export {
+  parsePoolOperationCalldata
+};

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

@@ -0,0 +1,6 @@
+function isPoolOperation(tx) {
+  return tx.operation === "Deposit" || 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
+};

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,117 @@
+import { isAddressEqual } from "viem";
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+function buildPrerequisites(tx, ctx) {
+  const { wallet } = ctx;
+  switch (tx.operation) {
+    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 "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 "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,6 @@
+export * from "./AllowancePrerequisite.js";
+export * from "./BalancePrerequisite.js";
+export * from "./buildPrerequisites.js";
+export * from "./Prerequisite.js";
+export * from "./runPrerequisites.js";
+export * from "./types.js";

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/decodeSimulationError.js

@@ -0,0 +1,44 @@
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  decodeErrorResult
+} from "viem";
+import { errorAbis } from "../../abi/errors.js";
+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 {
+  decodeSimulationError
+};