@avalabs/evm-module 0.0.22 → 0.1.0

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

@@ -1,62 +0,0 @@
-import type { NetworkToken, TransactionHistoryResponse } from '@avalabs/vm-module-types';
-import { convertTransaction } from './convert-transaction';
-import type { EvmGlacierService } from '../../../../services/glacier-service/glacier-service';
-
-export const getTransactionsFromGlacier = async ({
-  chainId,
-  explorerUrl,
-  networkToken,
-  address,
-  nextPageToken,
-  offset,
-  glacierService,
-}: {
-  chainId: number;
-  explorerUrl: string;
-  networkToken: NetworkToken;
-  address: string;
-  nextPageToken?: string;
-  offset?: number;
-  glacierService: EvmGlacierService;
-}): Promise<TransactionHistoryResponse> => {
-  try {
-    const response = await glacierService.listTransactions({
-      chainId: chainId.toString(),
-      address,
-      pageToken: nextPageToken,
-      pageSize: offset,
-    });
-
-    const convertedTxs = await Promise.all(
-      response.transactions
-        .filter(
-          // Currently not showing failed tx
-          (tranasaction) => tranasaction.nativeTransaction.txStatus === '1',
-        )
-        .map((transactions) =>
-          convertTransaction({
-            transactions,
-            explorerUrl,
-            networkToken,
-            chainId,
-            address,
-          }).then((tx) => tx),
-        ),
-    );
-
-    const transactions = convertedTxs.filter(
-      // Filtering txs with 0 value since there is no change in balance
-      (transaction) => transaction.tokens.find((token) => Number(token.amount) !== 0),
-    );
-
-    return {
-      transactions,
-      nextPageToken: response.nextPageToken,
-    };
-  } catch {
-    return {
-      transactions: [],
-      nextPageToken: '',
-    };
-  }
-};

package/src/handlers/get-transaction-history/converters/evm-transaction-converter/get-tx-type.ts

@@ -1,52 +0,0 @@
-import type { TransactionDetails } from '@avalabs/glacier-sdk';
-import { TokenType, TransactionType, type TxToken } from '@avalabs/vm-module-types';
-import startCase from 'lodash.startcase';
-
-export const getTxType = (
-  { nativeTransaction, erc20Transfers, erc721Transfers }: TransactionDetails,
-  userAddress: string,
-  tokens: TxToken[],
-): TransactionType => {
-  const nativeOnly = !erc20Transfers && !erc721Transfers;
-  const method = parseRawMethod(nativeTransaction.method?.methodName);
-
-  const address = userAddress.toLowerCase();
-
-  const isSwap = method.toLowerCase().includes('swap');
-  const isNativeSend = nativeOnly && nativeTransaction.from.address.toLowerCase() === address;
-  const isNativeReceive = nativeOnly && nativeTransaction.to.address.toLowerCase() === address;
-  const isNFTPurchase = method === 'Market Buy Orders With Eth' || method === 'Buy NFT';
-  const isApprove = method === 'Approve';
-  const isTransfer = method.toLowerCase().includes('transfer');
-  const isAirdrop = method.toLowerCase().includes('airdrop');
-  const isUnwrap = method.toLowerCase().includes('unwrap');
-  const isFillOrder = method === 'Fill Order';
-  const isNFTSend =
-    isTransfer && !!tokens[0] && isNFT(tokens[0].type) && tokens[0].from?.address.toLowerCase() === address;
-  const isNFTReceive =
-    isTransfer && !!tokens[0] && isNFT(tokens[0].type) && tokens[0].to?.address.toLowerCase() === address;
-
-  if (isSwap) return TransactionType.SWAP;
-  if (isNativeSend) return TransactionType.SEND;
-  if (isNativeReceive) return TransactionType.RECEIVE;
-  if (isNFTPurchase) return TransactionType.NFT_BUY;
-  if (isApprove) return TransactionType.APPROVE;
-  if (isNFTSend) return TransactionType.NFT_SEND;
-  if (isNFTReceive) return TransactionType.NFT_RECEIVE;
-  if (isTransfer) return TransactionType.TRANSFER;
-  if (isAirdrop) return TransactionType.AIRDROP;
-  if (isUnwrap) return TransactionType.UNWRAP;
-  if (isFillOrder) return TransactionType.FILL_ORDER;
-  return TransactionType.UNKNOWN;
-};
-
-function isNFT(tokenType: TokenType) {
-  return tokenType === TokenType.ERC721 || tokenType === TokenType.ERC1155;
-}
-
-const parseRawMethod = (method = ''): string => {
-  if (method.includes('(')) {
-    return startCase(method.split('(', 1)[0]);
-  }
-  return method;
-};

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

@@ -1,57 +0,0 @@
-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(),
-}));
-
-jest.mock('./converters/etherscan-transaction-converter/get-transaction-from-etherscan', () => ({
-  getTransactionFromEtherscan: jest.fn(),
-}));
-
-describe('get-transaction-history', () => {
-  it('should have called getTransactionFromEtherscan', async () => {
-    await getTransactionHistory({
-      glacierService: {} as EvmGlacierService,
-      chainId: 1,
-      isTestnet: false,
-      networkToken: {
-        name: 'networkToken',
-        symbol: 'networkToken',
-        decimals: 1,
-        description: 'description',
-        logoUri: 'logoUri',
-      },
-      explorerUrl: 'explorerUrl',
-      address: 'address',
-      nextPageToken: 'nextPageToken',
-      offset: 1,
-    });
-    expect(getTransactionFromEtherscan).toHaveBeenCalled();
-  });
-  it('should have called getTransactionsFromGlacier', async () => {
-    const mockGlacierService: EvmGlacierService = {
-      ...expect.any(Object),
-      isHealthy: jest.fn().mockReturnValue(true),
-    };
-    await getTransactionHistory({
-      glacierService: mockGlacierService,
-      chainId: 41334,
-      isTestnet: false,
-      networkToken: {
-        name: 'networkToken',
-        symbol: 'networkToken',
-        decimals: 1,
-        description: 'description',
-        logoUri: 'logoUri',
-      },
-      explorerUrl: 'explorerUrl',
-      address: 'address',
-      nextPageToken: 'nextPageToken',
-      offset: 1,
-    });
-    expect(getTransactionsFromGlacier).toHaveBeenCalled();
-  });
-});

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

@@ -1,55 +0,0 @@
-import { getTransactionFromEtherscan } from './converters/etherscan-transaction-converter/get-transaction-from-etherscan';
-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,
-  isTestnet,
-  networkToken,
-  explorerUrl,
-  address,
-  nextPageToken,
-  offset,
-  glacierService,
-}: {
-  chainId: number;
-  isTestnet?: boolean;
-  networkToken: NetworkToken;
-  explorerUrl: string;
-  address: string;
-  nextPageToken?: string;
-  offset?: number;
-  glacierService: EvmGlacierService;
-}): Promise<TransactionHistoryResponse> => {
-  if (isEthereumChainId(chainId)) {
-    return getTransactionFromEtherscan({
-      isTestnet,
-      networkToken,
-      explorerUrl,
-      chainId,
-      address,
-      nextPageToken,
-      offset,
-    });
-  }
-
-  const isHealthy = glacierService.isHealthy();
-  if (!isHealthy) {
-    return {
-      transactions: [],
-      nextPageToken: '',
-    };
-  }
-
-  return getTransactionsFromGlacier({
-    networkToken,
-    explorerUrl,
-    chainId,
-    address,
-    nextPageToken,
-    offset,
-    glacierService,
-  });
-};

package/src/handlers/get-transaction-history/utils/get-explorer-address-by-network.ts

@@ -1,7 +0,0 @@
-export function getExplorerAddressByNetwork(
-  explorerUrl: string,
-  hash: string,
-  hashType: 'address' | 'tx' = 'tx',
-): string {
-  return `${explorerUrl}/${hashType}/${hash}`;
-}

package/src/handlers/get-transaction-history/utils/get-small-image-for-nft.ts

@@ -1,16 +0,0 @@
-import { ipfsResolverWithFallback } from './ipfs-resolver-with-fallback';
-
-const COVALENT_IMG_SIZER = 'https://image-proxy.svc.prod.covalenthq.com/cdn-cgi/image';
-
-/**
- * Covalent has an on the fly image resizer, it resolves image urls then resizes the image.
- *
- * This allows us to request smaller images depending on the UI needs
- *
- * @param imgUrl the url of the image to convert to size
- * @returns The url to the image which is sized at the time of request
- */
-export function getSmallImageForNFT(imgUrl: string, imageSize: '256' | '512' | '1024' = '256') {
-  const url = ipfsResolverWithFallback(imgUrl);
-  return `${COVALENT_IMG_SIZER}/width=${imageSize},fit/${url}`;
-}

package/src/handlers/get-transaction-history/utils/ipfs-resolver-with-fallback.ts

@@ -1,18 +0,0 @@
-import { ipfsResolver } from '@avalabs/utils-sdk';
-
-export const CLOUDFLARE_IPFS_URL = 'https://cloudflare-ipfs.com';
-
-export function ipfsResolverWithFallback(
-  sourceUrl: string | undefined,
-  desiredGatewayPrefix: string = CLOUDFLARE_IPFS_URL,
-) {
-  if (!sourceUrl) {
-    return '';
-  }
-
-  try {
-    return ipfsResolver(sourceUrl, desiredGatewayPrefix);
-  } catch {
-    return sourceUrl;
-  }
-}

package/src/handlers/get-transaction-history/utils/is-ethereum-chain-id.ts

@@ -1,15 +0,0 @@
-enum ChainId {
-  ETHEREUM_HOMESTEAD = 1,
-  ETHEREUM_TEST_RINKEBY = 4,
-  ETHEREUM_TEST_GOERLY = 5,
-  ETHEREUM_TEST_SEPOLIA = 11155111,
-}
-
-export const isEthereumChainId = (chainId: number): boolean => {
-  return (
-    ChainId.ETHEREUM_HOMESTEAD === chainId ||
-    ChainId.ETHEREUM_TEST_GOERLY === chainId ||
-    ChainId.ETHEREUM_TEST_RINKEBY === chainId ||
-    ChainId.ETHEREUM_TEST_SEPOLIA === chainId
-  );
-};

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

@@ -1,7 +0,0 @@
-export async function resolve<T = unknown>(promise: Promise<T>) {
-  try {
-    return promise.then((res) => [res, null]).catch((err) => [null, err]);
-  } catch (err) {
-    return Promise.resolve([null, err]);
-  }
-}

package/src/index.ts

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

package/src/module.ts

@@ -1,138 +0,0 @@
-import type {
-  Module,
-  Manifest,
-  NetworkFees,
-  GetTransactionHistory,
-  RpcRequest,
-  Environment,
-  Network,
-  ApprovalController,
-  GetBalancesParams,
-  GetBalancesResponse,
-} from '@avalabs/vm-module-types';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { RpcMethod, parseManifest } from '@avalabs/vm-module-types';
-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 { 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';
-import { ethSign } from './handlers/eth-sign/eth-sign';
-import { forwardToRpcNode } from './handlers/forward-to-rpc-node/forward-to-rpc-node';
-
-export class EvmModule implements Module {
-  #glacierService: EvmGlacierService;
-  #proxyApiUrl: string;
-  #approvalController: ApprovalController;
-
-  constructor({
-    approvalController,
-    environment,
-  }: {
-    approvalController: ApprovalController;
-    environment: Environment;
-  }) {
-    const { glacierApiUrl, proxyApiUrl } = getEnv(environment);
-    this.#glacierService = new EvmGlacierService({ glacierApiUrl });
-    this.#proxyApiUrl = proxyApiUrl;
-    this.#approvalController = approvalController;
-  }
-
-  getAddress(): Promise<string> {
-    return Promise.resolve('EVM address');
-  }
-
-  getBalances({
-    addresses,
-    network,
-    currency,
-    customTokens,
-    storage,
-  }: GetBalancesParams): Promise<GetBalancesResponse> {
-    return getBalances({
-      addresses,
-      currency,
-      network,
-      proxyApiUrl: this.#proxyApiUrl,
-      customTokens,
-      glacierService: this.#glacierService,
-      storage,
-    });
-  }
-
-  getManifest(): Manifest | undefined {
-    const result = parseManifest(ManifestJson);
-    return result.success ? result.data : undefined;
-  }
-
-  getNetworkFee(network: Network): Promise<NetworkFees> {
-    const { chainId, chainName, rpcUrl, utilityAddresses } = network;
-    return getNetworkFee({
-      chainId,
-      chainName,
-      rpcUrl,
-      multiContractAddress: utilityAddresses?.multicall,
-    });
-  }
-
-  getTransactionHistory(params: GetTransactionHistory) {
-    const { network, address, nextPageToken, offset } = params;
-    const { chainId, isTestnet, networkToken, explorerUrl = '' } = network;
-
-    return getTransactionHistory({
-      chainId,
-      isTestnet,
-      networkToken,
-      explorerUrl,
-      address,
-      nextPageToken,
-      offset,
-      glacierService: this.#glacierService,
-    });
-  }
-
-  getTokens(network: Network) {
-    const { chainId } = network;
-    return getTokens({ chainId, proxyApiUrl: this.#proxyApiUrl });
-  }
-
-  async onRpcRequest(request: RpcRequest, network: Network) {
-    switch (request.method) {
-      case RpcMethod.ETH_SEND_TRANSACTION:
-        return ethSendTransaction({
-          request,
-          network,
-          approvalController: this.#approvalController,
-          proxyApiUrl: this.#proxyApiUrl,
-        });
-      case RpcMethod.PERSONAL_SIGN:
-      case RpcMethod.ETH_SIGN:
-      case RpcMethod.SIGN_TYPED_DATA:
-      case RpcMethod.SIGN_TYPED_DATA_V1:
-      case RpcMethod.SIGN_TYPED_DATA_V3:
-      case RpcMethod.SIGN_TYPED_DATA_V4:
-        return ethSign({
-          request,
-          network,
-          approvalController: this.#approvalController,
-          proxyApiUrl: this.#proxyApiUrl,
-        });
-      default:
-        if (shouldForwardToRpcNode(request.method)) {
-          return forwardToRpcNode(request, network);
-        }
-
-        return { error: rpcErrors.methodNotSupported(`Method ${request.method} not supported`) };
-    }
-  }
-}
-
-const shouldForwardToRpcNode = (method: RpcMethod) => {
-  return (
-    method.startsWith('eth_') ||
-    ['web3_clientVersion', 'web3_sha3', 'net_version', 'net_peerCount', 'net_listening'].includes(method)
-  );
-};

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;
-    }
-  }
-}