@avalabs/evm-module 0.0.2 → 0.0.6

package/package.json

@@ -1,24 +1,37 @@
 {
   "name": "@avalabs/evm-module",
-  "version": "0.0.2",
+  "version": "0.0.6",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "type": "module",
+  "dependencies": {
+    "@avalabs/utils-sdk": "v2.8.0-alpha.187",
+    "@avalabs/chains-sdk": "v2.8.0-alpha.187",
+    "@avalabs/etherscan-sdk": "v2.8.0-alpha.187",
+    "@avalabs/glacier-sdk": "v2.8.0-alpha.187",
+    "bn.js": "5.2.1",
+    "lodash.startcase": "4.4.0",
+    "@avalabs/vm-module-types": "0.0.6"
+  },
   "devDependencies": {
+    "@types/bn.js": "5.1.5",
     "@types/jest": "29.5.7",
-    "@types/lodash": "4.14.201",
+    "@types/lodash.startcase": "4.4.9",
     "jest": "29.7.0",
     "ts-jest": "29.1.1",
     "tsup": "7.2.0",
-    "@internal/types": "0.0.1",
+    "ethers": "6.8.1",
     "@internal/tsup-config": "0.0.1",
     "eslint-config-custom": "0.0.1"
   },
+  "peerDependencies": {
+    "ethers": "^6.8.1"
+  },
   "scripts": {
     "build": "tsup",
     "lint": "eslint \"src/**/*.ts\"",
-    "test": "jest --passWithNoTests",
+    "test": "jest",
     "test:watch": "jest --watch"
   }
 }

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

@@ -0,0 +1,38 @@
+import { getNetworkFee } from './get-network-fee';
+import { FeeData, JsonRpcProvider } from 'ethers';
+
+describe('get-network-fee', () => {
+  it("should throw error if provider.getFeeData() doesn't return eip-1559 compatible fees", async () => {
+    jest.spyOn(JsonRpcProvider.prototype, 'getFeeData').mockImplementationOnce(async () => {
+      return {
+        maxFeePerGas: null,
+      } as FeeData;
+    });
+    const provider = new JsonRpcProvider();
+    await expect(getNetworkFee(provider)).rejects.toThrow('Pre-EIP-1559 networks are not supported');
+  });
+
+  it('should return correct network fees based on maxFeePerGas returned from provider.getFeeData', async () => {
+    jest.spyOn(JsonRpcProvider.prototype, 'getFeeData').mockImplementationOnce(async () => {
+      return {
+        maxFeePerGas: 1000000000n, //1 gWei
+      } as FeeData;
+    });
+    const provider = new JsonRpcProvider();
+    await expect(getNetworkFee(provider)).resolves.toEqual({
+      baseFee: 1000000000n,
+      low: {
+        maxFeePerGas: 1500000000n,
+        maxPriorityFeePerGas: 500000000n,
+      },
+      medium: {
+        maxFeePerGas: 3000000000n,
+        maxPriorityFeePerGas: 2000000000n,
+      },
+      high: {
+        maxFeePerGas: 4000000000n,
+        maxPriorityFeePerGas: 3000000000n,
+      },
+    });
+  });
+});

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

@@ -0,0 +1,41 @@
+import { JsonRpcProvider } from 'ethers';
+import type { NetworkFees } from '@avalabs/vm-module-types';
+
+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.
+ * @param provider
+ * @throws Error if provider does not support eip-1559
+ */
+export async function getNetworkFee(provider: JsonRpcProvider): Promise<NetworkFees> {
+  const { maxFeePerGas: maxFeePerGasInWei } = await provider.getFeeData();
+  if (!maxFeePerGasInWei) {
+    throw new Error('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,
+    },
+  };
+}

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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,65 @@
+import { convertTransactionNormal } from './convert-transaction-normal';
+import { convertTransactionERC20 } from './convert-transaction-erc20';
+import type { GetTransactionHistory, 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,
+  chainId,
+  networkToken,
+  explorerUrl,
+  address,
+  nextPageToken,
+  offset,
+}: GetTransactionHistory): 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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,38 @@
+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 === address);
+  const isIncoming = isNativeReceive || (isTransfer && to === address);
+
+  const isSender = from === address;
+
+  return {
+    isOutgoing,
+    isIncoming,
+    isSender,
+    from,
+    to,
+  };
+};

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

@@ -0,0 +1,107 @@
+import type { TransactionDetails } from '@avalabs/glacier-sdk';
+import { balanceToDisplayValue } from '@avalabs/utils-sdk';
+import { BN } from 'bn.js';
+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 amountBN = new BN(nativeTransaction.value);
+    const amountDisplayValue = balanceToDisplayValue(amountBN, decimal);
+    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 amountBN = new BN(erc20Transfer.value);
+    const amountDisplayValue = balanceToDisplayValue(amountBN, decimals);
+
+    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) : '';
+    }
+  }
+};