@avalabs/evm-module 0.0.23 → 0.1.1

package/src/services/glacier-service/glacier-service.ts

@@ -1,238 +0,0 @@
-import {
-  CurrencyCode,
-  Erc1155Token,
-  Erc721Token,
-  type GetNativeBalanceResponse,
-  Glacier,
-  type ListErc1155BalancesResponse,
-  type ListErc20BalancesResponse,
-  type ListErc721BalancesResponse,
-} from '@avalabs/glacier-sdk';
-
-class GlacierUnhealthyError extends Error {
-  override message = 'Glacier is unhealthy. Try again later.';
-}
-
-export class EvmGlacierService {
-  glacierSdk: Glacier;
-  isGlacierHealthy = true;
-  supportedChainIds: string[] = [];
-
-  constructor({ glacierApiUrl }: { glacierApiUrl: string }) {
-    this.glacierSdk = new Glacier({ BASE: glacierApiUrl });
-    /**
-     * This is for performance, basically we just cache the health of glacier every 5 seconds and
-     * go off of that instead of every request
-     */
-    this.getSupportedChainIds().catch(() => {
-      // Noop. It will be retried by .isSupportedNetwork calls upon unlocking if necessary.
-    });
-  }
-
-  isHealthy = (): boolean => this.isGlacierHealthy;
-
-  setGlacierToUnhealthy(): void {
-    this.isGlacierHealthy = false;
-    setTimeout(
-      () => {
-        this.isGlacierHealthy = true;
-      },
-      5 * 60 * 1000,
-    ); // 5 minutes
-  }
-
-  async isNetworkSupported(chainId: number): Promise<boolean> {
-    const chainIds = await this.getSupportedChainIds();
-    return chainIds.some((id) => id === chainId.toString());
-  }
-
-  async getSupportedChainIds(): Promise<string[]> {
-    if (this.supportedChainIds.length) {
-      return this.supportedChainIds;
-    }
-
-    try {
-      const supportedChains = await this.glacierSdk.evmChains.supportedChains({});
-      this.supportedChainIds = supportedChains.chains.map((chain) => chain.chainId);
-      return this.supportedChainIds;
-    } catch {
-      return [];
-    }
-  }
-
-  async reindexNft({
-    address,
-    chainId,
-    tokenId,
-  }: {
-    address: string;
-    chainId: string;
-    tokenId: string;
-  }): Promise<void> {
-    try {
-      await this.glacierSdk.nfTs.reindexNft({
-        address,
-        chainId,
-        tokenId,
-      });
-    } catch (error) {
-      if (error instanceof GlacierUnhealthyError) {
-        this.setGlacierToUnhealthy();
-      }
-      throw error;
-    }
-  }
-
-  async getTokenDetails({
-    address,
-    chainId,
-    tokenId,
-  }: {
-    address: string;
-    chainId: string;
-    tokenId: string;
-  }): Promise<Erc721Token | Erc1155Token> {
-    try {
-      return this.glacierSdk.nfTs.getTokenDetails({
-        address,
-        chainId,
-        tokenId,
-      });
-    } catch (error) {
-      if (error instanceof GlacierUnhealthyError) {
-        this.setGlacierToUnhealthy();
-      }
-      throw error;
-    }
-  }
-
-  async getNativeBalance({
-    chainId,
-    address,
-    currency,
-  }: {
-    chainId: string;
-    address: string;
-    currency: CurrencyCode;
-  }): Promise<GetNativeBalanceResponse> {
-    try {
-      return this.glacierSdk.evmBalances.getNativeBalance({
-        chainId,
-        address,
-        currency: currency.toLocaleLowerCase() as CurrencyCode,
-      });
-    } catch (error) {
-      if (error instanceof GlacierUnhealthyError) {
-        this.setGlacierToUnhealthy();
-      }
-      throw error;
-    }
-  }
-
-  async listErc721Balances({
-    chainId,
-    address,
-    pageSize,
-    pageToken,
-  }: {
-    chainId: string;
-    address: string;
-    pageSize: number;
-    pageToken?: string;
-  }): Promise<ListErc721BalancesResponse> {
-    try {
-      return this.glacierSdk.evmBalances.listErc721Balances({
-        chainId,
-        address,
-        pageSize,
-        pageToken,
-      });
-    } catch (error) {
-      if (error instanceof GlacierUnhealthyError) {
-        this.setGlacierToUnhealthy();
-      }
-      throw error;
-    }
-  }
-
-  async listErc1155Balances({
-    chainId,
-    address,
-    pageSize,
-    pageToken,
-  }: {
-    chainId: string;
-    address: string;
-    pageSize: number;
-    pageToken?: string;
-  }): Promise<ListErc1155BalancesResponse> {
-    try {
-      return this.glacierSdk.evmBalances.listErc1155Balances({
-        chainId,
-        address,
-        pageSize,
-        pageToken,
-      });
-    } catch (error) {
-      if (error instanceof GlacierUnhealthyError) {
-        this.setGlacierToUnhealthy();
-      }
-      throw error;
-    }
-  }
-
-  async listErc20Balances({
-    chainId,
-    address,
-    currency,
-    pageSize,
-    pageToken,
-  }: {
-    chainId: string;
-    address: string;
-    currency: CurrencyCode;
-    pageSize: number;
-    pageToken?: string;
-  }): Promise<ListErc20BalancesResponse> {
-    try {
-      return this.glacierSdk.evmBalances.listErc20Balances({
-        chainId,
-        address,
-        currency: currency.toLocaleLowerCase() as CurrencyCode,
-        pageSize,
-        pageToken,
-      });
-    } catch (error) {
-      if (error instanceof GlacierUnhealthyError) {
-        this.setGlacierToUnhealthy();
-      }
-      throw error;
-    }
-  }
-
-  async listTransactions({
-    chainId,
-    address,
-    pageToken,
-    pageSize,
-  }: {
-    chainId: string;
-    address: string;
-    pageToken?: string;
-    pageSize?: number;
-  }) {
-    try {
-      return this.glacierSdk.evmTransactions.listTransactions({
-        chainId,
-        address,
-        pageToken,
-        pageSize,
-      });
-    } catch (error) {
-      if (error instanceof GlacierUnhealthyError) {
-        this.setGlacierToUnhealthy();
-      }
-      throw error;
-    }
-  }
-}

package/src/types.ts

@@ -1,25 +0,0 @@
-import { TransactionType } from '@avalabs/vm-module-types';
-
-export const NonContractCallTypes = [TransactionType.SEND, TransactionType.RECEIVE, TransactionType.TRANSFER];
-
-export type TransactionParams = {
-  from: string;
-  to: string;
-  data?: string;
-  value?: string;
-  gas?: string;
-  gasPrice?: string;
-  maxFeePerGas?: string;
-  maxPriorityFeePerGas?: string;
-  nonce?: string;
-  chainId?: string;
-};
-
-export enum ERC20TransactionType {
-  TOTAL_SUPPLY = 'totalSupply',
-  BALANCE_OF = 'balanceOf',
-  TRANSFER = 'transfer',
-  TRANSFER_FROM = 'transferFrom',
-  APPROVE = 'approve',
-  ALLOWANCE = 'allowance',
-}

package/src/utils/estimate-gas-limit.ts

@@ -1,27 +0,0 @@
-import { JsonRpcBatchInternal } from '@avalabs/wallets-sdk';
-import type { BigNumberish } from 'ethers';
-
-export const estimateGasLimit = async ({
-  transactionParams: { from, to, data, value },
-  provider,
-}: {
-  transactionParams: {
-    from: string;
-    to: string;
-    data?: string;
-    value?: BigNumberish;
-  };
-  provider: JsonRpcBatchInternal;
-}): Promise<number> => {
-  const nonce = await provider.getTransactionCount(from);
-
-  return Number(
-    await provider.estimateGas({
-      from,
-      to,
-      nonce,
-      data,
-      value,
-    }),
-  );
-};

package/src/utils/get-chain-id.ts

@@ -1,12 +0,0 @@
-import type { Caip2ChainId } from '@avalabs/vm-module-types';
-import { rpcErrors } from '@metamask/rpc-errors';
-
-export const getChainId = (caip2ChainId: Caip2ChainId): number => {
-  const chainId = caip2ChainId.split(':')[1];
-
-  if (!chainId || isNaN(Number(chainId))) {
-    throw rpcErrors.invalidParams('Invalid chainId');
-  }
-
-  return Number(chainId);
-};

package/src/utils/get-nonce.ts

@@ -1,11 +0,0 @@
-import { JsonRpcBatchInternal } from '@avalabs/wallets-sdk';
-
-export const getNonce = async ({
-  from,
-  provider,
-}: {
-  from: string;
-  provider: JsonRpcBatchInternal;
-}): Promise<number> => {
-  return provider.getTransactionCount(from);
-};

package/src/utils/get-provider.ts

@@ -1,46 +0,0 @@
-import { JsonRpcBatchInternal } from '@avalabs/wallets-sdk';
-import { Network as EVMNetwork } from 'ethers';
-
-// this key is only needed in development to bypass rate limit
-// it should never be used in production
-const GLACIER_API_KEY = process.env.GLACIER_API_KEY;
-
-type ProviderParams = {
-  chainId: number;
-  chainName: string;
-  rpcUrl: string;
-  multiContractAddress?: string;
-  pollingInterval?: number;
-};
-
-export const getProvider = (params: ProviderParams): JsonRpcBatchInternal => {
-  const { chainId, chainName, rpcUrl, multiContractAddress, pollingInterval = 2000 } = params;
-
-  const provider = new JsonRpcBatchInternal(
-    { maxCalls: 40, multiContractAddress },
-    addGlacierAPIKeyIfNeeded(rpcUrl, GLACIER_API_KEY),
-    new EVMNetwork(chainName, chainId),
-  );
-
-  provider.pollingInterval = pollingInterval;
-
-  return provider;
-};
-
-// RPC urls returned in the token list are always using the production URL
-const knownHosts = ['glacier-api.avax.network', 'proxy-api.avax.network'];
-
-/**
- * Glacier needs an API key for development, this adds the key if needed.
- */
-export function addGlacierAPIKeyIfNeeded(url: string, glacierApiKey?: string): string {
-  const urlObj = new URL(url);
-
-  if (glacierApiKey && knownHosts.includes(urlObj.hostname)) {
-    const search_params = urlObj.searchParams; // copy, does not update the URL
-    search_params.set('token', glacierApiKey);
-    urlObj.search = search_params.toString();
-    return urlObj.toString();
-  }
-  return url;
-}

package/src/utils/parse-erc20-transaction-type.ts

@@ -1,35 +0,0 @@
-import { Interface } from 'ethers';
-import ERC20 from '@openzeppelin/contracts/build/contracts/ERC20.json';
-import { ERC20TransactionType } from '../types';
-
-export const parseERC20TransactionType = (transaction: {
-  data?: string;
-  value?: string;
-}): ERC20TransactionType | undefined => {
-  if (!transaction.data) {
-    return undefined;
-  }
-
-  try {
-    const contractInterface = new Interface(ERC20.abi);
-
-    const description = contractInterface.parseTransaction({
-      data: transaction.data,
-      value: transaction.value,
-    });
-
-    const functionName = description?.name ?? description?.fragment?.name;
-
-    if (functionName && isERC20TransactionType(functionName)) {
-      return functionName;
-    }
-
-    return undefined;
-  } catch (e) {
-    return undefined;
-  }
-};
-
-function isERC20TransactionType(value: string): value is ERC20TransactionType {
-  return Object.values(ERC20TransactionType).includes(value as ERC20TransactionType);
-}

package/src/utils/process-transaction-simulation.test.ts

@@ -1,105 +0,0 @@
-import Blockaid from '@blockaid/client';
-import { processBalanceChange } from './process-transaction-simulation';
-
-jest.mock('@blockaid/client', () => {
-  return jest.fn().mockImplementation(() => {
-    return {};
-  });
-});
-
-describe('processBalanceChange', () => {
-  it('should sort asset diffs correctly within ins and outs', () => {
-    const assetDiffs: Blockaid.AssetDiff[] = [
-      {
-        asset: {
-          type: 'ERC20',
-          address: '0xTokenAddress1',
-          name: 'TokenName1',
-          symbol: 'TKN1',
-          decimals: 18,
-          logo_url: 'logo_url1',
-        },
-        in: [
-          { value: '1', usd_price: '1', raw_value: '0x1' },
-          { value: '2', usd_price: '2', raw_value: '0x2' },
-        ],
-        out: [
-          { value: '3', usd_price: '3', raw_value: '0x3' },
-          { value: '1', usd_price: '1', raw_value: '0x1' },
-        ],
-      },
-      {
-        asset: {
-          type: 'ERC20',
-          address: '0xTokenAddress2',
-          name: 'TokenName2',
-          symbol: 'TKN2',
-          decimals: 18,
-          logo_url: 'logo_url2',
-        },
-        in: [{ value: '4', usd_price: '4', raw_value: '0x4' }],
-        out: [{ value: '5', usd_price: '5', raw_value: '0x5' }],
-      },
-    ];
-
-    const result = processBalanceChange(assetDiffs);
-
-    // Verify sorting logic for 'ins'
-    expect(result?.ins).toEqual([
-      {
-        token: {
-          type: 'ERC20',
-          address: '0xTokenAddress2',
-          name: 'TokenName2',
-          symbol: 'TKN2',
-          decimals: 18,
-          logoUri: 'logo_url2',
-        },
-        items: [{ displayValue: '4', usdPrice: '4' }],
-      },
-      {
-        token: {
-          type: 'ERC20',
-          address: '0xTokenAddress1',
-          name: 'TokenName1',
-          symbol: 'TKN1',
-          decimals: 18,
-          logoUri: 'logo_url1',
-        },
-        items: [
-          { displayValue: '1', usdPrice: '1' },
-          { displayValue: '2', usdPrice: '2' },
-        ],
-      },
-    ]);
-
-    // Verify sorting logic for 'outs'
-    expect(result?.outs).toEqual([
-      {
-        token: {
-          type: 'ERC20',
-          address: '0xTokenAddress2',
-          name: 'TokenName2',
-          symbol: 'TKN2',
-          decimals: 18,
-          logoUri: 'logo_url2',
-        },
-        items: [{ displayValue: '5', usdPrice: '5' }],
-      },
-      {
-        token: {
-          type: 'ERC20',
-          address: '0xTokenAddress1',
-          name: 'TokenName1',
-          symbol: 'TKN1',
-          decimals: 18,
-          logoUri: 'logo_url1',
-        },
-        items: [
-          { displayValue: '3', usdPrice: '3' },
-          { displayValue: '1', usdPrice: '1' },
-        ],
-      },
-    ]);
-  });
-});