@pancakeswap/pools 4.0.9 → 4.0.11

package/src/queries/fetchUserPoolsData.ts

@@ -1,143 +0,0 @@
-import { ChainId } from '@pancakeswap/sdk'
-import BigNumber from 'bignumber.js'
-import uniq from 'lodash/uniq'
-import fromPairs from 'lodash/fromPairs'
-import { erc20ABI } from 'wagmi'
-import { Address } from 'viem'
-import { getPoolsConfig } from '../constants'
-import { sousChefABI } from '../abis/ISousChef'
-import { OnChainProvider, SerializedPool } from '../types'
-
-// Pool 0, Cake / Cake is a different kind of contract (master chef)
-// BNB pools use the native BNB token (wrapping ? unwrapping is done at the contract level)
-const getPoolsFactory = (filter: (pool: SerializedPool) => boolean) => (chainId: ChainId) => {
-  const poolsConfig = getPoolsConfig(chainId)
-  if (!poolsConfig) {
-    throw new Error(`Unable to get pools config on chain ${chainId}`)
-  }
-  return poolsConfig.filter(filter)
-}
-const getNonBnbPools = getPoolsFactory((pool) => pool.stakingToken.symbol !== 'BNB')
-const getBnbPools = getPoolsFactory((pool) => pool.stakingToken.symbol === 'BNB')
-const getNonMasterPools = getPoolsFactory((pool) => pool.sousId !== 0)
-
-interface FetchUserDataParams {
-  account: string
-  chainId: ChainId
-  provider: OnChainProvider
-}
-
-export const fetchPoolsAllowance = async ({ account, chainId, provider }: FetchUserDataParams) => {
-  const nonBnbPools = getNonBnbPools(chainId)
-
-  const client = provider({ chainId })
-  const allowances = await client.multicall({
-    contracts: nonBnbPools.map(
-      ({ contractAddress, stakingToken }) =>
-        ({
-          address: stakingToken.address,
-          abi: erc20ABI,
-          functionName: 'allowance',
-          args: [account as Address, contractAddress] as const,
-        } as const),
-    ),
-    allowFailure: false,
-  })
-  return fromPairs(
-    nonBnbPools.map((pool, index) => [pool.sousId, new BigNumber(allowances[index].toString()).toJSON()]),
-  )
-}
-
-export const fetchUserBalances = async ({ account, chainId, provider }: FetchUserDataParams) => {
-  const nonBnbPools = getNonBnbPools(chainId)
-  const bnbPools = getBnbPools(chainId)
-  // Non BNB pools
-  const tokens = uniq(nonBnbPools.map((pool) => pool.stakingToken.address))
-  const client = provider({ chainId })
-  const tokenBalance = await client.multicall({
-    contracts: [
-      {
-        abi: [
-          {
-            inputs: [{ internalType: 'address', name: 'addr', type: 'address' }],
-            name: 'getEthBalance',
-            outputs: [{ internalType: 'uint256', name: 'balance', type: 'uint256' }],
-            stateMutability: 'view',
-            type: 'function',
-          },
-        ] as const,
-        address: '0xcA11bde05977b3631167028862bE2a173976CA11', // TODO: Here is multicall address, should extract addresses to a package for multi chain
-        functionName: 'getEthBalance',
-        args: [account as Address] as const,
-      } as const,
-      ...tokens.map(
-        (token) =>
-          ({
-            abi: erc20ABI,
-            address: token,
-            functionName: 'balanceOf',
-            args: [account] as const,
-          } as const),
-      ),
-    ],
-  })
-  const [bnbBalance, ...tokenBalancesResults] = tokenBalance
-
-  const tokenBalances = fromPairs(tokens.map((token, index) => [token, tokenBalancesResults[index].result as bigint]))
-
-  const poolTokenBalances = fromPairs(
-    nonBnbPools
-      .map<[number, string] | null>((pool) => {
-        if (!tokenBalances[pool.stakingToken.address]) return null
-        return [pool.sousId, new BigNumber(tokenBalances[pool.stakingToken.address].toString()).toJSON()]
-      })
-      .filter((p): p is [number, string] => Boolean(p)),
-  )
-
-  // BNB pools
-  const bnbBalanceJson = new BigNumber((bnbBalance.result as bigint)?.toString()).toJSON()
-  const bnbBalances = fromPairs(bnbPools.map((pool) => [pool.sousId, bnbBalanceJson]))
-
-  return { ...poolTokenBalances, ...bnbBalances }
-}
-
-export const fetchUserStakeBalances = async ({ account, chainId, provider }: FetchUserDataParams) => {
-  const nonMasterPools = getNonMasterPools(chainId)
-
-  const client = provider({ chainId })
-  const userInfo = await client.multicall({
-    contracts: nonMasterPools.map(
-      ({ contractAddress }) =>
-        ({
-          abi: sousChefABI.filter((r) => r.name === 'userInfo'),
-          address: contractAddress,
-          functionName: 'userInfo',
-          args: [account as Address] as const,
-        } as const),
-    ),
-    allowFailure: false,
-  })
-
-  return fromPairs(
-    nonMasterPools.map((pool, index) => [pool.sousId, new BigNumber(userInfo[index][0].toString()).toJSON()]),
-  )
-}
-
-export const fetchUserPendingRewards = async ({ account, chainId, provider }: FetchUserDataParams) => {
-  const nonMasterPools = getNonMasterPools(chainId)
-
-  const client = provider({ chainId })
-  const res = await client.multicall({
-    contracts: nonMasterPools.map(
-      ({ contractAddress }) =>
-        ({
-          abi: sousChefABI.filter((r) => r.name === 'pendingReward'),
-          address: contractAddress,
-          functionName: 'pendingReward',
-          args: [account as Address] as const,
-        } as const),
-    ),
-    allowFailure: false,
-  })
-  return fromPairs(nonMasterPools.map((pool, index) => [pool.sousId, new BigNumber(res[index].toString()).toJSON()]))
-}

package/src/queries/fetchVaultPublic.ts

@@ -1,175 +0,0 @@
-import BigNumber from 'bignumber.js'
-import { BIG_ZERO } from '@pancakeswap/utils/bigNumber'
-import { ChainId } from '@pancakeswap/sdk'
-import { CAKE } from '@pancakeswap/tokens'
-import { Address } from 'viem'
-
-import { cakeVaultV2ABI } from '../abis/ICakeVaultV2'
-import { OnChainProvider } from '../types'
-import { getCakeFlexibleSideVaultAddress, getCakeVaultAddress } from './getAddresses'
-
-interface Params {
-  cakeVaultAddress?: Address
-  chainId: ChainId
-  provider: OnChainProvider
-}
-
-const balanceOfAbi = [
-  {
-    inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
-    name: 'balanceOf',
-    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
-    stateMutability: 'view',
-    type: 'function',
-  },
-] as const
-
-export const fetchPublicVaultData = async ({
-  chainId,
-  cakeVaultAddress = getCakeVaultAddress(chainId),
-  provider,
-}: Params) => {
-  try {
-    const client = provider({ chainId })
-
-    const [sharePrice, shares, totalLockedAmount, totalCakeInVault] = await client.multicall({
-      contracts: [
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'getPricePerFullShare',
-        },
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'totalShares',
-        },
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'totalLockedAmount',
-        },
-        {
-          abi: balanceOfAbi,
-          address: CAKE[ChainId.BSC].address,
-          functionName: 'balanceOf',
-          args: [cakeVaultAddress],
-        },
-      ],
-      allowFailure: true,
-    })
-
-    const totalSharesAsBigNumber =
-      shares.status === 'success' && shares.result ? new BigNumber(shares.result.toString()) : BIG_ZERO
-    const totalLockedAmountAsBigNumber =
-      totalLockedAmount.status === 'success' && totalLockedAmount.result
-        ? new BigNumber(totalLockedAmount.result.toString())
-        : BIG_ZERO
-    const sharePriceAsBigNumber =
-      sharePrice.status === 'success' && sharePrice.result ? new BigNumber(sharePrice.result.toString()) : BIG_ZERO
-
-    return {
-      totalShares: totalSharesAsBigNumber.toJSON(),
-      totalLockedAmount: totalLockedAmountAsBigNumber.toJSON(),
-      pricePerFullShare: sharePriceAsBigNumber.toJSON(),
-      totalCakeInVault: totalCakeInVault.result ? new BigNumber(totalCakeInVault.result.toString()).toJSON() : '0',
-    }
-  } catch (error) {
-    return {
-      totalShares: null,
-      totalLockedAmount: null,
-      pricePerFullShare: null,
-      totalCakeInVault: null,
-    }
-  }
-}
-
-export const fetchPublicFlexibleSideVaultData = async ({
-  chainId,
-  cakeVaultAddress = getCakeFlexibleSideVaultAddress(chainId),
-  provider,
-}: Params) => {
-  try {
-    const client = provider({ chainId })
-
-    const [sharePrice, shares, totalCakeInVault] = await client.multicall({
-      contracts: [
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'getPricePerFullShare',
-        },
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'totalShares',
-        },
-        {
-          abi: balanceOfAbi,
-          address: CAKE[ChainId.BSC].address,
-          functionName: 'balanceOf',
-          args: [cakeVaultAddress],
-        },
-      ],
-      allowFailure: true,
-    })
-
-    const totalSharesAsBigNumber = shares.status === 'success' ? new BigNumber(shares.result.toString()) : BIG_ZERO
-    const sharePriceAsBigNumber =
-      sharePrice.status === 'success' ? new BigNumber(sharePrice.result.toString()) : BIG_ZERO
-    return {
-      totalShares: totalSharesAsBigNumber.toJSON(),
-      pricePerFullShare: sharePriceAsBigNumber.toJSON(),
-      totalCakeInVault: new BigNumber((totalCakeInVault.result || '0').toString()).toJSON(),
-    }
-  } catch (error) {
-    return {
-      totalShares: null,
-      pricePerFullShare: null,
-      totalCakeInVault: null,
-    }
-  }
-}
-
-export const fetchVaultFees = async ({
-  chainId,
-  cakeVaultAddress = getCakeVaultAddress(chainId),
-  provider,
-}: Params) => {
-  try {
-    const client = provider({ chainId })
-
-    const [performanceFee, withdrawalFee, withdrawalFeePeriod] = await client.multicall({
-      contracts: [
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'performanceFee',
-        },
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'withdrawFee',
-        },
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'withdrawFeePeriod',
-        },
-      ],
-      allowFailure: false,
-    })
-
-    return {
-      performanceFee: Number(performanceFee),
-      withdrawalFee: Number(withdrawalFee),
-      withdrawalFeePeriod: Number(withdrawalFeePeriod),
-    }
-  } catch (error) {
-    return {
-      performanceFee: null,
-      withdrawalFee: null,
-      withdrawalFeePeriod: null,
-    }
-  }
-}

package/src/queries/fetchVaultUser.ts

@@ -1,106 +0,0 @@
-import BigNumber from 'bignumber.js'
-import { ChainId } from '@pancakeswap/sdk'
-import { Address } from 'viem'
-
-import { OnChainProvider, SerializedLockedVaultUser, SerializedVaultUser } from '../types'
-import { cakeVaultV2ABI } from '../abis/ICakeVaultV2'
-import { getCakeFlexibleSideVaultAddress, getCakeVaultAddress } from './getAddresses'
-import { cakeFlexibleSideVaultV2ABI } from '../abis/ICakeFlexibleSideVaultV2'
-
-interface Params {
-  account: Address
-  chainId: ChainId
-  provider: OnChainProvider
-}
-
-export const fetchVaultUser = async ({ account, chainId, provider }: Params): Promise<SerializedLockedVaultUser> => {
-  try {
-    const cakeVaultAddress = getCakeVaultAddress(chainId)
-
-    const client = provider({ chainId })
-
-    const [userContractResponse, currentPerformanceFee, currentOverdueFee] = await client.multicall({
-      contracts: [
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'userInfo',
-          args: [account],
-        },
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'calculatePerformanceFee',
-          args: [account],
-        },
-        {
-          abi: cakeVaultV2ABI,
-          address: cakeVaultAddress,
-          functionName: 'calculateOverdueFee',
-          args: [account],
-        },
-      ],
-      allowFailure: false,
-    })
-
-    return {
-      isLoading: false,
-      userShares: new BigNumber(userContractResponse[0].toString()).toJSON(),
-      lastDepositedTime: userContractResponse[1].toString(),
-      lastUserActionTime: userContractResponse[3].toString(),
-      cakeAtLastUserAction: new BigNumber(userContractResponse[2].toString()).toJSON(),
-      userBoostedShare: new BigNumber(userContractResponse[6].toString()).toJSON(),
-      locked: userContractResponse[7],
-      lockEndTime: userContractResponse[5].toString(),
-      lockStartTime: userContractResponse[4].toString(),
-      lockedAmount: new BigNumber(userContractResponse[8].toString()).toJSON(),
-      currentPerformanceFee: new BigNumber(currentPerformanceFee.toString()).toJSON(),
-      currentOverdueFee: new BigNumber(currentOverdueFee.toString()).toJSON(),
-    }
-  } catch (error) {
-    return {
-      isLoading: true,
-      userShares: '',
-      lastDepositedTime: '',
-      lastUserActionTime: '',
-      cakeAtLastUserAction: '',
-      userBoostedShare: '',
-      lockEndTime: '',
-      lockStartTime: '',
-      locked: false,
-      lockedAmount: '',
-      currentPerformanceFee: '',
-      currentOverdueFee: '',
-    }
-  }
-}
-
-export const fetchFlexibleSideVaultUser = async ({
-  account,
-  chainId,
-  provider,
-}: Params): Promise<SerializedVaultUser> => {
-  try {
-    const userContractResponse = await await provider({ chainId }).readContract({
-      abi: cakeFlexibleSideVaultV2ABI,
-      address: getCakeFlexibleSideVaultAddress(chainId),
-      functionName: 'userInfo',
-      args: [account],
-    })
-    return {
-      isLoading: false,
-      userShares: new BigNumber(userContractResponse[0].toString()).toJSON(),
-      lastDepositedTime: userContractResponse[1].toString(),
-      lastUserActionTime: userContractResponse[3].toString(),
-      cakeAtLastUserAction: new BigNumber(userContractResponse[2].toString()).toJSON(),
-    }
-  } catch (error) {
-    return {
-      isLoading: true,
-      userShares: '',
-      lastDepositedTime: '',
-      lastUserActionTime: '',
-      cakeAtLastUserAction: '',
-    }
-  }
-}

package/src/queries/getAddresses.ts

@@ -1,12 +0,0 @@
-import { ChainId } from '@pancakeswap/sdk'
-
-import { CAKE_FLEXIBLE_SIDE_VAULT, CAKE_VAULT } from '../constants/contracts'
-import { getContractAddress } from '../utils'
-
-export function getCakeFlexibleSideVaultAddress(chainId: ChainId) {
-  return getContractAddress(CAKE_FLEXIBLE_SIDE_VAULT, chainId)
-}
-
-export function getCakeVaultAddress(chainId: ChainId) {
-  return getContractAddress(CAKE_VAULT, chainId)
-}

package/src/queries/index.ts

@@ -1,6 +0,0 @@
-export * from './fetchPools'
-export * from './fetchUserPoolsData'
-export * from './fetchUserIfo'
-export * from './fetchVaultPublic'
-export * from './getAddresses'
-export * from './fetchVaultUser'

package/src/types.ts

@@ -1,207 +0,0 @@
-import { ChainId } from '@pancakeswap/sdk'
-import { PublicClient, Address } from 'viem'
-import type { SerializedWrappedToken } from '@pancakeswap/token-lists'
-import BigNumber from 'bignumber.js'
-
-export type OnChainProvider = ({ chainId }: { chainId?: ChainId }) => PublicClient
-
-export type SerializedBigNumber = string
-
-export interface Addresses {
-  [chainId: number]: string
-}
-
-export enum PoolCategory {
-  'COMMUNITY' = 'Community',
-  'CORE' = 'Core',
-  'BINANCE' = 'Binance', // Pools using native BNB behave differently than pools using a token
-  'AUTO' = 'Auto',
-}
-
-// @deprecated
-export interface LegacyPoolConfigBaseProps {
-  sousId: number
-  contractAddress: Address
-  poolCategory: PoolCategory
-  tokenPerBlock: string
-  isFinished?: boolean
-  enableEmergencyWithdraw?: boolean
-  version?: number
-}
-
-export interface PoolConfigBaseProps {
-  sousId: number
-  contractAddress: Address
-  poolCategory: PoolCategory
-  tokenPerSecond: string
-  isFinished?: boolean
-  enableEmergencyWithdraw?: boolean
-}
-
-interface GenericToken {
-  decimals: number
-  symbol: string
-  address: string
-}
-
-export interface LegacySerializedPoolConfig<T> extends LegacyPoolConfigBaseProps {
-  earningToken: T & GenericToken
-  stakingToken: T & GenericToken
-}
-
-export interface SerializedPoolConfig<T> extends PoolConfigBaseProps {
-  earningToken: T & GenericToken
-  stakingToken: T & GenericToken
-}
-
-export type LegacySerializedPool = LegacySerializedPoolConfig<SerializedWrappedToken>
-
-export type UpgradedSerializedPool = SerializedPoolConfig<SerializedWrappedToken>
-
-export type SerializedPool = LegacySerializedPool | UpgradedSerializedPool
-
-export type UpgradedSerializedPoolWithInfo = UpgradedSerializedPool & SerializedPoolInfo
-
-export type LegacySerializedPoolWithInfo = LegacySerializedPool & SerializedPoolInfo
-
-export type SerializedPoolWithInfo = LegacySerializedPoolWithInfo | UpgradedSerializedPoolWithInfo
-
-export interface SerializedVaultUser {
-  isLoading: boolean
-  userShares: SerializedBigNumber
-  cakeAtLastUserAction: SerializedBigNumber
-  lastDepositedTime: string
-  lastUserActionTime: string
-}
-
-export interface SerializedLockedVaultUser extends SerializedVaultUser {
-  lockStartTime: string
-  lockEndTime: string
-  userBoostedShare: SerializedBigNumber
-  locked: boolean
-  lockedAmount: SerializedBigNumber
-  currentPerformanceFee: SerializedBigNumber
-  currentOverdueFee: SerializedBigNumber
-}
-
-export interface LegacyDeserializedPoolConfig<T> extends LegacyPoolConfigBaseProps {
-  earningToken: T & GenericToken
-  stakingToken: T & GenericToken
-}
-
-export interface UpgradedDeserializedPoolConfig<T> extends PoolConfigBaseProps {
-  earningToken: T & GenericToken
-  stakingToken: T & GenericToken
-}
-
-export type DeserializedPoolConfig<T> = LegacyDeserializedPoolConfig<T> | UpgradedDeserializedPoolConfig<T>
-
-interface SerializedPoolInfo extends CorePoolProps {
-  totalStaked?: string
-  stakingLimit?: string
-  stakingLimitEndTimestamp?: number
-  profileRequirement?: {
-    required: boolean
-    thresholdPoints: string
-  }
-  userDataLoaded?: boolean
-  userData?: {
-    allowance: string
-    stakingTokenBalance: string
-    stakedBalance: string
-    pendingReward: string
-  }
-}
-
-interface PoolInfo extends CorePoolProps {
-  totalStaked?: BigNumber
-  stakingLimit?: BigNumber
-  stakingLimitEndTimestamp?: number
-  profileRequirement?: {
-    required: boolean
-    thresholdPoints: BigNumber
-  }
-  userDataLoaded?: boolean
-  userData?: {
-    allowance: BigNumber
-    stakingTokenBalance: BigNumber
-    stakedBalance: BigNumber
-    pendingReward: BigNumber
-  }
-}
-
-export type UpgradedDeserializedPool<T> = UpgradedDeserializedPoolConfig<T> & PoolInfo
-
-export type LegacyDeserializedPool<T> = LegacyDeserializedPoolConfig<T> & PoolInfo
-
-export type DeserializedPool<T> = UpgradedDeserializedPool<T> | LegacyDeserializedPool<T>
-
-export type DeserializedPoolVault<T> = DeserializedPool<T> & DeserializedCakeVault
-export type DeserializedPoolLockedVault<T> = DeserializedPool<T> & DeserializedLockedCakeVault
-
-export interface DeserializedLockedVaultUser extends DeserializedVaultUser {
-  lastDepositedTime: string
-  lastUserActionTime: string
-  lockStartTime: string
-  lockEndTime: string
-  burnStartTime: string
-  userBoostedShare: BigNumber
-  locked: boolean
-  lockedAmount: BigNumber
-  currentPerformanceFee: BigNumber
-  currentOverdueFee: BigNumber
-}
-
-export interface DeserializedLockedCakeVault extends Omit<DeserializedCakeVault, 'userData'> {
-  totalLockedAmount?: BigNumber
-  userData?: DeserializedLockedVaultUser
-}
-
-export interface SerializedVaultFees {
-  performanceFee: number
-  withdrawalFee: number
-  withdrawalFeePeriod: number
-}
-
-export interface DeserializedVaultFees extends SerializedVaultFees {
-  performanceFeeAsDecimal: number
-}
-
-export interface DeserializedVaultUser {
-  isLoading: boolean
-  userShares: BigNumber
-  cakeAtLastUserAction: BigNumber
-  lastDepositedTime: string
-  lastUserActionTime: string
-  balance: {
-    cakeAsNumberBalance: number
-    cakeAsBigNumber: BigNumber
-    cakeAsDisplayBalance: string
-  }
-}
-
-export interface DeserializedCakeVault {
-  totalShares?: BigNumber
-  totalLockedAmount?: BigNumber
-  pricePerFullShare: BigNumber
-  totalCakeInVault?: BigNumber
-  fees?: DeserializedVaultFees
-  userData?: DeserializedVaultUser
-}
-
-export enum VaultKey {
-  CakeVaultV1 = 'cakeVaultV1',
-  CakeVault = 'cakeVault',
-  CakeFlexibleSideVault = 'cakeFlexibleSideVault',
-  IfoPool = 'ifoPool',
-}
-
-interface CorePoolProps {
-  startTimestamp?: number
-  endTimestamp?: number
-  apr?: number
-  rawApr?: number
-  stakingTokenPrice?: number
-  earningTokenPrice?: number
-  vaultKey?: VaultKey
-}

package/src/utils/apr.ts

@@ -1,35 +0,0 @@
-import BigNumber from 'bignumber.js'
-
-import { BLOCKS_PER_YEAR, SECONDS_IN_YEAR } from '../constants'
-
-/**
- * Get the APR value in %
- * @param stakingTokenPrice Token price in the same quote currency
- * @param rewardTokenPrice Token price in the same quote currency
- * @param totalStaked Total amount of stakingToken in the pool
- * @param tokenPerBlock Amount of new cake allocated to the pool for each new block
- * @returns Null if the APR is NaN or infinite.
- */
-export const getPoolAprByTokenPerBlock = (
-  stakingTokenPrice: number,
-  rewardTokenPrice: number,
-  totalStaked: number,
-  tokenPerBlock: number,
-): number | null => {
-  const totalRewardPricePerYear = new BigNumber(rewardTokenPrice).times(tokenPerBlock).times(BLOCKS_PER_YEAR)
-  const totalStakingTokenInPool = new BigNumber(stakingTokenPrice).times(totalStaked)
-  const apr = totalRewardPricePerYear.div(totalStakingTokenInPool).times(100)
-  return apr.isNaN() || !apr.isFinite() ? null : apr.toNumber()
-}
-
-export const getPoolAprByTokenPerSecond = (
-  stakingTokenPrice: number,
-  rewardTokenPrice: number,
-  totalStaked: number,
-  tokenPerSecond: number,
-): number | null => {
-  const totalRewardPricePerYear = new BigNumber(rewardTokenPrice).times(tokenPerSecond).times(SECONDS_IN_YEAR)
-  const totalStakingTokenInPool = new BigNumber(stakingTokenPrice).times(totalStaked)
-  const apr = totalRewardPricePerYear.div(totalStakingTokenInPool).times(100)
-  return apr.isNaN() || !apr.isFinite() ? null : apr.toNumber()
-}

package/src/utils/getContractAddress.ts

@@ -1,11 +0,0 @@
-import { ChainId } from '@pancakeswap/sdk'
-
-import { ContractAddresses } from '../constants/contracts'
-import { isPoolsSupported } from './isPoolsSupported'
-
-export function getContractAddress(addresses: ContractAddresses, chainId: ChainId) {
-  if (!isPoolsSupported(chainId)) {
-    throw new Error(`Cannot get contract address. Unsupported chain ${chainId}`)
-  }
-  return addresses[chainId]
-}