@avalabs/evm-module 0.0.13 → 0.0.16

package/src/handlers/get-balances/evm-balance-service/get-erc20-balances.test.ts

@@ -0,0 +1,78 @@
+import { BN } from 'bn.js';
+import { getErc20Balances } from './get-erc20-balances';
+import { ethers } from 'ethers';
+
+describe('get-erc20-balances', () => {
+  it('should return erc20 token balances', async () => {
+    jest.spyOn(ethers, 'Contract').mockImplementation(() => {
+      return {
+        balanceOf: jest.fn().mockResolvedValue(new BN('1000000000000000000')),
+      } as never;
+    });
+
+    const balance = getErc20Balances({
+      tokens: [
+        {
+          address: '0x123',
+          name: 'Ethereum',
+          symbol: 'ETH',
+          decimals: 18,
+          logoUri: 'https://example.com/logo.png',
+          contractType: 'ERC-20',
+        },
+      ],
+      provider: {
+        getBalance: jest.fn().mockResolvedValue(new BN('1000000000000000000')),
+      } as never,
+      tokenService: {
+        getPricesByAddresses: jest.fn().mockResolvedValue({
+          '123': {
+            USD: {
+              price: 1000,
+              marketCap: 0,
+              vol24: 0,
+              change24: 0,
+            },
+          },
+        }),
+      } as never,
+      address: '0x123',
+      currency: 'USD',
+      network: {
+        pricingProviders: {
+          coingecko: {
+            nativeTokenId: '123',
+            assetPlatformId: '123',
+          },
+        },
+        networkToken: {
+          address: '0x123',
+          name: 'Ethereum',
+          symbol: 'ETH',
+          decimals: 18,
+          logoUri: 'https://example.com/logo.png',
+        },
+      } as never,
+    });
+
+    expect(balance).resolves.toEqual({
+      '0x123': {
+        address: '0x123',
+        name: 'Ethereum',
+        symbol: 'ETH',
+        decimals: 18,
+        logoUri: 'https://example.com/logo.png',
+        balance: new BN('1000000000000000000'),
+        balanceCurrencyDisplayValue: '1000.00',
+        balanceDisplayValue: '1',
+        balanceInCurrency: 1000,
+        priceInCurrency: 1000,
+        contractType: 'ERC-20',
+        type: 'ERC20',
+        change24: 0,
+        marketCap: 0,
+        vol24: 0,
+      },
+    });
+  });
+});

package/src/handlers/get-balances/evm-balance-service/get-erc20-balances.ts

@@ -0,0 +1,85 @@
+import { numberToBN, bnToBig, balanceToDisplayValue } from '@avalabs/utils-sdk';
+import { TokenType, type Network, type NetworkContractToken, type TokenWithBalance } from '@avalabs/vm-module-types';
+import { ethers, type Provider } from 'ethers';
+import ERC20 from '@openzeppelin/contracts/build/contracts/ERC20.json';
+import type { TokenService } from '@internal/utils';
+import { VsCurrencyType } from '@avalabs/coingecko-sdk';
+import BN from 'bn.js';
+
+const DEFAULT_DECIMALS = 18;
+
+export const getErc20Balances = async ({
+  provider,
+  tokenService,
+  address: userAddress,
+  currency,
+  tokens,
+  network,
+}: {
+  provider: Provider;
+  tokenService: TokenService;
+  address: string;
+  currency: string;
+  tokens: NetworkContractToken[];
+  network: Network;
+}): Promise<Record<string, TokenWithBalance>> => {
+  const coingeckoPlatformId = network.pricingProviders?.coingecko.assetPlatformId;
+  const coingeckoTokenId = network.pricingProviders?.coingecko.nativeTokenId;
+  const tokenAddresses = tokens.map((token) => token.address);
+
+  const tokensBalances = await Promise.allSettled(
+    tokens.map(async (token) => {
+      const contract = new ethers.Contract(token.address, ERC20.abi, provider);
+      const balanceBig = await contract.balanceOf?.(userAddress);
+      const balance = new BN(balanceBig) || numberToBN(0, token.decimals || DEFAULT_DECIMALS);
+
+      const tokenWithBalance = {
+        ...token,
+        balance,
+      };
+
+      return tokenWithBalance;
+    }),
+  ).then((res) => {
+    return res.reduce<(NetworkContractToken & { balance: BN })[]>((acc, result) => {
+      return result.status === 'fulfilled' && !result.value.balance.isZero() ? [...acc, result.value] : acc;
+    }, []);
+  });
+
+  if (!tokensBalances.length) return {};
+
+  const simplePriceResponse =
+    (coingeckoPlatformId &&
+      (await tokenService.getPricesByAddresses(tokenAddresses, coingeckoPlatformId, currency as VsCurrencyType))) ||
+    {};
+
+  return tokensBalances.reduce(
+    (acc, token) => {
+      const priceInCurrency = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.price ?? 0;
+      const marketCap = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.marketCap ?? 0;
+      const vol24 = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.vol24 ?? 0;
+      const change24 = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.change24 ?? 0;
+
+      const balanceInCurrency = bnToBig(token.balance, token.decimals).mul(priceInCurrency).toNumber();
+      const balanceDisplayValue = balanceToDisplayValue(token.balance, token.decimals);
+      const balanceCurrencyDisplayValue = balanceInCurrency.toFixed(2);
+
+      return {
+        ...acc,
+        [token.address.toLowerCase()]: {
+          ...token,
+          type: TokenType.ERC20,
+          balance: token.balance,
+          balanceDisplayValue,
+          balanceInCurrency,
+          balanceCurrencyDisplayValue,
+          priceInCurrency,
+          marketCap,
+          change24,
+          vol24,
+        },
+      };
+    },
+    {} as Record<string, TokenWithBalance>,
+  );
+};

package/src/handlers/get-balances/evm-balance-service/get-native-token-balances.test.ts

@@ -0,0 +1,102 @@
+import { BN } from 'bn.js';
+import { getNativeTokenBalances } from './get-native-token-balances';
+
+describe('get-native-token-balances', () => {
+  it('should return native token balances', async () => {
+    const balance = getNativeTokenBalances({
+      provider: {
+        getBalance: jest.fn().mockResolvedValue(new BN('1000000000000000000')),
+      } as never,
+      tokenService: {
+        getSimplePrice: jest.fn().mockResolvedValue({
+          '123': {
+            USD: {
+              price: 1000,
+              marketCap: 0,
+              vol24: 0,
+              change24: 0,
+            },
+          },
+        }),
+      } as never,
+      address: '0x123',
+      currency: 'USD',
+      network: {
+        pricingProviders: {
+          coingecko: {
+            nativeTokenId: '123',
+          },
+        },
+        networkToken: {
+          address: '0x123',
+          name: 'Ethereum',
+          symbol: 'ETH',
+          decimals: 18,
+          logoUri: 'https://example.com/logo.png',
+        },
+      } as never,
+    });
+
+    expect(balance).resolves.toEqual({
+      address: '0x123',
+      name: 'Ethereum',
+      symbol: 'ETH',
+      decimals: 18,
+      logoUri: 'https://example.com/logo.png',
+      balance: new BN('1000000000000000000'),
+      balanceCurrencyDisplayValue: '1000.00',
+      balanceDisplayValue: '1',
+      balanceInCurrency: 1000,
+      priceInCurrency: 1000,
+      coingeckoId: '123',
+      type: 'NATIVE',
+      marketCap: 0,
+      vol24: 0,
+      change24: 0,
+    });
+  });
+
+  it('should return native token object without balance data', async () => {
+    const balance = getNativeTokenBalances({
+      provider: {
+        getBalance: jest.fn().mockResolvedValue(new BN('0')),
+      } as never,
+      tokenService: {
+        getSimplePrice: jest.fn().mockResolvedValue({}),
+      } as never,
+      address: '0x123',
+      currency: 'USD',
+      network: {
+        pricingProviders: {
+          coingecko: {
+            nativeTokenId: '123',
+          },
+        },
+        networkToken: {
+          address: '0x123',
+          name: 'Ethereum',
+          symbol: 'ETH',
+          decimals: 18,
+          logoUri: 'https://example.com/logo.png',
+        },
+      } as never,
+    });
+    expect(balance).resolves.toEqual({
+      address: '0x123',
+      name: 'Ethereum',
+      symbol: 'ETH',
+      decimals: 18,
+      logoUri: 'https://example.com/logo.png',
+      balance: new BN('0'),
+      balanceCurrencyDisplayValue: '0.00',
+      balanceDisplayValue: '0',
+      balanceInCurrency: 0,
+      priceInCurrency: 0,
+      coingeckoId: '123',
+      type: 'NATIVE',
+      marketCap: 0,
+      vol24: 0,
+      change24: 0,
+    });
+  });
+});

package/src/handlers/get-balances/evm-balance-service/get-native-token-balances.ts

@@ -0,0 +1,54 @@
+import { balanceToDisplayValue, bigToBN, bigintToBig, bnToBig } from '@avalabs/utils-sdk';
+import { TokenType, type Network, type NetworkTokenWithBalance } from '@avalabs/vm-module-types';
+import type { VsCurrencyType } from '@avalabs/coingecko-sdk';
+import { TokenService } from '@internal/utils';
+import type { Provider } from 'ethers';
+
+export const getNativeTokenBalances = async ({
+  provider,
+  tokenService,
+  address,
+  currency,
+  network,
+}: {
+  provider: Provider;
+  tokenService: TokenService;
+  address: string;
+  currency: string;
+  network: Network;
+}): Promise<NetworkTokenWithBalance> => {
+  const coingeckoTokenId = network.pricingProviders?.coingecko.nativeTokenId;
+  const networkToken = network.networkToken;
+  const simplePriceResponse = coingeckoTokenId
+    ? await tokenService.getSimplePrice({
+        coinIds: [coingeckoTokenId],
+        currencies: [currency] as VsCurrencyType[],
+      })
+    : {};
+
+  const priceInCurrency = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.price ?? 0;
+  const marketCap = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.marketCap ?? 0;
+  const vol24 = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.vol24 ?? 0;
+  const change24 = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.change24 ?? 0;
+
+  const balanceBigint = await provider.getBalance(address);
+  const balaceBig = bigintToBig(balanceBigint, networkToken.decimals);
+  const balance = bigToBN(balaceBig, networkToken.decimals);
+  const balanceDisplayValue = balanceToDisplayValue(balance, networkToken.decimals);
+  const balanceInCurrency = bnToBig(balance, networkToken.decimals).mul(priceInCurrency).toNumber();
+  const balanceCurrencyDisplayValue = balanceInCurrency.toFixed(2);
+
+  return {
+    ...networkToken,
+    coingeckoId: coingeckoTokenId ?? '',
+    type: TokenType.NATIVE,
+    balance,
+    balanceDisplayValue,
+    balanceInCurrency,
+    balanceCurrencyDisplayValue,
+    priceInCurrency,
+    marketCap,
+    vol24,
+    change24,
+  };
+};

package/src/handlers/get-balances/get-balances.test.ts

@@ -0,0 +1,252 @@
+import { TokenType } from '@avalabs/vm-module-types';
+import { getBalances } from './get-balances';
+import * as GlacierNativeToken from './glacier-balance-service/get-native-token-balances';
+import { BN } from 'bn.js';
+import * as GlacierERC20Token from './glacier-balance-service/get-erc20-balances';
+import * as EvmNativeToken from './evm-balance-service/get-native-token-balances';
+import * as EvmERC20Token from './evm-balance-service/get-erc20-balances';
+import type { EvmGlacierService } from '../../services/glacier-service/glacier-service';
+
+describe('get-balances', () => {
+  it('should get balances from glacier', async () => {
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      isNetworkSupported: () => true,
+      isHealthy: () => true,
+    };
+    jest.spyOn(GlacierNativeToken, 'getNativeTokenBalances').mockImplementationOnce(async () => {
+      return {
+        name: 'Ether',
+        symbol: 'ETH',
+        decimals: 18,
+        type: TokenType.NATIVE,
+        logoUri:
+          'https://images.ctfassets.net/gcj8jwzm6086/6l56QLVZmvacuBfjHBTThP/791d743dd2c526692562780c2325fedf/eth-circle__1_.svg',
+        balance: new BN(1),
+        balanceDisplayValue: '1',
+        balanceInCurrency: 1,
+        balanceCurrencyDisplayValue: '1',
+        priceInCurrency: 1,
+        marketCap: 0,
+        vol24: 0,
+        change24: 0,
+        coingeckoId: '',
+      };
+    });
+
+    jest.spyOn(GlacierERC20Token, 'getErc20Balances').mockImplementationOnce(async () => {
+      return {
+        '0x123': {
+          chainId: 1,
+          address: '0x123',
+          name: 'DAI',
+          symbol: 'DAI',
+          decimals: 18,
+          logoUri: 'https://s3.us-east-2.amazonaws.com/nomics-api/static/images/currencies/dai.svg',
+          balance: new BN(1),
+          balanceCurrencyDisplayValue: '1',
+          balanceDisplayValue: '1',
+          balanceInCurrency: 1,
+          priceInCurrency: 1,
+          contractType: 'ERC-20',
+          type: TokenType.ERC20,
+          change24: 0,
+          marketCap: 0,
+          vol24: 0,
+        },
+      };
+    });
+    const balances = await getBalances({
+      addresses: ['0x123'],
+      currency: 'USD',
+      network: {
+        chainId: 1,
+        chainName: 'Ethereum',
+        isTestnet: false,
+        networkToken: {
+          name: 'Ether',
+          decimals: 18,
+          symbol: 'ETH',
+          description:
+            'Ether is used to pay for transaction fees and computational services on Etherum. Users can send Ether to other users, and developers can write smart contracts that receive, hold, and send Ether.',
+          logoUri:
+            'https://images.ctfassets.net/gcj8jwzm6086/6l56QLVZmvacuBfjHBTThP/791d743dd2c526692562780c2325fedf/eth-circle__1_.svg',
+        },
+        pricingProviders: { coingecko: { nativeTokenId: 'ethereum', assetPlatformId: 'ethereum' } },
+        rpcUrl: 'https://proxy-api.avax.network/proxy/infura/mainnet',
+        utilityAddresses: { multicall: '0x5ba1e12693dc8f9c48aad8770482f4739beed696' },
+      },
+      proxyApiUrl: 'proxyApiUrl',
+      glacierService: mockGlacierService,
+    });
+    expect(balances).toEqual({
+      '0x123': {
+        '0x123': {
+          address: '0x123',
+          balance: new BN(1),
+          balanceCurrencyDisplayValue: '1',
+          balanceDisplayValue: '1',
+          balanceInCurrency: 1,
+          chainId: 1,
+          change24: 0,
+          contractType: 'ERC-20',
+          decimals: 18,
+          logoUri: 'https://s3.us-east-2.amazonaws.com/nomics-api/static/images/currencies/dai.svg',
+          marketCap: 0,
+          name: 'DAI',
+          priceInCurrency: 1,
+          symbol: 'DAI',
+          type: 'ERC20',
+          vol24: 0,
+        },
+        ETH: {
+          balance: new BN(1),
+          balanceCurrencyDisplayValue: '1',
+          balanceDisplayValue: '1',
+          balanceInCurrency: 1,
+          change24: 0,
+          coingeckoId: '',
+          decimals: 18,
+          logoUri:
+            'https://images.ctfassets.net/gcj8jwzm6086/6l56QLVZmvacuBfjHBTThP/791d743dd2c526692562780c2325fedf/eth-circle__1_.svg',
+          marketCap: 0,
+          name: 'Ether',
+          priceInCurrency: 1,
+          symbol: 'ETH',
+          type: 'NATIVE',
+          vol24: 0,
+        },
+      },
+    });
+  });
+
+  it('should get balances from evm', async () => {
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      isNetworkSupported: () => false,
+      isHealthy: () => false,
+    };
+    global.fetch = jest.fn(() =>
+      Promise.resolve({
+        ok: true,
+        json: () =>
+          Promise.resolve([
+            {
+              chainId: 2,
+              address: '0x456',
+              name: 'DAI2',
+              symbol: 'DAI2',
+              decimals: 18,
+              logoUri: 'https://s3.us-east-2.amazonaws.com/nomics-api/static/images/currencies/dai.svg',
+              contractType: 'ERC-20',
+              type: TokenType.ERC20,
+            },
+          ]),
+      }),
+    ) as jest.Mock;
+    jest.spyOn(EvmNativeToken, 'getNativeTokenBalances').mockImplementationOnce(async () => {
+      return {
+        name: 'Ether2',
+        symbol: 'ETH2',
+        decimals: 18,
+        type: TokenType.NATIVE,
+        logoUri:
+          'https://images.ctfassets.net/gcj8jwzm6086/6l56QLVZmvacuBfjHBTThP/791d743dd2c526692562780c2325fedf/eth-circle__1_.svg',
+        balance: new BN(1),
+        balanceDisplayValue: '1',
+        balanceInCurrency: 1,
+        balanceCurrencyDisplayValue: '1',
+        priceInCurrency: 1,
+        marketCap: 0,
+        vol24: 0,
+        change24: 0,
+        coingeckoId: '',
+      };
+    });
+
+    jest.spyOn(EvmERC20Token, 'getErc20Balances').mockImplementationOnce(async () => {
+      return {
+        '0x456': {
+          chainId: 2,
+          address: '0x456',
+          name: 'DAI2',
+          symbol: 'DAI2',
+          decimals: 18,
+          logoUri: 'https://s3.us-east-2.amazonaws.com/nomics-api/static/images/currencies/dai.svg',
+          balance: new BN(1),
+          balanceCurrencyDisplayValue: '1',
+          balanceDisplayValue: '1',
+          balanceInCurrency: 1,
+          priceInCurrency: 1,
+          contractType: 'ERC-20',
+          type: TokenType.ERC20,
+          change24: 0,
+          marketCap: 0,
+          vol24: 0,
+        },
+      };
+    });
+    const balances = await getBalances({
+      addresses: ['0x456'],
+      currency: 'USD',
+      network: {
+        chainId: 2,
+        chainName: '2',
+        isTestnet: false,
+        networkToken: {
+          name: 'Ether2',
+          decimals: 18,
+          symbol: 'ETH2',
+          description:
+            'Ether is used to pay for transaction fees and computational services on Etherum. Users can send Ether to other users, and developers can write smart contracts that receive, hold, and send Ether.',
+          logoUri:
+            'https://images.ctfassets.net/gcj8jwzm6086/6l56QLVZmvacuBfjHBTThP/791d743dd2c526692562780c2325fedf/eth-circle__1_.svg',
+        },
+        pricingProviders: { coingecko: { nativeTokenId: 'ethereum', assetPlatformId: 'ethereum' } },
+        rpcUrl: 'https://proxy-api.avax.network/proxy/infura/mainnet',
+        utilityAddresses: { multicall: '0x5ba1e12693dc8f9c48aad8770482f4739beed696' },
+      },
+      proxyApiUrl: 'proxyApiUrl',
+      glacierService: mockGlacierService,
+    });
+    expect(balances).toEqual({
+      '0x456': {
+        '0x456': {
+          address: '0x456',
+          balance: new BN(1),
+          balanceCurrencyDisplayValue: '1',
+          balanceDisplayValue: '1',
+          balanceInCurrency: 1,
+          chainId: 2,
+          change24: 0,
+          contractType: 'ERC-20',
+          decimals: 18,
+          logoUri: 'https://s3.us-east-2.amazonaws.com/nomics-api/static/images/currencies/dai.svg',
+          marketCap: 0,
+          name: 'DAI2',
+          priceInCurrency: 1,
+          symbol: 'DAI2',
+          type: 'ERC20',
+          vol24: 0,
+        },
+        ETH2: {
+          balance: new BN(1),
+          balanceCurrencyDisplayValue: '1',
+          balanceDisplayValue: '1',
+          balanceInCurrency: 1,
+          change24: 0,
+          coingeckoId: '',
+          decimals: 18,
+          logoUri:
+            'https://images.ctfassets.net/gcj8jwzm6086/6l56QLVZmvacuBfjHBTThP/791d743dd2c526692562780c2325fedf/eth-circle__1_.svg',
+          marketCap: 0,
+          name: 'Ether2',
+          priceInCurrency: 1,
+          symbol: 'ETH2',
+          type: 'NATIVE',
+          vol24: 0,
+        },
+      },
+    });
+  });
+});

package/src/handlers/get-balances/get-balances.ts

@@ -0,0 +1,109 @@
+import type { GetBalancesResponse, GetBalancesParams, Storage } from '@avalabs/vm-module-types';
+import { getErc20Balances } from './evm-balance-service/get-erc20-balances';
+import { TokenService } from '@internal/utils';
+import { getProvider } from '../../utils/get-provider';
+import { getTokens } from '../get-tokens/get-tokens';
+import { getNativeTokenBalances } from './evm-balance-service/get-native-token-balances';
+import { getNativeTokenBalances as getNativeTokenBalancesFromGlacier } from './glacier-balance-service/get-native-token-balances';
+import { getErc20Balances as getErc20BalancesFromGlacier } from './glacier-balance-service/get-erc20-balances';
+import type { EvmGlacierService } from '../../services/glacier-service/glacier-service';
+
+export const getBalances = async ({
+  addresses,
+  currency,
+  network,
+  proxyApiUrl,
+  customTokens = [],
+  storage,
+  glacierService,
+}: GetBalancesParams & {
+  proxyApiUrl: string;
+  glacierService: EvmGlacierService;
+  storage?: Storage;
+}): Promise<GetBalancesResponse> => {
+  const chainId = network.chainId;
+  const isNetworkSupported = await glacierService.isNetworkSupported(network.chainId);
+  const isHealthy = glacierService.isHealthy();
+
+  let balances = [];
+  if (isHealthy && isNetworkSupported) {
+    balances = await Promise.allSettled(
+      addresses.map(async (address) => {
+        const nativeToken = await getNativeTokenBalancesFromGlacier({
+          address,
+          currency,
+          chainId,
+          glacierService,
+        });
+
+        const erc20Tokens = await getErc20BalancesFromGlacier({
+          customTokens,
+          glacierService,
+          currency,
+          chainId,
+          address,
+        });
+
+        return {
+          address,
+          balances: {
+            [nativeToken.symbol]: nativeToken,
+            ...erc20Tokens,
+          },
+        };
+      }),
+    );
+  } else {
+    const tokenService = new TokenService({ storage, proxyApiUrl });
+    const tokens = await getTokens({ chainId: Number(chainId), proxyApiUrl });
+    const allTokens = [...tokens, ...customTokens];
+    const provider = getProvider({
+      chainId,
+      chainName: network.chainName,
+      rpcUrl: network.rpcUrl,
+      multiContractAddress: network.utilityAddresses?.multicall,
+    });
+
+    balances = await Promise.allSettled(
+      addresses.map(async (address) => {
+        const nativeToken = await getNativeTokenBalances({
+          network,
+          tokenService,
+          address,
+          currency,
+          provider,
+        });
+
+        const erc20Tokens = await getErc20Balances({
+          provider,
+          network,
+          tokenService,
+          address,
+          currency,
+          tokens: allTokens,
+        });
+
+        return {
+          address,
+          balances: {
+            [nativeToken.symbol]: nativeToken,
+            ...erc20Tokens,
+          },
+        };
+      }),
+    );
+  }
+
+  const filterBalances = balances.reduce((acc, result) => {
+    if (result.status === 'rejected') {
+      return acc;
+    }
+
+    return {
+      ...acc,
+      [result.value.address]: result.value.balances,
+    };
+  }, {} as GetBalancesResponse);
+
+  return filterBalances;
+};