@gearbox-protocol/sdk 0.0.1

package/src/core/transactions.ts

@@ -0,0 +1,407 @@
+import { BigNumber } from "ethers";
+import { TokenData } from "./tokenData";
+import { formatBN } from "../utils/formatter";
+import { EVMTx, EVMTxProps } from "./eventOrTx";
+import { getContractName } from "./contractsRegister";
+import { LEVERAGE_DECIMALS } from "./constants";
+
+export interface TxSerialized {
+  type:
+    | "TxAddLiquidity"
+    | "TxRemoveLiquidity"
+    | "TxSwap"
+    | "TxAddCollateral"
+    | "TxIncreaseBorrowAmount"
+    | "TxOpenAccount"
+    | "TxRepayAccount"
+    | "TxCloseAccount"
+    | "TxApprove";
+  content: string;
+}
+
+export class TxSerializer {
+  static serialize(items: Array<EVMTx>): string {
+    return JSON.stringify(items.map(i => i.serialize()));
+  }
+
+  static deserialize(data: string): Array<EVMTx> {
+    return (JSON.parse(data) as Array<TxSerialized>).map(e => {
+      const params = JSON.parse(e.content);
+      switch (e.type) {
+        case "TxAddLiquidity":
+          return new TxAddLiquidity(params);
+        case "TxRemoveLiquidity":
+          return new TxRemoveLiquidity(params);
+        case "TxSwap":
+          return new TXSwap(params);
+        case "TxAddCollateral":
+          return new TxAddCollateral(params);
+        case "TxIncreaseBorrowAmount":
+          return new TxIncreaseBorrowAmount(params);
+        case "TxOpenAccount":
+          return new TxOpenAccount(params);
+        case "TxRepayAccount":
+          return new TxRepayAccount(params);
+        case "TxCloseAccount":
+          return new TxCloseAccount(params);
+        case "TxApprove":
+          return new TxApprove(params);
+        default:
+          throw new Error("Unknown transaction for parsing");
+      }
+    });
+  }
+}
+
+interface AddLiquidityProps extends EVMTxProps {
+  amount: BigNumber;
+  underlyingToken: string;
+  pool: string;
+}
+
+export class TxAddLiquidity extends EVMTx {
+  public readonly amount: BigNumber;
+  public readonly underlyingToken: string;
+  public readonly pool: string;
+
+  constructor(opts: AddLiquidityProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.amount = opts.amount;
+    this.underlyingToken = opts.underlyingToken;
+    this.pool = opts.pool;
+  }
+
+  toString(tokenData: Record<string, TokenData>): string {
+    const token = tokenData[this.underlyingToken];
+    return `${getContractName(this.pool)}: Deposit ${formatBN(
+      this.amount,
+      token?.decimals || 18
+    )} ${token?.symbol || ""}`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxAddLiquidity",
+      content: JSON.stringify(this)
+    };
+  }
+}
+
+interface RemoveLiquidityProps extends EVMTxProps {
+  amount: BigNumber;
+  dieselToken: string;
+  pool: string;
+}
+export class TxRemoveLiquidity extends EVMTx {
+  public readonly amount: BigNumber;
+  public readonly dieselToken: string;
+  public readonly pool: string;
+
+  constructor(opts: RemoveLiquidityProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.amount = opts.amount;
+    this.dieselToken = opts.dieselToken;
+    this.pool = opts.pool;
+  }
+
+  toString(tokenData: Record<string, TokenData>): string {
+    const dtoken = tokenData[this.dieselToken];
+    return `${getContractName(this.pool)}: Withdraw ${formatBN(
+      this.amount,
+      dtoken?.decimals || 18
+    )} ${dtoken?.symbol || ""}`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxRemoveLiquidity",
+      content: JSON.stringify(this)
+    };
+  }
+}
+
+interface SwapProps extends EVMTxProps {
+  protocol: string;
+  operation: string;
+  amountFrom: BigNumber;
+  amountTo?: BigNumber;
+  tokenFrom: string;
+  tokenTo?: string;
+  creditManager: string;
+}
+export class TXSwap extends EVMTx {
+  public readonly protocol: string;
+  public readonly operation: string;
+  public readonly amountFrom: BigNumber;
+  public readonly amountTo?: BigNumber;
+  public readonly tokenFrom: string;
+  public readonly tokenTo?: string;
+  public readonly creditManager: string;
+
+  constructor(opts: SwapProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.protocol = opts.protocol;
+    this.operation = opts.operation;
+    this.amountFrom = opts.amountFrom;
+    this.amountTo = opts.amountTo;
+    this.tokenFrom = opts.tokenFrom;
+    this.tokenTo = opts.tokenTo;
+    this.creditManager = opts.creditManager;
+  }
+
+  toString(tokenData: Record<string, TokenData>): string {
+    const tokenFrom = tokenData[this.tokenFrom];
+
+    let toPart = "";
+    if (this.tokenTo && this.amountTo) {
+      const tokenTo = tokenData[this.tokenTo];
+      toPart = ` ⇒  ${formatBN(this.amountTo, tokenTo?.decimals || 18)} ${
+        tokenTo?.symbol || ""
+      }`;
+    }
+
+    return `Credit account ${getContractName(this.creditManager)}: ${
+      this.operation
+    } ${formatBN(this.amountFrom, tokenFrom?.decimals || 18)} ${
+      tokenFrom?.symbol || ""
+    } ${toPart} on ${getContractName(this.protocol)}`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxSwap",
+      content: JSON.stringify(this)
+    };
+  }
+}
+
+interface AddCollateralProps extends EVMTxProps {
+  amount: BigNumber;
+  addedToken: string;
+  creditManager: string;
+}
+export class TxAddCollateral extends EVMTx {
+  public readonly amount: BigNumber;
+  public readonly addedToken: string;
+  public readonly creditManager: string;
+
+  constructor(opts: AddCollateralProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.amount = opts.amount;
+    this.addedToken = opts.addedToken;
+    this.creditManager = opts.creditManager;
+  }
+
+  toString(tokenData: Record<string, TokenData>): string {
+    const addedToken = tokenData[this.addedToken];
+    return `Credit account ${getContractName(
+      this.creditManager
+    )}: Added ${formatBN(this.amount, addedToken.decimals)} ${
+      addedToken.symbol
+    } as collateral`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxAddCollateral",
+      content: JSON.stringify(this)
+    };
+  }
+}
+
+interface IncreaseBorrowAmountProps extends EVMTxProps {
+  amount: BigNumber;
+  underlyingToken: string;
+  creditManager: string;
+}
+export class TxIncreaseBorrowAmount extends EVMTx {
+  public readonly amount: BigNumber;
+  public readonly underlyingToken: string;
+  public readonly creditManager: string;
+
+  constructor(opts: IncreaseBorrowAmountProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.amount = opts.amount;
+    this.underlyingToken = opts.underlyingToken;
+    this.creditManager = opts.creditManager;
+  }
+
+  toString(tokenData: Record<string, TokenData>): string {
+    const token = tokenData[this.underlyingToken];
+    return `Credit account ${getContractName(
+      this.creditManager
+    )}: Borrowed amount was increased for ${formatBN(
+      this.amount,
+      token?.decimals || 18
+    )} ${token?.symbol}`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxIncreaseBorrowAmount",
+      content: JSON.stringify(this)
+    };
+  }
+}
+
+interface OpenAccountProps extends EVMTxProps {
+  amount: BigNumber;
+  underlyingToken: string;
+  leverage: number;
+  creditManager: string;
+}
+export class TxOpenAccount extends EVMTx {
+  public readonly amount: BigNumber;
+  public readonly underlyingToken: string;
+  public readonly leverage: number;
+  public readonly creditManager: string;
+
+  constructor(opts: OpenAccountProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.amount = BigNumber.from(opts.amount);
+    this.underlyingToken = opts.underlyingToken;
+    this.leverage = opts.leverage;
+    this.creditManager = opts.creditManager;
+  }
+
+  toString(tokenData: Record<string, TokenData>): string {
+    const token = tokenData[this.underlyingToken];
+    return `Credit account ${getContractName(
+      this.creditManager
+    )}: opening ${formatBN(this.amount, token?.decimals || 18)} ${
+      token?.symbol
+    } x ${this.leverage.toFixed(2)} ⇒ 
+    ${formatBN(
+      this.amount
+        .mul(Math.floor(this.leverage * LEVERAGE_DECIMALS))
+        .div(LEVERAGE_DECIMALS),
+      token?.decimals || 18
+    )} ${token?.symbol}`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxOpenAccount",
+      content: JSON.stringify(this)
+    };
+  }
+}
+
+interface RepayAccountProps extends EVMTxProps {
+  creditManager: string;
+}
+export class TxRepayAccount extends EVMTx {
+  public readonly creditManager: string;
+
+  constructor(opts: RepayAccountProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.creditManager = opts.creditManager;
+  }
+
+  toString(_tokenData: Record<string, TokenData>): string {
+    return `Credit account ${getContractName(
+      this.creditManager
+    )}: Repaying account`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxRepayAccount",
+      content: JSON.stringify(this)
+    };
+  }
+}
+
+interface CloseAccountProps extends EVMTxProps {
+  creditManager: string;
+}
+export class TxCloseAccount extends EVMTx {
+  public readonly creditManager: string;
+
+  constructor(opts: CloseAccountProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.creditManager = opts.creditManager;
+  }
+
+  toString(_tokenData: Record<string, TokenData>): string {
+    return `Credit account ${getContractName(
+      this.creditManager
+    )}: Closing account`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxCloseAccount",
+      content: JSON.stringify(this)
+    };
+  }
+}
+
+interface ApproveProps extends EVMTxProps {
+  token: string;
+}
+export class TxApprove extends EVMTx {
+  public readonly token: string;
+
+  constructor(opts: ApproveProps) {
+    super({
+      block: opts.block,
+      txHash: opts.txHash,
+      txStatus: opts.txStatus,
+      timestamp: opts.timestamp
+    });
+    this.token = opts.token;
+  }
+
+  toString(tokenData: Record<string, TokenData>): string {
+    const token = tokenData[this.token];
+    return `Approve ${token?.symbol}`;
+  }
+
+  serialize(): TxSerialized {
+    return {
+      type: "TxApprove",
+      content: JSON.stringify(this)
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+export * from "./core/constants";
+export * from "./core/creditAccount";
+export * from "./core/creditManager";
+export * from "./core/creditSession";
+export * from "./core/contracts";
+export * from "./core/events";
+export * from "./core/errors";
+export * from "./core/pool";
+export * from "./core/operations";
+export * from "./core/oracles";
+export * from "./core/swap";
+export * from "./core/token";
+export * from "./core/tokenData";
+export * from "./core/tokenDistributor";
+export * from "./core/trade";
+export * from "./core/transactions";
+export * from "./payload/creditAccount";
+export * from "./payload/creditManager";
+export * from "./payload/creditSession";
+export * from "./payload/pool";
+export * from "./payload/token";
+export * from "./utils/formatter";
+export * from "./utils/loading";
+export * from "./utils/validate";
+export * from "./utils/events";
+export * from "./utils/math";
+export * from "./core/creditCard";
+export * from "./payload/graphPayload";
+export * from "./types/index"
+
+export type {
+  IAppPoolService,
+  IAppCreditManager,
+  IAppERC20,
+  IAppAddressProvider,
+  IDataCompressor,
+  IWETHGateway,
+} from "./types";
+
+export * from "./core/history";
+export { MultiCallContract} from "./utils/multicall";
+export { callRepeater } from "./utils/repeater"

package/src/payload/creditAccount.ts

@@ -0,0 +1,29 @@
+import {BigNumberish} from "ethers";
+
+export interface TokenBalancePayload {
+  token: string;
+  balance: BigNumberish;
+  isAllowed: boolean;
+}
+
+export interface CreditAccountDataPayload {
+  addr: string;
+  borrower: string;
+  inUse: boolean;
+  creditManager: string;
+  underlyingToken: string;
+  borrowedAmountPlusInterest: BigNumberish;
+  totalValue: BigNumberish;
+  healthFactor: BigNumberish;
+  borrowRate: BigNumberish;
+  balances?: Array<TokenBalancePayload>;
+}
+
+export interface CreditAccountDataExtendedPayload extends CreditAccountDataPayload {
+  repayAmount: BigNumberish;
+  liquidationAmount: BigNumberish;
+  canBeClosed?: boolean;
+  borrowedAmount: BigNumberish;
+  cumulativeIndexAtOpen: BigNumberish;
+  since: BigNumberish;
+}

package/src/payload/creditManager.ts

@@ -0,0 +1,46 @@
+import { BigNumberish } from "ethers";
+
+export interface AdapterPayload {
+  allowedContract: string;
+  adapter: string
+}
+
+export interface CreditManagerDataPayload {
+  addr: string;
+  hasAccount?: boolean;
+  underlyingToken?: string;
+  isWETH?: boolean;
+  canBorrow?: boolean;
+  borrowRate?: BigNumberish;
+  minAmount?: BigNumberish;
+  maxAmount?: BigNumberish;
+  maxLeverageFactor?: BigNumberish;
+  availableLiquidity?: BigNumberish;
+  allowedTokens?: Array<string>;
+  adapters?: Array<AdapterPayload>;
+}
+
+export interface CreditManagerStatPayload {
+  addr: string;
+  underlyingToken?: string;
+  isWETH?: boolean;
+  canBorrow?: boolean;
+  borrowRate?: BigNumberish;
+  minAmount?: BigNumberish;
+  maxAmount?: BigNumberish;
+  maxLeverageFactor?: BigNumberish;
+  availableLiquidity?: BigNumberish;
+  allowedTokens?: Array<string>;
+  allowedContracts?: Array<string>;
+  uniqueUsers: number;
+  openedAccountsCount?: number;
+  totalOpenedAccounts?: number;
+  totalClosedAccounts?: number;
+  totalRepaidAccounts?: number;
+  totalLiquidatedAccounts?: number;
+  totalBorrowed?: BigNumberish;
+  cumulativeBorrowed?: BigNumberish;
+  totalRepaid?: BigNumberish;
+  totalProfit?: BigNumberish;
+  totalLosses?: BigNumberish;
+}

package/src/payload/creditSession.ts

@@ -0,0 +1,24 @@
+import { BigNumberish } from "ethers";
+import { CreditOperation } from "../core/creditOperation";
+
+export interface CreditSessionPayload {
+  id: string;
+  status: number;
+  name: string;
+  background: string;
+  borrower: string;
+  creditManager: string;
+  account: string;
+  since: number;
+  sinceTimestamp: number;
+  closedAt: number;
+  closedAtTimestamp: number;
+  initialAmount: BigNumberish;
+  borrowedAmount: BigNumberish;
+  totalValue?: BigNumberish;
+  healthFactor?: BigNumberish;
+  profit: BigNumberish;
+  profitPercentage: number;
+  score: number;
+  operations: Array<CreditOperation>;
+}

package/src/payload/graphPayload.ts

@@ -0,0 +1,10 @@
+export interface GraphData {
+  time: number;
+  value: number;
+}
+
+export interface GraphPayload {
+  id: string;
+  title: string;
+  data: Array<GraphData>;
+}

package/src/payload/pool.ts

@@ -0,0 +1,20 @@
+import {BigNumberish} from "ethers";
+
+export interface PoolDataPayload {
+  addr: string;
+  underlyingToken: string;
+  dieselToken: string;
+  isWETH: boolean;
+  expectedLiquidity: BigNumberish;
+  expectedLiquidityLimit?: BigNumberish;
+  availableLiquidity: BigNumberish;
+  totalBorrowed: BigNumberish;
+  depositAPY_RAY: BigNumberish;
+  borrowAPY_RAY: BigNumberish;
+  dieselRate_RAY: BigNumberish;
+  withdrawFee: BigNumberish;
+  timestampLU?: BigNumberish;
+  cumulativeIndex_RAY?: BigNumberish
+}
+
+//

package/src/payload/token.ts

@@ -0,0 +1,5 @@
+export interface TokenDataPayload {
+    addr: string;
+    symbol: string;
+    decimals: number;
+}