@avalabs/evm-module 0.0.0-workspaces-20240716185307 → 0.0.2

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

@@ -1,59 +0,0 @@
-import type { NetworkFees } from '@avalabs/vm-module-types';
-import { getProvider } from '../../utils/get-provider';
-import { rpcErrors } from '@metamask/rpc-errors';
-
-const DEFAULT_PRESETS = {
-  LOW: 1n,
-  MEDIUM: 4n,
-  HIGH: 6n,
-};
-
-const BASE_PRIORITY_FEE_WEI = 500000000n; //0.5 GWei
-
-/**
- * Returns {@link NetworkFees} based on {@link DEFAULT_PRESETS} multipliers.
- * @throws Error if provider does not support eip-1559
- */
-export async function getNetworkFee({
-  chainId,
-  chainName,
-  rpcUrl,
-  multiContractAddress,
-}: {
-  chainId: number;
-  chainName: string;
-  rpcUrl: string;
-  multiContractAddress?: string;
-}): Promise<NetworkFees> {
-  const provider = getProvider({
-    chainId,
-    chainName,
-    rpcUrl,
-    multiContractAddress,
-  });
-
-  const { maxFeePerGas: maxFeePerGasInWei } = await provider.getFeeData();
-  if (!maxFeePerGasInWei) {
-    throw rpcErrors.internal('Pre-EIP-1559 networks are not supported');
-  }
-
-  const lowMaxTip = BASE_PRIORITY_FEE_WEI * DEFAULT_PRESETS.LOW;
-  const mediumMaxTip = BASE_PRIORITY_FEE_WEI * DEFAULT_PRESETS.MEDIUM;
-  const highMaxTip = BASE_PRIORITY_FEE_WEI * DEFAULT_PRESETS.HIGH;
-  return {
-    baseFee: maxFeePerGasInWei,
-    low: {
-      maxFeePerGas: maxFeePerGasInWei + lowMaxTip,
-      maxPriorityFeePerGas: lowMaxTip,
-    },
-    medium: {
-      maxFeePerGas: maxFeePerGasInWei + mediumMaxTip,
-      maxPriorityFeePerGas: mediumMaxTip,
-    },
-    high: {
-      maxFeePerGas: maxFeePerGasInWei + highMaxTip,
-      maxPriorityFeePerGas: highMaxTip,
-    },
-    isFixedFee: false,
-  };
-}

package/src/handlers/get-tokens/get-tokens.test.ts

@@ -1,100 +0,0 @@
-import { getTokens } from './get-tokens';
-
-const PROXY_API_URL = 'https://proxy-api.avax.network';
-
-global.fetch = jest.fn();
-
-describe('get-tokens', () => {
-  beforeAll(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should return an empty array if chain id is not for a valid network', async () => {
-    (global.fetch as jest.Mock).mockResolvedValueOnce({
-      ok: true,
-      json: async () => [],
-    });
-
-    const result = await getTokens({ chainId: 0, proxyApiUrl: PROXY_API_URL });
-
-    expect(result).toEqual([]);
-  });
-
-  it('should return correct contract tokens for Avalanche C-Chain', async () => {
-    (global.fetch as jest.Mock).mockResolvedValueOnce({
-      ok: true,
-      json: async () => [
-        {
-          address: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7',
-          name: 'Wrapped AVAX',
-          symbol: 'WAVAX',
-          contractType: 'ERC-20',
-          chainId: 43114,
-          decimals: 18,
-        },
-        {
-          address: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
-          name: 'USD Coin',
-          symbol: 'USDC',
-          contractType: 'ERC-20',
-          chainId: 43114,
-          decimals: 6,
-        },
-      ],
-    });
-
-    const result = await getTokens({ chainId: 43114, proxyApiUrl: PROXY_API_URL });
-
-    expect(result.length).toBeGreaterThan(0);
-    expect(result.find((token) => token.symbol === 'WAVAX')).toBeDefined();
-    expect(result.find((token) => token.symbol === 'USDC')).toBeDefined();
-  });
-
-  it('should return correct contract tokens for Ethereum', async () => {
-    (global.fetch as jest.Mock).mockResolvedValueOnce({
-      ok: true,
-      json: async () => [
-        {
-          address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
-          name: 'Tether USD',
-          symbol: 'USDT',
-          contractType: 'ERC-20',
-          chainId: 1,
-          decimals: 6,
-        },
-        {
-          address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
-          name: 'USDCoin',
-          symbol: 'USDC',
-          contractType: 'ERC-20',
-          chainId: 1,
-          decimals: 6,
-        },
-        {
-          address: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
-          name: 'Wrapped BTC',
-          symbol: 'WBTC',
-          contractType: 'ERC-20',
-          chainId: 1,
-          decimals: 8,
-        },
-        {
-          address: '0x514910771AF9Ca656af840dff83E8264EcF986CA',
-          name: 'ChainLink Token',
-          symbol: 'LINK',
-          contractType: 'ERC-20',
-          chainId: 1,
-          decimals: 18,
-        },
-      ],
-    });
-
-    const result = await getTokens({ chainId: 1, proxyApiUrl: PROXY_API_URL });
-
-    expect(result.length).toBeGreaterThan(0);
-    expect(result.find((token) => token.symbol === 'USDT')).toBeDefined();
-    expect(result.find((token) => token.symbol === 'USDC')).toBeDefined();
-    expect(result.find((token) => token.symbol === 'WBTC')).toBeDefined();
-    expect(result.find((token) => token.symbol === 'LINK')).toBeDefined();
-  });
-});

package/src/handlers/get-tokens/get-tokens.ts

@@ -1,18 +0,0 @@
-import type { NetworkContractToken } from '@avalabs/vm-module-types';
-import { rpcErrors } from '@metamask/rpc-errors';
-
-export async function getTokens({
-  chainId,
-  proxyApiUrl,
-}: {
-  chainId: number;
-  proxyApiUrl: string;
-}): Promise<NetworkContractToken[]> {
-  const response = await fetch(`${proxyApiUrl}/tokens?evmChainId=${chainId}`);
-
-  if (!response.ok) {
-    throw rpcErrors.internal(`Failed to fetch tokens for chainId ${chainId}`);
-  }
-
-  return response.json();
-}

package/src/handlers/get-transaction-history/converters/etherscan-transaction-converter/convert-transaction-erc20.ts

@@ -1,51 +0,0 @@
-import type { Erc20Tx } from '@avalabs/etherscan-sdk';
-import { TokenType, TransactionType, type Transaction } from '@avalabs/vm-module-types';
-import { balanceToDisplayValue } from '@avalabs/utils-sdk';
-import { getExplorerAddressByNetwork } from '../../utils/get-explorer-address-by-network';
-import { BN } from 'bn.js';
-
-export function convertTransactionERC20({
-  tx,
-  address,
-  explorerUrl,
-  chainId,
-}: {
-  tx: Erc20Tx;
-  address: string;
-  chainId: number;
-  explorerUrl: string;
-}): Transaction {
-  const isSender = tx.from.toLowerCase() === address.toLowerCase();
-  const timestamp = parseInt(tx.timeStamp) * 1000;
-  const decimals = parseInt(tx.tokenDecimal);
-  const amountBN = new BN(tx.value);
-  const amountDisplayValue = balanceToDisplayValue(amountBN, decimals);
-  const { from, to, gasPrice, gasUsed, hash, tokenDecimal, tokenName, tokenSymbol } = tx;
-  const txType = isSender ? TransactionType.SEND : TransactionType.RECEIVE;
-  const explorerLink = getExplorerAddressByNetwork(explorerUrl, hash);
-
-  return {
-    isIncoming: !isSender,
-    isOutgoing: isSender,
-    isContractCall: false,
-    timestamp,
-    hash,
-    isSender,
-    from,
-    to,
-    tokens: [
-      {
-        decimal: tokenDecimal,
-        name: tokenName,
-        symbol: tokenSymbol,
-        type: TokenType.ERC20,
-        amount: amountDisplayValue,
-      },
-    ],
-    gasUsed,
-    gasPrice,
-    chainId: chainId.toString(),
-    txType,
-    explorerLink,
-  };
-}

package/src/handlers/get-transaction-history/converters/etherscan-transaction-converter/convert-transaction-normal.ts

@@ -1,58 +0,0 @@
-import type { NormalTx } from '@avalabs/etherscan-sdk';
-import { TokenType, TransactionType, type NetworkToken, type Transaction } from '@avalabs/vm-module-types';
-import { balanceToDisplayValue } from '@avalabs/utils-sdk';
-import { BN } from 'bn.js';
-import { getExplorerAddressByNetwork } from '../../utils/get-explorer-address-by-network';
-
-export const convertTransactionNormal = ({
-  tx,
-  networkToken,
-  chainId,
-  explorerUrl,
-  address,
-}: {
-  tx: NormalTx;
-  networkToken: NetworkToken;
-  chainId: number;
-  explorerUrl: string;
-  address: string;
-}): Transaction => {
-  const isSender = tx.from.toLowerCase() === address.toLowerCase();
-  const timestamp = parseInt(tx.timeStamp) * 1000;
-  const decimals = networkToken.decimals;
-  const amountBN = new BN(tx.value);
-  const amountDisplayValue = balanceToDisplayValue(amountBN, decimals);
-  const txType = isSender ? TransactionType.SEND : TransactionType.RECEIVE;
-
-  const { from, to, gasPrice, gasUsed, hash } = tx;
-  const explorerLink = getExplorerAddressByNetwork(explorerUrl, hash);
-
-  return {
-    isIncoming: !isSender,
-    isOutgoing: isSender,
-    isContractCall: isContractCall(tx),
-    timestamp,
-    hash,
-    isSender,
-    from,
-    to,
-    tokens: [
-      {
-        decimal: decimals.toString(),
-        name: networkToken.name,
-        symbol: networkToken.symbol,
-        amount: amountDisplayValue,
-        type: TokenType.NATIVE,
-      },
-    ],
-    gasUsed,
-    gasPrice,
-    chainId: chainId.toString(),
-    txType,
-    explorerLink,
-  };
-};
-
-function isContractCall(tx: NormalTx): boolean {
-  return tx.input !== '0x';
-}

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

@@ -1,116 +0,0 @@
-import { TokenType } from '@avalabs/vm-module-types';
-import { getTransactionFromEtherscan } from './get-transaction-from-etherscan';
-import type { Erc20Tx, NormalTx } from '@avalabs/etherscan-sdk';
-
-const mockNormalTxs: NormalTx[] = [
-  {
-    blockNumber: 'blockNumber',
-    timeStamp: 'timeStamp',
-    hash: 'normalTxHash',
-    nonce: 'nonce',
-    blockHash: 'blockHash',
-    transactionIndex: 'transactionIndex',
-    from: 'from',
-    to: 'to',
-    value: '1',
-    gas: '1',
-    gasPrice: '1',
-    isError: 'isError',
-    txreceipt_status: 'txreceipt_status',
-    input: 'input',
-    contractAddress: 'contractAddress',
-    cumulativeGasUsed: '1',
-    gasUsed: '1',
-    confirmations: 'confirmations',
-  },
-];
-
-const mockErc20Txs: Erc20Tx[] = [
-  {
-    blockNumber: 'blockNumber',
-    timeStamp: 'timeStamp',
-    hash: 'erc20Hash',
-    nonce: 'nonce',
-    blockHash: 'blockHash',
-    from: 'from',
-    contractAddress: 'contractAddress',
-    to: 'to',
-    value: '1',
-    tokenName: 'tokenName',
-    tokenSymbol: 'tokenSymbol',
-    tokenDecimal: '1',
-    transactionIndex: 'transactionIndex',
-    gas: '1',
-    gasPrice: '1',
-    input: 'input',
-    cumulativeGasUsed: '1',
-    gasUsed: '1',
-    confirmations: 'confirmations',
-  },
-];
-// const mockTransactions = jest.fn();
-jest.mock('@avalabs/etherscan-sdk', () => ({
-  getNormalTxs: () => mockNormalTxs,
-  getErc20Txs: () => mockErc20Txs,
-}));
-
-describe('get-transaction-from-etherscan', () => {
-  it('should have returned 1 normal transaction and 1 erc20 transaction', async () => {
-    const result = await getTransactionFromEtherscan({
-      isTestnet: false,
-      chainId: 1,
-      networkToken: {
-        name: 'networkToken',
-        symbol: 'networkToken',
-        decimals: 1,
-        description: 'description',
-        logoUri: 'logoUri',
-      },
-      explorerUrl: 'explorerUrl',
-      address: 'address',
-      nextPageToken: '',
-      offset: 1,
-    });
-    expect(result.transactions.length).toEqual(2);
-  });
-
-  it('should have returned 1 normal if nextPageToken contains only normal', async () => {
-    const result = await getTransactionFromEtherscan({
-      isTestnet: false,
-      chainId: 1,
-      networkToken: {
-        name: 'networkToken',
-        symbol: 'networkToken',
-        decimals: 1,
-        description: 'description',
-        logoUri: 'logoUri',
-      },
-      explorerUrl: 'explorerUrl',
-      address: 'address',
-      nextPageToken: JSON.stringify({ page: 1, queries: ['normal'] }),
-      offset: 1,
-    });
-    expect(result.transactions.length).toEqual(1);
-    expect(result.transactions[0]?.tokens[0]?.type).toEqual(TokenType.NATIVE);
-  });
-
-  it('should have returned 1 erc20 if nextPageToken contains only erc20', async () => {
-    const result = await getTransactionFromEtherscan({
-      isTestnet: false,
-      chainId: 1,
-      networkToken: {
-        name: 'networkToken',
-        symbol: 'networkToken',
-        decimals: 1,
-        description: 'description',
-        logoUri: 'logoUri',
-      },
-      explorerUrl: 'explorerUrl',
-      address: 'address',
-      nextPageToken: JSON.stringify({ page: 1, queries: ['erc20'] }),
-      offset: 1,
-    });
-    expect(result.transactions.length).toEqual(1);
-    expect(result.transactions[0]?.tokens[0]?.type).toEqual(TokenType.ERC20);
-  });
-});

package/src/handlers/get-transaction-history/converters/etherscan-transaction-converter/get-transaction-from-etherscan.ts

@@ -1,73 +0,0 @@
-import { convertTransactionNormal } from './convert-transaction-normal';
-import { convertTransactionERC20 } from './convert-transaction-erc20';
-import type { NetworkToken, TransactionHistoryResponse } from '@avalabs/vm-module-types';
-import { getErc20Txs, getNormalTxs } from '@avalabs/etherscan-sdk';
-
-interface EtherscanPagination {
-  queries: ('normal' | 'erc20')[];
-  page?: number;
-}
-
-export const getTransactionFromEtherscan = async ({
-  isTestnet,
-  networkToken,
-  explorerUrl,
-  chainId,
-  address,
-  nextPageToken,
-  offset,
-}: {
-  isTestnet?: boolean;
-  networkToken: NetworkToken;
-  explorerUrl: string;
-  chainId: number;
-  address: string;
-  nextPageToken?: string;
-  offset?: number;
-}): Promise<TransactionHistoryResponse> => {
-  /*
-  Using JSON for nextPageToken because this function is managing both the Normal
-  and ERC20 queries. It encodes the current page and the queries that should be
-  run. For example, if 'normal' has no more records to fetch then it will be
-  excluded from the list and the JSON will be something like:
-  { page: 3, queries: ['erc20'] }
-  */
-  const parsedPageToken = nextPageToken ? (JSON.parse(nextPageToken) as EtherscanPagination) : undefined;
-  const page = parsedPageToken?.page || 1;
-  const queries = parsedPageToken?.queries || ['normal', 'erc20'];
-
-  const normalHist = (queries.includes('normal') ? await getNormalTxs(address, !isTestnet, { page, offset }) : []).map(
-    (tx) => convertTransactionNormal({ tx, chainId, networkToken, explorerUrl, address }),
-  );
-
-  const erc20Hist = (
-    queries.includes('erc20')
-      ? await getErc20Txs(address, !isTestnet, undefined, {
-          page,
-          offset,
-        })
-      : []
-  ).map((tx) =>
-    convertTransactionERC20({
-      tx,
-      address,
-      explorerUrl,
-      chainId,
-    }),
-  );
-
-  // Filter erc20 transactions from normal tx list
-  const erc20TxHashes = erc20Hist.map((tx) => tx.hash);
-  const filteredNormalTxs = normalHist.filter((tx) => {
-    return !erc20TxHashes.includes(tx.hash);
-  });
-
-  const next: EtherscanPagination = { queries: [], page: page + 1 };
-  if (normalHist.length) next.queries.push('normal');
-  if (erc20Hist.length) next.queries.push('erc20');
-
-  return {
-    transactions: [...filteredNormalTxs, ...erc20Hist],
-    nextPageToken: next.queries.length ? JSON.stringify(next) : '', // stop pagination
-  };
-};

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

@@ -1,47 +0,0 @@
-import type { Transaction, NetworkToken } from '@avalabs/vm-module-types';
-import { getTxType } from './get-tx-type';
-import { getSenderInfo } from './get-sender-info';
-import { getTokens } from './get-tokens';
-import { getExplorerAddressByNetwork } from '../../utils/get-explorer-address-by-network';
-import type { TransactionDetails } from '@avalabs/glacier-sdk';
-import { NonContractCallTypes } from '../../../../types';
-
-type ConvertTransactionParams = {
-  transactions: TransactionDetails;
-  explorerUrl: string;
-  networkToken: NetworkToken;
-  chainId: number;
-  address: string;
-};
-
-export const convertTransaction = async ({
-  transactions,
-  explorerUrl,
-  networkToken,
-  chainId,
-  address,
-}: ConvertTransactionParams): Promise<Transaction> => {
-  const tokens = await getTokens(transactions, networkToken);
-  const txType = getTxType(transactions, address, tokens);
-  const { isOutgoing, isIncoming, isSender, from, to } = getSenderInfo(txType, transactions, address);
-  const { blockTimestamp, txHash: hash, gasPrice, gasUsed } = transactions.nativeTransaction;
-  const explorerLink = getExplorerAddressByNetwork(explorerUrl, hash);
-  const isContractCall = !NonContractCallTypes.includes(txType);
-
-  return {
-    isContractCall,
-    isIncoming,
-    isOutgoing,
-    isSender,
-    timestamp: blockTimestamp * 1000, // s to ms
-    hash,
-    from,
-    to,
-    tokens,
-    gasPrice,
-    gasUsed,
-    chainId: chainId.toString(),
-    txType,
-    explorerLink,
-  };
-};

package/src/handlers/get-transaction-history/converters/evm-transaction-converter/get-nft-metadata.ts

@@ -1,35 +0,0 @@
-import { ipfsResolverWithFallback } from '../../utils/ipfs-resolver-with-fallback';
-
-interface NftMetadata {
-  attributes?: string;
-  name?: string;
-  image?: string;
-  description?: string;
-}
-
-async function fetchWithTimeout(uri: string, timeout = 5000) {
-  const controller = new AbortController();
-  setTimeout(() => controller.abort(), timeout);
-
-  return fetch(uri, { signal: controller.signal });
-}
-
-export async function getNftMetadata(tokenUri: string) {
-  let data: NftMetadata = {};
-  if (!tokenUri) {
-    return {};
-  } else if (tokenUri.startsWith('data:application/json;base64,')) {
-    const value = tokenUri.substring(29);
-    try {
-      const json = Buffer.from(value, 'base64').toString();
-      data = JSON.parse(json);
-    } catch {
-      data = {};
-    }
-  } else {
-    data = await fetchWithTimeout(ipfsResolverWithFallback(tokenUri))
-      .then((r) => r.json())
-      .catch(() => ({}));
-  }
-  return data;
-}

package/src/handlers/get-transaction-history/converters/evm-transaction-converter/get-sender-info.ts

@@ -1,38 +0,0 @@
-import type { TransactionDetails } from '@avalabs/glacier-sdk';
-import { TransactionType } from '@avalabs/vm-module-types';
-
-export const getSenderInfo = (
-  txType: TransactionType,
-  { nativeTransaction, erc20Transfers, erc721Transfers }: TransactionDetails,
-  address: string,
-): { isOutgoing: boolean; isIncoming: boolean; isSender: boolean; from: string; to: string } => {
-  const isTransfer = txType === TransactionType.TRANSFER;
-  const isNativeSend = txType === TransactionType.SEND;
-  const isNativeReceive = txType === TransactionType.RECEIVE;
-  let from = nativeTransaction?.from?.address;
-  let to = nativeTransaction?.to?.address;
-
-  // Until multi tokens transaction is supported in UI, using from and to of the only token is helpful for UI
-  if (isTransfer && erc20Transfers && erc20Transfers[0]) {
-    from = erc20Transfers[0].from.address;
-    to = erc20Transfers[0].to.address;
-  }
-
-  if (isTransfer && erc721Transfers && erc721Transfers[0]) {
-    from = erc721Transfers[0].from.address;
-    to = erc721Transfers[0].to.address;
-  }
-
-  const isOutgoing = isNativeSend || (isTransfer && from.toLowerCase() === address.toLowerCase());
-  const isIncoming = isNativeReceive || (isTransfer && to.toLowerCase() === address.toLowerCase());
-
-  const isSender = from === address;
-
-  return {
-    isOutgoing,
-    isIncoming,
-    isSender,
-    from,
-    to,
-  };
-};