@aurigami/sdk 1.4.8 → 1.5.0-dummy-1

package/src/Papermill.ts

@@ -0,0 +1,243 @@
+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';
+
+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()
+    );
+  }
+
+  /**
+   * Get all locking details of the user in all markets + all staking pools
+   */
+  public async getLockingDetails(
+    userAddress: Address
+  ): Promise<UserLockingDetails> {
+    const currentTime = getCurrentTimestamp();
+    const currentWeek = BN.from(currentTime - REWARD_CLAIM_START)
+      .div(ONE_WEEK)
+      .toNumber();
+    const denominator = BN.from(10000);
+    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(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 = denominator
+      .sub(percentLockCurrentWeek)
+      .toString();
+    let nextUnlockPortion = 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 getTimestampToUnlock(
+    userAddress: Address,
+    targetUnlockPortion: number
+  ): number {
+    let lockPortion = 100 - targetUnlockPortion;
+    if (lockPortion >= 95) {
+      return REWARD_CLAIM_START;
+    }
+
+    return REWARD_CLAIM_START + ONE_WEEK * Math.round((95 - lockPortion) / 2);
+  }
+}
+
+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);
+  }
+}