idquia/packages/core/src/update-balances.ts

Web3-Onboard makes it simple to connect Ethereum hardware and software wallets to your dapp. Features standardised spec compliant web3 providers for all supported wallets, framework agnostic modern javascript UI with code splitting, CSS customization, mul

import { state } from './store/index.js'
import { getBalance } from './provider.js'
import { updateAllWallets } from './store/actions.js'
import { ethers } from 'ethers'
import { AccountAddress, Chain, weiToEth } from '@web3-onboard/common'
import type { SecondaryTokenBalances, WalletState } from './types'

async function updateBalances(addresses?: string[]): Promise<void> {
  const { wallets, chains } = state.get()
  const updatedWallets = await Promise.all(
    wallets.map(async wallet => {
      const chain = chains.find(({ id }) => id === wallet.chains[0].id)

      const updatedAccounts = await Promise.all(
        wallet.accounts.map(async account => {
          const secondaryTokens = await updateSecondaryTokens(
            wallet,
            account.address,
            chain
          )
          // if no provided addresses, we want to update all balances
          // otherwise check if address is in addresses array
          if (
            !addresses ||
            addresses.some(
              address => address.toLowerCase() === account.address.toLowerCase()
            )
          ) {
            const updatedBalance = await getBalance(account.address, chain)
            return { ...account, balance: updatedBalance, secondaryTokens }
          }
          return { ...account, secondaryTokens }
        })
      )
      return { ...wallet, accounts: updatedAccounts }
    })
  )
  updateAllWallets(updatedWallets)
}

export const updateSecondaryTokens = async (
  wallet: WalletState,
  account: AccountAddress,
  chain: Chain
): Promise<SecondaryTokenBalances[]> => {
  if (!chain) return
  const chainRPC = chain.rpcUrl
  if (!chain.secondaryTokens || !chain.secondaryTokens.length || !chainRPC)
    return

  const ethersProvider = new ethers.providers.Web3Provider(
    wallet.provider,
    'any'
  )
  const signer = ethersProvider.getSigner()

  const erc20ABISubset = [
    {
      inputs: [{ name: 'owner', type: 'address' }],
      name: 'balanceOf',
      outputs: [{ name: '', type: 'uint256' }],
      stateMutability: 'view',
      type: 'function'
    },
    {
      inputs: [],
      name: 'symbol',
      outputs: [{ name: '', type: 'string' }],
      stateMutability: 'view',
      type: 'function'
    }
  ]

  const tokenBalances = await Promise.all(
    chain.secondaryTokens.map(async token => {
      try {
        const swapContract = new ethers.Contract(
          token.address,
          erc20ABISubset,
          signer
        )
        const bigNumBalance = await swapContract.balanceOf(account)
        const tokenName = await swapContract.symbol()
        return {
          name: tokenName,
          balance: weiToEth(bigNumBalance.toHexString()),
          icon: token.icon
        }
      } catch (error) {
        console.error(
          `There was an error fetching balance and/or symbol 
          for token contract: ${token.address} - ${error}`
        )
      }
    })
  )
  return tokenBalances
}

export default updateBalances