@aurigami/sdk 1.24.0 → 1.24.2

package/src/interactors/Staking.ts

@@ -1,156 +0,0 @@
-import { IERC20 } from '@aurigami/contracts/typechain';
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN } from 'ethers';
-import { EIP20InterfaceABI } from '../abis';
-import * as consts from '../consts';
-import {
-  AuriEnv,
-  BlockchainEntity,
-  BlockchainEntityRead,
-  PLYWNEARToken,
-  Token,
-  TokenAmount,
-} from '../entities';
-import { calcLMRewardApr, getDecimal } from '../helpers';
-import { createContract } from '../helpers/multicall';
-import { fetchValuation } from '../helpers/priceFetcher';
-import { NetworkConnection, PLYWNEARPoolDetails, TokenAPY } from '../types';
-
-export class StakingRead extends BlockchainEntityRead {
-  public readonly env: AuriEnv;
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-  }
-
-  public async getPLYWNEARPoolDetails(): Promise<PLYWNEARPoolDetails> {
-    const { stakedLiquidity, rewardPerSeconds } = await this.env.auriFairLaunch.callStatic
-      .getPoolInfo(consts.PLYWNEAR_POOL_ID)
-      .then((res) => {
-        const endedTime = res.endTime;
-        const startTime = res.startTime;
-        const now = Date.now() / 1000;
-        // If the pool has ended or not started, return 0 reward per second
-        if (endedTime < now || startTime > now) {
-          return {
-            stakedLiquidity: res.totalStake,
-            rewardPerSeconds: res.rewardPerSeconds.map((_) => BN.from(0)),
-          };
-        }
-        return { stakedLiquidity: res.totalStake, rewardPerSeconds: res.rewardPerSeconds };
-      });
-
-    let stakedLiquidityAmount = new TokenAmount(PLYWNEARToken, stakedLiquidity!.toString());
-
-    var totalStakeValuation: BigNumber = await fetchValuation(
-      stakedLiquidityAmount,
-      this._networkConnection.provider
-    );
-
-    var promises = [];
-
-    // Calculate the reward per second in USD
-    for (let i = 0; i < rewardPerSeconds!.length; i++) {
-      let rewardTokenAddress = consts.PLYWNEAR_REWARD_TOKENS[i];
-      let rewardToken = new Token(rewardTokenAddress, getDecimal(rewardTokenAddress));
-      let rewardPerSecond = rewardPerSeconds![i];
-      promises.push(
-        fetchValuation(
-          new TokenAmount(rewardToken, rewardPerSecond!.toString()),
-          this._networkConnection.provider
-        )
-      );
-    }
-
-    let APYs: TokenAPY[] = [];
-    (await Promise.all(promises)).forEach((rewardPerSecondValuation, i) => {
-      let rewardTokenAddress = consts.PLYWNEAR_REWARD_TOKENS[i];
-      let apy = calcLMRewardApr(
-        rewardPerSecondValuation,
-        totalStakeValuation,
-        consts.ONE_DAY * 365
-      ).toFixed(consts.DECIMAL_PRECISION);
-
-      APYs.push({
-        address: rewardTokenAddress,
-        apy: apy,
-      });
-    });
-
-    return {
-      totalStakedLiquidity: stakedLiquidityAmount,
-      APYs: APYs,
-    };
-  }
-
-  /**
-   * Get amount of staked LP tokens
-   */
-  public async stakeBalanceOf(user: string): Promise<TokenAmount> {
-    const userInfo = await this.env.auriFairLaunch.callStatic.getUserInfo(
-      consts.PLYWNEAR_POOL_ID,
-      user
-    );
-    return new TokenAmount(PLYWNEARToken, userInfo.amount.toString());
-  }
-
-  /**
-   * Get amount of LP token in user wallet
-   */
-  public async LpBalanceOf(user: string): Promise<TokenAmount> {
-    let lpContract = createContract<IERC20>(
-      consts.networkAddresses.tokens.PLYWNEAR,
-      EIP20InterfaceABI.abi,
-      this._networkConnection.provider
-    );
-    let balance = await lpContract.callStatic.balanceOf(user);
-
-    return new TokenAmount(PLYWNEARToken, balance.toString());
-  }
-
-  public async unclaimedRewardsOf(user: string): Promise<TokenAmount[]> {
-    let userInfo = await this.env.auriFairLaunch.raw.callStatic.updateAndGetUserInfo(
-      consts.PLYWNEAR_POOL_ID,
-      user,
-      { from: user }
-    );
-
-    let rewards = userInfo.unclaimedRewards;
-    return rewards.map((reward, i) =>
-      TokenAmount.fromAddressAndAmount(consts.PLYWNEAR_REWARD_TOKENS[i], reward.toString())
-    );
-  }
-}
-
-export class StakingReadWrite extends StakingRead {
-  public async stake(amount: TokenAmount): Promise<TransactionResponse> {
-    return this.env.auriFairLaunch.raw
-      .connect(this._networkConnection.signer!)
-      .deposit(consts.PLYWNEAR_POOL_ID, amount.rawAmount());
-  }
-
-  public async unstake(amount: TokenAmount): Promise<TransactionResponse> {
-    const msgSender = await this._networkConnection.signer!.getAddress();
-    const amountInput = BN.from(amount.rawAmount());
-    const stakedAmount = BN.from((await this.stakeBalanceOf(msgSender)).rawAmount());
-    // unstakeAmount = min(amountInput, stakedAmount - 1)
-    const unstakeAmount = amountInput.lt(stakedAmount) ? amountInput : stakedAmount.sub(1);
-    return this.env.auriFairLaunch.raw
-      .connect(this._networkConnection.signer!)
-      .withdraw(consts.PLYWNEAR_POOL_ID, unstakeAmount);
-  }
-}
-
-export class Staking extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): StakingRead {
-    return new StakingRead(networkConnection);
-  }
-
-  public readWrite(networkConnection: NetworkConnection): StakingReadWrite {
-    return new StakingReadWrite(networkConnection);
-  }
-}

package/src/interactors/index.ts

@@ -1,9 +0,0 @@
-export * from './Airdrop';
-export * from './MoneyMarket';
-export * from './Papermill';
-export * from './PlyGame';
-export * from './Pulp';
-export * from './Referral';
-export * from './Staking';
-export * from './misc';
-export * from './PlyTokenLock';

package/src/interactors/misc.ts

@@ -1,433 +0,0 @@
-import { AuToken } from '@aurigami/contracts/typechain';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN } from 'ethers';
-import * as abis from '../abis';
-import * as consts from '../consts';
-import { AuriEnv, BlockchainEntityRead, PLYToken, Token, TokenAmount } from '../entities';
-import { decimalFactor, getDecimal, getSymbol, isSameAddress } from '../helpers/helpers';
-import { calcValuation, fetchPrice } from '../helpers/priceFetcher';
-import * as types from '../types';
-import { MoneyMarketRead } from './MoneyMarket';
-import { MulticallRead } from './Multicall';
-import { StakingRead } from './Staking';
-
-export class MiscRead extends BlockchainEntityRead {
-  public readonly env: AuriEnv;
-  public readonly stakingRead: StakingRead;
-  constructor(networkConnection: types.NetworkConnection) {
-    super(networkConnection);
-    this.stakingRead = new StakingRead(networkConnection);
-    this.env = new AuriEnv(networkConnection);
-  }
-
-  public async getUserDetails(userAddress: string): Promise<types.UserDetails> {
-    const marketCount = consts.networkAddresses.auTokens.length;
-    var userMarketDetails: types.UserMarketDetails[] = [],
-      assetsIn: string[];
-    var totalBorrowLimit = new BigNumber(0);
-    for (const auToken of consts.networkAddresses.auTokens) {
-      const userMarketDetail: types.UserMarketDetails = {} as types.UserMarketDetails;
-      userMarketDetails.push(userMarketDetail);
-      userMarketDetail.market = auToken.underlying;
-      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
-        this._networkConnection,
-        auToken.address,
-        auToken.underlying
-      );
-      const [depositBalance, borrowBalance, collateralRatio, underlyingPrice] = await Promise.all([
-        moneyMarket.getUserDepositBalance(userAddress),
-        moneyMarket.getUserBorrowBalance(userAddress),
-        moneyMarket.getCollateralRatio(),
-        fetchPrice(moneyMarket.underlying.address, this._networkConnection.provider),
-      ]);
-
-      userMarketDetail.depositBalance = depositBalance;
-      userMarketDetail.borrowBalance = borrowBalance;
-      userMarketDetail.collateralRatio = collateralRatio.toNumber();
-      userMarketDetail.underlyingPrice = underlyingPrice.toString();
-    }
-
-    assetsIn = await this.env.comptroller.raw.getAssetsIn(userAddress);
-
-    var depositValues = [];
-    for (var i = 0; i < marketCount; i++) {
-      const auToken = consts.networkAddresses.auTokens[i];
-      if (
-        assetsIn!.find((auAddress: types.Address) => isSameAddress(auToken.address, auAddress)) !==
-        undefined
-      ) {
-        userMarketDetails[i].isCollateral = true;
-      } else {
-        userMarketDetails[i].isCollateral = false;
-      }
-      depositValues.push(
-        calcValuation(
-          userMarketDetails[i].depositBalance,
-          new BigNumber(userMarketDetails[i].underlyingPrice)
-        )
-      );
-    }
-
-    totalBorrowLimit = depositValues.reduce((p: BigNumber, v: BigNumber, index: number) => {
-      if (userMarketDetails[index].isCollateral)
-        return p.plus(v.multipliedBy(userMarketDetails[index].collateralRatio));
-      return p;
-    }, new BigNumber(0));
-
-    var accountLiquidity: [BN, BN] = await this.env.comptroller.raw.getAccountLiquidity(
-      userAddress
-    );
-
-    var borrowedvaluation: BigNumber = totalBorrowLimit.minus(
-      new BigNumber(accountLiquidity[0].toString()).div(decimalFactor(18))
-    );
-
-    if (borrowedvaluation.lt('0.00001')) {
-      // Igore dust, dust could be the result of network delay causing collateral valuation calc to be different on vs off chain
-      borrowedvaluation = new BigNumber(0);
-    }
-
-    const bufferedBorrowLimit: BigNumber = totalBorrowLimit.multipliedBy(
-      consts.BORROW_LIMIT_BUFFER
-    );
-    const minimumBorrowLimitAllowed = borrowedvaluation.div(consts.BORROW_LIMIT_BUFFER);
-
-    var borrowableAmount: BigNumber;
-    if (bufferedBorrowLimit.lte(borrowedvaluation)) {
-      borrowableAmount = new BigNumber(0);
-    } else {
-      borrowableAmount = bufferedBorrowLimit.minus(borrowedvaluation);
-    }
-
-    for (var i = 0; i < marketCount; i++) {
-      const auToken = consts.networkAddresses.auTokens[i];
-      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
-        this._networkConnection,
-        auToken.address,
-        auToken.underlying
-      );
-      const borrowLimitMargin = totalBorrowLimit.minus(minimumBorrowLimitAllowed).gt(0)
-        ? totalBorrowLimit.minus(minimumBorrowLimitAllowed)
-        : new BigNumber(0);
-      const maxWithdrawCap: BigNumber = borrowLimitMargin
-        .div(userMarketDetails[i].collateralRatio)
-        .div(userMarketDetails[i].underlyingPrice);
-      userMarketDetails[i].maxWithdrawableAmount =
-        userMarketDetails[i].isCollateral &&
-        maxWithdrawCap.lt(userMarketDetails[i].depositBalance.formattedAmount())
-          ? new TokenAmount(moneyMarket.underlying, maxWithdrawCap.toFixed(24), false)
-          : new TokenAmount(
-              moneyMarket.underlying,
-              userMarketDetails[i].depositBalance.rawAmount()
-            );
-    }
-
-    return {
-      markets: userMarketDetails,
-      borrowLimit: {
-        currency: 'USD',
-        amount: bufferedBorrowLimit.toFixed(consts.DECIMAL_PRECISION),
-      },
-      borrowableAmount: {
-        currency: 'USD',
-        amount: borrowableAmount.toFixed(consts.DECIMAL_PRECISION),
-      },
-    };
-  }
-
-  public async getTokenPrice(token: Token): Promise<types.CurrencyAmount> {
-    const price = await fetchPrice(token.address, this._networkConnection.provider);
-    return {
-      currency: 'USD',
-      amount: price.toFixed(consts.DECIMAL_PRECISION),
-    };
-  }
-
-  public async calcBorrowPower(tokenAmount: TokenAmount) {
-    const autoken = consts.networkAddresses.auTokens.find((auToken) =>
-      isSameAddress(auToken.underlying, tokenAmount.token.address)
-    )!;
-    const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
-      this._networkConnection,
-      autoken.address,
-      autoken.underlying
-    );
-    const collateralRatio = await moneyMarket.getCollateralRatio();
-    const underlyingPrice = await fetchPrice(
-      tokenAmount.token.address,
-      this._networkConnection.provider
-    );
-    const borrowPower = calcValuation(tokenAmount!, new BigNumber(underlyingPrice))
-      .multipliedBy(collateralRatio)
-      .multipliedBy(consts.BORROW_LIMIT_BUFFER);
-    return {
-      currency: 'USD',
-      amount: borrowPower.toFixed(consts.DECIMAL_PRECISION),
-    };
-  }
-
-  public calcHypotheticalStats({
-    userMarketDetail,
-    currentBorrowLimit,
-    currentBorrowValuation,
-    action,
-    tokenAmount,
-  }: {
-    userMarketDetail: types.UserMarketDetails;
-    currentBorrowLimit: types.CurrencyAmount;
-    currentBorrowValuation: types.CurrencyAmount;
-    action: types.MarketAction;
-    tokenAmount?: TokenAmount;
-  }): types.HypotheticalStats {
-    var newBorrowLimit = new BigNumber(currentBorrowLimit.amount),
-      newBorrowValuation = new BigNumber(currentBorrowValuation.amount);
-    switch (action) {
-      case types.MarketAction.EnableCollateral:
-      case types.MarketAction.DisableCollateral:
-        var deltaBorrowLimit = calcValuation(
-          userMarketDetail.depositBalance,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        )
-          .multipliedBy(userMarketDetail.collateralRatio)
-          .multipliedBy(consts.BORROW_LIMIT_BUFFER);
-        newBorrowLimit =
-          action == types.MarketAction.EnableCollateral
-            ? newBorrowLimit.plus(deltaBorrowLimit)
-            : newBorrowLimit.minus(deltaBorrowLimit);
-        break;
-
-      case types.MarketAction.Deposit:
-      case types.MarketAction.Withdraw:
-        deltaBorrowLimit = calcValuation(
-          tokenAmount!,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        )
-          .multipliedBy(userMarketDetail.collateralRatio)
-          .multipliedBy(consts.BORROW_LIMIT_BUFFER);
-        newBorrowLimit =
-          action == types.MarketAction.Deposit
-            ? newBorrowLimit.plus(deltaBorrowLimit)
-            : newBorrowLimit.minus(deltaBorrowLimit);
-        break;
-
-      case types.MarketAction.Borrow:
-      case types.MarketAction.Repay:
-        var deltaBorrowValuation = calcValuation(
-          tokenAmount!,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        );
-        newBorrowValuation =
-          action == types.MarketAction.Borrow
-            ? newBorrowValuation.plus(deltaBorrowValuation)
-            : newBorrowValuation.minus(deltaBorrowValuation);
-        break;
-    }
-    return {
-      newBorrowLimit: {
-        amount: newBorrowLimit!.toFixed(consts.DECIMAL_PRECISION),
-        currency: 'USD',
-      },
-      newBorrowUtilization: newBorrowLimit.eq(0)
-        ? newBorrowValuation.eq(0)
-          ? 0
-          : 9999.99
-        : newBorrowValuation!.div(newBorrowLimit!).toNumber(),
-    };
-  }
-
-  /**
-   * Get ply circulating supply.
-   * It is calculated by the total supply, minus:
-   *  - Ply in team multisig contract
-   *  - Ply in comptroller contract
-   *  - Ply in fairlaunch contract
-   *  - Ply in vesting contract
-   */
-  public async getPlyCirculatingSupply(): Promise<TokenAmount> {
-    const multicallRead = new MulticallRead(this._networkConnection);
-    const baseBalanceOfCall = {
-      contract: this.env.ply,
-      method: 'balanceOf',
-      returnTypes: ['uint256'],
-    };
-
-    const listAddrs = [
-      consts.networkAddresses.misc.TEAM_MULTISIG,
-      consts.networkAddresses.misc.COMPTROLLER,
-      consts.networkAddresses.misc.AURIFAIRLAUNCH,
-      consts.networkAddresses.misc.PLY_TOKEN_LOCK,
-      consts.networkAddresses.misc.TEAM_MULTISIG_AURORA_PLUS,
-      consts.networkAddresses.misc.AURORA_PLUS,
-      consts.networkAddresses.misc.PULP_CONTRACT,
-    ];
-
-    const calls = listAddrs.map((addr) => ({
-      ...baseBalanceOfCall,
-      args: [addr],
-    }));
-
-    const callResults = (await multicallRead.aggregate(calls)) as BN[][];
-
-    let circulatingSupply: BN = BN.from(
-      '1' + '0'.repeat(10) + '0'.repeat(getDecimal(this.env.ply.address))
-    );
-    callResults.forEach((result, i) => {
-      circulatingSupply = circulatingSupply.sub(result[0]);
-    });
-
-    return new TokenAmount(PLYToken, circulatingSupply.toString());
-  }
-
-  public async getUtilisation(userAddr: types.Address): Promise<BigNumber> {
-    let accountDetail =
-      await this.env.auriInternalLens.callStatic.getAccountLiquidityAccrueInterest(userAddr);
-    let sumBorrow = new BigNumber(accountDetail.sumBorrowPlusEffects.toString());
-    let sumCol = new BigNumber(accountDetail.sumCollateral.toString());
-    return sumBorrow.dividedBy(sumCol);
-  }
-
-  public async sneakAccounts(
-    accounts: string[],
-    tokenAddresses: string[],
-    dust: BigNumber = new BigNumber(0.1)
-  ): Promise<types.AccountAuTokensInfo[]> {
-    const _1E18 = BN.from(10).pow(18);
-    const oracle = this.env.oracle;
-    const tokens = tokenAddresses.map((addr) =>
-      this.env.getContract<AuToken>(addr, abis.AuTokenABI.abi)
-    );
-    const prices = await oracle.callStatic.getUnderlyingPrices(tokenAddresses);
-    const exrate = await this.env.auriInternalLens.callStatic.getExchangeRates(tokenAddresses);
-
-    const res: types.AccountAuTokensInfo[] = [];
-
-    for (let addr of accounts) {
-      const infos: types.AccountAuTokenInfo[] = [];
-      for (let i = 0; i < tokens.length; ++i) {
-        const snapshot = await tokens[i].callStatic.getAccountSnapshot(addr);
-        const bal = snapshot[0].mul(exrate[i]).div(_1E18).mul(prices[i]).div(_1E18);
-        const bor = snapshot[1].mul(prices[i]).div(_1E18);
-
-        let balR = new BigNumber(bal.toString()).dividedBy(_1E18.toString());
-        let borR = new BigNumber(bor.toString()).dividedBy(_1E18.toString());
-
-        if (balR.lte(dust) && borR.lte(dust)) continue;
-
-        infos.push({
-          token: getSymbol(tokenAddresses[i]),
-          deposit: balR,
-          borrow: borR,
-        });
-      }
-      res.push({
-        address: addr,
-        tokens: infos,
-      });
-    }
-    return res;
-  }
-
-  public async getLTVAndLiquidationThreshold(userAddr: types.Address) {
-    let totalSuppliedValue = new BigNumber(0);
-    let totalBorrowedValue = new BigNumber(0);
-    let collateralValue = new BigNumber(0);
-    const assetsIn = await this.env.comptroller.callStatic.getAssetsIn(userAddr);
-    const marketValues = await Promise.all(
-      consts.networkAddresses.auTokens.map(async (auToken) => {
-        const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
-          this._networkConnection,
-          auToken.address,
-          auToken.underlying
-        );
-        return Promise.all([
-          moneyMarket.getCollateralRatio(),
-          moneyMarket.getDepositBorrowValue(userAddr),
-        ]);
-      })
-    );
-    consts.networkAddresses.auTokens.forEach(async (auToken, i) => {});
-    for (var i = 0; i < marketValues.length; i++) {
-      const auToken = consts.networkAddresses.auTokens[i];
-      const [collateralRatio, depositBorrowValue] = marketValues[i];
-      if (
-        assetsIn!.find((auAddress: types.Address) => isSameAddress(auToken.address, auAddress)) !==
-        undefined
-      ) {
-        totalSuppliedValue = totalSuppliedValue.plus(depositBorrowValue.suppliedValue);
-        collateralValue = collateralValue.plus(
-          depositBorrowValue.suppliedValue.times(collateralRatio)
-        );
-      }
-      totalBorrowedValue = totalBorrowedValue.plus(depositBorrowValue.borrowedValue);
-    }
-    const ltv = totalBorrowedValue.div(totalSuppliedValue);
-    const liquidationThreshold = collateralValue.div(totalSuppliedValue);
-    return {
-      ltv,
-      liquidationThreshold,
-    };
-  }
-
-  public async getNetApyWithoutIncentive(userAddress: types.Address): Promise<BigNumber> {
-    let sum = new BigNumber(0);
-    let totalSuppliedValue = new BigNumber(0);
-    let totalBorrowedValue = new BigNumber(0);
-    let netApy = new BigNumber(0);
-
-    const apys = await Promise.all(
-      consts.networkAddresses.auTokens.map((auToken) => {
-        const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
-          this._networkConnection,
-          auToken.address,
-          auToken.underlying
-        );
-        const apyWithoutIncentive = moneyMarket.getApyWithoutIncentive(userAddress);
-        return apyWithoutIncentive;
-      })
-    );
-
-    for (const apy of apys) {
-      sum = sum.plus(apy.sum);
-      totalSuppliedValue = totalSuppliedValue.plus(apy.suppliedValue);
-      totalBorrowedValue = totalBorrowedValue.plus(apy.borrowedValue);
-    }
-
-    if (sum.gt(0)) {
-      netApy = sum.div(totalSuppliedValue);
-    } else if (sum.lt(0)) {
-      netApy = sum.div(totalBorrowedValue);
-    }
-    return netApy;
-  }
-
-  public async getNetApyWithIncentive(userAddress: types.Address): Promise<BigNumber> {
-    let sum = new BigNumber(0);
-    let totalSuppliedValue = new BigNumber(0);
-    let totalBorrowedValue = new BigNumber(0);
-    let netApy = new BigNumber(0);
-    const apys = await Promise.all(
-      consts.networkAddresses.auTokens.map((auToken) => {
-        const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
-          this._networkConnection,
-          auToken.address,
-          auToken.underlying
-        );
-        const apyWithIncentive = moneyMarket.getApyWithIncentive(userAddress);
-        return apyWithIncentive;
-      })
-    );
-
-    for (const apy of apys) {
-      sum = sum.plus(apy.sum);
-      totalSuppliedValue = totalSuppliedValue.plus(apy.suppliedValue);
-      totalBorrowedValue = totalBorrowedValue.plus(apy.borrowedValue);
-    }
-
-    if (sum.gt(0)) {
-      netApy = sum.div(totalSuppliedValue);
-    } else if (sum.lt(0)) {
-      netApy = sum.div(totalBorrowedValue);
-    }
-    return netApy;
-  }
-}