@avalabs/evm-module 0.0.22 → 0.1.0

package/src/handlers/forward-to-rpc-node/forward-to-rpc-node.ts

@@ -1,23 +0,0 @@
-import type { Network, RpcRequest } from '@avalabs/vm-module-types';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { getProvider } from '../../utils/get-provider';
-
-export const forwardToRpcNode = async (request: RpcRequest, network: Network) => {
-  try {
-    const provider = getProvider({
-      chainId: network.chainId,
-      chainName: network.chainName,
-      rpcUrl: network.rpcUrl,
-      multiContractAddress: network.utilityAddresses?.multicall,
-      pollingInterval: 1000,
-    });
-
-    const response = await provider.send(request.method, request.params as unknown[]);
-    return { result: response };
-  } catch (error) {
-    // extracting the error message based on the error object structure from ethers lib
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const message = (error as any).info?.error?.message || (error as any).error?.message || (error as Error).message;
-    return { error: rpcErrors.internal(message) };
-  }
-};

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

@@ -1,78 +0,0 @@
-import { BN } from 'bn.js';
-import { getErc20Balances } from './get-erc20-balances';
-import { ethers } from 'ethers';
-import { TokenType } from '@avalabs/vm-module-types';
-
-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',
-          type: TokenType.ERC20,
-        },
-      ],
-      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,
-        type: 'ERC20',
-        change24: 0,
-        marketCap: 0,
-        vol24: 0,
-      },
-    });
-  });
-});

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

@@ -1,85 +0,0 @@
-import { numberToBN, bnToBig, balanceToDisplayValue } from '@avalabs/utils-sdk';
-import { TokenType, type ERC20Token, type Network, 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';
-
-export const getErc20Balances = async ({
-  provider,
-  tokenService,
-  address: userAddress,
-  currency,
-  tokens,
-  network,
-}: {
-  provider: Provider;
-  tokenService: TokenService;
-  address: string;
-  currency: string;
-  tokens: ERC20Token[];
-  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);
-
-      const tokenWithBalance = {
-        ...token,
-        balance,
-      };
-
-      return tokenWithBalance;
-    }),
-  ).then((res) => {
-    return res.reduce<(ERC20Token & { 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 ?? undefined;
-      const marketCap = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.marketCap ?? undefined;
-      const vol24 = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.vol24 ?? undefined;
-      const change24 = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.change24 ?? undefined;
-
-      const balanceInCurrency = priceInCurrency
-        ? bnToBig(token.balance, token.decimals).mul(priceInCurrency).toNumber()
-        : undefined;
-      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

@@ -1,97 +0,0 @@
-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: undefined,
-      balanceDisplayValue: '0',
-      coingeckoId: '123',
-      type: 'NATIVE',
-    });
-  });
-});

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

@@ -1,56 +0,0 @@
-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 ?? undefined;
-  const marketCap = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.marketCap ?? undefined;
-  const vol24 = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.vol24 ?? undefined;
-  const change24 = simplePriceResponse?.[coingeckoTokenId ?? '']?.[currency]?.change24 ?? undefined;
-
-  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 = priceInCurrency
-    ? bnToBig(balance, networkToken.decimals).mul(priceInCurrency).toNumber()
-    : undefined;
-  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

@@ -1,249 +0,0 @@
-import { NetworkVMType, 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,
-          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' },
-        vmName: NetworkVMType.EVM,
-      },
-      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,
-          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',
-              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,
-          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' },
-        vmName: NetworkVMType.EVM,
-      },
-      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,
-          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,
-        },
-      },
-    });
-  });
-});