@gearbox-protocol/sdk 0.0.99 → 0.0.102

package/src/core/creditManager.ts

@@ -1,174 +1,257 @@
-import {BigNumber, ethers, Signer} from "ethers";
-import {formatBN} from "../utils/formatter";
+import { BigNumber, ethers, Signer } from "ethers";
 import {
-    PERCENTAGE_FACTOR,
-    RAY,
-    UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD
-} from "./constants";
-import {
-    CreditManagerDataPayload,
-    CreditManagerStatPayload
+  CreditManagerDataPayload,
+  CreditManagerStatPayload
 } from "../payload/creditManager";
-import {ICreditManager, ICreditManager__factory} from "../types";
+
+import {
+  ICreditManager,
+  ICreditManager__factory,
+  ICreditFacade__factory
+} from "../types";
+
+import { MultiCall } from "./multicall";
+import {
+  PERCENTAGE_FACTOR,
+  RAY,
+  UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD,
+  LEVERAGE_DECIMALS,
+  PERCENTAGE_DECIMALS
+} from "./constants";
+import { OpenAccountError } from "./errors";
 
 export class CreditManagerData {
-    public readonly id: string;
-    public readonly address: string;
-    public readonly underlyingToken: string;
-    public readonly isWETH: boolean;
-    public readonly canBorrow: boolean;
-    public readonly borrowRate: number;
-    public readonly minAmount: BigNumber;
-    public readonly maxAmount: BigNumber;
-    public readonly maxLeverageFactor: number;
-    public readonly availableLiquidity: BigNumber;
-    public readonly allowedTokens: Array<string>;
-    public readonly adapters: Record<string, string> = {};
-    public readonly version: number = 1;
-
-    constructor(payload: CreditManagerDataPayload) {
-        this.id = payload.addr;
-        this.address = payload.addr;
-
-        this.underlyingToken = payload.underlyingToken || "";
-        this.isWETH = payload.isWETH || false;
-        this.canBorrow = payload.canBorrow || false;
-        this.borrowRate =
-            BigNumber.from(payload.borrowRate || 0)
-                .mul(PERCENTAGE_FACTOR)
-                .mul(100)
-                .div(RAY)
-                .toNumber() / PERCENTAGE_FACTOR;
-        this.minAmount = BigNumber.from(payload.minAmount || 0);
-        this.maxAmount = BigNumber.from(payload.maxAmount || 0);
-        this.maxLeverageFactor = BigNumber.from(
-            payload.maxLeverageFactor || 0
-        ).toNumber();
-        this.availableLiquidity = BigNumber.from(payload.availableLiquidity || 0);
-        this.allowedTokens = payload.allowedTokens || [];
-        payload.adapters?.forEach(a => {
-            this.adapters[a.allowedContract] = a.adapter;
-        });
-    }
-
-    validateOpenAccount(
-        balance: BigNumber,
-        decimals: number,
-        amount_BN: BigNumber,
-        leverage: number
-    ): string | null {
-        if (balance.lt(amount_BN)) return "Insufficient funds";
-
-        if (amount_BN.lt(this.minAmount))
-            return `Amount is less than minimal (${formatBN(
-                this.minAmount,
-                decimals
-            )})`;
-
-        if (amount_BN.gt(this.maxAmount))
-            return `Amount is greater than maximum (${formatBN(
-                this.maxAmount,
-                decimals
-            )})`;
-
-        if (leverage > this.maxLeverageFactor) return `Leverage is bigger than max`;
-
-        if (amount_BN.mul(leverage).div(100).gt(this.availableLiquidity))
-            return "Insufficient liquidity in the pool";
-
-        return null;
-    }
-
-    getContractETH(
-        signer: Signer | ethers.providers.Provider
-    ): ICreditManager {
-        return ICreditManager__factory.connect(this.address, signer);
-    }
-
-    get isPaused(): boolean {
-        return false;
-    }
+  public readonly id: string;
+  public readonly address: string;
+  public readonly underlyingToken: string;
+  public readonly isWETH: boolean;
+  public readonly canBorrow: boolean;
+  public readonly borrowRate: number;
+  public readonly minAmount: BigNumber;
+  public readonly maxAmount: BigNumber;
+  public readonly maxLeverageFactor: number; // for V1 only
+  public readonly availableLiquidity: BigNumber;
+  public readonly allowedTokens: Array<string>;
+  public readonly adapters: Record<string, string>;
+
+  public readonly liquidationThresholds: Record<string, BigNumber>;
+  public readonly version: number;
+  public readonly creditFacade: string; // V2 only: address of creditFacade
+  public readonly isDegenMode: boolean; // V2 only: true if contract is in Degen mode
+  public readonly degenNFT: string; // V2 only: degenNFT, address(0) if not in degen mode
+  public readonly isIncreaseDebtForbidden: boolean; // V2 only: true if increasing debt is forbidden
+  public readonly forbiddenTokenMask: BigNumber; // V2 only: mask which forbids some particular tokens
+
+  constructor(payload: CreditManagerDataPayload) {
+    this.id = payload.addr;
+    this.address = payload.addr;
+
+    this.underlyingToken = payload.underlying || "";
+
+    this.isWETH = payload.isWETH || false;
+    this.canBorrow = payload.canBorrow || false;
+
+    this.borrowRate =
+      BigNumber.from(payload.borrowRate || 0)
+        .mul(PERCENTAGE_FACTOR)
+        .mul(PERCENTAGE_DECIMALS)
+        .div(RAY)
+        .toNumber() / PERCENTAGE_FACTOR;
+    this.minAmount = BigNumber.from(payload.minAmount || 0);
+    this.maxAmount = BigNumber.from(payload.maxAmount || 0);
+
+    this.maxLeverageFactor = BigNumber.from(
+      payload.maxLeverageFactor || 0
+    ).toNumber();
+    this.availableLiquidity = BigNumber.from(payload.availableLiquidity || 0);
+
+    this.allowedTokens = payload.collateralTokens || [];
+    this.adapters = (payload.adapters || []).reduce<Record<string, string>>(
+      (acc, { allowedContract, adapter }) => ({
+        ...acc,
+        [allowedContract]: adapter
+      }),
+      {}
+    );
+
+    this.liquidationThresholds = (payload.liquidationThresholds || []).reduce<
+      Record<string, BigNumber>
+    >((acc, threshold, index) => {
+      const address = payload.collateralTokens[index];
+
+      if (address) acc[address.toLowerCase()] = BigNumber.from(threshold);
+
+      return acc;
+    }, {});
+
+    this.version = BigNumber.from(payload.version || 1).toNumber();
+    this.creditFacade = payload.creditFacade || "";
+    this.isDegenMode = payload.isDegenMode || false;
+    this.degenNFT = payload.degenNFT || "";
+    this.isIncreaseDebtForbidden = payload.isIncreaseDebtForbidden || false;
+    this.forbiddenTokenMask = BigNumber.from(payload.forbiddenTokenMask || 0);
+  }
+
+  get isPaused(): boolean {
+    return false;
+  }
+
+  getContractETH(signer: Signer | ethers.providers.Provider): ICreditManager {
+    return ICreditManager__factory.connect(this.address, signer);
+  }
+
+  contractToAdapter(contractAddress: string): string | undefined {
+    return this.adapters[contractAddress];
+  }
+
+  encodeAddCollateral(
+    accountAddress: string,
+    tokenAddress: string,
+    amount: BigNumber
+  ): MultiCall {
+    if (this.version !== 2)
+      throw new Error("Multicall is eligible only for version 2");
+    return {
+      target: this.creditFacade,
+      callData: ICreditFacade__factory.createInterface().encodeFunctionData(
+        "addCollateral",
+        [accountAddress, tokenAddress, amount]
+      )
+    };
+  }
+
+  encodeIncreaseDebt(amount: BigNumber): MultiCall {
+    if (this.version !== 2)
+      throw new Error("Multicall is eligible only for version 2");
+    return {
+      target: this.creditFacade,
+      callData: ICreditFacade__factory.createInterface().encodeFunctionData(
+        "increaseDebt",
+        [amount]
+      )
+    };
+  }
+
+  encodeDecreaseDebt(amount: BigNumber): MultiCall {
+    if (this.version !== 2)
+      throw new Error("Multicall is eligible only for version 2");
+    return {
+      target: this.creditFacade,
+      callData: ICreditFacade__factory.createInterface().encodeFunctionData(
+        "decreaseDebt",
+        [amount]
+      )
+    };
+  }
+
+  validateOpenAccount(totalAmount: BigNumber, leverage: number): true {
+    if (totalAmount.lt(this.minAmount))
+      throw new OpenAccountError("amountLessMin", this.minAmount);
+
+    if (totalAmount.gt(this.maxAmount))
+      throw new OpenAccountError("amountGreaterMax", this.maxAmount);
+
+    if (leverage > this.maxLeverageFactor)
+      throw new OpenAccountError(
+        "leverageGreaterMax",
+        BigNumber.from(this.maxLeverageFactor)
+      );
+
+    if (
+      totalAmount
+        .mul(leverage)
+        .div(LEVERAGE_DECIMALS)
+        .gt(this.availableLiquidity)
+    )
+      throw new OpenAccountError(
+        "insufficientPoolLiquidity",
+        BigNumber.from(this.availableLiquidity)
+      );
+
+    return true;
+  }
 }
 
 export function calcMaxIncreaseBorrow(
-    healthFactor: number,
-    borrowAmountPlusInterest: BigNumber,
-    maxLeverageFactor: number
+  healthFactor: number,
+  borrowAmountPlusInterest: BigNumber,
+  maxLeverageFactor: number
 ): BigNumber {
-    const healthFactorPercentage = Math.floor(healthFactor * PERCENTAGE_FACTOR);
+  const healthFactorPercentage = Math.floor(healthFactor * PERCENTAGE_FACTOR);
 
-    const minHealthFactor = Math.floor(
-        (UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD * (maxLeverageFactor + 100)) /
-        maxLeverageFactor
-    );
+  const minHealthFactor = Math.floor(
+    (UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD *
+      (maxLeverageFactor + LEVERAGE_DECIMALS)) /
+      maxLeverageFactor
+  );
 
-    const result = borrowAmountPlusInterest
-        .mul(healthFactorPercentage - minHealthFactor)
-        .div(minHealthFactor - UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD);
-    return result.isNegative() ? BigNumber.from(0) : result;
+  const result = borrowAmountPlusInterest
+    .mul(healthFactorPercentage - minHealthFactor)
+    .div(minHealthFactor - UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD);
+  return result.isNegative() ? BigNumber.from(0) : result;
 }
 
 export function calcHealthFactorAfterIncreasingBorrow(
-    healthFactor: number | undefined,
-    borrowAmountPlusInterest: BigNumber | undefined,
-    additional: BigNumber
+  healthFactor: number | undefined,
+  borrowAmountPlusInterest: BigNumber | undefined,
+  additional: BigNumber
 ): number {
-    if (!healthFactor || !borrowAmountPlusInterest) return 0;
+  if (!healthFactor || !borrowAmountPlusInterest) return 0;
 
-    const healthFactorPercentage = Math.floor(healthFactor * PERCENTAGE_FACTOR);
+  const healthFactorPercentage = Math.floor(healthFactor * PERCENTAGE_FACTOR);
 
-    return (
-        borrowAmountPlusInterest
-            .mul(healthFactorPercentage)
-            .add(additional.mul(UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD))
-            .div(borrowAmountPlusInterest.add(additional))
-            .toNumber() / PERCENTAGE_FACTOR
-    );
+  return (
+    borrowAmountPlusInterest
+      .mul(healthFactorPercentage)
+      .add(additional.mul(UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD))
+      .div(borrowAmountPlusInterest.add(additional))
+      .toNumber() / PERCENTAGE_FACTOR
+  );
 }
 
 export function calcHealthFactorAfterAddingCollateral(
-    healthFactor: number | undefined,
-    borrowAmountPlusInterest: BigNumber | undefined,
-    additionalCollateral: BigNumber
+  healthFactor: number | undefined,
+  borrowAmountPlusInterest: BigNumber | undefined,
+  additionalCollateral: BigNumber
 ): number {
-    if (!healthFactor || !borrowAmountPlusInterest) return 0;
+  if (!healthFactor || !borrowAmountPlusInterest) return 0;
 
-    const healthFactorPercentage = Math.floor(healthFactor * PERCENTAGE_FACTOR);
+  const healthFactorPercentage = Math.floor(healthFactor * PERCENTAGE_FACTOR);
 
-    return (
-        borrowAmountPlusInterest
-            .mul(healthFactorPercentage)
-            .add(additionalCollateral.mul(UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD))
-            .div(borrowAmountPlusInterest)
-            .toNumber() / PERCENTAGE_FACTOR
-    );
+  return (
+    borrowAmountPlusInterest
+      .mul(healthFactorPercentage)
+      .add(additionalCollateral.mul(UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD))
+      .div(borrowAmountPlusInterest)
+      .toNumber() / PERCENTAGE_FACTOR
+  );
 }
 
 export class CreditManagerStat extends CreditManagerData {
-    public readonly uniqueUsers: number;
-    public readonly openedAccountsCount: number;
-    public readonly totalOpenedAccounts: number;
-    public readonly totalClosedAccounts: number;
-    public readonly totalRepaidAccounts: number;
-    public readonly totalLiquidatedAccounts: number;
-    public readonly totalBorrowed: BigNumber;
-    public readonly cumulativeBorrowed: BigNumber;
-    public readonly totalRepaid: BigNumber;
-    public readonly totalProfit: BigNumber;
-    public readonly totalLosses: BigNumber;
-
-    constructor(payload: CreditManagerStatPayload) {
-        super(payload);
-        this.uniqueUsers = payload.uniqueUsers;
-        this.openedAccountsCount = payload.openedAccountsCount || 0;
-        this.totalOpenedAccounts = payload.totalOpenedAccounts || 0;
-        this.totalClosedAccounts = payload.totalClosedAccounts || 0;
-        this.totalRepaidAccounts = payload.totalRepaidAccounts || 0;
-        this.totalLiquidatedAccounts = payload.totalLiquidatedAccounts || 0;
-        this.totalBorrowed = BigNumber.from(payload.totalBorrowed || 0);
-        this.cumulativeBorrowed = BigNumber.from(payload.cumulativeBorrowed || 0);
-        this.totalRepaid = BigNumber.from(payload.totalRepaid || 0);
-        this.totalProfit = BigNumber.from(payload.totalProfit || 0);
-        this.totalLosses = BigNumber.from(payload.totalLosses || 0);
-    }
+  public readonly uniqueUsers: number;
+  public readonly openedAccountsCount: number;
+  public readonly totalOpenedAccounts: number;
+  public readonly totalClosedAccounts: number;
+  public readonly totalRepaidAccounts: number;
+  public readonly totalLiquidatedAccounts: number;
+  public readonly totalBorrowed: BigNumber;
+  public readonly cumulativeBorrowed: BigNumber;
+  public readonly totalRepaid: BigNumber;
+  public readonly totalProfit: BigNumber;
+  public readonly totalLosses: BigNumber;
+
+  constructor(payload: CreditManagerStatPayload) {
+    super(payload);
+    this.uniqueUsers = payload.uniqueUsers;
+    this.openedAccountsCount = payload.openedAccountsCount || 0;
+    this.totalOpenedAccounts = payload.totalOpenedAccounts || 0;
+    this.totalClosedAccounts = payload.totalClosedAccounts || 0;
+    this.totalRepaidAccounts = payload.totalRepaidAccounts || 0;
+    this.totalLiquidatedAccounts = payload.totalLiquidatedAccounts || 0;
+    this.totalBorrowed = BigNumber.from(payload.totalBorrowed || 0);
+    this.cumulativeBorrowed = BigNumber.from(payload.cumulativeBorrowed || 0);
+    this.totalRepaid = BigNumber.from(payload.totalRepaid || 0);
+    this.totalProfit = BigNumber.from(payload.totalProfit || 0);
+    this.totalLosses = BigNumber.from(payload.totalLosses || 0);
+  }
 }

package/src/core/errors.ts

@@ -1,3 +1,5 @@
+import { BigNumber } from "ethers";
+
 export interface MetamaskError {
   code: number;
   message: string;
@@ -43,3 +45,25 @@ export class AccountsInAlllCreditManagersError extends Error {
     super("errors.youOpenedAccountsInAllCreditManagersError");
   }
 }
+
+export type OpenAccountErrorTypes =
+  | "insufficientPoolLiquidity"
+  | "leverageGreaterMax"
+  | "amountGreaterMax"
+  | "amountLessMin";
+
+export class OpenAccountError extends Error {
+  message: OpenAccountErrorTypes;
+  payload: { amount: BigNumber };
+
+  constructor(errorType: OpenAccountErrorTypes, amount: BigNumber) {
+    super();
+    Object.setPrototypeOf(this, OpenAccountError.prototype);
+    this.message = errorType;
+    this.payload = { amount };
+  }
+
+  static isOpenAccountError(e: unknown): e is OpenAccountError {
+    return e instanceof OpenAccountError;
+  }
+}