@avalabs/evm-module 0.0.22 → 0.1.0

package/src/types.ts

@@ -1,25 +0,0 @@
-import { TransactionType } from '@avalabs/vm-module-types';
-
-export const NonContractCallTypes = [TransactionType.SEND, TransactionType.RECEIVE, TransactionType.TRANSFER];
-
-export type TransactionParams = {
-  from: string;
-  to: string;
-  data?: string;
-  value?: string;
-  gas?: string;
-  gasPrice?: string;
-  maxFeePerGas?: string;
-  maxPriorityFeePerGas?: string;
-  nonce?: string;
-  chainId?: string;
-};
-
-export enum ERC20TransactionType {
-  TOTAL_SUPPLY = 'totalSupply',
-  BALANCE_OF = 'balanceOf',
-  TRANSFER = 'transfer',
-  TRANSFER_FROM = 'transferFrom',
-  APPROVE = 'approve',
-  ALLOWANCE = 'allowance',
-}

package/src/utils/estimate-gas-limit.ts

@@ -1,27 +0,0 @@
-import { JsonRpcBatchInternal } from '@avalabs/wallets-sdk';
-import type { BigNumberish } from 'ethers';
-
-export const estimateGasLimit = async ({
-  transactionParams: { from, to, data, value },
-  provider,
-}: {
-  transactionParams: {
-    from: string;
-    to: string;
-    data?: string;
-    value?: BigNumberish;
-  };
-  provider: JsonRpcBatchInternal;
-}): Promise<number> => {
-  const nonce = await provider.getTransactionCount(from);
-
-  return Number(
-    await provider.estimateGas({
-      from,
-      to,
-      nonce,
-      data,
-      value,
-    }),
-  );
-};

package/src/utils/get-chain-id.ts

@@ -1,12 +0,0 @@
-import type { Caip2ChainId } from '@avalabs/vm-module-types';
-import { rpcErrors } from '@metamask/rpc-errors';
-
-export const getChainId = (caip2ChainId: Caip2ChainId): number => {
-  const chainId = caip2ChainId.split(':')[1];
-
-  if (!chainId || isNaN(Number(chainId))) {
-    throw rpcErrors.invalidParams('Invalid chainId');
-  }
-
-  return Number(chainId);
-};

package/src/utils/get-nonce.ts

@@ -1,11 +0,0 @@
-import { JsonRpcBatchInternal } from '@avalabs/wallets-sdk';
-
-export const getNonce = async ({
-  from,
-  provider,
-}: {
-  from: string;
-  provider: JsonRpcBatchInternal;
-}): Promise<number> => {
-  return provider.getTransactionCount(from);
-};

package/src/utils/get-provider.ts

@@ -1,46 +0,0 @@
-import { JsonRpcBatchInternal } from '@avalabs/wallets-sdk';
-import { Network as EVMNetwork } from 'ethers';
-
-// this key is only needed in development to bypass rate limit
-// it should never be used in production
-const GLACIER_API_KEY = process.env.GLACIER_API_KEY;
-
-type ProviderParams = {
-  chainId: number;
-  chainName: string;
-  rpcUrl: string;
-  multiContractAddress?: string;
-  pollingInterval?: number;
-};
-
-export const getProvider = (params: ProviderParams): JsonRpcBatchInternal => {
-  const { chainId, chainName, rpcUrl, multiContractAddress, pollingInterval = 2000 } = params;
-
-  const provider = new JsonRpcBatchInternal(
-    { maxCalls: 40, multiContractAddress },
-    addGlacierAPIKeyIfNeeded(rpcUrl, GLACIER_API_KEY),
-    new EVMNetwork(chainName, chainId),
-  );
-
-  provider.pollingInterval = pollingInterval;
-
-  return provider;
-};
-
-// RPC urls returned in the token list are always using the production URL
-const knownHosts = ['glacier-api.avax.network', 'proxy-api.avax.network'];
-
-/**
- * Glacier needs an API key for development, this adds the key if needed.
- */
-export function addGlacierAPIKeyIfNeeded(url: string, glacierApiKey?: string): string {
-  const urlObj = new URL(url);
-
-  if (glacierApiKey && knownHosts.includes(urlObj.hostname)) {
-    const search_params = urlObj.searchParams; // copy, does not update the URL
-    search_params.set('token', glacierApiKey);
-    urlObj.search = search_params.toString();
-    return urlObj.toString();
-  }
-  return url;
-}

package/src/utils/parse-erc20-transaction-type.ts

@@ -1,35 +0,0 @@
-import { Interface } from 'ethers';
-import ERC20 from '@openzeppelin/contracts/build/contracts/ERC20.json';
-import { ERC20TransactionType } from '../types';
-
-export const parseERC20TransactionType = (transaction: {
-  data?: string;
-  value?: string;
-}): ERC20TransactionType | undefined => {
-  if (!transaction.data) {
-    return undefined;
-  }
-
-  try {
-    const contractInterface = new Interface(ERC20.abi);
-
-    const description = contractInterface.parseTransaction({
-      data: transaction.data,
-      value: transaction.value,
-    });
-
-    const functionName = description?.name ?? description?.fragment?.name;
-
-    if (functionName && isERC20TransactionType(functionName)) {
-      return functionName;
-    }
-
-    return undefined;
-  } catch (e) {
-    return undefined;
-  }
-};
-
-function isERC20TransactionType(value: string): value is ERC20TransactionType {
-  return Object.values(ERC20TransactionType).includes(value as ERC20TransactionType);
-}

package/src/utils/process-transaction-simulation.test.ts

@@ -1,105 +0,0 @@
-import Blockaid from '@blockaid/client';
-import { processBalanceChange } from './process-transaction-simulation';
-
-jest.mock('@blockaid/client', () => {
-  return jest.fn().mockImplementation(() => {
-    return {};
-  });
-});
-
-describe('processBalanceChange', () => {
-  it('should sort asset diffs correctly within ins and outs', () => {
-    const assetDiffs: Blockaid.AssetDiff[] = [
-      {
-        asset: {
-          type: 'ERC20',
-          address: '0xTokenAddress1',
-          name: 'TokenName1',
-          symbol: 'TKN1',
-          decimals: 18,
-          logo_url: 'logo_url1',
-        },
-        in: [
-          { value: '1', usd_price: '1', raw_value: '0x1' },
-          { value: '2', usd_price: '2', raw_value: '0x2' },
-        ],
-        out: [
-          { value: '3', usd_price: '3', raw_value: '0x3' },
-          { value: '1', usd_price: '1', raw_value: '0x1' },
-        ],
-      },
-      {
-        asset: {
-          type: 'ERC20',
-          address: '0xTokenAddress2',
-          name: 'TokenName2',
-          symbol: 'TKN2',
-          decimals: 18,
-          logo_url: 'logo_url2',
-        },
-        in: [{ value: '4', usd_price: '4', raw_value: '0x4' }],
-        out: [{ value: '5', usd_price: '5', raw_value: '0x5' }],
-      },
-    ];
-
-    const result = processBalanceChange(assetDiffs);
-
-    // Verify sorting logic for 'ins'
-    expect(result?.ins).toEqual([
-      {
-        token: {
-          type: 'ERC20',
-          address: '0xTokenAddress2',
-          name: 'TokenName2',
-          symbol: 'TKN2',
-          decimals: 18,
-          logoUri: 'logo_url2',
-        },
-        items: [{ displayValue: '4', usdPrice: '4' }],
-      },
-      {
-        token: {
-          type: 'ERC20',
-          address: '0xTokenAddress1',
-          name: 'TokenName1',
-          symbol: 'TKN1',
-          decimals: 18,
-          logoUri: 'logo_url1',
-        },
-        items: [
-          { displayValue: '1', usdPrice: '1' },
-          { displayValue: '2', usdPrice: '2' },
-        ],
-      },
-    ]);
-
-    // Verify sorting logic for 'outs'
-    expect(result?.outs).toEqual([
-      {
-        token: {
-          type: 'ERC20',
-          address: '0xTokenAddress2',
-          name: 'TokenName2',
-          symbol: 'TKN2',
-          decimals: 18,
-          logoUri: 'logo_url2',
-        },
-        items: [{ displayValue: '5', usdPrice: '5' }],
-      },
-      {
-        token: {
-          type: 'ERC20',
-          address: '0xTokenAddress1',
-          name: 'TokenName1',
-          symbol: 'TKN1',
-          decimals: 18,
-          logoUri: 'logo_url1',
-        },
-        items: [
-          { displayValue: '3', usdPrice: '3' },
-          { displayValue: '1', usdPrice: '1' },
-        ],
-      },
-    ]);
-  });
-});

package/src/utils/process-transaction-simulation.ts

@@ -1,293 +0,0 @@
-import Blockaid from '@blockaid/client';
-import type { TransactionParams } from '../types';
-import {
-  type NetworkContractToken,
-  type NetworkToken,
-  TokenType,
-  AlertType,
-  type Alert,
-  type BalanceChange,
-  type TokenApproval,
-  type TokenDiff,
-  type TokenDiffItem,
-  type TokenApprovals,
-  type RpcRequest,
-  RpcMethod,
-} from '@avalabs/vm-module-types';
-import { balanceToDisplayValue, numberToBN } from '@avalabs/utils-sdk';
-import { isHexString } from 'ethers';
-import { scanJsonRpc, scanTransaction } from './scan-transaction';
-
-export const processTransactionSimulation = async ({
-  request,
-  dAppUrl,
-  params,
-  chainId,
-  proxyApiUrl,
-}: {
-  request: RpcRequest;
-  dAppUrl?: string;
-  params: TransactionParams;
-  chainId: number;
-  proxyApiUrl: string;
-}) => {
-  let alert: Alert | undefined;
-  let balanceChange: BalanceChange | undefined;
-  let tokenApprovals: TokenApprovals | undefined;
-
-  try {
-    const { validation, simulation } = await scanTransaction({
-      proxyApiUrl,
-      chainId,
-      params,
-      domain: dAppUrl,
-    });
-
-    if (!validation || validation.result_type === 'Error' || validation.result_type === 'Warning') {
-      alert = transactionAlerts[AlertType.WARNING];
-    } else if (validation.result_type === 'Malicious') {
-      alert = transactionAlerts[AlertType.DANGER];
-    }
-
-    if (simulation?.status === 'Success') {
-      tokenApprovals = processTokenApprovals(request, simulation.account_summary.exposures);
-      balanceChange = processBalanceChange(simulation.account_summary.assets_diffs);
-    }
-  } catch (error) {
-    console.error('processTransactionSimulation error', error);
-    alert = transactionAlerts[AlertType.WARNING];
-  }
-
-  return { alert, balanceChange, tokenApprovals };
-};
-
-const processTokenApprovals = (
-  request: RpcRequest,
-  exposures: Blockaid.AddressAssetExposure[],
-): TokenApprovals | undefined => {
-  const approvals: TokenApproval[] = [];
-
-  for (const exposurePerAsset of exposures) {
-    const token = convertAssetToNetworkContractToken(exposurePerAsset.asset);
-    if (!token) {
-      continue;
-    }
-
-    for (const [spenderAddress, exposurePerSpender] of Object.entries(exposurePerAsset.spenders)) {
-      if (exposurePerSpender.exposure.length === 0) {
-        approvals.push({
-          token,
-          spenderAddress,
-          logoUri: token.logoUri,
-        });
-      } else {
-        for (const exposure of exposurePerSpender.exposure) {
-          if ('raw_value' in exposure) {
-            approvals.push({
-              token,
-              spenderAddress,
-              value: exposure.raw_value,
-              usdPrice: exposure.usd_price,
-              logoUri: token.logoUri,
-            });
-          } else {
-            approvals.push({
-              token,
-              spenderAddress,
-              logoUri: exposure.logo_url,
-              usdPrice: exposure.usd_price,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  if (approvals.length === 0) {
-    return undefined;
-  }
-
-  const isEditable =
-    approvals.length === 1 &&
-    approvals[0]?.token.type === TokenType.ERC20 &&
-    request.method === RpcMethod.ETH_SEND_TRANSACTION;
-
-  return { isEditable, approvals };
-};
-
-export const processBalanceChange = (assetDiffs: Blockaid.AssetDiff[]): BalanceChange | undefined => {
-  const ins = processAssetDiffs(assetDiffs, 'in');
-  const outs = processAssetDiffs(assetDiffs, 'out');
-
-  if (ins.length === 0 && outs.length === 0) {
-    return undefined;
-  }
-
-  return { ins, outs };
-};
-
-const processAssetDiffs = (assetDiffs: Blockaid.AssetDiff[], type: 'in' | 'out'): TokenDiff[] => {
-  return (
-    assetDiffs
-      .filter((assetDiff) => assetDiff[type].length > 0)
-      // sort asset diffs by length of in/out array
-      // this is done to ensure that the token with multiple in/out values are displayed last,
-      // to put them in groups with appropriate UI(i.e. accordion), after single in/out tokens
-      .sort((a, b) => a[type].length - b[type].length)
-      .map((assetDiff) => {
-        const asset = assetDiff.asset;
-        // convert blockaid asset to network token
-        const token: NetworkToken | NetworkContractToken | undefined =
-          'address' in asset ? convertAssetToNetworkContractToken(asset) : convertNativeAssetToToken(asset);
-        if (!token) {
-          return undefined;
-        }
-
-        const items = assetDiff[type]
-          .map((diff) => {
-            let displayValue;
-            if ('value' in diff && diff.value) {
-              if ('decimals' in token) {
-                const valueBN = numberToBN(diff.value, token.decimals);
-                displayValue = balanceToDisplayValue(valueBN, token.decimals);
-              } else if (isHexString(diff.value)) {
-                // for some token (like ERC1155) blockaid returns value in hex format
-                displayValue = parseInt(diff.value, 16).toString();
-              }
-            } else if ('type' in token && token.type === TokenType.ERC721) {
-              // for ERC721 type token, we just display 1 to indicate that a single NFT will be transferred
-              displayValue = '1';
-            }
-
-            return displayValue ? { displayValue, usdPrice: diff.usd_price } : undefined;
-          })
-          .filter((x): x is TokenDiffItem => x !== undefined);
-
-        return { token, items };
-      })
-      .filter((x): x is TokenDiff => x !== undefined)
-  );
-};
-
-const convertAssetToNetworkContractToken = (
-  asset:
-    | Blockaid.Erc20TokenDetails
-    | Blockaid.Erc1155TokenDetails
-    | Blockaid.Erc721TokenDetails
-    | Blockaid.NonercTokenDetails,
-): NetworkContractToken | undefined => {
-  let token: NetworkContractToken | undefined;
-  if (asset.type === 'ERC20') {
-    token = {
-      type: TokenType.ERC20,
-      address: asset.address,
-      decimals: asset.decimals,
-      name: asset.name ?? asset.symbol ?? '',
-      symbol: asset.symbol ?? '',
-      logoUri: asset.logo_url,
-    };
-  } else if (asset.type === 'ERC1155') {
-    token = {
-      type: TokenType.ERC1155,
-      address: asset.address,
-      logoUri: asset.logo_url,
-      name: asset.name,
-      symbol: asset.symbol,
-    };
-  } else if (asset.type === 'ERC721') {
-    token = {
-      type: TokenType.ERC721,
-      address: asset.address,
-      logoUri: asset.logo_url,
-      name: asset.name,
-      symbol: asset.symbol,
-    };
-  } else if (asset.type === 'NONERC') {
-    token = {
-      type: TokenType.NONERC,
-      address: asset.address,
-      logoUri: asset.logo_url,
-      name: asset.name,
-      symbol: asset.symbol,
-    };
-  }
-
-  return token;
-};
-
-const convertNativeAssetToToken = (asset: Blockaid.NativeAssetDetails): NetworkToken => {
-  return {
-    name: asset.name ?? '',
-    symbol: asset.symbol ?? '',
-    decimals: asset.decimals,
-    description: '',
-    logoUri: asset.logo_url,
-  };
-};
-
-export const processJsonRpcSimulation = async ({
-  request,
-  dAppUrl,
-  accountAddress,
-  chainId,
-  data,
-  proxyApiUrl,
-}: {
-  request: RpcRequest;
-  dAppUrl?: string;
-  accountAddress: string;
-  data: { method: string; params: unknown };
-  chainId: number;
-  proxyApiUrl: string;
-}) => {
-  let alert: Alert | undefined;
-  let balanceChange: BalanceChange | undefined;
-  let tokenApprovals: TokenApprovals | undefined;
-
-  try {
-    const { validation, simulation } = await scanJsonRpc({
-      proxyApiUrl,
-      chainId,
-      accountAddress,
-      data: data as Blockaid.Evm.JsonRpcScanParams.Data,
-      domain: dAppUrl,
-    });
-
-    if (!validation || validation.result_type === 'Error' || validation.result_type === 'Warning') {
-      alert = transactionAlerts[AlertType.WARNING];
-    } else if (validation.result_type === 'Malicious') {
-      alert = transactionAlerts[AlertType.DANGER];
-    }
-
-    if (simulation?.status === 'Success') {
-      tokenApprovals = processTokenApprovals(request, simulation.account_summary.exposures);
-      balanceChange = processBalanceChange(simulation.account_summary.assets_diffs);
-    }
-  } catch (error) {
-    console.error('processJsonRpcSimulation error', error);
-    alert = transactionAlerts[AlertType.WARNING];
-  }
-
-  return { alert, balanceChange, tokenApprovals };
-};
-
-const transactionAlerts = {
-  [AlertType.WARNING]: {
-    type: AlertType.WARNING,
-    details: {
-      title: 'Suspicious Transaction',
-      description: 'Use caution, this transaction may be malicious.',
-    },
-  },
-  [AlertType.DANGER]: {
-    type: AlertType.DANGER,
-    details: {
-      title: 'Scam Transaction',
-      description: 'This transaction is malicious, do not proceed.',
-      actionTitles: {
-        reject: 'Reject Transaction',
-        proceed: 'Proceed Anyway',
-      },
-    },
-  },
-};

package/src/utils/scan-transaction.ts

@@ -1,63 +0,0 @@
-import Blockaid from '@blockaid/client';
-import type { TransactionParams } from '../types';
-
-const DUMMY_API_KEY = 'DUMMY_API_KEY'; // since we're using our own proxy and api key is handled there, we can use a dummy key here
-
-export const scanTransaction = async ({
-  proxyApiUrl,
-  chainId,
-  params,
-  domain,
-}: {
-  proxyApiUrl: string;
-  chainId: number;
-  params: TransactionParams;
-  domain?: string;
-}): Promise<Blockaid.TransactionScanResponse> => {
-  const blockaid = new Blockaid({
-    baseURL: proxyApiUrl + '/proxy/blockaid/',
-    apiKey: DUMMY_API_KEY,
-  });
-
-  return blockaid.evm.transaction.scan({
-    account_address: params.from,
-    chain: chainId.toString(),
-    options: ['validation', 'simulation'],
-    data: {
-      from: params.from,
-      to: params.to,
-      data: params.data,
-      value: params.value,
-      gas: params.gas,
-      gas_price: params.gasPrice,
-    },
-    metadata: (domain && domain.length > 0 ? { domain } : { non_dapp: true }) as Blockaid.Evm.Metadata,
-  });
-};
-
-export const scanJsonRpc = async ({
-  proxyApiUrl,
-  chainId,
-  accountAddress,
-  data,
-  domain,
-}: {
-  proxyApiUrl: string;
-  chainId: number;
-  accountAddress: string;
-  data: Blockaid.Evm.JsonRpcScanParams.Data;
-  domain?: string;
-}): Promise<Blockaid.TransactionScanResponse> => {
-  const blockaid = new Blockaid({
-    baseURL: proxyApiUrl + '/proxy/blockaid/',
-    apiKey: DUMMY_API_KEY,
-  });
-
-  return blockaid.evm.jsonRpc.scan({
-    chain: chainId.toString(),
-    options: ['validation', 'simulation'],
-    account_address: accountAddress,
-    data,
-    metadata: (domain && domain.length > 0 ? { domain } : { non_dapp: true }) as Blockaid.Evm.Metadata,
-  });
-};

package/tsconfig.jest.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "verbatimModuleSyntax": false,
-    "esModuleInterop": true
-  }
-}

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "extends": "@internal/tsconfig/tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "declaration": false,
-    "incremental": false // Need to turn off because of tsup dts
-  },
-  "include": ["src"],
-  "references": [
-    {
-      "path": "../../packages-internal/utils/tsconfig.json"
-    }
-  ]
-}

package/tsup.config.ts

@@ -1,4 +0,0 @@
-import { defineConfig } from 'tsup';
-import { baseConfig } from '@internal/tsup-config';
-
-export default defineConfig(baseConfig);