@avalabs/evm-module 0.0.13 → 0.0.16

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

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

@@ -0,0 +1,61 @@
+import { BN } from 'bn.js';
+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: new BN('1000000000000000000'),
+          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,
+    });
+
+    expect(balance).resolves.toEqual({
+      name: 'Ethereum',
+      symbol: 'ETH',
+      decimals: 18,
+      type: 'NATIVE',
+      logoUri: 'https://example.com/logo.png',
+      balance: new BN('1000000000000000000'),
+      balanceDisplayValue: '1',
+      balanceInCurrency: 1000,
+      balanceCurrencyDisplayValue: '1000.00',
+      priceInCurrency: 1000,
+      marketCap: 0,
+      vol24: 0,
+      change24: 0,
+      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,
+    });
+    expect(balance).rejects.toEqual(new Error('Failed to get native balance'));
+  });
+});

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

@@ -0,0 +1,46 @@
+import type { CurrencyCode } from '@avalabs/glacier-sdk';
+import { TokenType, type NetworkTokenWithBalance } from '@avalabs/vm-module-types';
+import { balanceToDisplayValue, bnToBig } from '@avalabs/utils-sdk';
+import { BN } from 'bn.js';
+import type { EvmGlacierService } from '../../../services/glacier-service/glacier-service';
+
+export const getNativeTokenBalances = async ({
+  address,
+  currency,
+  chainId,
+  glacierService,
+}: {
+  chainId: number;
+  address: string;
+  currency: string;
+  glacierService: EvmGlacierService;
+}): Promise<NetworkTokenWithBalance> => {
+  const nativeBalance = await glacierService.getNativeBalance({
+    chainId: chainId.toString(),
+    address,
+    currency: currency.toLocaleLowerCase() as CurrencyCode,
+  });
+  const nativeTokenBalance = nativeBalance.nativeTokenBalance;
+  const balance = new BN(nativeTokenBalance.balance);
+  const balanceDisplayValue = balanceToDisplayValue(balance, nativeTokenBalance.decimals);
+  const priceInCurrency = nativeTokenBalance.price?.value ?? 0;
+  const balanceInCurrency = bnToBig(balance, nativeTokenBalance.decimals).mul(priceInCurrency).toNumber();
+  const balanceCurrencyDisplayValue = balanceInCurrency.toFixed(2);
+
+  return {
+    name: nativeTokenBalance.name,
+    symbol: nativeTokenBalance.symbol,
+    decimals: nativeTokenBalance.decimals,
+    type: TokenType.NATIVE,
+    logoUri: nativeTokenBalance.logoUri,
+    balance,
+    balanceDisplayValue,
+    balanceInCurrency,
+    balanceCurrencyDisplayValue,
+    priceInCurrency,
+    marketCap: 0,
+    vol24: 0,
+    change24: 0,
+    coingeckoId: '',
+  };
+};

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

@@ -2,7 +2,6 @@ import { getNetworkFee } from './get-network-fee';
 import { FeeData, JsonRpcProvider } from 'ethers';
 
 const params = {
-  glacierApiUrl: 'https://glacier-api.avax.network',
   chainId: 1,
   chainName: 'Ethereum Mainnet',
   rpcUrl: 'https://mainnet.infura.io/v3/1234567890',

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

@@ -23,7 +23,6 @@ export async function getNetworkFee({
   chainId: number;
   chainName: string;
   rpcUrl: string;
-  glacierApiUrl: string;
   multiContractAddress?: string;
 }): Promise<NetworkFees> {
   const provider = getProvider({

package/src/handlers/get-transaction-history/converters/evm-transaction-converter/get-transaction-from-glacier.test.ts

@@ -1,5 +1,6 @@
 import type { ListTransactionDetailsResponse } from '@avalabs/glacier-sdk';
 import { getTransactionsFromGlacier } from './get-transactions-from-glacier';
+import { EvmGlacierService } from '../../../../services/glacier-service/glacier-service';
 
 const mockListTransactionDetailsResponse: ListTransactionDetailsResponse = {
   nextPageToken: 'nextPageToken',
@@ -29,43 +30,16 @@ const mockListTransactionDetailsResponse: ListTransactionDetailsResponse = {
   ],
 };
 
-const mockListTransactions = jest.fn();
-jest.mock('@avalabs/glacier-sdk', () => ({
-  Glacier: jest.fn(() => ({
-    evmTransactions: {
-      listTransactions: mockListTransactions,
-    },
-  })),
-}));
-
 describe('get-transactions-from-glacier', () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
-
-  it('should have returned error with missing glacier api url', async () => {
-    try {
-      await getTransactionsFromGlacier({
-        networkToken: {
-          name: 'networkToken',
-          symbol: 'networkToken',
-          decimals: 1,
-          description: 'description',
-          logoUri: 'logoUri',
-        },
-        explorerUrl: 'explorerUrl',
-        chainId: 1,
-        address: 'address',
-        nextPageToken: 'nextPageToken',
-        offset: 1,
-        glacierApiUrl: 'glacierApiUrl',
-      });
-    } catch (error) {
-      expect(error).toEqual(new Error('Glacier API URL is required'));
-    }
-  });
   it('should have returned empty response when listTransaction failed', async () => {
-    mockListTransactions.mockRejectedValue(new Error('failed to list transactions'));
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      listTransactions: jest.fn().mockRejectedValue(new Error('failed to list transactions')),
+      isHealthy: jest.fn().mockReturnValue(true),
+    };
     const result = await getTransactionsFromGlacier({
       networkToken: {
         name: 'networkToken',
@@ -79,7 +53,7 @@ describe('get-transactions-from-glacier', () => {
       address: 'address',
       nextPageToken: 'nextPageToken',
       offset: 1,
-      glacierApiUrl: 'glacierApiUrl',
+      glacierService: mockGlacierService,
     });
     expect(result).toEqual({
       transactions: [],
@@ -87,18 +61,22 @@ describe('get-transactions-from-glacier', () => {
     });
   });
   it('should have returned filtered response with no transaction status of 0', async () => {
-    mockListTransactions.mockResolvedValue({
-      ...mockListTransactionDetailsResponse,
-      transactions: [
-        {
-          ...mockListTransactionDetailsResponse.transactions[0],
-          nativeTransaction: {
-            ...mockListTransactionDetailsResponse.transactions[0]?.nativeTransaction,
-            txStatus: '0',
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      listTransactions: jest.fn().mockResolvedValue({
+        ...mockListTransactionDetailsResponse,
+        transactions: [
+          {
+            ...mockListTransactionDetailsResponse.transactions[0],
+            nativeTransaction: {
+              ...mockListTransactionDetailsResponse.transactions[0]?.nativeTransaction,
+              txStatus: '0',
+            },
           },
-        },
-      ],
-    });
+        ],
+      }),
+      isHealthy: jest.fn().mockReturnValue(true),
+    };
     const result = await getTransactionsFromGlacier({
       networkToken: {
         name: 'networkToken',
@@ -112,7 +90,7 @@ describe('get-transactions-from-glacier', () => {
       address: 'address',
       nextPageToken: 'nextPageToken',
       offset: 1,
-      glacierApiUrl: 'glacierApiUrl',
+      glacierService: mockGlacierService,
     });
     expect(result).toEqual({
       transactions: [],
@@ -120,18 +98,22 @@ describe('get-transactions-from-glacier', () => {
     });
   });
   it('should have returned filtered response without transaction with amount 0', async () => {
-    mockListTransactions.mockResolvedValue({
-      ...mockListTransactionDetailsResponse,
-      transactions: [
-        {
-          ...mockListTransactionDetailsResponse.transactions[0],
-          nativeTransaction: {
-            ...mockListTransactionDetailsResponse.transactions[0]?.nativeTransaction,
-            value: '0',
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      listTransactions: jest.fn().mockResolvedValue({
+        ...mockListTransactionDetailsResponse,
+        transactions: [
+          {
+            ...mockListTransactionDetailsResponse.transactions[0],
+            nativeTransaction: {
+              ...mockListTransactionDetailsResponse.transactions[0]?.nativeTransaction,
+              txStatus: '0',
+            },
           },
-        },
-      ],
-    });
+        ],
+      }),
+      isHealthy: jest.fn().mockReturnValue(true),
+    };
     const result = await getTransactionsFromGlacier({
       networkToken: {
         name: 'networkToken',
@@ -145,7 +127,7 @@ describe('get-transactions-from-glacier', () => {
       address: 'address',
       nextPageToken: 'nextPageToken',
       offset: 1,
-      glacierApiUrl: 'glacierApiUrl',
+      glacierService: mockGlacierService,
     });
     expect(result).toEqual({
       transactions: [],
@@ -154,7 +136,11 @@ describe('get-transactions-from-glacier', () => {
   });
 
   it('should have returned response', async () => {
-    mockListTransactions.mockResolvedValue(mockListTransactionDetailsResponse);
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      listTransactions: jest.fn().mockResolvedValue(mockListTransactionDetailsResponse),
+      isHealthy: jest.fn().mockReturnValue(true),
+    };
     const result = await getTransactionsFromGlacier({
       networkToken: {
         name: 'networkToken',
@@ -168,7 +154,7 @@ describe('get-transactions-from-glacier', () => {
       address: 'address',
       nextPageToken: 'nextPageToken',
       offset: 1,
-      glacierApiUrl: 'glacierApiUrl',
+      glacierService: mockGlacierService,
     });
     expect(result).toEqual({
       transactions: [
@@ -206,4 +192,31 @@ describe('get-transactions-from-glacier', () => {
       nextPageToken: 'nextPageToken',
     });
   });
+
+  it('should have returned empty response', async () => {
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      listTransactions: jest.fn(),
+      isHealthy: jest.fn().mockReturnValue(false),
+    };
+    const result = await getTransactionsFromGlacier({
+      networkToken: {
+        name: 'networkToken',
+        symbol: 'networkToken',
+        decimals: 1,
+        description: 'description',
+        logoUri: 'logoUri',
+      },
+      explorerUrl: 'explorerUrl',
+      chainId: 1,
+      address: 'address',
+      nextPageToken: 'nextPageToken',
+      offset: 1,
+      glacierService: mockGlacierService,
+    });
+    expect(result).toEqual({
+      transactions: [],
+      nextPageToken: '',
+    });
+  });
 });

package/src/handlers/get-transaction-history/converters/evm-transaction-converter/get-transactions-from-glacier.ts

@@ -1,7 +1,6 @@
 import type { NetworkToken, TransactionHistoryResponse } from '@avalabs/vm-module-types';
-import { Glacier } from '@avalabs/glacier-sdk';
-import { rpcErrors } from '@metamask/rpc-errors';
 import { convertTransaction } from './convert-transaction';
+import type { EvmGlacierService } from '../../../../services/glacier-service/glacier-service';
 
 export const getTransactionsFromGlacier = async ({
   chainId,
@@ -10,7 +9,7 @@ export const getTransactionsFromGlacier = async ({
   address,
   nextPageToken,
   offset,
-  glacierApiUrl,
+  glacierService,
 }: {
   chainId: number;
   explorerUrl: string;
@@ -18,16 +17,10 @@ export const getTransactionsFromGlacier = async ({
   address: string;
   nextPageToken?: string;
   offset?: number;
-  glacierApiUrl: string;
+  glacierService: EvmGlacierService;
 }): Promise<TransactionHistoryResponse> => {
-  if (!glacierApiUrl) {
-    throw rpcErrors.invalidParams('Glacier API URL is required');
-  }
-
-  const glacierSdk = new Glacier({ BASE: glacierApiUrl });
-
   try {
-    const response = await glacierSdk.evmTransactions.listTransactions({
+    const response = await glacierService.listTransactions({
       chainId: chainId.toString(),
       address,
       pageToken: nextPageToken,

package/src/handlers/get-transaction-history/get-transaction-history.test.ts

@@ -1,6 +1,7 @@
 import { getTransactionHistory } from './get-transaction-history';
 import { getTransactionFromEtherscan } from './converters/etherscan-transaction-converter/get-transaction-from-etherscan';
 import { getTransactionsFromGlacier } from './converters/evm-transaction-converter/get-transactions-from-glacier';
+import type { EvmGlacierService } from '../../services/glacier-service/glacier-service';
 
 jest.mock('./converters/evm-transaction-converter/get-transactions-from-glacier', () => ({
   getTransactionsFromGlacier: jest.fn(),
@@ -13,7 +14,7 @@ jest.mock('./converters/etherscan-transaction-converter/get-transaction-from-eth
 describe('get-transaction-history', () => {
   it('should have called getTransactionFromEtherscan', async () => {
     await getTransactionHistory({
-      glacierApiUrl: 'glacierApiUrl',
+      glacierService: {} as EvmGlacierService,
       chainId: 1,
       isTestnet: false,
       networkToken: {
@@ -31,8 +32,12 @@ describe('get-transaction-history', () => {
     expect(getTransactionFromEtherscan).toHaveBeenCalled();
   });
   it('should have called getTransactionsFromGlacier', async () => {
+    const mockGlacierService: EvmGlacierService = {
+      ...expect.any(Object),
+      isHealthy: jest.fn().mockReturnValue(true),
+    };
     await getTransactionHistory({
-      glacierApiUrl: 'glacierApiUrl',
+      glacierService: mockGlacierService,
       chainId: 41334,
       isTestnet: false,
       networkToken: {

package/src/handlers/get-transaction-history/get-transaction-history.ts

@@ -2,6 +2,7 @@ import { getTransactionFromEtherscan } from './converters/etherscan-transaction-
 import { isEthereumChainId } from './utils/is-ethereum-chain-id';
 import type { NetworkToken, TransactionHistoryResponse } from '@avalabs/vm-module-types';
 import { getTransactionsFromGlacier } from './converters/evm-transaction-converter/get-transactions-from-glacier';
+import type { EvmGlacierService } from '../../services/glacier-service/glacier-service';
 
 export const getTransactionHistory = async ({
   chainId,
@@ -11,7 +12,7 @@ export const getTransactionHistory = async ({
   address,
   nextPageToken,
   offset,
-  glacierApiUrl,
+  glacierService,
 }: {
   chainId: number;
   isTestnet?: boolean;
@@ -20,7 +21,7 @@ export const getTransactionHistory = async ({
   address: string;
   nextPageToken?: string;
   offset?: number;
-  glacierApiUrl: string;
+  glacierService: EvmGlacierService;
 }): Promise<TransactionHistoryResponse> => {
   if (isEthereumChainId(chainId)) {
     return getTransactionFromEtherscan({
@@ -33,6 +34,15 @@ export const getTransactionHistory = async ({
       offset,
     });
   }
+
+  const isHealthy = glacierService.isHealthy();
+  if (!isHealthy) {
+    return {
+      transactions: [],
+      nextPageToken: '',
+    };
+  }
+
   return getTransactionsFromGlacier({
     networkToken,
     explorerUrl,
@@ -40,6 +50,6 @@ export const getTransactionHistory = async ({
     address,
     nextPageToken,
     offset,
-    glacierApiUrl,
+    glacierService,
   });
 };

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from './module';
 export * from './types';
+export * from './handlers/eth-sign/utils/typeguards';