@pancakeswap/pools 4.0.9 → 4.0.10

package/src/constants/pools/97.ts

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

@@ -1,56 +0,0 @@
-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 { pools as arbPools, livePools as arbLivePools } from './42161'
-import { pools as arbTestnetPools, livePools as arbTestnetLivePools } from './421613'
-import { pools as zkSyncPools, livePools as zkSyncLivePools } from './324'
-import { pools as zkSyncTestnetPools, livePools as zkSyncTestnetLivePools } from './280'
-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,
-  [ChainId.ARBITRUM_ONE]: arbPools,
-  [ChainId.ARBITRUM_GOERLI]: arbTestnetPools,
-  [ChainId.ZKSYNC]: zkSyncPools,
-  [ChainId.ZKSYNC_TESTNET]: zkSyncTestnetPools,
-} as PoolsConfigByChain<SupportedChainId>
-
-export const LIVE_POOLS_CONFIG_BY_CHAIN = {
-  [ChainId.ETHEREUM]: ethLivePools,
-  [ChainId.BSC]: bscLivePools,
-  [ChainId.BSC_TESTNET]: bscTestnetLivePools,
-  [ChainId.ARBITRUM_ONE]: arbLivePools,
-  [ChainId.ARBITRUM_GOERLI]: arbTestnetLivePools,
-  [ChainId.ZKSYNC]: zkSyncLivePools,
-  [ChainId.ZKSYNC_TESTNET]: zkSyncTestnetLivePools,
-} 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

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

package/src/index.ts

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

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

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