@pancakeswap/pools 4.0.3

package/src/queries/fetchVaultPublic.ts

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,12 @@
+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

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

package/src/types.ts

@@ -0,0 +1,207 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,11 @@
+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]
+}

package/src/utils/getPoolContractBySousId.ts

@@ -0,0 +1,111 @@
+import { ChainId } from '@pancakeswap/sdk'
+import { WalletClient, getContract, PublicClient, Address, GetContractReturnType, Account, Chain } from 'viem'
+
+import { getPoolsConfig } from '../constants'
+import { isLegacyPool } from './isLegacyPool'
+import { smartChefABI } from '../abis/ISmartChef'
+import { PoolCategory } from '../types'
+import { sousChefV2ABI } from '../abis/ISousChefV2'
+import { sousChefBnbABI } from '../abis/ISousChefBNB'
+
+interface Params {
+  chainId?: ChainId
+  sousId: number
+  signer?: any
+  publicClient?: any
+}
+
+type GetContractReturnType_<TAbi extends readonly unknown[]> = GetContractReturnType<TAbi, any, any> & {
+  abi: TAbi
+  address: Address
+  account?: Account
+  chain?: Chain
+}
+
+export function getSousChefBNBContract({
+  address,
+  signer,
+  publicClient,
+}: {
+  address: Address
+  signer?: WalletClient
+  publicClient?: PublicClient
+}): GetContractReturnType_<typeof sousChefBnbABI> {
+  return {
+    ...getContract({
+      abi: sousChefBnbABI,
+      address,
+      walletClient: signer,
+      publicClient,
+    }),
+    abi: sousChefBnbABI,
+    address,
+    account: signer?.account,
+    chain: signer?.chain,
+  }
+}
+
+export function getSousChefV2Contract({
+  address,
+  signer,
+  publicClient,
+}: {
+  address: Address
+  signer?: WalletClient
+  publicClient?: PublicClient
+}): GetContractReturnType_<typeof sousChefV2ABI> {
+  return {
+    ...getContract({
+      abi: sousChefV2ABI,
+      address,
+      walletClient: signer,
+      publicClient,
+    }),
+    abi: sousChefV2ABI,
+    address,
+    account: signer?.account,
+    chain: signer?.chain,
+  }
+}
+
+export function getSmartChefChefV2Contract({
+  address,
+  signer,
+  publicClient,
+}: {
+  address: Address
+  signer?: WalletClient
+  publicClient?: PublicClient
+}): GetContractReturnType_<typeof smartChefABI> {
+  return {
+    ...getContract({
+      abi: smartChefABI,
+      address,
+      walletClient: signer,
+      publicClient,
+    }),
+    abi: smartChefABI,
+    address,
+    account: signer?.account,
+    chain: signer?.chain,
+  }
+}
+
+export function getPoolContractBySousId({ chainId, sousId, signer, publicClient }: Params): any | null {
+  if (!chainId) {
+    return null
+  }
+  const pools = getPoolsConfig(chainId)
+  const pool = pools?.find((p) => p.sousId === Number(sousId))
+  if (!pool) {
+    return null
+  }
+  const { contractAddress } = pool
+  if (isLegacyPool(pool)) {
+    if (pool.poolCategory === PoolCategory.BINANCE) {
+      return getSousChefBNBContract({ address: contractAddress, signer, publicClient })
+    }
+    return getSousChefV2Contract({ address: contractAddress, signer, publicClient })
+  }
+  return getSmartChefChefV2Contract({ address: contractAddress, signer, publicClient })
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './getContractAddress'
+export * from './isPoolsSupported'
+export * from './isLegacyPool'
+export * from './apr'
+export * from './getPoolContractBySousId'

package/src/utils/isLegacyPool.ts

@@ -0,0 +1,15 @@
+import { LegacySerializedPool, SerializedPool, UpgradedSerializedPool } from '../types'
+
+export function isLegacyPool(pool: SerializedPool): pool is LegacySerializedPool {
+  if ((pool as any).tokenPerBlock) {
+    return true
+  }
+  return false
+}
+
+export function isUpgradedPool(pool: SerializedPool): pool is UpgradedSerializedPool {
+  if ((pool as any).tokenPerSecond) {
+    return true
+  }
+  return false
+}

package/src/utils/isPoolsSupported.ts

@@ -0,0 +1,5 @@
+import { SupportedChainId, SUPPORTED_CHAIN_IDS } from '../constants/supportedChains'
+
+export function isPoolsSupported(chainId: number): chainId is SupportedChainId {
+  return SUPPORTED_CHAIN_IDS.includes(chainId)
+}