@pancakeswap/pools 4.0.3

package/src/constants/pools/97.ts

@@ -0,0 +1,74 @@
+import { bscTestnetTokens } from '@pancakeswap/tokens'
+import { getAddress } from 'viem'
+
+import { PoolCategory, SerializedPool } from '../../types'
+
+export const livePools: SerializedPool[] = [
+  // {
+  //   sousId: 0,
+  //   stakingToken: bscTestnetTokens.cake2,
+  //   earningToken: bscTestnetTokens.cake2,
+  //   contractAddress: '0x4c650FB471fe4e0f476fD3437C3411B1122c4e3B',
+  //   poolCategory: PoolCategory.CORE,
+  //   tokenPerBlock: '0.01',
+  //   isFinished: false,
+  // },
+  {
+    sousId: 1,
+    stakingToken: bscTestnetTokens.cake2,
+    earningToken: bscTestnetTokens.mockA,
+    contractAddress: '0xe7080E3afDfF2322080B5ba85700FE41287D864B',
+    poolCategory: PoolCategory.CORE,
+    tokenPerSecond: '0.01',
+  },
+  {
+    sousId: 2,
+    stakingToken: bscTestnetTokens.mockA,
+    earningToken: bscTestnetTokens.mockB,
+    contractAddress: '0x31a069925fb770202b302c7911af1acbe0395420',
+    poolCategory: PoolCategory.CORE,
+    tokenPerSecond: '0.01',
+  },
+  {
+    sousId: 3,
+    stakingToken: bscTestnetTokens.wbnb,
+    earningToken: bscTestnetTokens.cake2,
+    contractAddress: '0x550d3a43D5CB57E70dD1F53699CEaA0f371ADbBb',
+    poolCategory: PoolCategory.CORE,
+    tokenPerSecond: '0.01',
+  },
+  {
+    sousId: 5,
+    stakingToken: bscTestnetTokens.msix,
+    earningToken: bscTestnetTokens.cake2,
+    contractAddress: '0xf45c9e61318006Dc31CA4993b8ab75E611fe0792',
+    poolCategory: PoolCategory.CORE,
+    tokenPerSecond: '0.0001',
+  },
+  {
+    sousId: 6,
+    stakingToken: bscTestnetTokens.cake2,
+    earningToken: bscTestnetTokens.msix,
+    contractAddress: '0xeB019927EB2d79b6A03B728a6f7A9020f3e2E25f',
+    poolCategory: PoolCategory.CORE,
+    tokenPerSecond: '1',
+  },
+  {
+    sousId: 7,
+    stakingToken: bscTestnetTokens.cake2,
+    earningToken: bscTestnetTokens.msix,
+    contractAddress: '0xd41F619f2f2E91F77054877Ed1a47661f290d19e',
+    poolCategory: PoolCategory.CORE,
+    tokenPerSecond: '0.1',
+  },
+].map((p) => ({
+  ...p,
+  contractAddress: getAddress(p.contractAddress, 97),
+  stakingToken: p.stakingToken.serialize,
+  earningToken: p.earningToken.serialize,
+}))
+
+// known finished pools
+export const finishedPools: SerializedPool[] = []
+
+export const pools: SerializedPool[] = [...livePools, ...finishedPools]

package/src/constants/pools/index.ts

@@ -0,0 +1,44 @@
+import { ChainId } from '@pancakeswap/sdk'
+
+import { pools as ethPools, livePools as ethLivePools } from './1'
+import { pools as bscPools, livePools as bscLivePools } from './56'
+import { pools as bscTestnetPools, livePools as bscTestnetLivePools } from './97'
+import { SerializedPool } from '../../types'
+import { SupportedChainId } from '../supportedChains'
+import { isPoolsSupported } from '../../utils/isPoolsSupported'
+
+export type PoolsConfigByChain<TChainId extends ChainId> = {
+  [chainId in TChainId]: SerializedPool[]
+}
+
+export const POOLS_CONFIG_BY_CHAIN = {
+  [ChainId.ETHEREUM]: ethPools,
+  [ChainId.BSC]: bscPools,
+  [ChainId.BSC_TESTNET]: bscTestnetPools,
+} as PoolsConfigByChain<SupportedChainId>
+
+export const LIVE_POOLS_CONFIG_BY_CHAIN = {
+  [ChainId.ETHEREUM]: ethLivePools,
+  [ChainId.BSC]: bscLivePools,
+  [ChainId.BSC_TESTNET]: bscTestnetLivePools,
+} as PoolsConfigByChain<SupportedChainId>
+
+export const getPoolsConfig = (chainId: ChainId) => {
+  if (!isPoolsSupported(chainId)) {
+    return undefined
+  }
+  return POOLS_CONFIG_BY_CHAIN[chainId]
+}
+
+export const getLivePoolsConfig = (chainId: ChainId) => {
+  if (!isPoolsSupported(chainId)) {
+    return undefined
+  }
+  return LIVE_POOLS_CONFIG_BY_CHAIN[chainId]
+}
+
+export const MAX_LOCK_DURATION = 31536000
+export const UNLOCK_FREE_DURATION = 604800
+export const ONE_WEEK_DEFAULT = 604800
+export const BOOST_WEIGHT = 20000000000000n
+export const DURATION_FACTOR = 31536000n

package/src/constants/supportedChains.ts

@@ -0,0 +1,5 @@
+import { ChainId } from '@pancakeswap/sdk'
+
+export const SUPPORTED_CHAIN_IDS = [ChainId.BSC, ChainId.BSC_TESTNET, ChainId.ETHEREUM] as const
+
+export type SupportedChainId = (typeof SUPPORTED_CHAIN_IDS)[number]

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from './constants'
+export * from './types'
+export * from './queries'
+export * from './utils'
+
+// abi
+export * from './abis/ICake'
+export * from './abis/ICakeFlexibleSideVaultV2'
+export * from './abis/ICakeVaultV2'
+export * from './abis/ISmartChef'
+export * from './abis/ISousChef'
+export * from './abis/ISousChefBNB'
+export * from './abis/ISousChefV2'
+export * from './abis/ISousChefV3'

package/src/queries/fetchPools.ts

@@ -0,0 +1,350 @@
+import BigNumber from 'bignumber.js'
+import fromPairs from 'lodash/fromPairs'
+import chunk from 'lodash/chunk'
+import { BIG_ZERO } from '@pancakeswap/utils/bigNumber'
+import { ChainId } from '@pancakeswap/sdk'
+import { erc20ABI } from 'wagmi'
+
+import { BSC_BLOCK_TIME, getPoolsConfig } from '../constants'
+import { sousChefABI } from '../abis/ISousChef'
+import { sousChefV2ABI } from '../abis/ISousChefV2'
+import { smartChefABI } from '../abis/ISmartChef'
+import { sousChefV3ABI } from '../abis/ISousChefV3'
+import { LegacySerializedPool, OnChainProvider, UpgradedSerializedPool } from '../types'
+import { isLegacyPool, isUpgradedPool } from '../utils'
+
+const getLivePoolsWithEnd = async (chainId: ChainId) => {
+  const poolsConfig = getPoolsConfig(chainId)
+  if (!poolsConfig) {
+    return null
+  }
+  return poolsConfig.filter((p) => p.sousId !== 0 && !p.isFinished)
+}
+
+async function fetchUpgradedPoolsTimeLimits(
+  pools: UpgradedSerializedPool[],
+  chainId: ChainId,
+  provider: OnChainProvider,
+) {
+  if (!pools.length) {
+    return []
+  }
+
+  const calls = pools.flatMap(({ contractAddress }) => {
+    return [
+      {
+        abi: smartChefABI,
+        address: contractAddress,
+        functionName: 'startTimestamp',
+      },
+      {
+        abi: smartChefABI,
+        address: contractAddress,
+        functionName: 'endTimestamp',
+      },
+    ] as const
+  })
+
+  const client = provider({ chainId })
+  const startEndRaw = await client.multicall({
+    contracts: calls,
+    allowFailure: false,
+  })
+
+  const startEndResult = startEndRaw.reduce<bigint[][]>((resultArray, item, index) => {
+    const chunkIndex = Math.floor(index / 2)
+
+    if (!resultArray[chunkIndex]) {
+      // eslint-disable-next-line no-param-reassign
+      resultArray[chunkIndex] = [] // start a new chunk
+    }
+
+    resultArray[chunkIndex].push(item)
+
+    return resultArray
+  }, [])
+
+  return pools.map((cakePoolConfig, index) => {
+    const [startTimestamp, endTimestamp] = startEndResult[index]
+    return {
+      sousId: cakePoolConfig.sousId,
+      startTimestamp: Number(startTimestamp),
+      endTimestamp: Number(endTimestamp),
+    }
+  })
+}
+
+const fetchLegacyPoolsBlockLimits = async (
+  pools: LegacySerializedPool[],
+  chainId: ChainId,
+  provider: OnChainProvider,
+) => {
+  if (!pools.length) {
+    return []
+  }
+  const startEndBlockCalls = pools.flatMap(({ contractAddress }) => {
+    return [
+      {
+        abi: sousChefABI,
+        address: contractAddress,
+        functionName: 'startBlock',
+      },
+      {
+        abi: sousChefABI,
+        address: contractAddress,
+        functionName: 'bonusEndBlock',
+      },
+    ] as const
+  })
+
+  const client = provider({ chainId })
+
+  const [block, startEndBlockRaw] = await Promise.all([
+    client.getBlock({ blockTag: 'latest' }),
+    client.multicall({
+      contracts: startEndBlockCalls,
+      allowFailure: false,
+    }),
+  ])
+
+  const startEndBlockResult = startEndBlockRaw.reduce<bigint[][]>((resultArray, item, index) => {
+    const chunkIndex = Math.floor(index / 2)
+
+    if (!resultArray[chunkIndex]) {
+      // eslint-disable-next-line no-param-reassign
+      resultArray[chunkIndex] = [] // start a new chunk
+    }
+
+    resultArray[chunkIndex].push(item)
+
+    return resultArray
+  }, [])
+
+  const getTimestampFromBlock = (targetBlock: number) => {
+    return Number(block.timestamp) + (targetBlock - Number(block.number)) * BSC_BLOCK_TIME
+  }
+  return pools.map((cakePoolConfig, index) => {
+    const [startBlock, endBlock] = startEndBlockResult[index]
+    return {
+      sousId: cakePoolConfig.sousId,
+      startTimestamp: getTimestampFromBlock(Number(startBlock)),
+      endTimestamp: getTimestampFromBlock(Number(endBlock)),
+    }
+  })
+}
+
+export const fetchPoolsTimeLimits = async (chainId: ChainId, provider: OnChainProvider) => {
+  const livedPools = await getLivePoolsWithEnd(chainId)
+  if (!livedPools) {
+    return null
+  }
+  const upgradedPools = livedPools.filter(isUpgradedPool)
+  const legacyPools = livedPools.filter(isLegacyPool)
+  const [upgradePoolLimits, legacyPoolLimits] = await Promise.all([
+    fetchUpgradedPoolsTimeLimits(upgradedPools, chainId, provider),
+    fetchLegacyPoolsBlockLimits(legacyPools, chainId, provider),
+  ])
+  return [...upgradePoolLimits, ...legacyPoolLimits]
+}
+
+export const fetchPoolsTotalStaking = async (chainId: ChainId, provider: OnChainProvider) => {
+  const poolsConfig = getPoolsConfig(chainId)
+  if (!poolsConfig) {
+    return null
+  }
+  const poolsBalanceOf = poolsConfig.map(({ contractAddress, stakingToken }) => {
+    return {
+      abi: erc20ABI,
+      address: stakingToken.address,
+      functionName: 'balanceOf',
+      args: [contractAddress],
+    } as const
+  })
+
+  const client = provider({ chainId })
+  const poolsTotalStaked = await client.multicall({
+    contracts: poolsBalanceOf,
+    allowFailure: false,
+  })
+
+  return poolsConfig.map((p, index) => ({
+    sousId: p.sousId,
+    totalStaked: new BigNumber(poolsTotalStaked[index].toString()).toJSON(),
+  }))
+}
+
+interface FetchingPoolsStakingLimitsParams {
+  poolsWithStakingLimit: number[]
+  chainId: ChainId
+  provider: OnChainProvider
+}
+
+export const fetchPoolsStakingLimitsByBlock = async ({
+  poolsWithStakingLimit,
+  chainId,
+  provider,
+}: FetchingPoolsStakingLimitsParams): Promise<{
+  [key: string]: { stakingLimit: BigNumber; numberSecondsForUserLimit: number }
+}> => {
+  const poolsConfig = getPoolsConfig(chainId)
+  if (!poolsConfig) {
+    throw new Error(`No pools found on chain ${chainId}`)
+  }
+
+  const validPools = poolsConfig
+    .filter(isLegacyPool)
+    .filter((p) => p.stakingToken.symbol !== 'BNB' && !p.isFinished)
+    .filter((p) => !poolsWithStakingLimit.includes(p.sousId))
+
+  // Get the staking limit for each valid pool
+  const poolStakingCalls = validPools
+    .map(({ contractAddress }) => {
+      return (['hasUserLimit', 'poolLimitPerUser', 'numberBlocksForUserLimit'] as const).map(
+        (method) =>
+          ({
+            address: contractAddress,
+            functionName: method,
+            abi: sousChefV2ABI,
+          } as const),
+      )
+    })
+    .flat()
+
+  const client = provider({ chainId })
+
+  const poolStakingResultRaw = await client.multicall({
+    contracts: poolStakingCalls,
+    allowFailure: true,
+  })
+
+  const chunkSize = poolStakingCalls.length / validPools.length
+  const poolStakingChunkedResultRaw = chunk(poolStakingResultRaw.flat(), chunkSize)
+  return fromPairs(
+    poolStakingChunkedResultRaw.map((stakingLimitRaw, index) => {
+      const hasUserLimit = stakingLimitRaw[0]?.result as boolean
+      const stakingLimit =
+        hasUserLimit && stakingLimitRaw[1].result ? new BigNumber(stakingLimitRaw[1].result.toString()) : BIG_ZERO
+      const numberBlocksForUserLimit = stakingLimitRaw[2].result ? Number(stakingLimitRaw[2].result) : 0
+      const numberSecondsForUserLimit = numberBlocksForUserLimit * BSC_BLOCK_TIME
+      return [validPools[index].sousId, { stakingLimit, numberSecondsForUserLimit }]
+    }),
+  )
+}
+
+const fetchPoolsStakingLimitsByTime = async ({
+  poolsWithStakingLimit,
+  chainId,
+  provider,
+}: FetchingPoolsStakingLimitsParams): Promise<{
+  [key: string]: { stakingLimit: BigNumber; numberSecondsForUserLimit: number }
+}> => {
+  const poolsConfig = getPoolsConfig(chainId)
+  if (!poolsConfig) {
+    throw new Error(`No pools found on chain ${chainId}`)
+  }
+
+  const validPools = poolsConfig
+    .filter(isUpgradedPool)
+    .filter((p) => p.stakingToken.symbol !== 'BNB' && !p.isFinished)
+    .filter((p) => !poolsWithStakingLimit.includes(p.sousId))
+
+  // Get the staking limit for each valid pool
+  const poolStakingCalls = validPools
+    .map(({ contractAddress }) => {
+      return (['hasUserLimit', 'poolLimitPerUser', 'numberSecondsForUserLimit'] as const).map(
+        (method) =>
+          ({
+            abi: smartChefABI,
+            address: contractAddress,
+            functionName: method,
+          } as const),
+      )
+    })
+    .flat()
+
+  const client = provider({ chainId })
+  const poolStakingResultRaw = await client.multicall({
+    contracts: poolStakingCalls,
+    allowFailure: true,
+  })
+  const chunkSize = poolStakingCalls.length / validPools.length
+  const poolStakingChunkedResultRaw = chunk(poolStakingResultRaw.flat(), chunkSize)
+  return fromPairs(
+    poolStakingChunkedResultRaw.map((stakingLimitRaw, index) => {
+      const hasUserLimit = stakingLimitRaw[0].result
+      const stakingLimit =
+        hasUserLimit && stakingLimitRaw[1].result ? new BigNumber(stakingLimitRaw[1].result.toString()) : BIG_ZERO
+      const numberSecondsForUserLimit = stakingLimitRaw[2].result ? Number(stakingLimitRaw[2].result) : 0
+      return [validPools[index].sousId, { stakingLimit, numberSecondsForUserLimit }]
+    }),
+  )
+}
+
+export const fetchPoolsStakingLimits = async (
+  params: FetchingPoolsStakingLimitsParams,
+): Promise<{
+  [key: string]: { stakingLimit: BigNumber; numberSecondsForUserLimit: number }
+}> => {
+  const [limitsByTime, limitsByBlock] = await Promise.all([
+    fetchPoolsStakingLimitsByTime(params),
+    fetchPoolsStakingLimitsByBlock(params),
+  ])
+  return {
+    ...limitsByTime,
+    ...limitsByBlock,
+  }
+}
+
+export const fetchPoolsProfileRequirement = async (
+  chainId: ChainId,
+  provider: OnChainProvider,
+): Promise<{
+  [key: string]: {
+    required: boolean
+    thresholdPoints: string
+  }
+}> => {
+  const poolsConfig = getPoolsConfig(chainId)
+  if (!poolsConfig) {
+    throw new Error(`No pools found on chain ${chainId}`)
+  }
+
+  const livePoolsWithV3 = poolsConfig.filter(
+    (pool) => (isUpgradedPool(pool) || (isLegacyPool(pool) && pool?.version === 3)) && !pool?.isFinished,
+  )
+  const poolProfileRequireCalls = livePoolsWithV3
+    .map(({ contractAddress }) => {
+      return (['pancakeProfileIsRequested', 'pancakeProfileThresholdPoints'] as const).map(
+        (method) =>
+          ({
+            abi: sousChefV3ABI,
+            address: contractAddress,
+            functionName: method,
+          } as const),
+      )
+    })
+    .flat()
+
+  const client = provider({ chainId })
+  const poolProfileRequireResultRaw = await client.multicall({
+    contracts: poolProfileRequireCalls,
+  })
+
+  const chunkSize = poolProfileRequireCalls.length / livePoolsWithV3.length
+  const poolStakingChunkedResultRaw = chunk(poolProfileRequireResultRaw.flat(), chunkSize)
+  return fromPairs(
+    poolStakingChunkedResultRaw.map((poolProfileRequireRaw, index) => {
+      const hasProfileRequired = poolProfileRequireRaw[0].result
+      const profileThresholdPoints = poolProfileRequireRaw[1].result
+        ? new BigNumber(poolProfileRequireRaw[1].result.toString())
+        : BIG_ZERO
+      return [
+        livePoolsWithV3[index].sousId,
+        {
+          required: !!hasProfileRequired,
+          thresholdPoints: profileThresholdPoints.toJSON(),
+        },
+      ]
+    }),
+  )
+}

package/src/queries/fetchUserIfo.ts

@@ -0,0 +1,53 @@
+import BigNumber from 'bignumber.js'
+import { BIG_ZERO } from '@pancakeswap/utils/bigNumber'
+import { ChainId } from '@pancakeswap/sdk'
+import { Address, getContract, WalletClient, GetContractReturnType, PublicClient } from 'viem'
+
+import { iCakeABI } from '../abis/ICake'
+import { ICAKE } from '../constants/contracts'
+import { OnChainProvider } from '../types'
+import { getContractAddress } from '../utils'
+
+export const getIfoCreditAddressContract = (
+  chainId: ChainId,
+  provider: OnChainProvider,
+  walletClient?: WalletClient,
+): GetContractReturnType<typeof iCakeABI, PublicClient, WalletClient> => {
+  const address = getContractAddress(ICAKE, chainId)
+  if (!address || address === '0x') {
+    throw new Error(`ICAKE not supported on chain ${chainId}`)
+  }
+
+  return getContract({ abi: iCakeABI, address, publicClient: provider({ chainId }), walletClient })
+}
+
+export const fetchPublicIfoData = async (chainId: ChainId, provider: OnChainProvider) => {
+  try {
+    const ifoCreditAddressContract = getIfoCreditAddressContract(chainId, provider)
+    const ceiling = await ifoCreditAddressContract.read.ceiling()
+    return {
+      ceiling: new BigNumber(ceiling.toString()).toJSON(),
+    }
+  } catch (error) {
+    return {
+      ceiling: BIG_ZERO.toJSON(),
+    }
+  }
+}
+
+interface Params {
+  account: Address
+  chainId: ChainId
+  provider: OnChainProvider
+}
+
+export const fetchUserIfoCredit = async ({ account, chainId, provider }: Params) => {
+  try {
+    const ifoCreditAddressContract = getIfoCreditAddressContract(chainId, provider)
+    const credit = await ifoCreditAddressContract.read.getUserCredit([account])
+    return new BigNumber(credit.toString()).toJSON()
+  } catch (error) {
+    console.error(error)
+    return BIG_ZERO.toJSON()
+  }
+}

package/src/queries/fetchUserPoolsData.ts

@@ -0,0 +1,143 @@
+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()]))
+}