@aurigami/sdk 1.6.0-no-src → 1.6.0

package/src/contracts/MoneyMarket.ts

@@ -0,0 +1,510 @@
+import AuErc20ABI from '@aurigami/contracts/artifacts/contracts/AuErc20.sol/AuErc20.json';
+import AuETHABI from '@aurigami/contracts/artifacts/contracts/AuETH.sol/AuETH.json';
+import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
+import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
+import EthRepayHelperABI from '@aurigami/contracts/artifacts/contracts/EthRepayHelper.sol/EthRepayHelper.json';
+import {
+  AuErc20,
+  AuETH,
+  AuriLens,
+  Comptroller,
+  EthRepayHelper,
+} from '@aurigami/contracts/typechain';
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import BigNumber from 'bignumber.js';
+import { BigNumber as BN, Contract } from 'ethers';
+import * as consts from '../consts';
+import {
+  BlockchainEntity,
+  BlockchainEntityRead,
+  PLYToken,
+  Token,
+  TokenAmount,
+} from '../entities';
+import * as helpers from '../helpers/';
+import {
+  calcValuation,
+  fetchPrice,
+  fetchValuation,
+} from '../helpers/priceFetcher';
+import {
+  Address,
+  ComptrollerRewardType,
+  MoneyMarketDetails,
+  NetworkConnection,
+} from '../types';
+
+type RewardSpeeds = {
+  plyRewardSupplySpeed: BN;
+  plyRewardBorrowSpeed: BN;
+  auroraRewardSupplySpeed: BN;
+  auroraRewardBorrowSpeed: BN;
+};
+
+export class MoneyMarketRead extends BlockchainEntityRead {
+  public underlying: Token;
+  public auToken: AuErc20 | AuETH;
+  protected _comptroller: Comptroller;
+
+  protected _auriLens: AuriLens;
+  constructor(
+    networkConnection: NetworkConnection,
+    auToken: Address,
+    underlyingAsset: Address
+  ) {
+    super(networkConnection);
+    if (helpers.isSameAddress(underlyingAsset, consts.ETHAddress)) {
+      this.auToken = new Contract(
+        auToken,
+        AuETHABI.abi,
+        networkConnection.provider
+      ) as AuETH;
+    } else {
+      this.auToken = new Contract(
+        auToken,
+        AuErc20ABI.abi,
+        networkConnection.provider
+      ) as AuErc20;
+    }
+    this.underlying = new Token(
+      underlyingAsset,
+      helpers.getDecimal(underlyingAsset)
+    );
+    this._comptroller = new Contract(
+      consts.networkAddresses.misc.COMPTROLLER,
+      ComptrollerABI.abi,
+      networkConnection.provider
+    ) as Comptroller;
+    this._auriLens = new Contract(
+      consts.networkAddresses.misc.AURILENS,
+      AuriLensABI.abi,
+      networkConnection.provider
+    ) as AuriLens;
+  }
+
+  protected async getRewardSpeeds(): Promise<RewardSpeeds> {
+    var speeds = await this._auriLens.getRewardSpeeds(
+      this._comptroller.address,
+      this.auToken.address
+    );
+    return speeds;
+  }
+  public async getTotalTokenBorrowed(): Promise<TokenAmount> {
+    return new TokenAmount(
+      this.underlying,
+      (await this.auToken.totalBorrows()).toString()
+    );
+  }
+  public async getTotalTokenDeposited(): Promise<TokenAmount> {
+    var promises = [];
+    var totalBorrow: TokenAmount, totalCash: TokenAmount;
+    promises.push(
+      this.getTotalTokenBorrowed().then((res: TokenAmount) => {
+        totalBorrow = res;
+      })
+    );
+    promises.push(
+      this.auToken.getCash().then((res: BN) => {
+        totalCash = new TokenAmount(this.underlying, res.toString());
+      })
+    );
+    await Promise.all(promises);
+    return new TokenAmount(
+      this.underlying,
+      BN.from(totalCash!.rawAmount()).add(totalBorrow!.rawAmount()).toString()
+    );
+  }
+
+  public async getDepositAPY(): Promise<BigNumber> {
+    const supplyRatePerTimestamp = await this.auToken.supplyRatePerTimestamp();
+    return new BigNumber(supplyRatePerTimestamp.toString())
+      .multipliedBy(60 * 60 * 24 * 365)
+      .div(helpers.decimalFactor(18));
+  }
+
+  public async getBorrowAPY(): Promise<BigNumber> {
+    const borrowRatePerTimestamp = await this.auToken.borrowRatePerTimestamp();
+    return new BigNumber(borrowRatePerTimestamp.toString())
+      .multipliedBy(60 * 60 * 24 * 365)
+      .div(helpers.decimalFactor(18));
+  }
+
+  public async getCollateralRatio(): Promise<BigNumber> {
+    return this._comptroller.markets(this.auToken.address).then((res: any) => {
+      return new BigNumber(res.collateralFactorMantissa.toString()).div(
+        helpers.decimalFactor(18)
+      );
+    });
+  }
+
+  public async getBorrowPlyAPY(): Promise<BigNumber> {
+    var promises = [];
+    var totalBorrowed: TokenAmount,
+      rewardSpeed: TokenAmount,
+      plyPrice: BigNumber,
+      underlyingPrice: BigNumber;
+    promises.push(
+      this.getTotalTokenBorrowed().then((res: TokenAmount) => {
+        totalBorrowed = res;
+      })
+    );
+    promises.push(
+      this._comptroller
+        .rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address, false)
+        .then((res) => {
+          rewardSpeed = new TokenAmount(PLYToken, res.toString());
+        })
+    );
+    promises.push(
+      fetchPrice(
+        consts.networkAddresses.tokens.PLY,
+        this._networkConnection.provider
+      ).then((res) => {
+        plyPrice = res;
+      })
+    );
+    promises.push(
+      fetchPrice(
+        this.underlying.address,
+        this._networkConnection.provider
+      ).then((res) => {
+        underlyingPrice = res;
+      })
+    );
+    await Promise.all(promises);
+    return helpers.calcLMRewardApr(
+      plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+      underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()),
+      consts.ONE_YEAR
+    );
+  }
+
+  public async getDepositPlyAPY(): Promise<BigNumber> {
+    var promises = [];
+    var totalDeposited: TokenAmount,
+      rewardSpeed: TokenAmount,
+      plyPrice: BigNumber,
+      underlyingPrice: BigNumber;
+    promises.push(
+      this.getTotalTokenDeposited().then((res: TokenAmount) => {
+        totalDeposited = res;
+      })
+    );
+    promises.push(
+      this._comptroller
+        .rewardSpeeds(ComptrollerRewardType.PLY, this.auToken.address, true)
+        .then((res) => {
+          rewardSpeed = new TokenAmount(PLYToken, res.toString());
+        })
+    );
+    promises.push(
+      fetchPrice(
+        consts.networkAddresses.tokens.PLY,
+        this._networkConnection.provider
+      ).then((res) => {
+        plyPrice = res;
+      })
+    );
+    promises.push(
+      fetchPrice(
+        this.underlying.address,
+        this._networkConnection.provider
+      ).then((res) => {
+        underlyingPrice = res;
+      })
+    );
+    await Promise.all(promises);
+    return helpers.calcLMRewardApr(
+      plyPrice!.multipliedBy(rewardSpeed!.formattedAmount()),
+      underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
+      consts.ONE_YEAR
+    );
+  }
+  public async getDetails(): Promise<MoneyMarketDetails> {
+    var promises = [],
+      totalDeposited: TokenAmount,
+      totalBorrowed: TokenAmount,
+      depositAPY: number,
+      borrowAPY: number,
+      collateralRatio: number;
+    promises.push(
+      this.getTotalTokenDeposited().then((res: TokenAmount) => {
+        totalDeposited = res;
+      })
+    );
+    promises.push(
+      this.getTotalTokenBorrowed().then((res: TokenAmount) => {
+        totalBorrowed = res;
+      })
+    );
+    promises.push(
+      this.getDepositAPY().then((res: BigNumber) => {
+        depositAPY = res.toNumber();
+      })
+    );
+    promises.push(
+      this.getBorrowAPY().then((res: BigNumber) => {
+        borrowAPY = res.toNumber();
+      })
+    );
+    promises.push(
+      this.getCollateralRatio().then((res: BigNumber) => {
+        collateralRatio = res.toNumber();
+      })
+    );
+
+    var plyPrice: BigNumber,
+      underlyingPrice: BigNumber,
+      rewardSpeeds: RewardSpeeds;
+    promises.push(
+      this.getRewardSpeeds().then((res) => {
+        rewardSpeeds = res;
+      })
+    );
+    promises.push(
+      fetchPrice(
+        consts.networkAddresses.tokens.PLY,
+        this._networkConnection.provider
+      ).then((res) => {
+        plyPrice = res;
+      })
+    );
+    promises.push(
+      fetchPrice(
+        this.underlying.address,
+        this._networkConnection.provider
+      ).then((res) => {
+        underlyingPrice = res;
+      })
+    );
+
+    await Promise.all(promises);
+
+    var borrowPlyApy = helpers.calcLMRewardApr(
+      calcValuation(
+        new TokenAmount(
+          PLYToken,
+          rewardSpeeds!.plyRewardBorrowSpeed.toString()
+        ),
+        plyPrice!
+      ),
+      underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()),
+      consts.ONE_YEAR
+    );
+    var depositPlyApy = helpers.calcLMRewardApr(
+      calcValuation(
+        new TokenAmount(
+          PLYToken,
+          rewardSpeeds!.plyRewardSupplySpeed.toString()
+        ),
+        plyPrice!
+      ),
+      underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
+      consts.ONE_YEAR
+    );
+
+    var depositNEARApy = helpers.calcLMRewardApr(
+      await fetchValuation(
+        this.getDepositNEARRewardPerWeek(),
+        this._networkConnection.provider
+      ),
+      underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
+      52
+    );
+    var borrowNEARApy = helpers.calcLMRewardApr(
+      await fetchValuation(
+        this.getBorrowNEARRewardPerWeek(),
+        this._networkConnection.provider
+      ),
+      underlyingPrice!.multipliedBy(totalBorrowed!.formattedAmount()),
+      52
+    );
+    var depositMETAApy;
+    if (
+      helpers.isSameAddress(
+        this.underlying.address,
+        consts.networkAddresses.tokens.stNEAR
+      )
+    ) {
+      depositMETAApy = helpers.calcLMRewardApr(
+        new BigNumber(50000),
+        underlyingPrice!.multipliedBy(totalDeposited!.formattedAmount()),
+        12
+      );
+    } else {
+      depositMETAApy = new BigNumber(0);
+    }
+
+    return {
+      auTokenAddress: this.auToken.address,
+      totalTokenDeposited: totalDeposited!,
+      totalTokenBorrowed: totalBorrowed!,
+      depositApy: depositAPY!,
+      depositPlyApy: depositPlyApy.toNumber(),
+      borrowApy: borrowAPY!,
+      borrowPlyApy: borrowPlyApy.toNumber() * -1,
+      collateralRatio: collateralRatio!,
+      depositPlyPerWeek: new TokenAmount(
+        PLYToken,
+        rewardSpeeds!.plyRewardSupplySpeed.mul(consts.ONE_DAY).mul(7).toString()
+      ),
+      borrowPlyPerWeek: new TokenAmount(
+        PLYToken,
+        rewardSpeeds!.plyRewardBorrowSpeed.mul(consts.ONE_DAY).mul(7).toString()
+      ),
+      depositNEARApy: depositNEARApy.toNumber(),
+      borrowNEARApy: borrowNEARApy.toNumber() * -1,
+      depositMETAApy: depositMETAApy.toNumber(),
+    };
+  }
+
+  public async getUserBorrowBalance(userAddress: string): Promise<TokenAmount> {
+    const totalBorrow: BN = await this.auToken.callStatic.borrowBalanceCurrent(
+      userAddress
+    );
+    return new TokenAmount(this.underlying, totalBorrow.toString());
+  }
+
+  public async getUserDepositBalance(
+    userAddress: string
+  ): Promise<TokenAmount> {
+    const totalDeposit: BN = await this.auToken.callStatic.balanceOfUnderlying(
+      userAddress
+    );
+    return new TokenAmount(this.underlying, totalDeposit.toString());
+  }
+
+  private getDepositNEARRewardPerWeek(): TokenAmount {
+    const NEARToken = new Token(
+      consts.networkAddresses.tokens.WNEAR,
+      helpers.getDecimal(consts.networkAddresses.tokens.WNEAR)
+    );
+    const rewardStartTime = 1650636000;
+    const rewardStopTime = 1651845600; // May 06, 2022 2 PM GMT
+    const currentTime = helpers.getCurrentTimestamp();
+    if (currentTime <= rewardStopTime && currentTime > rewardStartTime) {
+      const reward =
+        consts.DEPOSIT_NEAR_REWARDS_PER_WEEK[
+          this.underlying.address.toLocaleLowerCase()
+        ] ?? '0';
+      return new TokenAmount(NEARToken, reward, false);
+    } else {
+      return new TokenAmount(NEARToken, '0');
+    }
+  }
+
+  private getBorrowNEARRewardPerWeek(): TokenAmount {
+    const NEARToken = new Token(
+      consts.networkAddresses.tokens.WNEAR,
+      helpers.getDecimal(consts.networkAddresses.tokens.WNEAR)
+    );
+    const rewardStartTime = 1650636000;
+    const rewardStopTime = 1651845600; // May 06, 2022 2 PM GMT
+    const currentTime = helpers.getCurrentTimestamp();
+    if (currentTime <= rewardStopTime && currentTime > rewardStartTime) {
+      const reward =
+        consts.BORROW_NEAR_REWARDS_PER_WEEK[
+          this.underlying.address.toLocaleLowerCase()
+        ] ?? '0';
+      return new TokenAmount(NEARToken, reward, false);
+    } else {
+      return new TokenAmount(NEARToken, '0');
+    }
+  }
+}
+
+export class MoneyMarketReadWrite extends MoneyMarketRead {
+  protected _EthRepayHelper: EthRepayHelper;
+  constructor(
+    networkConnection: NetworkConnection,
+    auToken: Address,
+    underlyingAsset: Address
+  ) {
+    super(networkConnection, auToken, underlyingAsset);
+    this._EthRepayHelper = new Contract(
+      consts.networkAddresses.misc.ETHREPAYHELPER,
+      EthRepayHelperABI.abi,
+      networkConnection.provider
+    ) as EthRepayHelper;
+  }
+
+  public async deposit(amount: TokenAmount): Promise<TransactionResponse> {
+    if (helpers.isSameAddress(amount.token.address, consts.ETHAddress)) {
+      return (this.auToken as AuETH)
+        .connect(this._networkConnection.signer!)
+        .mint({ value: amount.rawAmount() });
+    } else {
+      return (this.auToken as AuErc20)
+        .connect(this._networkConnection.signer!)
+        .mint(amount.rawAmount());
+    }
+  }
+  public async borrow(amount: TokenAmount): Promise<TransactionResponse> {
+    return this.auToken
+      .connect(this._networkConnection.signer!)
+      .borrow(amount.rawAmount());
+  }
+  public async withdraw(amount: TokenAmount): Promise<TransactionResponse> {
+    if (new BigNumber(amount.rawAmount()).lt(0)) {
+      return this.auToken
+        .connect(this._networkConnection.signer!)
+        .redeemUnderlying(consts.INF);
+    }
+    return this.auToken
+      .connect(this._networkConnection.signer!)
+      .redeemUnderlying(amount.rawAmount());
+  }
+  public async repay(amount: TokenAmount): Promise<TransactionResponse> {
+    if (helpers.isSameAddress(amount.token.address, consts.ETHAddress)) {
+      return this._EthRepayHelper
+        .connect(this._networkConnection.signer!)
+        .repayBorrow({ value: amount.rawAmount() });
+    } else {
+      if (new BigNumber(amount.rawAmount()).lt(0)) {
+        return this.auToken
+          .connect(this._networkConnection.signer!)
+          .repayBorrow(consts.INF);
+      } else {
+        return this.auToken
+          .connect(this._networkConnection.signer!)
+          .repayBorrow(amount.rawAmount());
+      }
+    }
+  }
+  public async enableCollateral(): Promise<TransactionResponse> {
+    return this._comptroller
+      .connect(this._networkConnection.signer!)
+      .enterMarkets([this.auToken.address]);
+  }
+  public async disableCollateral(): Promise<TransactionResponse> {
+    return this._comptroller
+      .connect(this._networkConnection.signer!)
+      .exitMarket(this.auToken.address);
+  }
+}
+
+export class MoneyMarket extends BlockchainEntity {
+  protected address: Address;
+
+  protected underlying: Address;
+  constructor(address: string, underlying: string) {
+    super();
+    this.address = helpers.validateAndParseAddress(address);
+    this.underlying = helpers.validateAndParseAddress(underlying);
+  }
+  public read(networkConnection: NetworkConnection): MoneyMarketRead {
+    return new MoneyMarketRead(
+      networkConnection,
+      this.address,
+      this.underlying
+    );
+  }
+
+  public readWrite(networkConnection: NetworkConnection): MoneyMarketReadWrite {
+    return new MoneyMarketReadWrite(
+      networkConnection,
+      this.address,
+      this.underlying
+    );
+  }
+}