@avalabs/evm-module 0.0.23 → 0.1.1

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

@@ -1,123 +0,0 @@
-import {
-  type GetBalancesParams,
-  type Storage,
-  TokenType,
-  type NetworkContractToken,
-  type ERC20Token,
-  type TokenWithBalanceEVM,
-} 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';
-
-type GetEvmBalancesResponse = Record<string, Record<string, TokenWithBalanceEVM>>;
-
-export const getBalances = async ({
-  addresses,
-  currency,
-  network,
-  proxyApiUrl,
-  customTokens = [],
-  storage,
-  glacierService,
-}: GetBalancesParams & {
-  proxyApiUrl: string;
-  glacierService: EvmGlacierService;
-  storage?: Storage;
-}): Promise<GetEvmBalancesResponse> => {
-  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,
-          coingeckoId: network.pricingProviders?.coingecko.nativeTokenId ?? '',
-        });
-
-        const erc20Tokens = await getErc20BalancesFromGlacier({
-          customTokens: customTokens.filter(isERC20Token),
-          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.filter(isERC20Token),
-        });
-
-        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 GetEvmBalancesResponse);
-
-  return filterBalances;
-};
-
-function isERC20Token(token: NetworkContractToken): token is ERC20Token {
-  return token.type === TokenType.ERC20;
-}

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

@@ -1,71 +0,0 @@
-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: 1000000000000000000n,
-        balanceCurrencyDisplayValue: '1000',
-        balanceDisplayValue: '1',
-        balanceInCurrency: 1000,
-        priceInCurrency: 1000,
-        type: 'ERC20',
-      },
-    });
-  });
-
-  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

@@ -1,106 +0,0 @@
-import { TokenUnit } from '@avalabs/utils-sdk';
-import {
-  type ERC20Token,
-  TokenType,
-  type TokenWithBalanceEVM,
-  type TokenWithBalanceERC20,
-} from '@avalabs/vm-module-types';
-import { CurrencyCode, Erc20TokenBalance } from '@avalabs/glacier-sdk';
-import type { EvmGlacierService } from '../../../services/glacier-service/glacier-service';
-import { DEFAULT_DECIMALS } from '../../../constants';
-
-export const getErc20Balances = async ({
-  glacierService,
-  currency,
-  chainId,
-  address,
-  customTokens,
-}: {
-  glacierService: EvmGlacierService;
-  address: string;
-  currency: string;
-  chainId: number;
-  customTokens: ERC20Token[];
-}): Promise<Record<string, TokenWithBalanceEVM>> => {
-  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(
-      ...convertErc20TokenWithBalanceToTokenWithBalance(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 [
-    ...convertErc20TokenToTokenWithBalance(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, TokenWithBalanceEVM>,
-  );
-};
-
-const convertErc20TokenToTokenWithBalance = (tokens: ERC20Token[]): TokenWithBalanceERC20[] => {
-  return tokens.map((token) => {
-    return {
-      ...token,
-      decimals: token.decimals ?? DEFAULT_DECIMALS,
-      type: TokenType.ERC20,
-      balance: 0n,
-      balanceInCurrency: 0,
-      balanceDisplayValue: '0',
-      balanceCurrencyDisplayValue: '0',
-      priceInCurrency: 0,
-      marketCap: 0,
-      change24: 0,
-      vol24: 0,
-    };
-  });
-};
-
-const convertErc20TokenWithBalanceToTokenWithBalance = (
-  tokenBalances: Erc20TokenBalance[],
-  chainId: number,
-): TokenWithBalanceERC20[] => {
-  return tokenBalances.map((token: Erc20TokenBalance): TokenWithBalanceERC20 => {
-    const balance = new TokenUnit(token.balance, token.decimals, token.symbol);
-    const balanceDisplayValue = balance.toDisplay();
-    const balanceCurrencyDisplayValue = token.balanceValue?.value.toString();
-    const priceInCurrency = token.price?.value;
-    const balanceInCurrency = priceInCurrency ? Number(balance.mul(priceInCurrency).toDisplay(2)) : undefined;
-
-    return {
-      chainId,
-      address: token.address,
-      name: token.name,
-      symbol: token.symbol,
-      decimals: token.decimals,
-      logoUri: token.logoUri,
-      balance: balance.toSubUnit(),
-      balanceCurrencyDisplayValue,
-      balanceDisplayValue,
-      balanceInCurrency,
-      priceInCurrency,
-      type: TokenType.ERC20,
-    };
-  });
-};

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

@@ -1,59 +0,0 @@
-import { getNativeTokenBalances } from './get-native-token-balances';
-import type { EvmGlacierService } from '../../../services/glacier-service/glacier-service';
-
-describe('get-native-token-balances', () => {
-  it('should return native token balances', async () => {
-    const mockGlacierService: EvmGlacierService = {
-      ...expect.any(Object),
-      getNativeBalance: jest.fn().mockResolvedValue({
-        nativeTokenBalance: {
-          balance: 1000000000000000000n,
-          decimals: 18,
-          name: 'Ethereum',
-          symbol: 'ETH',
-          price: {
-            value: 1000,
-          },
-          logoUri: 'https://example.com/logo.png',
-        },
-      }),
-    };
-
-    const balance = getNativeTokenBalances({
-      address: '0x123',
-      currency: 'USD',
-      chainId: 123,
-      glacierService: mockGlacierService,
-      coingeckoId: '',
-    });
-
-    expect(balance).resolves.toEqual({
-      name: 'Ethereum',
-      symbol: 'ETH',
-      decimals: 18,
-      type: 'NATIVE',
-      logoUri: 'https://example.com/logo.png',
-      balance: 1000000000000000000n,
-      balanceDisplayValue: '1',
-      balanceInCurrency: 1000,
-      balanceCurrencyDisplayValue: '1000.00',
-      priceInCurrency: 1000,
-      coingeckoId: '',
-    });
-  });
-
-  it('should return native token object without balance data', async () => {
-    const mockGlacierService: EvmGlacierService = {
-      ...expect.any(Object),
-      getNativeBalance: jest.fn().mockRejectedValue(new Error('Failed to get native balance')),
-    };
-    const balance = getNativeTokenBalances({
-      address: '0x123',
-      currency: 'USD',
-      chainId: 123,
-      glacierService: mockGlacierService,
-      coingeckoId: '',
-    });
-    expect(balance).rejects.toEqual(new Error('Failed to get native balance'));
-  });
-});

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

@@ -1,48 +0,0 @@
-import type { CurrencyCode } from '@avalabs/glacier-sdk';
-import { TokenType, type NetworkTokenWithBalance } from '@avalabs/vm-module-types';
-import { TokenUnit } from '@avalabs/utils-sdk';
-import type { EvmGlacierService } from '../../../services/glacier-service/glacier-service';
-
-export const getNativeTokenBalances = async ({
-  address,
-  currency,
-  chainId,
-  glacierService,
-  coingeckoId,
-}: {
-  chainId: number;
-  address: string;
-  currency: string;
-  coingeckoId: string;
-  glacierService: EvmGlacierService;
-}): Promise<NetworkTokenWithBalance> => {
-  const nativeBalance = await glacierService.getNativeBalance({
-    chainId: chainId.toString(),
-    address,
-    currency: currency.toLocaleLowerCase() as CurrencyCode,
-  });
-  const nativeTokenBalance = nativeBalance.nativeTokenBalance;
-  const balanceTokenUnit = new TokenUnit(
-    nativeTokenBalance.balance,
-    nativeTokenBalance.decimals,
-    nativeTokenBalance.symbol,
-  );
-  const balanceDisplayValue = balanceTokenUnit.toDisplay();
-  const priceInCurrency = nativeTokenBalance.price?.value;
-  const balanceCurrencyDisplayValue = priceInCurrency ? balanceTokenUnit.mul(priceInCurrency).toDisplay(2) : undefined;
-  const balanceInCurrency = balanceCurrencyDisplayValue ? Number(balanceCurrencyDisplayValue) : undefined;
-
-  return {
-    name: nativeTokenBalance.name,
-    symbol: nativeTokenBalance.symbol,
-    decimals: nativeTokenBalance.decimals,
-    type: TokenType.NATIVE,
-    logoUri: nativeTokenBalance.logoUri,
-    balance: balanceTokenUnit.toSubUnit(),
-    balanceDisplayValue,
-    balanceInCurrency,
-    balanceCurrencyDisplayValue,
-    priceInCurrency,
-    coingeckoId,
-  };
-};

package/src/handlers/get-network-fee/get-network-fee.test.ts

@@ -1,43 +0,0 @@
-import { getNetworkFee } from './get-network-fee';
-import { FeeData, JsonRpcProvider } from 'ethers';
-
-const params = {
-  chainId: 1,
-  chainName: 'Ethereum Mainnet',
-  rpcUrl: 'https://mainnet.infura.io/v3/1234567890',
-};
-
-describe('get-network-fee', () => {
-  it("should throw error if provider.getFeeData() doesn't return eip-1559 compatible fees", async () => {
-    jest.spyOn(JsonRpcProvider.prototype, 'getFeeData').mockImplementationOnce(async () => {
-      return {
-        maxFeePerGas: null,
-      } as FeeData;
-    });
-    await expect(getNetworkFee(params)).rejects.toThrow('Pre-EIP-1559 networks are not supported');
-  });
-
-  it('should return correct network fees based on maxFeePerGas returned from provider.getFeeData', async () => {
-    jest.spyOn(JsonRpcProvider.prototype, 'getFeeData').mockImplementationOnce(async () => {
-      return {
-        maxFeePerGas: 1000000000n, //1 gWei
-      } as FeeData;
-    });
-    await expect(getNetworkFee(params)).resolves.toEqual({
-      baseFee: 1000000000n,
-      low: {
-        maxFeePerGas: 1500000000n,
-        maxPriorityFeePerGas: 500000000n,
-      },
-      medium: {
-        maxFeePerGas: 3000000000n,
-        maxPriorityFeePerGas: 2000000000n,
-      },
-      high: {
-        maxFeePerGas: 4000000000n,
-        maxPriorityFeePerGas: 3000000000n,
-      },
-      isFixedFee: false,
-    });
-  });
-});

package/src/handlers/get-network-fee/get-network-fee.ts

@@ -1,59 +0,0 @@
-import type { NetworkFees } from '@avalabs/vm-module-types';
-import { getProvider } from '../../utils/get-provider';
-import { rpcErrors } from '@metamask/rpc-errors';
-
-const DEFAULT_PRESETS = {
-  LOW: 1n,
-  MEDIUM: 4n,
-  HIGH: 6n,
-};
-
-const BASE_PRIORITY_FEE_WEI = 500000000n; //0.5 GWei
-
-/**
- * Returns {@link NetworkFees} based on {@link DEFAULT_PRESETS} multipliers.
- * @throws Error if provider does not support eip-1559
- */
-export async function getNetworkFee({
-  chainId,
-  chainName,
-  rpcUrl,
-  multiContractAddress,
-}: {
-  chainId: number;
-  chainName: string;
-  rpcUrl: string;
-  multiContractAddress?: string;
-}): Promise<NetworkFees> {
-  const provider = getProvider({
-    chainId,
-    chainName,
-    rpcUrl,
-    multiContractAddress,
-  });
-
-  const { maxFeePerGas: maxFeePerGasInWei } = await provider.getFeeData();
-  if (!maxFeePerGasInWei) {
-    throw rpcErrors.internal('Pre-EIP-1559 networks are not supported');
-  }
-
-  const lowMaxTip = BASE_PRIORITY_FEE_WEI * DEFAULT_PRESETS.LOW;
-  const mediumMaxTip = BASE_PRIORITY_FEE_WEI * DEFAULT_PRESETS.MEDIUM;
-  const highMaxTip = BASE_PRIORITY_FEE_WEI * DEFAULT_PRESETS.HIGH;
-  return {
-    baseFee: maxFeePerGasInWei,
-    low: {
-      maxFeePerGas: maxFeePerGasInWei + lowMaxTip,
-      maxPriorityFeePerGas: lowMaxTip,
-    },
-    medium: {
-      maxFeePerGas: maxFeePerGasInWei + mediumMaxTip,
-      maxPriorityFeePerGas: mediumMaxTip,
-    },
-    high: {
-      maxFeePerGas: maxFeePerGasInWei + highMaxTip,
-      maxPriorityFeePerGas: highMaxTip,
-    },
-    isFixedFee: false,
-  };
-}

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

@@ -1,100 +0,0 @@
-import { getTokens } from './get-tokens';
-
-const PROXY_API_URL = 'https://proxy-api.avax.network';
-
-global.fetch = jest.fn();
-
-describe('get-tokens', () => {
-  beforeAll(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should return an empty array if chain id is not for a valid network', async () => {
-    (global.fetch as jest.Mock).mockResolvedValueOnce({
-      ok: true,
-      json: async () => [],
-    });
-
-    const result = await getTokens({ chainId: 0, proxyApiUrl: PROXY_API_URL });
-
-    expect(result).toEqual([]);
-  });
-
-  it('should return correct contract tokens for Avalanche C-Chain', async () => {
-    (global.fetch as jest.Mock).mockResolvedValueOnce({
-      ok: true,
-      json: async () => [
-        {
-          address: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7',
-          name: 'Wrapped AVAX',
-          symbol: 'WAVAX',
-          type: 'ERC20',
-          chainId: 43114,
-          decimals: 18,
-        },
-        {
-          address: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
-          name: 'USD Coin',
-          symbol: 'USDC',
-          type: 'ERC20',
-          chainId: 43114,
-          decimals: 6,
-        },
-      ],
-    });
-
-    const result = await getTokens({ chainId: 43114, proxyApiUrl: PROXY_API_URL });
-
-    expect(result.length).toBeGreaterThan(0);
-    expect(result.find((token) => token.symbol === 'WAVAX')).toBeDefined();
-    expect(result.find((token) => token.symbol === 'USDC')).toBeDefined();
-  });
-
-  it('should return correct contract tokens for Ethereum', async () => {
-    (global.fetch as jest.Mock).mockResolvedValueOnce({
-      ok: true,
-      json: async () => [
-        {
-          address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
-          name: 'Tether USD',
-          symbol: 'USDT',
-          type: 'ERC20',
-          chainId: 1,
-          decimals: 6,
-        },
-        {
-          address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
-          name: 'USDCoin',
-          symbol: 'USDC',
-          type: 'ERC20',
-          chainId: 1,
-          decimals: 6,
-        },
-        {
-          address: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
-          name: 'Wrapped BTC',
-          symbol: 'WBTC',
-          type: 'ERC20',
-          chainId: 1,
-          decimals: 8,
-        },
-        {
-          address: '0x514910771AF9Ca656af840dff83E8264EcF986CA',
-          name: 'ChainLink Token',
-          symbol: 'LINK',
-          type: 'ERC20',
-          chainId: 1,
-          decimals: 18,
-        },
-      ],
-    });
-
-    const result = await getTokens({ chainId: 1, proxyApiUrl: PROXY_API_URL });
-
-    expect(result.length).toBeGreaterThan(0);
-    expect(result.find((token) => token.symbol === 'USDT')).toBeDefined();
-    expect(result.find((token) => token.symbol === 'USDC')).toBeDefined();
-    expect(result.find((token) => token.symbol === 'WBTC')).toBeDefined();
-    expect(result.find((token) => token.symbol === 'LINK')).toBeDefined();
-  });
-});

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

@@ -1,18 +0,0 @@
-import type { NetworkContractToken } from '@avalabs/vm-module-types';
-import { rpcErrors } from '@metamask/rpc-errors';
-
-export async function getTokens({
-  chainId,
-  proxyApiUrl,
-}: {
-  chainId: number;
-  proxyApiUrl: string;
-}): Promise<NetworkContractToken[]> {
-  const response = await fetch(`${proxyApiUrl}/tokens?evmChainId=${chainId}`);
-
-  if (!response.ok) {
-    throw rpcErrors.internal(`Failed to fetch tokens for chainId ${chainId}`);
-  }
-
-  return response.json();
-}

package/src/handlers/get-transaction-history/converters/etherscan-transaction-converter/convert-transaction-erc20.test.ts

@@ -1,53 +0,0 @@
-import { TokenType, TransactionType } from '@avalabs/vm-module-types';
-import { convertTransactionERC20 } from './convert-transaction-erc20';
-import type { Erc20Tx } from '@avalabs/etherscan-sdk';
-
-describe('convertTransactionERC20 ', () => {
-  it('should correctly convert ERC20 transaction data', () => {
-    const tx = {
-      from: '0xSenderAddress',
-      to: '0xReceiverAddress',
-      timeStamp: '1625794800', // Unix timestamp in seconds
-      value: '1000000000000000000', // in wei
-      gasPrice: '20000000000', // in wei
-      gasUsed: '21000',
-      hash: '0xTransactionHash',
-      tokenDecimal: '18',
-      tokenName: 'MyToken',
-      tokenSymbol: 'MTK',
-    } as Erc20Tx;
-
-    const address = '0xSenderAddress';
-    const explorerUrl = 'https://explorer.example.com';
-    const chainId = 1;
-
-    const expected = {
-      isIncoming: false,
-      isOutgoing: true,
-      isContractCall: false,
-      timestamp: 1625794800000, // Converted timestamp in milliseconds
-      hash: '0xTransactionHash',
-      isSender: true,
-      from: '0xSenderAddress',
-      to: '0xReceiverAddress',
-      tokens: [
-        {
-          decimal: '18',
-          name: 'MyToken',
-          symbol: 'MTK',
-          type: TokenType.ERC20,
-          amount: '1',
-        },
-      ],
-      gasUsed: '21000',
-      gasPrice: '20000000000',
-      chainId: '1',
-      txType: TransactionType.SEND,
-      explorerLink: 'https://explorer.example.com/tx/0xTransactionHash', // Assuming this is how the explorer link is formatted
-    };
-
-    const result = convertTransactionERC20({ tx, address, explorerUrl, chainId });
-
-    expect(result).toEqual(expected);
-  });
-});