@aurigami/sdk 1.24.0 → 1.24.2

package/src/interactors/MoneyMarket.ts

@@ -1,486 +0,0 @@
-import { AuETH, AuErc20, EthRepayHelper } from '@aurigami/contracts/typechain';
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import BigNumber from 'bignumber.js';
-import { CacheType, cache } from 'cache-decorator';
-import { BigNumber as BN } from 'ethers';
-import * as abis from '../abis';
-import * as consts from '../consts';
-import { CACHE_TIMEOUT, ONE_DAY } from '../consts';
-import {
-  AuriEnv,
-  BlockchainEntity,
-  BlockchainEntityRead,
-  PLYToken,
-  Token,
-  TokenAmount,
-} from '../entities';
-import * as helpers from '../helpers';
-import { createContract } from '../helpers/multicall';
-import { calcValuation, fetchPrice, fetchValuation } from '../helpers/priceFetcher';
-import { Address, Apy, MoneyMarketDetails, MulticallStatic, NetworkConnection } from '../types';
-
-type RewardSpeeds = {
-  plyRewardSupplySpeed: BN;
-  plyRewardBorrowSpeed: BN;
-  auroraRewardSupplySpeed: BN;
-  auroraRewardBorrowSpeed: BN;
-};
-
-export class MoneyMarketRead extends BlockchainEntityRead {
-  public underlying: Token;
-  public auToken: MulticallStatic<AuErc20 | AuETH>;
-  public readonly env: AuriEnv;
-  constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-    if (helpers.isSameAddress(underlyingAsset, consts.ETHAddress)) {
-      this.auToken = createContract<AuETH>(auToken, abis.AuETHABI.abi, networkConnection.provider);
-    } else {
-      this.auToken = createContract<AuErc20>(
-        auToken,
-        abis.AuErc20ABI.abi,
-        networkConnection.provider
-      );
-    }
-    this.underlying = new Token(underlyingAsset, helpers.getDecimal(underlyingAsset));
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getUnderlyingPrice(): Promise<BigNumber> {
-    return fetchPrice(this.underlying.address, this._networkConnection.provider);
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getPlyPrice(): Promise<BigNumber> {
-    return fetchPrice(consts.networkAddresses.tokens.PLY, this._networkConnection.provider);
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  protected async getRewardSpeeds(): Promise<RewardSpeeds> {
-    var speeds = await this.env.auriLens.callStatic.getRewardSpeeds(
-      this.env.comptroller.address,
-      this.auToken.address
-    );
-    return speeds;
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getTotalTokenBorrowed(): Promise<TokenAmount> {
-    return new TokenAmount(
-      this.underlying,
-      (await this.auToken.callStatic.totalBorrows()).toString()
-    );
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getTotalTokenDeposited(): Promise<TokenAmount> {
-    const [totalBorrow, totalCash] = await Promise.all([
-      this.getTotalTokenBorrowed(),
-      this.auToken.callStatic.getCash(),
-    ]);
-    return new TokenAmount(
-      this.underlying,
-      BN.from(new TokenAmount(this.underlying, totalCash.toString()).rawAmount())
-        .add(totalBorrow.rawAmount())
-        .toString()
-    );
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositAPY(): Promise<BigNumber> {
-    const supplyRatePerTimestamp = await this.auToken.callStatic.supplyRatePerTimestamp();
-    const supplyRatePerDay = new BigNumber(supplyRatePerTimestamp.toString())
-      .multipliedBy(ONE_DAY)
-      .div(helpers.decimalFactor(18));
-
-    return new BigNumber(supplyRatePerDay.plus(1)).pow(365).minus(1);
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getBorrowAPY(): Promise<BigNumber> {
-    const borrowRatePerTimestamp = await this.auToken.callStatic.borrowRatePerTimestamp();
-    const borrowRatePerDay = new BigNumber(borrowRatePerTimestamp.toString())
-      .multipliedBy(ONE_DAY)
-      .div(helpers.decimalFactor(18));
-    return new BigNumber(borrowRatePerDay.plus(1)).pow(365).minus(1);
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getCollateralRatio(): Promise<BigNumber> {
-    return this.env.comptroller.callStatic.markets(this.auToken.address).then((res: any) => {
-      return new BigNumber(res.collateralFactorMantissa.toString()).div(helpers.decimalFactor(18));
-    });
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getBorrowPlyAPY(): Promise<BigNumber> {
-    const [totalBorrowed, rewardSpeeds, plyPrice, underlyingPrice] = await Promise.all([
-      this.getTotalTokenBorrowed(),
-      this.getRewardSpeeds(),
-      this.getPlyPrice(),
-      this.getUnderlyingPrice(),
-    ]);
-    return helpers.calcLMRewardApr(
-      calcValuation(
-        new TokenAmount(PLYToken, rewardSpeeds.plyRewardBorrowSpeed.toString()),
-        plyPrice
-      ),
-      underlyingPrice.multipliedBy(totalBorrowed.formattedAmount()),
-      consts.ONE_YEAR
-    );
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositPlyAPY(): Promise<BigNumber> {
-    const [totalDeposited, rewardSpeeds, plyPrice, underlyingPrice] = await Promise.all([
-      this.getTotalTokenDeposited(),
-      this.getRewardSpeeds(),
-      this.getPlyPrice(),
-      this.getUnderlyingPrice(),
-    ]);
-    return helpers.calcLMRewardApr(
-      calcValuation(
-        new TokenAmount(PLYToken, rewardSpeeds.plyRewardSupplySpeed.toString()),
-        plyPrice
-      ),
-      underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
-      consts.ONE_YEAR
-    );
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositNearAPY(): Promise<BigNumber> {
-    const [totalDeposited, underlyingPrice] = await Promise.all([
-      this.getTotalTokenDeposited(),
-      this.getUnderlyingPrice(),
-    ]);
-    let depositNEARApy = helpers.calcLMRewardApr(
-      await fetchValuation(this.getDepositNEARRewardPerWeek(), this._networkConnection.provider),
-      underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
-      52
-    );
-    return depositNEARApy;
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getBorrowNearAPY(): Promise<BigNumber> {
-    const [totalBorrowed, underlyingPrice] = await Promise.all([
-      this.getTotalTokenBorrowed(),
-      this.getUnderlyingPrice(),
-    ]);
-    let borrowNEARApy = helpers.calcLMRewardApr(
-      await fetchValuation(this.getBorrowNEARRewardPerWeek(), this._networkConnection.provider),
-      underlyingPrice.multipliedBy(totalBorrowed.formattedAmount()),
-      52
-    );
-    return borrowNEARApy;
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositMetaAPY(): Promise<BigNumber> {
-    return new BigNumber(0);
-    // const [totalDeposited, underlyingPrice] = await Promise.all([
-    //   this.getTotalTokenDeposited(),
-    //   fetchPrice(this.underlying.address, this._networkConnection.provider),
-    // ]);
-    // let depositMETAApy;
-    // if (helpers.isSameAddress(this.underlying.address, consts.networkAddresses.tokens.stNEAR)) {
-    //   depositMETAApy = helpers.calcLMRewardApr(
-    //     await fetchValuation(
-    //       TokenAmount.fromAddressAndAmount(consts.networkAddresses.tokens.META, '250000', false),
-    //       this._networkConnection.provider
-    //     ),
-    //     underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
-    //     12
-    //   );
-    // } else {
-    //   depositMETAApy = new BigNumber(0);
-    // }
-    // return depositMETAApy;
-  }
-
-  @cache({ ttl: CACHE_TIMEOUT, type: CacheType.MEMO })
-  public async getDepositStaderAPY(): Promise<BigNumber> {
-    return new BigNumber(0);
-    // const rewardStartTime = 1675346400;
-    // const currentTime = helpers.getCurrentTimestamp();
-    // if (currentTime < rewardStartTime) {
-    //   return new BigNumber(0);
-    // }
-    // const [totalDeposited, underlyingPrice] = await Promise.all([
-    //   this.getTotalTokenDeposited(),
-    //   fetchPrice(this.underlying.address, this._networkConnection.provider),
-    // ]);
-    // let depositStaderApy;
-    // if (helpers.isSameAddress(this.underlying.address, consts.networkAddresses.tokens.NEARX)) {
-    //   depositStaderApy = helpers.calcLMRewardApr(
-    //     await fetchValuation(
-    //       TokenAmount.fromAddressAndAmount(consts.networkAddresses.tokens.STADER, '40', false),
-    //       this._networkConnection.provider
-    //     ),
-    //     underlyingPrice.multipliedBy(totalDeposited.formattedAmount()),
-    //     365
-    //   );
-    // } else {
-    //   depositStaderApy = new BigNumber(0);
-    // }
-    // return depositStaderApy;
-  }
-
-  public async getDetails(): Promise<MoneyMarketDetails> {
-    const [totalDeposited, totalBorrowed, depositAPY, borrowAPY, collateralRatio, rewardSpeeds] =
-      await Promise.all([
-        this.getTotalTokenDeposited(),
-        this.getTotalTokenBorrowed(),
-        this.getDepositAPY(),
-        this.getBorrowAPY(),
-        this.getCollateralRatio(),
-        this.getRewardSpeeds(),
-      ]);
-    const [
-      depositPlyAPY,
-      borrowPlyAPY,
-      depositNearAPY,
-      borrowNearAPY,
-      depositMetaAPY,
-      staderDepositApy,
-    ] = await Promise.all([
-      this.getDepositPlyAPY(),
-      this.getBorrowPlyAPY(),
-      this.getDepositNearAPY(),
-      this.getBorrowNearAPY(),
-      this.getDepositMetaAPY(),
-      this.getDepositStaderAPY(),
-    ]);
-    return {
-      auTokenAddress: this.auToken.address,
-      totalTokenDeposited: totalDeposited,
-      totalTokenBorrowed: totalBorrowed,
-      depositApy: depositAPY.toNumber(),
-      depositPlyApy: depositPlyAPY.toNumber(),
-      borrowApy: borrowAPY.toNumber(),
-      borrowPlyApy: borrowPlyAPY.toNumber() * -1,
-      collateralRatio: collateralRatio.toNumber(),
-      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(),
-      staderDepositApy: staderDepositApy.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');
-    }
-  }
-  public async mintCap(): Promise<TokenAmount> {
-    return new TokenAmount(
-      this.underlying,
-      (await this.env.comptroller.callStatic.mintCaps(this.auToken.address)).toString()
-    );
-  }
-  public async borrowCap(): Promise<TokenAmount> {
-    return new TokenAmount(
-      this.underlying,
-      (await this.env.comptroller.callStatic.borrowCaps(this.auToken.address)).toString()
-    );
-  }
-
-  public async getDepositBorrowValue(userAddress: Address) {
-    const [price, depositBalance, borrowBalance] = await Promise.all([
-      this.getUnderlyingPrice(),
-      this.getUserDepositBalance(userAddress),
-      this.getUserBorrowBalance(userAddress),
-    ]);
-    const suppliedValue = price.multipliedBy(depositBalance.formattedAmount());
-    const borrowedValue = price.multipliedBy(borrowBalance.formattedAmount());
-    return {
-      suppliedValue,
-      borrowedValue,
-    };
-  }
-
-  public async getApyWithoutIncentive(userAddress: Address): Promise<Apy> {
-    const [price, depositApy, borrowApy, depositBalance, borrowBalance] = await Promise.all([
-      this.getUnderlyingPrice(),
-      this.getDepositAPY(),
-      this.getBorrowAPY(),
-      this.getUserDepositBalance(userAddress),
-      this.getUserBorrowBalance(userAddress),
-    ]);
-    const suppliedValue = price.multipliedBy(depositBalance.formattedAmount());
-    const borrowedValue = price.multipliedBy(borrowBalance.formattedAmount());
-    const sum = helpers.calcNetApy(suppliedValue, depositApy, borrowedValue, borrowApy);
-    return {
-      sum,
-      suppliedValue,
-      borrowedValue,
-    };
-  }
-
-  public async getApyWithIncentive(userAddress: Address): Promise<Apy> {
-    const [
-      price,
-      depositApy,
-      borrowApy,
-      depositBalance,
-      borrowBalance,
-      nearDepositApy,
-      plyDepositApy,
-      metaDepositApy,
-      nearBorrowApy,
-      plyBorrowApy,
-    ] = await Promise.all([
-      this.getUnderlyingPrice(),
-      this.getDepositAPY(),
-      this.getBorrowAPY(),
-      this.getUserDepositBalance(userAddress),
-      this.getUserBorrowBalance(userAddress),
-      this.getDepositNearAPY(),
-      this.getDepositPlyAPY(),
-      this.getDepositMetaAPY(),
-      this.getBorrowNearAPY(),
-      this.getBorrowPlyAPY(),
-    ]);
-    // idk why i cannot put this to promise.all, txds keep getting error
-    const staderDepositApy = await this.getDepositStaderAPY();
-    const suppliedValue = price.multipliedBy(depositBalance.formattedAmount());
-    const borrowedValue = price.multipliedBy(borrowBalance.formattedAmount());
-    const totalDepositApy = depositApy
-      .plus(nearDepositApy)
-      .plus(plyDepositApy)
-      .plus(metaDepositApy)
-      .plus(staderDepositApy);
-    const totalBorrowApy = borrowApy.plus(nearBorrowApy).plus(plyBorrowApy);
-    const sum = helpers.calcNetApy(suppliedValue, totalDepositApy, borrowedValue, totalBorrowApy);
-    return {
-      sum,
-      suppliedValue,
-      borrowedValue,
-    };
-  }
-}
-
-export class MoneyMarketReadWrite extends MoneyMarketRead {
-  protected _EthRepayHelper: MulticallStatic<EthRepayHelper>;
-  constructor(networkConnection: NetworkConnection, auToken: Address, underlyingAsset: Address) {
-    super(networkConnection, auToken, underlyingAsset);
-    this._EthRepayHelper = createContract<EthRepayHelper>(
-      consts.networkAddresses.misc.ETHREPAYHELPER,
-      abis.EthRepayHelperABI.abi,
-      networkConnection.provider
-    );
-  }
-
-  public async deposit(amount: TokenAmount): Promise<TransactionResponse> {
-    if (helpers.isSameAddress(amount.token.address, consts.ETHAddress)) {
-      return (this.auToken.raw as AuETH)
-        .connect(this._networkConnection.signer!)
-        .mint({ value: amount.rawAmount() });
-    } else {
-      return (this.auToken.raw as AuErc20)
-        .connect(this._networkConnection.signer!)
-        .mint(amount.rawAmount());
-    }
-  }
-  public async borrow(amount: TokenAmount): Promise<TransactionResponse> {
-    return this.auToken.raw.connect(this._networkConnection.signer!).borrow(amount.rawAmount());
-  }
-  public async withdraw(amount: TokenAmount): Promise<TransactionResponse> {
-    if (new BigNumber(amount.rawAmount()).lt(0)) {
-      return this.auToken.raw.connect(this._networkConnection.signer!).redeemUnderlying(consts.INF);
-    }
-    return this.auToken.raw
-      .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.raw
-        .connect(this._networkConnection.signer!)
-        .repayBorrow({ value: amount.rawAmount() });
-    } else {
-      if (new BigNumber(amount.rawAmount()).lt(0)) {
-        return this.auToken.raw.connect(this._networkConnection.signer!).repayBorrow(consts.INF);
-      } else {
-        return this.auToken.raw
-          .connect(this._networkConnection.signer!)
-          .repayBorrow(amount.rawAmount());
-      }
-    }
-  }
-  public async enableCollateral(): Promise<TransactionResponse> {
-    return this.env.comptroller.raw
-      .connect(this._networkConnection.signer!)
-      .enterMarkets([this.auToken.address]);
-  }
-  public async disableCollateral(): Promise<TransactionResponse> {
-    return this.env.comptroller.raw
-      .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);
-  }
-}

package/src/interactors/Multicall.ts

@@ -1,50 +0,0 @@
-import { Multicall2 } from '@aurigami/contracts/typechain';
-import { Contract, ethers } from 'ethers';
-import { Result } from 'ethers/lib/utils';
-import * as abis from '../abis';
-import * as consts from '../consts';
-import { BlockchainEntityRead } from '../entities';
-import { MulticallStatic, NetworkConnection } from '../types';
-
-export class MulticallRead extends BlockchainEntityRead {
-  public readonly multicall: Multicall2;
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.multicall = new Contract(
-      consts.networkAddresses.misc.MULTICALL,
-      abis.Multicall2ABI.abi,
-      networkConnection.provider
-    ) as Multicall2;
-  }
-
-  /**
-   * Run multiple calls via multicall contract
-   */
-  public async aggregate(
-    calls: {
-      contract: MulticallStatic<Contract>;
-      method: string;
-      args: any[];
-      returnTypes: string[];
-    }[]
-  ): Promise<Result[]> {
-    const txns = [];
-    // prepare transactions
-    for (let i = 0; i < calls.length; i++) {
-      const call = calls[i];
-      let txn = await call.contract.raw.populateTransaction[call.method](...call.args);
-      txns.push({ target: txn.to!, callData: txn.data! });
-    }
-
-    const response = await this.multicall.callStatic.aggregate(txns);
-
-    // parse results
-    const decodedReturn = [];
-    for (let i = 0; i < calls.length; i++) {
-      decodedReturn.push(
-        ethers.utils.defaultAbiCoder.decode(calls[i].returnTypes, response.returnData[i])
-      );
-    }
-    return decodedReturn;
-  }
-}