@avalabs/evm-module 0.0.12 → 0.0.15

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;
+};

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

@@ -0,0 +1,76 @@
+import { BN } from 'bn.js';
+import { getErc20Balances } from './get-erc20-balances';
+import type { EvmGlacierService } from '../../../services/glacier-service/glacier-service';
+
+describe('get-erc20-balances', () => {
+  it('should return erc20 token balances', async () => {
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      listErc20Balances: jest.fn().mockResolvedValue({
+        erc20TokenBalances: [
+          {
+            address: '0x123',
+            name: 'Ethereum',
+            symbol: 'ETH',
+            decimals: 18,
+            logoUri: 'https://example.com/logo.png',
+            ercType: 'ERC20',
+            price: {
+              currency: 'USD',
+              value: 1000,
+            },
+            chainId: '123',
+            balance: '1000000000000000000',
+            balanceValue: {
+              currency: 'USD',
+              value: 1000,
+            },
+          },
+        ],
+      }),
+    };
+    const balance = getErc20Balances({
+      glacierService: mockGlacierService,
+      currency: 'USD',
+      chainId: 123,
+      address: '0x123',
+      customTokens: [],
+    });
+
+    expect(balance).resolves.toEqual({
+      '0x123': {
+        chainId: 123,
+        address: '0x123',
+        name: 'Ethereum',
+        symbol: 'ETH',
+        decimals: 18,
+        logoUri: 'https://example.com/logo.png',
+        balance: new BN('1000000000000000000'),
+        balanceCurrencyDisplayValue: '1000',
+        balanceDisplayValue: '1',
+        balanceInCurrency: 1000,
+        priceInCurrency: 1000,
+        contractType: 'ERC-20',
+        type: 'ERC20',
+        change24: 0,
+        marketCap: 0,
+        vol24: 0,
+      },
+    });
+  });
+
+  it('should return native token object without balance data', async () => {
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      listErc20Balances: jest.fn().mockRejectedValue(new Error('Failed to get erc20 balance')),
+    };
+    const balance = getErc20Balances({
+      glacierService: mockGlacierService,
+      currency: 'USD',
+      chainId: 123,
+      address: '0x123',
+      customTokens: [],
+    });
+    expect(balance).rejects.toEqual(new Error('Failed to get erc20 balance'));
+  });
+});

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

@@ -0,0 +1,107 @@
+import { balanceToDisplayValue, bnToBig } from '@avalabs/utils-sdk';
+import {
+  TokenType,
+  type TokenWithBalanceERC20,
+  type NetworkContractToken,
+  type TokenWithBalance,
+} from '@avalabs/vm-module-types';
+import { CurrencyCode, Erc20TokenBalance } from '@avalabs/glacier-sdk';
+import BN from 'bn.js';
+import type { EvmGlacierService } from '../../../services/glacier-service/glacier-service';
+
+export const getErc20Balances = async ({
+  glacierService,
+  currency,
+  chainId,
+  address,
+  customTokens,
+}: {
+  glacierService: EvmGlacierService;
+  address: string;
+  currency: string;
+  chainId: number;
+  customTokens: NetworkContractToken[];
+}): Promise<Record<string, TokenWithBalance>> => {
+  const tokensWithBalance: TokenWithBalanceERC20[] = [];
+  /**
+   *  Load all pages to make sure we have all the tokens with balances
+   */
+  let nextPageToken: string | undefined;
+  do {
+    const response = await glacierService.listErc20Balances({
+      chainId: chainId.toString(),
+      address,
+      currency: currency.toLocaleLowerCase() as CurrencyCode,
+      // glacier has a cap on page size of 100
+      pageSize: 100,
+      pageToken: nextPageToken,
+    });
+
+    tokensWithBalance.push(...convertErc20ToTokenWithBalance(response.erc20TokenBalances, Number(chainId)));
+    nextPageToken = response.nextPageToken;
+  } while (nextPageToken);
+
+  /**
+   * Glacier doesnt return tokens without balances so we need to polyfill that list
+   * from our own list of tokens. We just set the balance to 0, these zero balance
+   * tokens are only used for swap, bridge and tx parsing.
+   */
+  return [
+    ...convertNetworkTokenToTokenWithBalance(customTokens),
+    ...tokensWithBalance, // this needs to be second in the list so it overwrites its zero balance counterpart if there is one
+  ].reduce(
+    (acc, token) => {
+      return { ...acc, [token.address.toLowerCase()]: token };
+    },
+    {} as Record<string, TokenWithBalance>,
+  );
+};
+
+const convertNetworkTokenToTokenWithBalance = (tokens: NetworkContractToken[]): TokenWithBalanceERC20[] => {
+  return tokens.map((token) => {
+    return {
+      ...token,
+      type: TokenType.ERC20,
+      balance: new BN(0),
+      balanceInCurrency: 0,
+      balanceDisplayValue: '0',
+      balanceCurrencyDisplayValue: '0',
+      priceInCurrency: 0,
+      marketCap: 0,
+      change24: 0,
+      vol24: 0,
+    };
+  });
+};
+
+const convertErc20ToTokenWithBalance = (
+  tokenBalances: Erc20TokenBalance[],
+  chainId: number,
+): TokenWithBalanceERC20[] => {
+  return tokenBalances.map((token: Erc20TokenBalance): TokenWithBalanceERC20 => {
+    const balance = new BN(token.balance);
+    const balanceDisplayValue = balanceToDisplayValue(balance, token.decimals);
+    const balanceCurrencyDisplayValue = token.balanceValue?.value.toString() ?? '0';
+    const priceInCurrency = token.price?.value ?? 0;
+    const balanceInCurrency = bnToBig(balance, token.decimals).mul(priceInCurrency).toNumber();
+
+    return {
+      chainId,
+      address: token.address,
+      name: token.name,
+      symbol: token.symbol,
+      decimals: token.decimals,
+      logoUri: token.logoUri,
+      balance,
+      balanceCurrencyDisplayValue,
+      balanceDisplayValue,
+      balanceInCurrency,
+      priceInCurrency,
+      contractType: 'ERC-20',
+      type: TokenType.ERC20,
+      change24: 0,
+      marketCap: 0,
+      vol24: 0,
+    };
+  });
+};