@aurigami/sdk 1.6.0-no-src → 1.6.1

package/src/contracts/Papermill.ts

@@ -0,0 +1,271 @@
+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 EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
+import PulpABI from '@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json';
+import {
+  AuriFairLaunch,
+  AuriLens,
+  Comptroller,
+  IERC20,
+  PULP,
+} 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,
+  Token,
+  TokenAmount,
+} from '../entities';
+import * as helpers from '../helpers';
+import { Address, NetworkConnection, UserLockingDetails } from '../types';
+
+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 = consts.networkAddresses.tokens.PLY;
+    let pulpAddress = consts.networkAddresses.tokens.PULP;
+
+    this.plyToken = new Token(plyAddress, helpers.getDecimal(plyAddress));
+    this.pulpToken = new Token(pulpAddress, helpers.getDecimal(pulpAddress));
+
+    this._comptroller = new Contract(
+      consts.networkAddresses.misc.COMPTROLLER,
+      ComptrollerABI.abi,
+      networkConnection.provider
+    ) as Comptroller;
+    this._auriFairLaunch = new Contract(
+      consts.networkAddresses.misc.AURIFAIRLAUNCH,
+      AuriFairLaunchABI.abi,
+      networkConnection.provider
+    ) as AuriFairLaunch;
+    this._auriLens = new Contract(
+      consts.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,
+      consts.ALL_STAKING_POOLS,
+      { from: userAddress }
+    );
+
+    return new TokenAmount(
+      this.plyToken,
+      rewardBalancesMetadata.plyAccrured.toString()
+    );
+  }
+
+  private getWeek(timestamp: number): number {
+    return BN.from(timestamp - consts.REWARD_CLAIM_START)
+      .div(consts.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(helpers.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: consts.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 consts.REWARD_CLAIM_START + consts.ONE_WEEK * weekId.toNumber();
+  }
+
+  /**
+   * Get the start timestamp of next week of the papermill contract.
+   *
+   * This is a sync function!
+   *
+   * @returns the timestamp in seconds
+   */
+  public getNextWeekTimestamp(): number {
+    const nextWeek = this.getWeek(helpers.getCurrentTimestamp()) + 1;
+    return consts.REWARD_CLAIM_START + consts.ONE_WEEK * nextWeek;
+  }
+
+  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/contracts/Staking.ts

@@ -0,0 +1,183 @@
+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 EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
+import {
+  AuriFairLaunch,
+  AuriLens,
+  Comptroller,
+  IERC20,
+} 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,
+  PLYWNEARToken,
+  Token,
+  TokenAmount,
+} from '../entities';
+import { calcLMRewardApr, getDecimal } from '../helpers';
+import { fetchValuation } from '../helpers/priceFetcher';
+import { NetworkConnection, PLYWNEARPoolDetails, TokenAPY } from '../types';
+
+export class StakingRead extends BlockchainEntityRead {
+  protected _comptroller: Comptroller;
+  protected _auriFairLaunch: AuriFairLaunch;
+  protected _auriLens: AuriLens;
+  constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+    this._comptroller = new Contract(
+      consts.networkAddresses.misc.COMPTROLLER,
+      ComptrollerABI.abi,
+      networkConnection.provider
+    ) as Comptroller;
+    this._auriFairLaunch = new Contract(
+      consts.networkAddresses.misc.AURIFAIRLAUNCH,
+      AuriFairLaunchABI.abi,
+      networkConnection.provider
+    ) as AuriFairLaunch;
+    this._auriLens = new Contract(
+      consts.networkAddresses.misc.AURILENS,
+      AuriLensABI.abi,
+      networkConnection.provider
+    ) as AuriLens;
+  }
+
+  public async getPLYWNEARPoolDetails(): Promise<PLYWNEARPoolDetails> {
+    var stakedLiquidity: BN, rewardPerSeconds: BN[];
+    await this._auriFairLaunch
+      .getPoolInfo(consts.PLYWNEAR_POOL_ID)
+      .then((res) => {
+        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._auriFairLaunch.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 = new Contract(
+      consts.networkAddresses.tokens.PLYWNEAR,
+      EIP20InterfaceABI.abi,
+      this._networkConnection.provider
+    ) as IERC20;
+    let balance = await lpContract.balanceOf(user);
+
+    return new TokenAmount(PLYWNEARToken, balance.toString());
+  }
+
+  public async unclaimedRewardsOf(user: string): Promise<TokenAmount[]> {
+    let userInfo = await this._auriFairLaunch.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._auriFairLaunch
+      .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._auriFairLaunch
+      .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);
+  }
+}