@avalabs/evm-module 0.0.23 → 0.1.1

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

@@ -1,222 +0,0 @@
-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',
-  transactions: [
-    {
-      nativeTransaction: {
-        from: {
-          address: 'address',
-        },
-        to: {
-          address: 'address',
-        },
-        value: '1',
-        gasLimit: '1',
-        nonce: '1',
-        txStatus: '1',
-        txType: 1,
-        blockHash: 'blockHash',
-        blockIndex: 1,
-        blockNumber: '1',
-        blockTimestamp: 1,
-        txHash: 'txHash',
-        gasPrice: '1',
-        gasUsed: '1',
-      },
-    },
-  ],
-};
-
-describe('get-transactions-from-glacier', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-  it('should have returned empty response when listTransaction failed', async () => {
-    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',
-        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: '',
-    });
-  });
-  it('should have returned filtered response with no transaction status of 0', async () => {
-    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',
-        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: 'nextPageToken',
-    });
-  });
-  it('should have returned filtered response without transaction with amount 0', async () => {
-    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',
-        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: 'nextPageToken',
-    });
-  });
-
-  it('should have returned response', async () => {
-    const mockGlacierService: EvmGlacierService = {
-      ...expect.any(Object),
-      listTransactions: jest.fn().mockResolvedValue(mockListTransactionDetailsResponse),
-      isHealthy: jest.fn().mockReturnValue(true),
-    };
-    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: [
-        {
-          isContractCall: false,
-          isIncoming: false,
-          isOutgoing: true,
-          isSender: true,
-          timestamp: 1000,
-          hash: 'txHash',
-          from: 'address',
-          to: 'address',
-          tokens: [
-            {
-              amount: '0.1',
-              symbol: 'networkToken',
-              decimal: '1',
-              name: 'networkToken',
-              type: 'NATIVE',
-              from: {
-                address: 'address',
-              },
-              to: {
-                address: 'address',
-              },
-            },
-          ],
-          gasPrice: '1',
-          gasUsed: '1',
-          chainId: '1',
-          txType: 'Send',
-          explorerLink: 'explorerUrl/tx/txHash',
-        },
-      ],
-      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,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,141 +0,0 @@
-import type {
-  Module,
-  Manifest,
-  NetworkFees,
-  GetTransactionHistory,
-  RpcRequest,
-  Environment,
-  Network,
-  ApprovalController,
-  GetBalancesParams,
-  GetBalancesResponse,
-  GetAddressParams,
-  GetAddressResponse,
-} 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';
-import { getAddress } from './handlers/get-address/get-address';
-
-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({ accountIndex, xpub, walletType }: GetAddressParams): Promise<GetAddressResponse> {
-    return getAddress({ accountIndex, xpub, walletType });
-  }
-
-  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)
-  );
-};