@gearbox-protocol/sdk 0.0.100 → 0.0.103

package/src/core/creditAccount.ts

@@ -3,8 +3,14 @@ import {
   CreditAccountDataExtendedPayload,
   CreditAccountDataPayload
 } from "../payload/creditAccount";
-import { PERCENTAGE_FACTOR, RAY } from "./constants";
+import {
+  PERCENTAGE_FACTOR,
+  RAY,
+  PERCENTAGE_DECIMALS,
+  PRICE_DECIMALS
+} from "./constants";
 import { TokenData } from "../tokens/tokenData";
+import { calcTotalPrice } from "./price";
 
 export type Balance = { address: string; balance: BigNumber };
 
@@ -12,19 +18,33 @@ export class CreditAccountData {
   public readonly id: string;
 
   public readonly addr: string;
+
   public readonly borrower: string;
+
   public readonly inUse: boolean;
+
   public readonly creditManager: string;
+
   public readonly underlyingToken: string;
+
   public borrowedAmountPlusInterest: BigNumber;
+
   public totalValue: BigNumber;
+
   public healthFactor: number;
+
   public borrowRate: number;
+
   public readonly allowedTokens: Array<string> = [];
+
   public readonly allTokens: Array<string> = [];
+
   public balances: Record<string, BigNumber> = {};
+
   public allBalances: Record<string, BigNumber> = {};
+
   public isDeleting: boolean;
+
   public readonly version: number = 1;
 
   constructor(payload: CreditAccountDataPayload) {
@@ -33,7 +53,7 @@ export class CreditAccountData {
     this.borrower = payload.borrower;
     this.inUse = payload.inUse;
     this.creditManager = payload.creditManager;
-    this.underlyingToken = payload.underlyingToken;
+    this.underlyingToken = payload.underlying;
     this.borrowedAmountPlusInterest = BigNumber.from(
       payload.borrowedAmountPlusInterest
     );
@@ -43,7 +63,7 @@ export class CreditAccountData {
     this.borrowRate =
       BigNumber.from(payload.borrowRate)
         .mul(PERCENTAGE_FACTOR)
-        .mul(100)
+        .mul(PERCENTAGE_DECIMALS)
         .div(RAY)
         .toNumber() / PERCENTAGE_FACTOR;
 
@@ -61,51 +81,63 @@ export class CreditAccountData {
   }
 
   balancesSorted(
-    prices: Record<string, number>,
+    prices: Record<string, BigNumber>,
     tokens: Record<string, TokenData>
   ): Array<Balance> {
-    const priceCalc = (addr: string, amount: BigNumber) => {
-      const price = prices[addr] || 0;
-      const { decimals = 18 } = tokens[addr] || {};
-
-      return amount
-        .mul(Math.floor(1000 * price))
-        .div(BigNumber.from(10).pow(decimals));
-    };
-
-    const tokensAbcComparator = (t1?: TokenData, t2?: TokenData) => {
-      const { symbol: symbol1 = "" } = t1 || {};
-      const { symbol: symbol2 = "" } = t2 || {};
-
-      return symbol1 > symbol2 ? 1 : -1;
-    };
-
-    const safeBalances = this.balances || [];
-
-    return Object.entries(safeBalances)
-      .sort(([addr1, amount1], [addr2, amount2]) => {
-        const addr1Lc = addr1.toLowerCase();
-        const addr2Lc = addr2.toLowerCase();
-
-        const price1 = priceCalc(addr1Lc, amount1);
-        const price2 = priceCalc(addr2Lc, amount2);
-
-        return price1.eq(price2)
-          ? tokensAbcComparator(tokens[addr1Lc], tokens[addr2Lc])
-          : price1.gt(price2)
-          ? -1
-          : 1;
-      })
-      .map(([address, balance]) => ({ address, balance }));
+    return sortBalances(this.balances, prices, tokens).map(
+      ([address, balance]) => ({ address, balance })
+    );
   }
 }
 
+export function sortBalances(
+  balances: Record<string, BigNumber>,
+  prices: Record<string, BigNumber>,
+  tokens: Record<string, TokenData>
+) {
+  return Object.entries(balances).sort(([addr1, amount1], [addr2, amount2]) => {
+    const addr1Lc = addr1.toLowerCase();
+    const addr2Lc = addr2.toLowerCase();
+
+    const token1 = tokens[addr1Lc];
+    const token2 = tokens[addr2Lc];
+
+    const price1 = prices[addr1Lc] || PRICE_DECIMALS;
+    const price2 = prices[addr2Lc] || PRICE_DECIMALS;
+
+    const totalPrice1 = calcTotalPrice(price1, amount1, token1?.decimals);
+    const totalPrice2 = calcTotalPrice(price2, amount2, token2?.decimals);
+
+    if (totalPrice1.eq(totalPrice2)) {
+      return tokensAbcComparator(token1, token2);
+    }
+
+    if (totalPrice1.gt(totalPrice2)) {
+      return -1;
+    }
+
+    return 1;
+  });
+}
+
+export function tokensAbcComparator(t1?: TokenData, t2?: TokenData) {
+  const { symbol: symbol1 = "" } = t1 || {};
+  const { symbol: symbol2 = "" } = t2 || {};
+
+  return symbol1 > symbol2 ? 1 : -1;
+}
+
 export class CreditAccountDataExtended extends CreditAccountData {
   public readonly repayAmount: BigNumber;
+
   public readonly liquidationAmount: BigNumber;
+
   public readonly borrowedAmount: BigNumber;
+
   public readonly canBeClosed: boolean;
+
   public readonly cumulativeIndexAtOpen: BigNumber;
+
   public readonly since: number;
 
   constructor(payload: CreditAccountDataExtendedPayload) {

package/src/core/creditManager.ts

@@ -1,174 +1,282 @@
-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
+
+  public readonly isPaused: boolean = false;
+
+  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);
+  }
+
+  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/creditOperation.ts

@@ -1,9 +1,9 @@
 export interface CreditOperation {
-    id: number,
-    txHash: string,
-    blockNum: number,
-    protocol: string,
-    operation: string,
-    timestamp: number,
-    date: string
+  id: number;
+  txHash: string;
+  blockNum: number;
+  protocol: string;
+  operation: string;
+  timestamp: number;
+  date: string;
 }