@gearbox-protocol/sdk 0.0.1

package/src/core/creditManager.ts

@@ -0,0 +1,171 @@
+import {BigNumber, ethers, Signer} from "ethers";
+import {IAppCreditManager, IAppCreditManager__factory} from "../types";
+import { formatBN } from "../utils/formatter";
+import {
+  PERCENTAGE_FACTOR,
+  RAY,
+  UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD,
+} from "./constants";
+import {
+  CreditManagerDataPayload,
+  CreditManagerStatPayload,
+} from "../payload/creditManager";
+
+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> = {};
+
+  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) : IAppCreditManager {
+    return IAppCreditManager__factory.connect(this.address, signer)
+  }
+}
+
+export function calcMaxIncreaseBorrow(
+  healthFactor: number,
+  borrowAmountPlusInterest: BigNumber,
+  maxLeverageFactor: number
+): BigNumber {
+  const healthFactorPercentage = Math.floor(healthFactor * PERCENTAGE_FACTOR);
+
+  const minHealthFactor = Math.floor(
+    (UNDERLYING_TOKEN_LIQUIDATION_THRESHOLD * (maxLeverageFactor + 100)) /
+      maxLeverageFactor
+  );
+
+
+  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
+): number {
+  if (!healthFactor || !borrowAmountPlusInterest) return 0;
+
+  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
+  );
+}
+
+export function calcHealthFactorAfterAddingCollateral(
+  healthFactor: number | undefined,
+  borrowAmountPlusInterest: BigNumber | undefined,
+  additionalCollateral: BigNumber
+): number {
+  if (!healthFactor || !borrowAmountPlusInterest) return 0;
+
+  const healthFactorPercentage = Math.floor(healthFactor * 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);
+  }
+}

package/src/core/creditOperation.ts

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

package/src/core/creditSession.ts

@@ -0,0 +1,67 @@
+import { BigNumber } from "ethers";
+import { CreditOperation } from "./creditOperation";
+import { CreditSessionPayload } from "../payload/creditSession";
+import moment from "moment";
+import { PERCENTAGE_FACTOR } from "./constants";
+
+export type CreditSessionStatus = "active" | "closed" | "repaid" | "liquidated";
+
+const statusEnum: Array<CreditSessionStatus> = [
+  "active",
+  "closed",
+  "repaid",
+  "liquidated",
+];
+
+export class CreditSession {
+  public readonly id: string;
+
+  public readonly status: CreditSessionStatus;
+  public readonly name: string;
+  public readonly background: string;
+  public readonly borrower: string;
+  public readonly creditManager: string;
+  public readonly account: string;
+  public readonly since: number;
+  public readonly sinceDate: string;
+  public readonly closedAt: number;
+  public readonly closedAtDate: string;
+  public readonly initialAmount: BigNumber;
+  public readonly borrowedAmount: BigNumber;
+  public readonly totalValue: BigNumber;
+  public readonly healthFactor: number;
+  public readonly profit: BigNumber;
+  public readonly profitPercentage: number;
+  public readonly score: number;
+  public readonly operations: Array<CreditOperation>;
+
+  constructor(payload: CreditSessionPayload) {
+    this.id = payload.id;
+    this.status = statusEnum[payload.status];
+    this.name = payload.name;
+    this.background = payload.background;
+    this.borrower = payload.borrower;
+    this.creditManager = payload.creditManager;
+    this.account = payload.account;
+    this.since = payload.since;
+    this.closedAt = payload.closedAt;
+    this.initialAmount = BigNumber.from(payload.initialAmount || 0);
+    this.borrowedAmount = BigNumber.from(payload.borrowedAmount || 0);
+    this.profit = BigNumber.from(payload.profit || 0);
+    this.profitPercentage = payload.profitPercentage || 0;
+    this.totalValue = BigNumber.from(payload.totalValue || 0);
+    this.healthFactor =
+      BigNumber.from(payload.healthFactor || 0).toNumber() / PERCENTAGE_FACTOR;
+    this.score = payload.score;
+    this.operations = (payload.operations || []).map((op) => {
+      op.date = moment(op.timestamp * 1000).format("Do MMM YYYY");
+      return op;
+    });
+    this.sinceDate = moment(payload.sinceTimestamp * 1000).format(
+      "Do MMM YYYY"
+    );
+    this.closedAtDate = moment(payload.closedAtTimestamp * 1000).format(
+      "Do MMM YYYY"
+    );
+  }
+}

package/src/core/errors.ts

@@ -0,0 +1,45 @@
+export interface MetamaskError {
+  code: number;
+  message: string;
+  data: string;
+}
+
+export class NetworkError extends Error {
+  constructor() {
+    super("errors.networkError");
+  }
+}
+export class IncorrectEthAddressError extends Error {
+  constructor() {
+    super("errors.incorrectEthAddressError");
+  }
+}
+
+export class PoolNotExistsError extends Error {
+  constructor() {
+    super("errors.poolDoesntExistsError");
+  }
+}
+
+export class CreditManagerNotExistsError extends Error {
+  constructor() {
+    super("errors.creditManagerDoesntExistsError");
+  }
+}
+export class UserHasNotAccountError extends Error {
+  constructor() {
+    super("errors.noOpenedAccountsError");
+  }
+}
+
+export class PathNotFoundError extends Error {
+  constructor() {
+    super("errors.pathNotFoundError");
+  }
+}
+
+export class AccountsInAlllCreditManagersError extends Error {
+  constructor() {
+    super("errors.youOpenedAccountsInAllCreditManagersError");
+  }
+}

package/src/core/eventOrTx.ts

@@ -0,0 +1,94 @@
+import { TokenData } from "./tokenData";
+import { TxSerialized } from "./transactions";
+
+export interface Display {
+  toString(tokenData: Record<string, TokenData>): string;
+}
+
+export type TxStatus = "pending" | "success" | "reverted";
+
+export interface EventOrTxProps {
+  block: number;
+  txHash: string;
+  txStatus: TxStatus;
+  timestamp: number;
+}
+
+export abstract class EventOrTx implements Display {
+  public block: number;
+  public readonly txHash: string;
+  public readonly timestamp: number;
+  protected _txStatus: TxStatus;
+
+  constructor({ block, txHash, txStatus, timestamp = 0 }: EventOrTxProps) {
+    this.block = block;
+    this.txHash = txHash;
+    this._txStatus = txStatus;
+    this.timestamp = timestamp;
+  }
+
+  public get isPending(): boolean {
+    return this._txStatus === "pending";
+  }
+
+  public get txStatus() {
+    return this._txStatus;
+  }
+
+  public compare(item: EventOrTx): number {
+    if (this.isPending && !item.isPending) {
+      return -1;
+    }
+
+    if (!this.isPending && item.isPending) {
+      return 1;
+    }
+
+    return this.block > item.block ? -1 : 1;
+  }
+
+  public abstract toString(tokenData: Record<string, TokenData>): string;
+}
+
+export type EVMEventProps = Omit<EventOrTxProps, "txStatus">;
+
+export abstract class EVMEvent extends EventOrTx {
+  constructor(opts: EVMEventProps) {
+    super({ ...opts, txStatus: "success" });
+  }
+}
+
+type OptionalFields = "block" | "txStatus";
+export type EVMTxProps = Omit<EventOrTxProps, OptionalFields> &
+  Partial<Pick<EventOrTxProps, OptionalFields>>;
+
+export abstract class EVMTx extends EventOrTx {
+  constructor({
+    txHash,
+    block = 0,
+    txStatus = "pending",
+    timestamp = 0
+  }: EVMTxProps) {
+    super({
+      block: block,
+      txStatus: txStatus,
+      txHash: txHash,
+      timestamp: timestamp
+    });
+    if (this.txStatus !== "pending" && this.block === 0) {
+      throw new Error("Block not specified for non-pending tx");
+    }
+  }
+
+  abstract serialize(): TxSerialized;
+
+  public revert(block: number) {
+    this._txStatus = "reverted";
+    this.block = block;
+  }
+
+  public success(block: number) {
+    this._txStatus = "success";
+    this.block = block;
+  }
+}