@aurigami/sdk 1.5.0 → 1.5.2

package/dist/tokenAmount.d.ts

@@ -1,8 +1,10 @@
 import { Token } from './token';
+import { Address } from './types';
 export declare class TokenAmount {
     readonly token: Token;
     private rawAmnt;
     constructor(token: Token, amount: string, isRaw?: boolean);
     formattedAmount(): string;
     rawAmount(): string;
+    static fromAddressAndAmount(tokenAddress: Address, amount: string, isRaw?: boolean): TokenAmount;
 }

package/dist/types.d.ts

@@ -57,9 +57,13 @@ export declare type UserMarketDetails = {
     collateralRatio: number;
     underlyingPrice: string;
 };
+export declare type TokenAPY = {
+    address: string;
+    apy: string;
+};
 export declare type PLYWNEARPoolDetails = {
     totalStakedLiquidity: TokenValuation;
-    apy: string;
+    APYs: TokenAPY[];
 };
 export declare enum MarketAction {
     Deposit = 0,

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.0",
+  "version": "1.5.2",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/Papermill.ts

@@ -27,6 +27,7 @@ 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;
@@ -102,17 +103,18 @@ export class PapermillRead extends BlockchainEntityRead {
     );
   }
 
+  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 currentTime = getCurrentTimestamp();
-    const currentWeek = BN.from(currentTime - REWARD_CLAIM_START)
-      .div(ONE_WEEK)
-      .toNumber();
-    const denominator = BN.from(10000);
+    const currentWeek = this.getWeek(getCurrentTimestamp());
     var promises: any[] = [];
 
     promises.push(
@@ -144,17 +146,18 @@ export class PapermillRead extends BlockchainEntityRead {
     // This doesn't take (the reward that user might earn in the next week) into account
     let plyAmountNextWeek = percentLockNextWeek
       .mul(totalRewards.rawAmount())
-      .div(denominator);
+      .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 = denominator
-      .sub(percentLockCurrentWeek)
-      .toString();
-    let nextUnlockPortion = denominator.sub(percentLockNextWeek).toString();
+    let currentUnlockPortion = LOCKING_DENOMINATOR.sub(
+      percentLockCurrentWeek
+    ).toString();
+    let nextUnlockPortion =
+      LOCKING_DENOMINATOR.sub(percentLockNextWeek).toString();
 
     return {
       vestingStart: REWARD_CLAIM_START,
@@ -197,6 +200,21 @@ export class PapermillRead extends BlockchainEntityRead {
 
     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 {

package/src/SDK.ts

@@ -1,54 +1,40 @@
+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 {
-  PLYWNEARPoolDetails,
-  NetworkConnection,
-  UserDetails,
-  UserMarketDetails,
+  ALL_STAKING_POOLS,
+  BORROW_LIMIT_BUFFER,
+  DECIMAL_PRECISION,
+  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,
   TokenValuation,
+  UserDetails,
+  UserMarketDetails,
 } from './types';
-import {
-  networkAddresses,
-  BORROW_LIMIT_BUFFER,
-  DECIMAL_PRECISION,
-  ONE_DAY,
-  PLYWNEAR_POOL_ID,
-  ALL_STAKING_POOLS,
-  PLYWNEAR_REWARD_TOKENS,
-} from './constants';
-import { TransactionResponse } from '@ethersproject/abstract-provider';
-import { Contract, BigNumber as BN } from 'ethers';
-import {
-  isSameAddress,
-  decimalFactor,
-  calcLMRewardApr,
-  getDecimal,
-} from './helpers';
-import { MoneyMarketRead } from './MoneyMarket';
-import {
-  fetchValuation,
-  fetchPrice,
-  calcValuation,
-  valuateToken,
-} from './priceFetcher';
-import {
-  AuriFairLaunch,
-  Comptroller,
-  AuriLens,
-  IERC20,
-} from '@aurigami/contracts/typechain';
-import { TokenAmount } from './tokenAmount';
-import { PLYWNEARToken, PLYToken, Token } from './token';
-import BigNumber from 'bignumber.js';
-import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
-import ComptrollerABI from '@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json';
-import AuriFairLaunchABI from '@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json';
-import FaucetABI from '@aurigami/contracts/artifacts/contracts/mock/Faucet.sol/Faucet.json';
-import EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
-import { PapermillRead } from './Papermill';
 
 export class SdkRead extends BlockchainEntityRead {
   protected _comptroller: Comptroller;
@@ -225,59 +211,7 @@ export class SdkRead extends BlockchainEntityRead {
   }
 
   public async getPLYWNEARPoolDetails(): Promise<PLYWNEARPoolDetails> {
-    var stakedLiquidity: BN, rewardPerSeconds: BN[];
-    await this._auriFairLaunch.getPoolInfo(PLYWNEAR_POOL_ID).then((res) => {
-      stakedLiquidity = res.totalStake;
-      rewardPerSeconds = res.rewardPerSeconds;
-    });
-
-    let stakedLiquidityAmount = new TokenAmount(
-      PLYWNEARToken,
-      stakedLiquidity!.toString()
-    );
-
-    var promises = [];
-
-    // Calculate the reward per second in USD
-    for (let i = 0; i < rewardPerSeconds!.length; i++) {
-      let rewardTokenAddress = 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
-        )
-      );
-    }
-
-    const rewardPerSecondValuation = (await Promise.all(promises)).reduce(
-      (p: BigNumber, v: BigNumber) => p.plus(v),
-      new BigNumber(0)
-    );
-
-    var totalStakeValuation: BigNumber = await fetchValuation(
-      stakedLiquidityAmount,
-      this._networkConnection.provider
-    );
-
-    return {
-      totalStakedLiquidity: {
-        tokenAmount: stakedLiquidityAmount,
-        currencyAmount: {
-          currency: 'USD',
-          amount: totalStakeValuation!.toFixed(DECIMAL_PRECISION),
-        },
-      },
-      apy: calcLMRewardApr(
-        rewardPerSecondValuation,
-        totalStakeValuation,
-        ONE_DAY * 365
-      ).toFixed(DECIMAL_PRECISION),
-    };
+    return new StakingRead(this._networkConnection).getPLYWNEARPoolDetails();
   }
 
   public async getTokenPrice(token: Token): Promise<CurrencyAmount> {
@@ -295,33 +229,18 @@ export class SdkRead extends BlockchainEntityRead {
    * Get amount and value in $ of staked LP tokens
    */
   public async stakeBalanceOf(user: string): Promise<TokenValuation> {
-    const userInfo = await this._auriFairLaunch.getUserInfo(
-      PLYWNEAR_POOL_ID,
-      user
-    );
-    let stakeAmount = new TokenAmount(
-      PLYWNEARToken,
-      userInfo.amount.toString()
-    );
-
-    return valuateToken(stakeAmount, this._networkConnection.provider);
+    return new StakingRead(this._networkConnection).stakeBalanceOf(user);
   }
 
   /**
    * Get amount and value in $ of LP token in user wallet
    */
   public async LpBalanceOf(user: string): Promise<TokenValuation> {
-    let lpContract = new Contract(
-      networkAddresses.tokens.PLYWNEAR,
-      EIP20InterfaceABI.abi,
-      this._networkConnection.provider
-    ) as IERC20;
-    let balance = await lpContract.balanceOf(user);
+    return new StakingRead(this._networkConnection).LpBalanceOf(user);
+  }
 
-    return valuateToken(
-      new TokenAmount(PLYWNEARToken, balance.toString()),
-      this._networkConnection.provider
-    );
+  public async unclaimedRewardsOf(user: string): Promise<TokenAmount[]> {
+    return new StakingRead(this._networkConnection).unclaimedRewardsOf(user);
   }
 
   public calcHypotheticalStats({
@@ -409,15 +328,11 @@ export class SdkReadWrite extends SdkRead {
   }
 
   public async stake(amount: TokenAmount): Promise<TransactionResponse> {
-    return this._auriFairLaunch
-      .connect(this._networkConnection.signer!)
-      .deposit(PLYWNEAR_POOL_ID, amount.rawAmount());
+    return new StakingReadWrite(this._networkConnection).stake(amount);
   }
 
   public async unstake(amount: TokenAmount): Promise<TransactionResponse> {
-    return this._auriFairLaunch
-      .connect(this._networkConnection.signer!)
-      .withdraw(PLYWNEAR_POOL_ID, amount.rawAmount());
+    return new StakingReadWrite(this._networkConnection).unstake(amount);
   }
 
   public async faucetDrip(): Promise<TransactionResponse> {

package/src/Staking.ts

@@ -0,0 +1,193 @@
+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 { BlockchainEntity, BlockchainEntityRead } from './BlockchainEntity';
+import {
+  DECIMAL_PRECISION,
+  networkAddresses,
+  ONE_DAY,
+  PLYWNEAR_POOL_ID,
+  PLYWNEAR_REWARD_TOKENS,
+} from './constants';
+import { calcLMRewardApr, getDecimal } from './helpers';
+import { fetchValuation, valuateToken } from './priceFetcher';
+import { PLYWNEARToken, Token } from './token';
+import { TokenAmount } from './tokenAmount';
+import {
+  NetworkConnection,
+  PLYWNEARPoolDetails,
+  TokenAPY,
+  TokenValuation,
+} 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(
+      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 getPLYWNEARPoolDetails(): Promise<PLYWNEARPoolDetails> {
+    var stakedLiquidity: BN, rewardPerSeconds: BN[];
+    await this._auriFairLaunch.getPoolInfo(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 = 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 = PLYWNEAR_REWARD_TOKENS[i];
+      let apy = calcLMRewardApr(
+        rewardPerSecondValuation,
+        totalStakeValuation,
+        ONE_DAY * 365
+      ).toFixed(DECIMAL_PRECISION);
+
+      APYs.push({
+        address: rewardTokenAddress,
+        apy: apy,
+      });
+    });
+
+    return {
+      totalStakedLiquidity: {
+        tokenAmount: stakedLiquidityAmount,
+        currencyAmount: {
+          currency: 'USD',
+          amount: totalStakeValuation!.toFixed(DECIMAL_PRECISION),
+        },
+      },
+      APYs: APYs,
+    };
+  }
+
+  /**
+   * Get amount and value in $ of staked LP tokens
+   */
+  public async stakeBalanceOf(user: string): Promise<TokenValuation> {
+    const userInfo = await this._auriFairLaunch.getUserInfo(
+      PLYWNEAR_POOL_ID,
+      user
+    );
+    let stakeAmount = new TokenAmount(
+      PLYWNEARToken,
+      userInfo.amount.toString()
+    );
+
+    return valuateToken(stakeAmount, this._networkConnection.provider);
+  }
+
+  /**
+   * Get amount and value in $ of LP token in user wallet
+   */
+  public async LpBalanceOf(user: string): Promise<TokenValuation> {
+    let lpContract = new Contract(
+      networkAddresses.tokens.PLYWNEAR,
+      EIP20InterfaceABI.abi,
+      this._networkConnection.provider
+    ) as IERC20;
+    let balance = await lpContract.balanceOf(user);
+
+    return valuateToken(
+      new TokenAmount(PLYWNEARToken, balance.toString()),
+      this._networkConnection.provider
+    );
+  }
+
+  public async unclaimedRewardsOf(user: string): Promise<TokenAmount[]> {
+    let userInfo = await this._auriFairLaunch.callStatic.updateAndGetUserInfo(
+      PLYWNEAR_POOL_ID,
+      user,
+      { from: user }
+    );
+
+    let rewards = userInfo.unclaimedRewards;
+    return rewards.map((reward, i) =>
+      TokenAmount.fromAddressAndAmount(
+        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(PLYWNEAR_POOL_ID, amount.rawAmount());
+  }
+
+  public async unstake(amount: TokenAmount): Promise<TransactionResponse> {
+    return this._auriFairLaunch
+      .connect(this._networkConnection.signer!)
+      .withdraw(PLYWNEAR_POOL_ID, amount.rawAmount());
+  }
+}
+
+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/constants.ts

@@ -96,7 +96,7 @@ export const PRICE_WHITELISTED = new Set([
   networkAddresses.tokens.stNEAR,
 ]);
 
-export const REWARD_CLAIM_START = 1651762800; // 5 May 2022 15:00:00 UTC
+export const REWARD_CLAIM_START = 1651748400; // 5 May 2022 11:00:00 UTC
 
 export const BORROW_LIMIT_BUFFER = new BigNumber(1);
 
@@ -114,7 +114,7 @@ export const PLYWNEAR_REWARD_TOKENS = [
 // could call RPC to get all the staking pools but it's not necessary for now
 // export const ALL_STAKING_POOLS = [PLYWNEAR_POOL_ID];
 // TODO: fix this
-export const ALL_STAKING_POOLS = [];
+export const ALL_STAKING_POOLS: number[] = [];
 export const INF = BN.from(2).pow(256).sub(1);
 
 export const AIRDROP_START_TIMESTAMP = 1649858400;

package/src/helpers.ts

@@ -1,12 +1,10 @@
-import EIP20InterfaceABI from '@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json';
-import { EIP20Interface, IERC20 } from '@aurigami/contracts/typechain';
 import { Provider } from '@ethersproject/abstract-provider';
+import assert from 'assert';
 import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract, providers, utils } from 'ethers';
+import { BigNumber as BN, utils } from 'ethers';
 import { getQuery as getAuroraAPIQuery } from './aurora-api-helpers';
 import { decimalRecords } from './decimals';
-import { Address, NetworkConnection } from './types';
-import assert from 'assert';
+import { Address } from './types';
 
 export function formatObject(object: Object) {
   return JSON.stringify(object, null, '  ');

package/src/priceFetcher.ts

@@ -245,30 +245,28 @@ export async function fetchPLYPrice(
   provider: providers.Provider
 ): Promise<BigNumber> {
   //TODO: Fetch PLY price from CEX?
-  return new BigNumber(0);
-  const LPInfo = await fetchLPPositions(
-    networkAddresses.tokens.PLYWNEAR,
-    provider
-  );
+  return fetchToken0PriceByLP(networkAddresses.tokens.PLYWNEAR, provider);
+}
+
+export async function fetchToken0PriceByLP(
+  LP: Address,
+  provider: providers.Provider
+): Promise<BigNumber> {
+  const LPInfo = await fetchLPPositions(LP, provider);
 
   if (LPInfo.reserve1.isZero()) {
     return new BigNumber(0);
   }
 
-  const plyAddress = LPInfo.token0;
-  assert(isSameAddress(plyAddress, networkAddresses.tokens.PLY));
-  const plyDecimal = getDecimal(plyAddress);
-
-  const wnearAddress = LPInfo.token1;
-  assert(isSameAddress(wnearAddress, networkAddresses.tokens.WNEAR));
-  const wnearDecimal = getDecimal(wnearAddress);
+  const token0Decimal = getDecimal(LPInfo.token0);
+  const token1Decimal = getDecimal(LPInfo.token1);
 
   // (token0Price * reserve0) / 10^decimal0 = (token1Price * reserve1) / 10^decimal1
   // token0Price = (token1Price * reserve1) * 10^decimal0 / 10^decimal1  / reserve0
-  return (await fetchPrice(wnearAddress, provider))
+  return (await fetchPrice(LPInfo.token1, provider))
     .multipliedBy(LPInfo.reserve1.toString())
-    .multipliedBy(decimalFactor(plyDecimal))
-    .dividedBy(decimalFactor(wnearDecimal))
+    .multipliedBy(decimalFactor(token0Decimal))
+    .dividedBy(decimalFactor(token1Decimal))
     .dividedBy(LPInfo.reserve0.toString());
 }
 

package/src/tokenAmount.ts

@@ -1,6 +1,7 @@
 import { Token } from './token';
 import BigNumber from 'bignumber.js';
-import { decimalFactor } from './helpers';
+import { decimalFactor, getDecimal } from './helpers';
+import { Address } from './types';
 
 export class TokenAmount {
   public readonly token: Token;
@@ -26,4 +27,16 @@ export class TokenAmount {
   public rawAmount(): string {
     return this.rawAmnt;
   }
+
+  public static fromAddressAndAmount(
+    tokenAddress: Address,
+    amount: string,
+    isRaw: boolean = true
+  ): TokenAmount {
+    return new TokenAmount(
+      new Token(tokenAddress, getDecimal(tokenAddress)),
+      amount,
+      isRaw
+    );
+  }
 }

package/src/types.ts

@@ -81,9 +81,14 @@ export type UserMarketDetails = {
   underlyingPrice: string;
 };
 
+export type TokenAPY = {
+  address: string;
+  apy: string;
+};
+
 export type PLYWNEARPoolDetails = {
   totalStakedLiquidity: TokenValuation;
-  apy: string;
+  APYs: TokenAPY[];
 };
 
 export enum MarketAction {