@aurigami/sdk 1.5.9 → 1.6.0-no-src

package/src/Papermill.ts

@@ -1,262 +0,0 @@
-import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
-import { NetworkConnection, Address, UserLockingDetails } from './types';
-import { Contract, BigNumber as BN } from 'ethers';
-import AuriFairLaunchABI from '@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json';
-import PulpABI from '@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json';
-import EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
-import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
-import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
-import {
-  AuriFairLaunch,
-  AuriLens,
-  Comptroller,
-  IERC20,
-  PULP,
-} from '@aurigami/contracts/typechain';
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import {
-  networkAddresses,
-  ONE_DAY,
-  ALL_STAKING_POOLS,
-  REWARD_CLAIM_START,
-  ONE_WEEK,
-} from './constants';
-import { getCurrentTimestamp } from './helpers';
-import { Token } from './token';
-import { TokenAmount } from './tokenAmount';
-import { getDecimal } from './helpers';
-import BigNumber from 'bignumber.js';
-
-const LOCKING_DENOMINATOR = BN.from(10000);
-export class PapermillRead extends BlockchainEntityRead {
-  public plyToken: Token;
-  public pulpToken: Token;
-
-  protected _ply: IERC20;
-  protected _pulp: PULP;
-  protected _comptroller: Comptroller;
-  protected _auriFairLaunch: AuriFairLaunch;
-  protected _auriLens: AuriLens;
-
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-
-    let plyAddress = networkAddresses.tokens.PLY;
-    let pulpAddress = networkAddresses.tokens.PULP;
-
-    this.plyToken = new Token(plyAddress, getDecimal(plyAddress));
-    this.pulpToken = new Token(pulpAddress, getDecimal(pulpAddress));
-
-    this._comptroller = new Contract(
-      networkAddresses.misc.COMPTROLLER,
-      ComptrollerABI.abi,
-      networkConnection.provider
-    ) as Comptroller;
-    this._auriFairLaunch = new Contract(
-      networkAddresses.misc.AURIFAIRLAUNCH,
-      AuriFairLaunchABI.abi,
-      networkConnection.provider
-    ) as AuriFairLaunch;
-    this._auriLens = new Contract(
-      networkAddresses.misc.AURILENS,
-      AuriLensABI.abi,
-      networkConnection.provider
-    ) as AuriLens;
-    this._ply = new Contract(
-      plyAddress,
-      EIP20InterfaceABI.abi,
-      networkConnection.provider
-    ) as IERC20;
-    this._pulp = new Contract(
-      pulpAddress,
-      PulpABI.abi,
-      networkConnection.provider
-    ) as PULP;
-  }
-
-  public async getPlyBalance(userAddress: Address): Promise<TokenAmount> {
-    const plyBalance = await this._ply.balanceOf(userAddress);
-    return new TokenAmount(this.plyToken, plyBalance.toString());
-  }
-
-  public async getPulpBalance(userAddress: Address): Promise<TokenAmount> {
-    const pulpBalance = await this._pulp.balanceOf(userAddress);
-    return new TokenAmount(this.pulpToken, pulpBalance.toString());
-  }
-
-  /**
-   * Get all unclaimed PLY reward of the user in all markets + all staking pools
-   */
-  public async getUnclaimedPlyReward(
-    userAddress: Address
-  ): Promise<TokenAmount> {
-    let rewardBalancesMetadata = await this._auriLens.callStatic.claimRewards(
-      this._comptroller.address,
-      this._auriFairLaunch.address,
-      ALL_STAKING_POOLS,
-      { from: userAddress }
-    );
-
-    return new TokenAmount(
-      this.plyToken,
-      rewardBalancesMetadata.plyAccrured.toString()
-    );
-  }
-
-  private getWeek(timestamp: number): number {
-    return BN.from(timestamp - REWARD_CLAIM_START)
-      .div(ONE_WEEK)
-      .toNumber();
-  }
-  /**
-   * Get all locking details of the user in all markets + all staking pools
-   */
-  public async getLockingDetails(
-    userAddress: Address
-  ): Promise<UserLockingDetails> {
-    const currentWeek = this.getWeek(getCurrentTimestamp());
-    var promises: any[] = [];
-
-    promises.push(
-      this._auriLens.getPercentLock(
-        this._pulp.address,
-        userAddress,
-        currentWeek
-      )
-    );
-    promises.push(
-      this._auriLens.getPercentLock(
-        this._pulp.address,
-        userAddress,
-        currentWeek + 1
-      )
-    );
-    promises.push(this.getUnclaimedPlyReward(userAddress));
-
-    var values: any[] = await Promise.all(promises);
-
-    let percentLockCurrentWeek = BN.from(values[0]);
-    let percentLockNextWeek = BN.from(values[1]);
-    let totalRewards = values[2] as TokenAmount;
-
-    let [pulpAmountCurrentWeek, plyAmountCurrentWeek] =
-      await this._pulp.calcLockAmount(userAddress, totalRewards.rawAmount());
-
-    // Predict next week lock amount = totalRewards * percentLock next week
-    // This doesn't take (the reward that user might earn in the next week) into account
-    let plyAmountNextWeek = percentLockNextWeek
-      .mul(totalRewards.rawAmount())
-      .div(LOCKING_DENOMINATOR);
-    let pulpAmountNextWeek = BN.from(totalRewards.rawAmount()).sub(
-      plyAmountNextWeek
-    );
-
-    // we need to divide these two number by 10000 and multiple by 100 to get the percentage
-    // I need to use BigNumber to do this because BN of ethers.js doesn't support floating point
-    let currentUnlockPortion = LOCKING_DENOMINATOR.sub(
-      percentLockCurrentWeek
-    ).toString();
-    let nextUnlockPortion =
-      LOCKING_DENOMINATOR.sub(percentLockNextWeek).toString();
-
-    return {
-      vestingStart: REWARD_CLAIM_START,
-      currentUnlockPortion: new BigNumber(currentUnlockPortion)
-        .dividedBy(100)
-        .toNumber(),
-      accruedPly: totalRewards,
-      currentPly: new TokenAmount(
-        this.plyToken,
-        plyAmountCurrentWeek.toString()
-      ),
-      currentPulp: new TokenAmount(
-        this.pulpToken,
-        pulpAmountCurrentWeek.toString()
-      ),
-      //
-      nextUnlockPortion: new BigNumber(nextUnlockPortion)
-        .dividedBy(100)
-        .toNumber(),
-      nextPly: new TokenAmount(this.plyToken, plyAmountNextWeek.toString()),
-      nextPulp: new TokenAmount(this.pulpToken, pulpAmountNextWeek.toString()),
-    };
-  }
-
-  /**
-   * Get the first timestamp that the unlockPortion reach the target
-   *
-   * @param userAddress currently doesn't matter
-   * @param targetUnlockPortion unlockPortion target
-   */
-  public async getTimestampToUnlock(
-    userAddress: Address,
-    targetUnlockPortion: number
-  ): Promise<number> {
-    let weekId = await this._auriLens.getWeekToUnlock(
-      this._pulp.address,
-      userAddress,
-      targetUnlockPortion * 100
-    );
-
-    return REWARD_CLAIM_START + ONE_WEEK * weekId.toNumber();
-  }
-
-  public async getUnlockPortionAt(
-    userAddress: Address,
-    timestamp: number
-  ): Promise<number> {
-    let lockPortion = await this._auriLens.getPercentLock(
-      this._pulp.address,
-      userAddress,
-      this.getWeek(timestamp)
-    );
-
-    let unlockPortion = LOCKING_DENOMINATOR.sub(lockPortion);
-
-    return unlockPortion.toNumber() / 100;
-  }
-}
-
-export class PapermillReadWrite extends PapermillRead {
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-  }
-
-  /**
-   * Redeem PLY from PULP and transfer PLY to another address
-   * @param recipient Address that will receive the PLY.
-   * @param amount Amount of PULP to be converted to PLY.
-   * Set to ethers.constants.MaxUint256 for max redeem.
-   */
-  public async redeem(
-    recipient: Address,
-    amount: TokenAmount
-  ): Promise<TransactionResponse> {
-    return this._pulp
-      .connect(this._networkConnection.signer!)
-      .redeem(recipient, amount.rawAmount());
-  }
-
-  /**
-   * Redeem PLY from PULP and transfer PLY to msg.sender
-   * @param amount Amount of PULP to be converted to PLY.
-   * Set to ethers.constants.MaxUint256 for max redeem.
-   */
-  public async selfRedeem(amount: TokenAmount): Promise<TransactionResponse> {
-    let msgSender: string = await this._networkConnection.signer!.getAddress();
-    return this.redeem(msgSender, amount);
-  }
-}
-
-export class Papermill extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): PapermillRead {
-    return new PapermillRead(networkConnection);
-  }
-
-  public readWrite(networkConnection: NetworkConnection): PapermillReadWrite {
-    return new PapermillReadWrite(networkConnection);
-  }
-}

package/src/SDK.ts

@@ -1,366 +0,0 @@
-import AuriFairLaunchABI from '@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json';
-import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
-import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
-import FaucetABI from '@aurigami/contracts/artifacts/contracts/mock/Faucet.sol/Faucet.json';
-import {
-  AuriFairLaunch,
-  AuriLens,
-  Comptroller,
-} from '@aurigami/contracts/typechain';
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract } from 'ethers';
-import { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
-import {
-  ALL_STAKING_POOLS,
-  BORROW_LIMIT_BUFFER,
-  DECIMAL_PRECISION,
-  INF,
-  networkAddresses,
-} from './constants';
-import { decimalFactor, isSameAddress } from './helpers';
-import { MoneyMarketRead } from './MoneyMarket';
-import { PapermillRead } from './Papermill';
-import { calcValuation, fetchPrice } from './priceFetcher';
-import { StakingRead, StakingReadWrite } from './Staking';
-import { Token } from './token';
-import { TokenAmount } from './tokenAmount';
-import {
-  Address,
-  CurrencyAmount,
-  HypotheticalStats,
-  MarketAction,
-  NetworkConnection,
-  PLYWNEARPoolDetails,
-  UserDetails,
-  UserMarketDetails,
-} from './types';
-
-export class SdkRead extends BlockchainEntityRead {
-  protected _comptroller: Comptroller;
-  protected _auriFairLaunch: AuriFairLaunch;
-  protected _auriLens: AuriLens;
-  protected _stakingRead: StakingRead;
-  constructor(networkConnection: NetworkConnection) {
-    super(networkConnection);
-    this._stakingRead = new StakingRead(networkConnection);
-    this._comptroller = new Contract(
-      networkAddresses.misc.COMPTROLLER,
-      ComptrollerABI.abi,
-      networkConnection.provider
-    ) as Comptroller;
-    this._auriFairLaunch = new Contract(
-      networkAddresses.misc.AURIFAIRLAUNCH,
-      AuriFairLaunchABI.abi,
-      networkConnection.provider
-    ) as AuriFairLaunch;
-    this._auriLens = new Contract(
-      networkAddresses.misc.AURILENS,
-      AuriLensABI.abi,
-      networkConnection.provider
-    ) as AuriLens;
-  }
-
-  public async getUserDetails(userAddress: string): Promise<UserDetails> {
-    const marketCount = networkAddresses.auTokens.length;
-    var userMarketDetails: UserMarketDetails[] = [],
-      assetsIn: string[];
-    var promises = [];
-    var totalBorrowLimit = new BigNumber(0);
-    var pricePromises = [];
-    for (const auToken of networkAddresses.auTokens) {
-      const userMarketDetail: UserMarketDetails = {} as UserMarketDetails;
-      userMarketDetails.push(userMarketDetail);
-      userMarketDetail.market = auToken.underlying;
-      const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
-        this._networkConnection,
-        auToken.address,
-        auToken.underlying
-      );
-      promises.push(
-        moneyMarket
-          .getUserDepositBalance(userAddress)
-          .then((res: TokenAmount) => {
-            userMarketDetail.depositBalance = res;
-          })
-      );
-      promises.push(
-        moneyMarket
-          .getUserBorrowBalance(userAddress)
-          .then((res: TokenAmount) => {
-            userMarketDetail.borrowBalance = res;
-          })
-      );
-      promises.push(
-        moneyMarket.getCollateralRatio().then((res: BigNumber) => {
-          userMarketDetail.collateralRatio = res.toNumber();
-        })
-      );
-      pricePromises.push(
-        fetchPrice(
-          moneyMarket.underlying.address,
-          this._networkConnection.provider
-        ).then((res) => {
-          userMarketDetail.underlyingPrice = res.toString();
-          return res;
-        })
-      );
-    }
-
-    promises.push(
-      this._comptroller.getAssetsIn(userAddress).then((res: string[]) => {
-        assetsIn = res;
-      })
-    );
-
-    await Promise.all(promises);
-    var underlyingPrices = await Promise.all(pricePromises);
-    var depositValues = [];
-    for (var i = 0; i < marketCount; i++) {
-      const auToken = networkAddresses.auTokens[i];
-      if (
-        assetsIn!.find((auAddress: Address) =>
-          isSameAddress(auToken.address, auAddress)
-        ) !== undefined
-      ) {
-        userMarketDetails[i].isCollateral = true;
-      } else {
-        userMarketDetails[i].isCollateral = false;
-      }
-      depositValues.push(
-        calcValuation(userMarketDetails[i].depositBalance, underlyingPrices[i])
-      );
-    }
-
-    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._comptroller.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(BORROW_LIMIT_BUFFER);
-    const minimumBorrowLimitAllowed =
-      borrowedvaluation.div(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 = 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(underlyingPrices[i]);
-      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(DECIMAL_PRECISION),
-      },
-      userLockingDetails: await new PapermillRead(
-        this._networkConnection
-      ).getLockingDetails(userAddress),
-      borrowableAmount: {
-        currency: 'USD',
-        amount: borrowableAmount.toFixed(DECIMAL_PRECISION),
-      },
-    };
-  }
-
-  public async getPLYWNEARPoolDetails(): Promise<PLYWNEARPoolDetails> {
-    return this._stakingRead.getPLYWNEARPoolDetails();
-  }
-
-  public async getTokenPrice(token: Token): Promise<CurrencyAmount> {
-    const price = await fetchPrice(
-      token.address,
-      this._networkConnection.provider
-    );
-    return {
-      currency: 'USD',
-      amount: price.toFixed(DECIMAL_PRECISION),
-    };
-  }
-
-  /**
-   * Get amount of staked LP tokens
-   */
-  public async stakeBalanceOf(user: string): Promise<TokenAmount> {
-    return this._stakingRead.stakeBalanceOf(user);
-  }
-
-  /**
-   * Get amount of LP token in user wallet
-   */
-  public async LpBalanceOf(user: string): Promise<TokenAmount> {
-    return this._stakingRead.LpBalanceOf(user);
-  }
-
-  public async unclaimedRewardsOf(user: string): Promise<TokenAmount[]> {
-    return this._stakingRead.unclaimedRewardsOf(user);
-  }
-
-  public calcHypotheticalStats({
-    userMarketDetail,
-    currentBorrowLimit,
-    currentBorrowValuation,
-    action,
-    tokenAmount,
-  }: {
-    userMarketDetail: UserMarketDetails;
-    currentBorrowLimit: CurrencyAmount;
-    currentBorrowValuation: CurrencyAmount;
-    action: MarketAction;
-    tokenAmount?: TokenAmount;
-  }): HypotheticalStats {
-    var newBorrowLimit = new BigNumber(currentBorrowLimit.amount),
-      newBorrowValuation = new BigNumber(currentBorrowValuation.amount);
-    switch (action) {
-      case MarketAction.EnableCollateral:
-      case MarketAction.DisableCollateral:
-        var deltaBorrowLimit = calcValuation(
-          userMarketDetail.depositBalance,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        )
-          .multipliedBy(userMarketDetail.collateralRatio)
-          .multipliedBy(BORROW_LIMIT_BUFFER);
-        newBorrowLimit =
-          action == MarketAction.EnableCollateral
-            ? newBorrowLimit.plus(deltaBorrowLimit)
-            : newBorrowLimit.minus(deltaBorrowLimit);
-        break;
-
-      case MarketAction.Deposit:
-      case MarketAction.Withdraw:
-        deltaBorrowLimit = calcValuation(
-          tokenAmount!,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        )
-          .multipliedBy(userMarketDetail.collateralRatio)
-          .multipliedBy(BORROW_LIMIT_BUFFER);
-        newBorrowLimit =
-          action == MarketAction.Deposit
-            ? newBorrowLimit.plus(deltaBorrowLimit)
-            : newBorrowLimit.minus(deltaBorrowLimit);
-        break;
-
-      case MarketAction.Borrow:
-      case MarketAction.Repay:
-        var deltaBorrowValuation = calcValuation(
-          tokenAmount!,
-          new BigNumber(userMarketDetail.underlyingPrice)
-        );
-        newBorrowValuation =
-          action == MarketAction.Borrow
-            ? newBorrowValuation.plus(deltaBorrowValuation)
-            : newBorrowValuation.minus(deltaBorrowValuation);
-        break;
-    }
-    return {
-      newBorrowLimit: {
-        amount: newBorrowLimit!.toFixed(DECIMAL_PRECISION),
-        currency: 'USD',
-      },
-      newBorrowUtilization: newBorrowLimit.eq(0)
-        ? newBorrowValuation.eq(0)
-          ? 0
-          : 9999.99
-        : newBorrowValuation!.div(newBorrowLimit!).toNumber(),
-    };
-  }
-}
-
-export class SdkReadWrite extends SdkRead {
-  /**
-   * Claim PLY reward in all markets + staking pools
-   */
-  public async claim(): Promise<TransactionResponse> {
-    return this._comptroller
-      .connect(this._networkConnection.signer!)
-      ['claimReward(uint8,address)'](
-        0,
-        await this._networkConnection.signer!.getAddress()
-      );
-  }
-
-  public async claimLpRewards(): Promise<TransactionResponse> {
-    return this._auriFairLaunch
-      .connect(this._networkConnection.signer!)
-      .harvest(await this._networkConnection.signer!.getAddress(), 0, INF);
-  }
-
-  public async stake(amount: TokenAmount): Promise<TransactionResponse> {
-    return new StakingReadWrite(this._networkConnection).stake(amount);
-  }
-
-  public async unstake(amount: TokenAmount): Promise<TransactionResponse> {
-    return new StakingReadWrite(this._networkConnection).unstake(amount);
-  }
-
-  public async faucetDrip(): Promise<TransactionResponse> {
-    const faucet = new Contract(
-      networkAddresses.misc.FAUCET,
-      FaucetABI.abi,
-      this._networkConnection.provider
-    );
-    return faucet.connect(this._networkConnection.signer!).drip();
-  }
-}
-
-export class SDK extends BlockchainEntity {
-  constructor() {
-    super();
-  }
-  public read(networkConnection: NetworkConnection): SdkRead {
-    return new SdkRead(networkConnection);
-  }
-
-  public readWrite(networkConnection: NetworkConnection): SdkReadWrite {
-    return new SdkReadWrite(networkConnection);
-  }
-}