@aurigami/sdk 1.6.3 → 1.6.5

package/src/contracts/Referral.ts

@@ -1,7 +1,7 @@
-import ReferralDirectoryABI from '@aurigami/contracts/artifacts/contracts/ReferralDirectory.sol/ReferralDirectory.json';
 import { ReferralDirectory } from '@aurigami/contracts/typechain';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import { Contract, ethers } from 'ethers';
+import * as abis from '../abis';
 import * as consts from '../consts';
 import { BlockchainEntity, BlockchainEntityRead } from '../entities';
 import { Address, NetworkConnection } from '../types';
@@ -12,7 +12,7 @@ export class ReferralRead extends BlockchainEntityRead {
     super(networkConnection);
     this._referral = new Contract(
       consts.networkAddresses.misc.REFERRAL,
-      ReferralDirectoryABI.abi,
+      abis.ReferralDirectoryABI.abi,
       networkConnection.provider
     ) as ReferralDirectory;
   }
@@ -26,8 +26,7 @@ export class ReferralRead extends BlockchainEntityRead {
     let numbers = '1234567890';
     let charset = letters + letters.toUpperCase() + numbers;
     let R = '';
-    for (var i = 0; i < 10; i++)
-      R += charset[Math.floor(Math.random() * charset.length)];
+    for (var i = 0; i < 10; i++) R += charset[Math.floor(Math.random() * charset.length)];
     return R;
   }
 
@@ -65,9 +64,7 @@ export class ReferralReadWrite extends ReferralRead {
    * Called when an user want to creates his own referral code
    */
   public async registerNewReferralCode(): Promise<TransactionResponse> {
-    const referralCode = ethers.utils.formatBytes32String(
-      this.generateReferralCode()
-    );
+    const referralCode = ethers.utils.formatBytes32String(this.generateReferralCode());
     return this._referral
       .connect(this._networkConnection.signer!)
       .registerNewUserReferralCode(referralCode);

package/src/contracts/Staking.ts

@@ -1,18 +1,11 @@
-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 { IERC20 } from '@aurigami/contracts/typechain';
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import BigNumber from 'bignumber.js';
 import { BigNumber as BN, Contract } from 'ethers';
+import { EIP20InterfaceABI } from '../abis';
 import * as consts from '../consts';
 import {
+  AuriEnv,
   BlockchainEntity,
   BlockchainEntityRead,
   PLYWNEARToken,
@@ -24,41 +17,20 @@ 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;
+  protected env: AuriEnv;
   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;
+    this.env = new AuriEnv(networkConnection);
   }
 
   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;
-      });
+    await this.env.auriFairLaunch.getPoolInfo(consts.PLYWNEAR_POOL_ID).then((res) => {
+      stakedLiquidity = res.totalStake;
+      rewardPerSeconds = res.rewardPerSeconds;
+    });
 
-    let stakedLiquidityAmount = new TokenAmount(
-      PLYWNEARToken,
-      stakedLiquidity!.toString()
-    );
+    let stakedLiquidityAmount = new TokenAmount(PLYWNEARToken, stakedLiquidity!.toString());
 
     var totalStakeValuation: BigNumber = await fetchValuation(
       stakedLiquidityAmount,
@@ -70,10 +42,7 @@ export class StakingRead extends BlockchainEntityRead {
     // 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 rewardToken = new Token(rewardTokenAddress, getDecimal(rewardTokenAddress));
       let rewardPerSecond = rewardPerSeconds![i];
       promises.push(
         fetchValuation(
@@ -108,10 +77,7 @@ export class StakingRead extends BlockchainEntityRead {
    * Get amount of staked LP tokens
    */
   public async stakeBalanceOf(user: string): Promise<TokenAmount> {
-    const userInfo = await this._auriFairLaunch.getUserInfo(
-      consts.PLYWNEAR_POOL_ID,
-      user
-    );
+    const userInfo = await this.env.auriFairLaunch.getUserInfo(consts.PLYWNEAR_POOL_ID, user);
     return new TokenAmount(PLYWNEARToken, userInfo.amount.toString());
   }
 
@@ -130,7 +96,7 @@ export class StakingRead extends BlockchainEntityRead {
   }
 
   public async unclaimedRewardsOf(user: string): Promise<TokenAmount[]> {
-    let userInfo = await this._auriFairLaunch.callStatic.updateAndGetUserInfo(
+    let userInfo = await this.env.auriFairLaunch.callStatic.updateAndGetUserInfo(
       consts.PLYWNEAR_POOL_ID,
       user,
       { from: user }
@@ -138,17 +104,14 @@ export class StakingRead extends BlockchainEntityRead {
 
     let rewards = userInfo.unclaimedRewards;
     return rewards.map((reward, i) =>
-      TokenAmount.fromAddressAndAmount(
-        consts.PLYWNEAR_REWARD_TOKENS[i],
-        reward.toString()
-      )
+      TokenAmount.fromAddressAndAmount(consts.PLYWNEAR_REWARD_TOKENS[i], reward.toString())
     );
   }
 }
 
 export class StakingReadWrite extends StakingRead {
   public async stake(amount: TokenAmount): Promise<TransactionResponse> {
-    return this._auriFairLaunch
+    return this.env.auriFairLaunch
       .connect(this._networkConnection.signer!)
       .deposit(consts.PLYWNEAR_POOL_ID, amount.rawAmount());
   }
@@ -156,14 +119,10 @@ export class StakingReadWrite extends StakingRead {
   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()
-    );
+    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
+    const unstakeAmount = amountInput.lt(stakedAmount) ? amountInput : stakedAmount.sub(1);
+    return this.env.auriFairLaunch
       .connect(this._networkConnection.signer!)
       .withdraw(consts.PLYWNEAR_POOL_ID, unstakeAmount);
   }

package/src/contracts/index.ts

@@ -1,4 +1,5 @@
-export * from './airdrop-lottery';
+export * from './Airdrop';
+export * from './misc';
 export * from './MoneyMarket';
 export * from './Papermill';
 export * from './Referral';

package/src/contracts/misc.ts

@@ -0,0 +1,281 @@
+import BigNumber from 'bignumber.js';
+import { BigNumber as BN } from 'ethers';
+import * as consts from '../consts';
+import { MoneyMarketRead, PapermillRead, StakingRead } from '../contracts';
+import { MulticallRead } from '../contracts/Multicall';
+import { AuriEnv, BlockchainEntityRead, PLYToken, Token, TokenAmount } from '../entities';
+import { decimalFactor, isSameAddress } from '../helpers/helpers';
+import { calcValuation, fetchPrice } from '../helpers/priceFetcher';
+import * as types from '../types';
+
+export class MiscRead extends BlockchainEntityRead {
+  protected env: AuriEnv;
+  protected _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 promises = [];
+    var totalBorrowLimit = new BigNumber(0);
+    var pricePromises = [];
+    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
+      );
+      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.env.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 = 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, 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.env.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(
+      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(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(consts.DECIMAL_PRECISION),
+      },
+      userLockingDetails: await new PapermillRead(this._networkConnection).getLockingDetails(
+        userAddress
+      ),
+      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 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 callResults = (await multicallRead.aggregate([
+      // Get total supply
+      {
+        ...baseBalanceOfCall,
+        method: 'totalSupply',
+        args: [],
+      },
+      // balance in team multisig
+      {
+        ...baseBalanceOfCall,
+        args: [consts.networkAddresses.misc.TEAM_MULTISIG],
+      },
+      // balance in comptroller
+      {
+        ...baseBalanceOfCall,
+        args: [consts.networkAddresses.misc.COMPTROLLER],
+      },
+      // balance in fair launch
+      {
+        ...baseBalanceOfCall,
+        args: [consts.networkAddresses.misc.AURIFAIRLAUNCH],
+      },
+      // balance in vesting contract
+      {
+        ...baseBalanceOfCall,
+        args: [consts.networkAddresses.misc.PLY_TOKEN_LOCK],
+      },
+    ])) as BN[][];
+    let circulatingSupply: BN = BN.from(0);
+    callResults.forEach((result, i) => {
+      if (i === 0) {
+        circulatingSupply = result[0];
+      } else {
+        circulatingSupply = circulatingSupply.sub(result[0]);
+      }
+    });
+
+    return new TokenAmount(PLYToken, circulatingSupply.toString());
+  }
+}

package/src/entities/BlockchainEntity.ts

@@ -11,9 +11,7 @@ export class BlockchainEntityRead {
 export class BlockchainEntityReadWrite extends BlockchainEntityRead {
   public constructor(networkConnection: NetworkConnection) {
     if (!(networkConnection.signer instanceof Signer)) {
-      throw Error(
-        'Signer is not provided when constructing BlockchainEntityReadWrite'
-      );
+      throw Error('Signer is not provided when constructing BlockchainEntityReadWrite');
     }
     super(networkConnection);
   }
@@ -25,9 +23,7 @@ export class BlockchainEntity {
     return new BlockchainEntityRead(networkConnection);
   }
 
-  public readWrite(
-    networkConnection: NetworkConnection
-  ): BlockchainEntityReadWrite {
+  public readWrite(networkConnection: NetworkConnection): BlockchainEntityReadWrite {
     return new BlockchainEntityReadWrite(networkConnection);
   }
 }

package/src/entities/auriEnv.ts

@@ -0,0 +1,39 @@
+import { AuriFairLaunch, AuriLens, Comptroller, IERC20, PULP } from '@aurigami/contracts/typechain';
+import { Contract } from 'ethers';
+import * as abis from '../abis';
+import { networkAddresses } from '../consts/constants';
+import { NetworkConnection } from '../types';
+import { BlockchainEntityRead } from './BlockchainEntity';
+
+export class AuriEnv extends BlockchainEntityRead {
+  public comptroller: Comptroller;
+  public auriFairLaunch: AuriFairLaunch;
+  public auriLens: AuriLens;
+  public ply: IERC20;
+  public pulp: PULP;
+  // public faucet: Faucet;
+
+  public getContract<CType extends Contract>(address: string, abi: any) {
+    return new Contract(address, abi, this._networkConnection.provider) as CType;
+  }
+
+  public constructor(networkConnection: NetworkConnection) {
+    super(networkConnection);
+    this.comptroller = this.getContract<Comptroller>(
+      networkAddresses.misc.COMPTROLLER,
+      abis.ComptrollerABI.abi
+    );
+    this.auriFairLaunch = this.getContract<AuriFairLaunch>(
+      networkAddresses.misc.AURIFAIRLAUNCH,
+      abis.AuriFairLaunchABI.abi
+    );
+    this.auriLens = this.getContract<AuriLens>(
+      networkAddresses.misc.AURILENS,
+      abis.AuriLensABI.abi
+    );
+
+    this.ply = this.getContract<IERC20>(networkAddresses.tokens.PLY, abis.EIP20InterfaceABI.abi);
+    this.pulp = this.getContract<PULP>(networkAddresses.tokens.PULP, abis.PulpABI.abi);
+    // this.faucet = this.getContract<Faucet>(networkAddresses.misc.FAUCET, abis.FaucetABI.abi);
+  }
+}

package/src/entities/index.ts

@@ -1,3 +1,4 @@
+export * from './auriEnv';
 export * from './BlockchainEntity';
 export * from './token';
 export * from './tokenAmount';

package/src/entities/token.ts

@@ -1,5 +1,5 @@
-import { getDecimal } from '../helpers/helpers';
 import { networkAddresses } from '../consts/constants';
+import { getDecimal } from '../helpers/helpers';
 
 export class Token {
   public readonly address: string;

package/src/entities/tokenAmount.ts

@@ -1,7 +1,7 @@
-import { Token } from './token';
 import BigNumber from 'bignumber.js';
 import { decimalFactor, getDecimal } from '../helpers/helpers';
 import { Address } from '../types';
+import { Token } from './token';
 
 export class TokenAmount {
   public readonly token: Token;
@@ -11,17 +11,13 @@ export class TokenAmount {
     if (isRaw) {
       this.rawAmnt = amount;
     } else {
-      this.rawAmnt = new BigNumber(amount)
-        .times(decimalFactor(token.decimals))
-        .toFixed(0);
+      this.rawAmnt = new BigNumber(amount).times(decimalFactor(token.decimals)).toFixed(0);
     }
     this.token = token;
   }
 
   public formattedAmount(): string {
-    return new BigNumber(this.rawAmnt)
-      .div(decimalFactor(this.token.decimals))
-      .toString();
+    return new BigNumber(this.rawAmnt).div(decimalFactor(this.token.decimals)).toString();
   }
 
   public rawAmount(): string {
@@ -33,10 +29,6 @@ export class TokenAmount {
     amount: string,
     isRaw: boolean = true
   ): TokenAmount {
-    return new TokenAmount(
-      new Token(tokenAddress, getDecimal(tokenAddress)),
-      amount,
-      isRaw
-    );
+    return new TokenAmount(new Token(tokenAddress, getDecimal(tokenAddress)), amount, isRaw);
   }
 }

package/src/helpers/aurora-api-helpers.ts

@@ -9,12 +9,9 @@ export async function getQuery(
 ): Promise<any> {
   params = { ...params, module: module, action: action };
 
-  let resp = await axios.get(
-    AURORA_API_BASE_URL + '?' + new URLSearchParams(params),
-    {
-      headers: { 'Content-Type': 'application/json' },
-    }
-  );
+  let resp = await axios.get(AURORA_API_BASE_URL + '?' + new URLSearchParams(params), {
+    headers: { 'Content-Type': 'application/json' },
+  });
 
   return resp.data.result!;
 }

package/src/helpers/helpers.ts

@@ -1,9 +1,9 @@
 import { Provider } from '@ethersproject/abstract-provider';
 import BigNumber from 'bignumber.js';
 import { BigNumber as BN, utils } from 'ethers';
-import { getQuery as getAuroraAPIQuery } from './aurora-api-helpers';
 import { decimalRecords } from '../consts/decimals';
 import { Address } from '../types';
+import { getQuery as getAuroraAPIQuery } from './aurora-api-helpers';
 
 export function assert(condition: boolean, message: string = ''): void {
   if (!condition) {
@@ -20,10 +20,7 @@ export function decimalFactor(decimal: number) {
   return BN.from(10).pow(decimal).toString();
 }
 
-export const isSameAddress = (
-  address1: Address,
-  address2: Address
-): boolean => {
+export const isSameAddress = (address1: Address, address2: Address): boolean => {
   return address1.toLowerCase() == address2.toLowerCase();
 };
 
@@ -41,10 +38,7 @@ export function validateAndParseAddress(address: Address): Address {
 
 export function getDecimal(address: Address): number {
   let addressLowercase = address.toLowerCase();
-  assert(
-    decimalRecords[addressLowercase] != undefined,
-    'Decimal not found for ' + address
-  );
+  assert(decimalRecords[addressLowercase] != undefined, 'Decimal not found for ' + address);
   return decimalRecords[addressLowercase];
 }
 
@@ -53,17 +47,17 @@ export function calcLMRewardApr(
   totalStakeValue: BigNumber,
   frequencyPerYear: number
 ): BigNumber {
+  if (rewardsValue.isZero()) {
+    return new BigNumber(0);
+  }
   if (totalStakeValue.lte(0)) {
     // avoid division by zero when there is no stake
-    return new BigNumber('999999999');
+    return rewardsValue;
   }
   return rewardsValue.multipliedBy(frequencyPerYear).dividedBy(totalStakeValue);
 }
 
-export async function getBlockTimestamp(
-  provider: Provider,
-  blockNumber: number
-): Promise<number> {
+export async function getBlockTimestamp(provider: Provider, blockNumber: number): Promise<number> {
   const block = await provider.getBlock(blockNumber);
   return block.timestamp;
 }
@@ -76,10 +70,7 @@ export async function getBlockTimestamp(
  *
  * This function is much faster than using binary search.
  */
-export async function getBlockBeforeTimestamp(
-  provider: Provider,
-  timestamp: number
-) {
+export async function getBlockBeforeTimestamp(provider: Provider, timestamp: number) {
   let result = await getAuroraAPIQuery('block', 'getblocknobytime', {
     timestamp: timestamp,
     closest: 'before',