@avalabs/evm-module 0.0.13 → 0.0.15

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/module.ts

@@ -7,6 +7,8 @@ import type {
   Environment,
   Network,
   ApprovalController,
+  GetBalancesParams,
+  GetBalancesResponse,
 } from '@avalabs/vm-module-types';
 import { rpcErrors } from '@metamask/rpc-errors';
 import { RpcMethod, parseManifest } from '@avalabs/vm-module-types';
@@ -14,11 +16,13 @@ import { getTokens } from './handlers/get-tokens/get-tokens';
 import { getNetworkFee } from './handlers/get-network-fee/get-network-fee';
 import { getTransactionHistory } from './handlers/get-transaction-history/get-transaction-history';
 import ManifestJson from '../manifest.json';
-import { getEnv } from './env';
 import { ethSendTransaction } from './handlers/eth-send-transaction/eth-send-transaction';
+import { getBalances } from './handlers/get-balances/get-balances';
+import { getEnv } from './env';
+import { EvmGlacierService } from './services/glacier-service/glacier-service';
 
 export class EvmModule implements Module {
-  #glacierApiUrl: string;
+  #glacierService: EvmGlacierService;
   #proxyApiUrl: string;
   #approvalController: ApprovalController;
 
@@ -30,7 +34,7 @@ export class EvmModule implements Module {
     environment: Environment;
   }) {
     const { glacierApiUrl, proxyApiUrl } = getEnv(environment);
-    this.#glacierApiUrl = glacierApiUrl;
+    this.#glacierService = new EvmGlacierService({ glacierApiUrl });
     this.#proxyApiUrl = proxyApiUrl;
     this.#approvalController = approvalController;
   }
@@ -39,8 +43,15 @@ export class EvmModule implements Module {
     return Promise.resolve('EVM address');
   }
 
-  getBalances(): Promise<string> {
-    return Promise.resolve('EVM balances');
+  getBalances({ addresses, network, currency, customTokens }: GetBalancesParams): Promise<GetBalancesResponse> {
+    return getBalances({
+      addresses,
+      currency,
+      network,
+      proxyApiUrl: this.#proxyApiUrl,
+      customTokens,
+      glacierService: this.#glacierService,
+    });
   }
 
   getManifest(): Manifest | undefined {
@@ -55,7 +66,6 @@ export class EvmModule implements Module {
       chainName,
       rpcUrl,
       multiContractAddress: utilityAddresses?.multicall,
-      glacierApiUrl: this.#glacierApiUrl,
     });
   }
 
@@ -71,7 +81,7 @@ export class EvmModule implements Module {
       address,
       nextPageToken,
       offset,
-      glacierApiUrl: this.#glacierApiUrl,
+      glacierService: this.#glacierService,
     });
   }