@avalabs/evm-module 0.0.23 → 0.1.1

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

@@ -1,49 +0,0 @@
-import type { Erc20Tx } from '@avalabs/etherscan-sdk';
-import { TokenType, TransactionType, type Transaction } from '@avalabs/vm-module-types';
-import { TokenUnit } from '@avalabs/utils-sdk';
-import { getExplorerAddressByNetwork } from '../../utils/get-explorer-address-by-network';
-
-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 amount = new TokenUnit(tx.value, Number(tx.tokenDecimal), tx.tokenSymbol);
-  const amountDisplayValue = amount.toDisplay();
-  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.test.ts

@@ -1,57 +0,0 @@
-import { TokenType, TransactionType } from '@avalabs/vm-module-types';
-import { convertTransactionNormal } from './convert-transaction-normal';
-import type { NormalTx } from '@avalabs/etherscan-sdk';
-
-describe('convertTransactionNormal ', () => {
-  it('correctly converts normal transaction data', () => {
-    const tx = {
-      from: '0xSenderAddress',
-      to: '0xReceiverAddress',
-      timeStamp: '1625794800', // Unix timestamp in seconds
-      value: '1000000000000000000', // 1 token in wei
-      gasPrice: '20000000000', // in wei
-      gasUsed: '21000',
-      hash: '0xTransactionHash',
-      input: '0x', // Empty input for a non-contract call
-    } as NormalTx;
-
-    const networkToken = {
-      name: 'Ethereum',
-      symbol: 'ETH',
-      decimals: 18,
-    };
-
-    const address = '0xSenderAddress';
-    const explorerUrl = 'https://explorer.example.com';
-    const chainId = 1;
-
-    const expected = {
-      isIncoming: false,
-      isOutgoing: true,
-      isContractCall: false,
-      timestamp: 1625794800000, // Converted timestamp in milliseconds
-      hash: '0xTransactionHash',
-      isSender: true,
-      from: '0xSenderAddress',
-      to: '0xReceiverAddress',
-      tokens: [
-        {
-          decimal: '18',
-          name: 'Ethereum',
-          symbol: 'ETH',
-          amount: '1',
-          type: TokenType.NATIVE,
-        },
-      ],
-      gasUsed: '21000',
-      gasPrice: '20000000000',
-      chainId: '1',
-      txType: TransactionType.SEND,
-      explorerLink: 'https://explorer.example.com/tx/0xTransactionHash', // Assuming this is how the explorer link is formatted
-    };
-
-    const result = convertTransactionNormal({ tx, networkToken, chainId, explorerUrl, address });
-
-    expect(result).toEqual(expected);
-  });
-});

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

@@ -1,57 +0,0 @@
-import type { NormalTx } from '@avalabs/etherscan-sdk';
-import { TokenType, TransactionType, type NetworkToken, type Transaction } from '@avalabs/vm-module-types';
-import { TokenUnit } from '@avalabs/utils-sdk';
-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 amount = new TokenUnit(tx.value, networkToken.decimals, networkToken.symbol);
-  const amountDisplayValue = amount.toDisplay();
-  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,
-  };
-};

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

@@ -1,106 +0,0 @@
-import type { TransactionDetails } from '@avalabs/glacier-sdk';
-import { TokenUnit } from '@avalabs/utils-sdk';
-import type { TxToken, NetworkToken } from '@avalabs/vm-module-types';
-import { TokenType } from '@avalabs/vm-module-types';
-import { resolve } from '../../utils/resolve';
-import { getNftMetadata } from './get-nft-metadata';
-import { getSmallImageForNFT } from '../../utils/get-small-image-for-nft';
-import { ipfsResolverWithFallback } from '../../utils/ipfs-resolver-with-fallback';
-
-export const getTokens = async (
-  { nativeTransaction, erc20Transfers, erc721Transfers, erc1155Transfers }: TransactionDetails,
-  networkToken: NetworkToken,
-): Promise<TxToken[]> => {
-  const result: TxToken[] = [];
-
-  if (nativeTransaction.value !== '0') {
-    const decimal = networkToken.decimals;
-    const amount = new TokenUnit(nativeTransaction.value, networkToken.decimals, networkToken.symbol);
-    const amountDisplayValue = amount.toDisplay();
-    result.push({
-      decimal: decimal.toString(),
-      name: networkToken.name,
-      symbol: networkToken.symbol,
-      amount: amountDisplayValue,
-      from: nativeTransaction.from,
-      to: nativeTransaction.to,
-      type: TokenType.NATIVE,
-    });
-  }
-
-  erc20Transfers?.forEach((erc20Transfer) => {
-    const decimals = erc20Transfer.erc20Token.decimals;
-    const amount = new TokenUnit(erc20Transfer.value, decimals, erc20Transfer.erc20Token.symbol);
-    const amountDisplayValue = amount.toDisplay();
-
-    result.push({
-      decimal: decimals.toString(),
-      name: erc20Transfer.erc20Token.name,
-      symbol: erc20Transfer.erc20Token.symbol,
-      amount: amountDisplayValue,
-      from: erc20Transfer.from,
-      to: erc20Transfer.to,
-      imageUri: erc20Transfer.erc20Token.logoUri,
-      type: TokenType.ERC20,
-    });
-  });
-
-  if (erc721Transfers) {
-    await Promise.allSettled(
-      erc721Transfers.map(async (erc721Transfer) => {
-        const token = erc721Transfer.erc721Token;
-        const imageUri = await getImageUri(token.tokenUri, token.metadata.imageUri);
-
-        result.push({
-          name: erc721Transfer.erc721Token.name,
-          symbol: erc721Transfer.erc721Token.symbol,
-          amount: '1',
-          imageUri,
-          from: erc721Transfer.from,
-          to: erc721Transfer.to,
-          collectableTokenId: erc721Transfer.erc721Token.tokenId,
-          type: TokenType.ERC721,
-        });
-      }),
-    );
-  }
-
-  if (erc1155Transfers) {
-    await Promise.allSettled(
-      erc1155Transfers.map(async (erc1155Transfer) => {
-        const token = erc1155Transfer.erc1155Token;
-        const imageUri = await getImageUri(token.tokenUri, token.metadata.imageUri);
-
-        result.push({
-          name: erc1155Transfer.erc1155Token.metadata.name ?? '',
-          symbol: erc1155Transfer.erc1155Token.metadata.symbol ?? '',
-          amount: erc1155Transfer.value,
-          imageUri,
-          from: erc1155Transfer.from,
-          to: erc1155Transfer.to,
-          collectableTokenId: erc1155Transfer.erc1155Token.tokenId,
-          type: TokenType.ERC1155,
-        });
-      }),
-    );
-  }
-
-  return result;
-};
-
-const getImageUri = async (tokenUri: string, imageUri?: string): Promise<string> => {
-  if (imageUri) {
-    if (imageUri.startsWith('ipfs://')) {
-      return ipfsResolverWithFallback(imageUri);
-    } else {
-      return imageUri;
-    }
-  } else {
-    const [metadata, error] = await resolve(getNftMetadata(tokenUri));
-    if (error) {
-      return '';
-    } else {
-      return metadata.image ? getSmallImageForNFT(metadata.image) : '';
-    }
-  }
-};