@avalabs/evm-module 0.0.1 → 0.0.5

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

@@ -0,0 +1,60 @@
+import type { GetTransactionHistory, TransactionHistoryResponse } from '@avalabs/vm-module-types';
+import { Glacier } from '@avalabs/glacier-sdk';
+import { convertTransaction } from './convert-transaction';
+
+export const getTransactionsFromGlacier = async ({
+  chainId,
+  explorerUrl,
+  networkToken,
+  address,
+  nextPageToken,
+  offset,
+  glacierApiUrl,
+}: GetTransactionHistory): Promise<TransactionHistoryResponse> => {
+  if (!glacierApiUrl) {
+    throw new Error('Glacier API URL is required');
+  }
+
+  const glacierSdk = new Glacier({ BASE: glacierApiUrl });
+
+  try {
+    const response = await glacierSdk.evmTransactions.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

@@ -0,0 +1,48 @@
+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,
+  address: string,
+  tokens: TxToken[],
+): TransactionType => {
+  const nativeOnly = !erc20Transfers && !erc721Transfers;
+  const method = parseRawMethod(nativeTransaction.method?.methodName);
+
+  const isSwap = method.toLowerCase().includes('swap');
+  const isNativeSend = nativeOnly && nativeTransaction.from.address === address;
+  const isNativeReceive = nativeOnly && nativeTransaction.to.address === 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 === address;
+  const isNFTReceive = isTransfer && !!tokens[0] && isNFT(tokens[0].type) && tokens[0].to?.address === 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/index.test.ts

@@ -0,0 +1,50 @@
+import { getTransactionHistory } from './index';
+import { getTransactionFromEtherscan } from './converters/etherscan-transaction-converter/get-transaction-from-etherscan';
+import { getTransactionsFromGlacier } from './converters/evm-transaction-converter/get-transactions-from-glacier';
+
+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({
+      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 () => {
+    await getTransactionHistory({
+      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/index.ts

@@ -0,0 +1,37 @@
+import { getTransactionFromEtherscan } from './converters/etherscan-transaction-converter/get-transaction-from-etherscan';
+import { isEthereumChainId } from './utils/is-ethereum-chain-id';
+import type { GetTransactionHistory, TransactionHistoryResponse } from '@avalabs/vm-module-types';
+import { getTransactionsFromGlacier } from './converters/evm-transaction-converter/get-transactions-from-glacier';
+
+export const getTransactionHistory = async ({
+  chainId,
+  isTestnet,
+  networkToken,
+  explorerUrl,
+  address,
+  nextPageToken,
+  offset,
+  glacierApiUrl,
+}: GetTransactionHistory): Promise<TransactionHistoryResponse> => {
+  if (isEthereumChainId(chainId)) {
+    return getTransactionFromEtherscan({
+      isTestnet,
+      networkToken,
+      explorerUrl,
+      chainId,
+      address,
+      nextPageToken,
+      offset,
+    });
+  }
+  return getTransactionsFromGlacier({
+    isTestnet,
+    networkToken,
+    explorerUrl,
+    chainId,
+    address,
+    nextPageToken,
+    offset,
+    glacierApiUrl,
+  });
+};

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

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

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

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

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

@@ -0,0 +1,7 @@
+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,22 +1,34 @@
-import { parseManifest } from '@internal/types';
-import type { Module } from '@internal/types';
+import type { Module, Manifest, NetworkFees, GetTransactionHistory } from '@avalabs/vm-module-types';
+import { parseManifest } from '@avalabs/vm-module-types';
+import type { JsonRpcProvider } from 'ethers';
+import { getNetworkFee } from './handlers/get-network-fee';
+import { getTransactionHistory } from './handlers/get-transaction-history';
+import ManifestJson from './manifest.json';
 
-export const evm: Module = {
-  getManifest: () => {
-    const manifest = require('./manifest.json');
-    const result = parseManifest(manifest);
-    return result.success ? result.data : undefined;
-  },
-  getBalances: () => {
-    return Promise.resolve('EVM balances');
-  },
-  getTransactionHistory: () => {
-    return Promise.resolve('EVM transaction history');
-  },
-  getNetworkFee: () => {
-    return Promise.resolve('EVM network fee');
-  },
-  getAddress: () => {
+export class EvmModule implements Module {
+  #provider: JsonRpcProvider;
+
+  constructor(provider: JsonRpcProvider) {
+    this.#provider = provider;
+  }
+  getAddress(): Promise<string> {
     return Promise.resolve('EVM address');
-  },
-};
+  }
+
+  getBalances(): Promise<string> {
+    return Promise.resolve('EVM balances');
+  }
+
+  getManifest(): Manifest | undefined {
+    const result = parseManifest(ManifestJson);
+    return result.success ? result.data : undefined;
+  }
+
+  getNetworkFee(): Promise<NetworkFees> {
+    return getNetworkFee(this.#provider);
+  }
+
+  getTransactionHistory(params: GetTransactionHistory) {
+    return getTransactionHistory(params);
+  }
+}

package/src/manifest.json

@@ -32,7 +32,7 @@
   "permissions": {
     "rpc": {
       "dapps": true,
-      "methods": ["eth_sendTransaction", "eth_*"]
+      "methods": ["eth_sendTransaction", "eth_*", "getTransactionHistory"]
     }
   },
   "manifestVersion": "0.0"

package/src/types.ts

@@ -0,0 +1,3 @@
+import { TransactionType } from '@avalabs/vm-module-types';
+
+export const NonContractCallTypes = [TransactionType.SEND, TransactionType.RECEIVE, TransactionType.TRANSFER];

package/tsconfig.json

@@ -4,5 +4,9 @@
     "outDir": "./dist",
     "incremental": false // Need to turn off because of tsup dts
   },
-  "include": ["src", "src/types"]
+  "include": ["src"],
+  "references": [
+    { "path": "../../packages/vm-module-types/tsconfig.json" },
+    { "path": "../../packages-internal/types/tsconfig.json" }
+  ]
 }