simulate move address

InnerApp.tsx

import { useEffect } from 'react'
import { Toaster } from 'react-hot-toast'
import { useAppSelector } from 'state/hooks'
import { useLocation } from 'react-router-dom'
import { useWallet } from '@razorlabs/razorkit'
import TopNav from './TopNav'
import { Routing } from './Routing'
import { AppModals } from '../components/modals/AppModals'
import { useAptos, useAptosLongCache, useEnvironment } from 'layout/EnvironmentProvider'
import { ThemeProvider } from 'state/ThemeContext'
import {
  selectCanopyMetaLoadedOnce,
  selectLiquidswapVaultAddresses,
  selectLoadedCanopyMeta,
  selectAllVaultAddressToPools
} from 'state/slices/app/canopyMeta'
import {
  getVaultByVaultAddress,
  selectUnifiedVaults
} from 'state/slices/app/unifiedVaults'
import {
  selectSatayVaultsLoaded,
  selectSharesAddressListFromVaults
} from 'state/slices/app/satayVaults'
import { selectGlobalMetaLoadedOnce, selectLoadedGlobalMeta } from 'state/slices/app/globalMeta'
import {
  selectLiquidswapTokenDataIds,
  selectLiquidVaultsLoaded
} from 'state/slices/app/liquidVaults'
import { dispatch } from 'state/dispatch'
import { fetchLiquidVaults } from 'state/thunks/fetchLiquidVaults'
import { fetchPoolInfo } from 'state/thunks/fetchPoolInfo'
import { isEmptyOrNil } from 'toolbox/account'
import { selectPoolInfo, selectPoolInfoBusy, selectPoolInfoLoaded } from 'state/slices/app/poolInfo'
import { fetchStakedBalances } from 'state/thunks/fetchStakedBalances'
import { fetchV2Balances } from 'state/thunks/fetchV2Balances'
import { fetchAccountResources } from 'state/thunks/fetchAccountResources'
import { fetchSatayBalances } from 'state/thunks/fetchSatayBalances'
import { fetchIchiLPs } from 'state/thunks/fetchIchiLPs'
import { selectActiveVault, setActiveVaultState } from 'state/slices/ui/form'
import { selectAccountResources } from 'state/slices/user/accountResources'
import { fetchRewardsBalances } from 'state/thunks/fetchRewardsBalances'
import { fetchClaimAddresses } from 'state/thunks/fetchClaimAddresses'
import { useAppKitAccount } from '@reown/appkit/react'
import { selectLinkWalletsSuccess, setLinkWalletsSuccessState } from 'state/slices/ui/wallet'
import { selectClaimAddressGlobal } from 'state/slices/user/claimAddress'
import { selectClaimAddressSingleAsset } from 'state/slices/user/claimAddress'
import { fetchCornDeployers } from 'state/thunks/fetchCornDeployers'
import { fetchCornBalances } from 'state/thunks/fetchCornBalances'
import Footer from '../components/common/Footer'

function InnerApp() {
  const { connected, account } = useWallet()
  const { pathname } = useLocation()
  const { config } = useEnvironment()
  const canopyMeta = useAppSelector(selectLoadedCanopyMeta)
  console.log('LOADED CANOPY META', canopyMeta)
  const canopyMetaLoadedOnce = useAppSelector(selectCanopyMetaLoadedOnce)
  const globalTokensLoadedOnce = useAppSelector(selectGlobalMetaLoadedOnce)
  const globalMeta = useAppSelector(selectLoadedGlobalMeta)
  const liquidswapVaultAddresses = useAppSelector(selectLiquidswapVaultAddresses)
  const vaultAddressToPoolsFromUnifiedVaults = useAppSelector(selectAllVaultAddressToPools)

  const { isConnected: evmConnected, address: evmAddress } = useAppKitAccount()
  const linkWalletsSuccess = useAppSelector(selectLinkWalletsSuccess)
  const claimAddressGlobal = useAppSelector(selectClaimAddressGlobal)
  const claimAddressSingleAsset = useAppSelector(selectClaimAddressSingleAsset)
  const claimAdressGlobalMatch = claimAddressGlobal === account?.address
  const claimAdressSingleAssetMatch = claimAddressSingleAsset === account?.address
  const bothAddressesMatch = claimAdressGlobalMatch && claimAdressSingleAssetMatch
  const vaults = useAppSelector(selectUnifiedVaults)
  const poolInfos = useAppSelector(selectPoolInfo)
  const aptos = useAptos()
  const aptosLongCache = useAptosLongCache()
  const satayVaultsLoadedOnce = useAppSelector(selectSatayVaultsLoaded)
  const sataySharesAddressList = useAppSelector(selectSharesAddressListFromVaults)
  const liquidVaultsLoadedOnce = useAppSelector(selectLiquidVaultsLoaded)
  const allVaultsLoadedOnce = config.liquidswapEnabled
    ? satayVaultsLoadedOnce && liquidVaultsLoadedOnce
    : satayVaultsLoadedOnce
  const poolInfosLoadedOnce = useAppSelector(selectPoolInfoLoaded)
  const poolInfosLoading = useAppSelector(selectPoolInfoBusy)
  const liquidswapTokenDataIds = useAppSelector(selectLiquidswapTokenDataIds)
  const activeVault = useAppSelector(selectActiveVault)
  const accountResources = useAppSelector(selectAccountResources)

  const splash = pathname === '/'

  //v1 wallet fetch all resources for legacy coin balances and Token Store
  useEffect(() => {
    if (connected && account?.address && !isEmptyOrNil(globalMeta) && globalTokensLoadedOnce) {
      const simulatedMovementAddress = "0xbee7f0e5192c31d6fd4c90c83d567230ee23cbc2f10138a89c231e40c05bee13"
      dispatch(fetchAccountResources({ address: simulatedMovementAddress, aptos }))
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [connected, account?.address, globalMeta, globalTokensLoadedOnce])

  //v2 FA token wallet balances
  useEffect(() => {
    if (connected && account?.address && !isEmptyOrNil(globalMeta) && globalTokensLoadedOnce) {
      const simulatedMovementAddress = "0xbee7f0e5192c31d6fd4c90c83d567230ee23cbc2f10138a89c231e40c05bee13"
      dispatch(
        fetchV2Balances({
          address: simulatedMovementAddress,
          aptos,
          globalMeta
        })
      )
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [connected, account?.address, globalMeta, globalTokensLoadedOnce])

  //v2 FA token balances for satay vaults only (not staked)
  useEffect(() => {
    if (
      connected &&
      account?.address &&
      satayVaultsLoadedOnce &&
      canopyMetaLoadedOnce &&
      globalTokensLoadedOnce
    ) {
      const simulatedMovementAddress = "0xbee7f0e5192c31d6fd4c90c83d567230ee23cbc2f10138a89c231e40c05bee13"
      dispatch(
        fetchSatayBalances({
          userAddress: simulatedMovementAddress,
          sharesAddressList: sataySharesAddressList,
          aptos
        })
      )
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [
    connected,
    account?.address,
    satayVaultsLoadedOnce,
    canopyMetaLoadedOnce,
    globalTokensLoadedOnce
  ])

  //fetch liquidswap vaults data
  useEffect(() => {
    if (
      liquidswapVaultAddresses.length > 0 &&
      config.liquidswapEnabled &&
      canopyMetaLoadedOnce &&
      globalTokensLoadedOnce
    ) {
      dispatch(
        fetchLiquidVaults({
          aptos: aptosLongCache,
          canopyMeta,
          globalMeta,
          liquidswapVaultAddresses,
          config
        })
      )
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [
    liquidswapVaultAddresses,
    config.liquidswapEnabled,
    canopyMetaLoadedOnce,
    globalTokensLoadedOnce
  ])

  //fetch ICHI LP balances (not staked)
  useEffect(() => {
    if (
      liquidswapTokenDataIds.length > 0 &&
      liquidVaultsLoadedOnce &&
      account?.address &&
      !isEmptyOrNil(accountResources)
    ) {
      const simulatedMovementAddress = "0xbee7f0e5192c31d6fd4c90c83d567230ee23cbc2f10138a89c231e40c05bee13"
      dispatch(
        fetchIchiLPs({
          address: simulatedMovementAddress,
          aptos: aptosLongCache,
          tokenDataIds: liquidswapTokenDataIds,
          accountResources
        })
      )
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [liquidswapTokenDataIds, liquidVaultsLoadedOnce, account?.address, accountResources])

  //fetch rewards tokens and staking tokens for all pools
  //UI is built to use only one reward token per pool for MVP
  useEffect(() => {
    const hasVaultAddressToPools = !isEmptyOrNil(vaultAddressToPoolsFromUnifiedVaults)
    const hasAllVaultsLoaded = allVaultsLoadedOnce
    if (hasVaultAddressToPools && hasAllVaultsLoaded && !poolInfosLoading && !poolInfosLoadedOnce) {
      dispatch(
        fetchPoolInfo({
          aptos: aptosLongCache,
          config,
          vaultAddressToPools: vaultAddressToPoolsFromUnifiedVaults,
          fetchedPoolInfos: poolInfos
        })
      )
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [vaultAddressToPoolsFromUnifiedVaults, config, allVaultsLoadedOnce, poolInfosLoading])

  //fetch staked balances and rewards balances for all pools
  useEffect(() => {
    if (poolInfos.length > 0 && account?.address && poolInfosLoadedOnce) {
      const simulatedMovementAddress = "0xbee7f0e5192c31d6fd4c90c83d567230ee23cbc2f10138a89c231e40c05bee13"
      if (config.stakeAddress) {
        dispatch(
          fetchStakedBalances({
            config,
            userAddress: simulatedMovementAddress,
            poolInfo: poolInfos,
            aptos
          })
        )
      }

      dispatch(
        fetchRewardsBalances({
          config,
          userAddress: simulatedMovementAddress,
          poolInfo: poolInfos,
          aptos
        })
      )
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [poolInfos, config, account?.address, poolInfosLoadedOnce])

  //fetch user claim addresses for Cornucopia OFT linking (initial fetch)
  useEffect(() => {
    if (evmConnected && evmAddress) {
      dispatch(fetchClaimAddresses({ config, ethAddress: evmAddress }))
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [evmConnected, evmAddress])

  //fetch user claim addresses for Cornucopia triggered by wallet linking event
  useEffect(() => {
    if (!linkWalletsSuccess) {
      return
    }

    if (bothAddressesMatch) {
      setLinkWalletsSuccessState(false)
    } else {
      if (evmConnected && evmAddress) {
        let retryCount = 0
        const maxRetries = 10
        const baseDelay = 3000

        const retryWithBackoff = () => {
          const delay = baseDelay * Math.pow(1.5, retryCount)
          setTimeout(() => {
            dispatch(fetchClaimAddresses({ config, ethAddress: evmAddress }))
            retryCount++

            if (retryCount < maxRetries && !bothAddressesMatch) {
              retryWithBackoff()
            }
          }, delay)
        }

        retryWithBackoff()
      }
    }
  }, [evmConnected, evmAddress, linkWalletsSuccess, bothAddressesMatch, config])

  //ensures active vault state is updated when new vault option is selected from dropdown
  useEffect(() => {
    if (activeVault) {
      const updatedVault = getVaultByVaultAddress(activeVault.vaultAddress, vaults)
      if (updatedVault && JSON.stringify(updatedVault) !== JSON.stringify(activeVault)) {
        setActiveVaultState(updatedVault)
      }
    }
  }, [activeVault, vaults])

  //takes in meta and formats into unified vaults for corn deployers
  useEffect(() => {
    if (canopyMetaLoadedOnce && globalTokensLoadedOnce) {
      dispatch(fetchCornDeployers({ aptos, config, canopyMeta, globalMeta, evmConnected }))
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [canopyMetaLoadedOnce, globalTokensLoadedOnce, evmConnected, canopyMeta, globalMeta])

  //takes in meta and formats into unified vaults for corn deployers
  useEffect(() => {
    console.log('FCB1')
    if (canopyMetaLoadedOnce && globalTokensLoadedOnce && evmConnected && evmAddress) {
      console.log('FCB2')
      const simulatedMovementAddress = "0xbee7f0e5192c31d6fd4c90c83d567230ee23cbc2f10138a89c231e40c05bee13"
      dispatch(fetchCornBalances({ 
        aptos, 
        config, 
        canopyMeta, 
        globalMeta, 
        ethAddress: evmAddress,
        accountAddress: simulatedMovementAddress
      }))
    }
  }, [
    canopyMetaLoadedOnce,
    globalTokensLoadedOnce,
    aptos,
    config,
    canopyMeta,
    globalMeta,
    evmConnected,
    evmAddress
  ])

  return (
    <>
      <ThemeProvider>
        {/* <Context.Provider value={{ context, setContext }}> */}
        <div id="App">
          <TopNav />
          <section className="section-wrapper">
            <div className="section">
              <Routing />
            </div>
          </section>
          <section className="section-wrapper">
            <div className="section no-height">
              <Footer />
            </div>
          </section>
        </div>
        <AppModals />

        <Toaster position="bottom-left" />
        {/* </Context.Provider> */}
        {!!splash && <div className="splash-bg" />}
        <div className="gradient-background">
          <div className="gradient-background-inner" />
        </div>
      </ThemeProvider>
    </>
  )
}

export default InnerApp