@avalabs/evm-module 0.0.15 → 0.0.17

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

@@ -48,7 +48,6 @@ describe('get-balances', () => {
           balanceDisplayValue: '1',
           balanceInCurrency: 1,
           priceInCurrency: 1,
-          contractType: 'ERC-20',
           type: TokenType.ERC20,
           change24: 0,
           marketCap: 0,
@@ -89,7 +88,6 @@ describe('get-balances', () => {
           balanceInCurrency: 1,
           chainId: 1,
           change24: 0,
-          contractType: 'ERC-20',
           decimals: 18,
           logoUri: 'https://s3.us-east-2.amazonaws.com/nomics-api/static/images/currencies/dai.svg',
           marketCap: 0,
@@ -138,7 +136,6 @@ describe('get-balances', () => {
               symbol: 'DAI2',
               decimals: 18,
               logoUri: 'https://s3.us-east-2.amazonaws.com/nomics-api/static/images/currencies/dai.svg',
-              contractType: 'ERC-20',
               type: TokenType.ERC20,
             },
           ]),
@@ -178,7 +175,6 @@ describe('get-balances', () => {
           balanceDisplayValue: '1',
           balanceInCurrency: 1,
           priceInCurrency: 1,
-          contractType: 'ERC-20',
           type: TokenType.ERC20,
           change24: 0,
           marketCap: 0,
@@ -219,7 +215,6 @@ describe('get-balances', () => {
           balanceInCurrency: 1,
           chainId: 2,
           change24: 0,
-          contractType: 'ERC-20',
           decimals: 18,
           logoUri: 'https://s3.us-east-2.amazonaws.com/nomics-api/static/images/currencies/dai.svg',
           marketCap: 0,

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

@@ -1,4 +1,11 @@
-import type { GetBalancesResponse, GetBalancesParams, Storage } from '@avalabs/vm-module-types';
+import {
+  type GetBalancesResponse,
+  type GetBalancesParams,
+  type Storage,
+  TokenType,
+  type NetworkContractToken,
+  type ERC20Token,
+} from '@avalabs/vm-module-types';
 import { getErc20Balances } from './evm-balance-service/get-erc20-balances';
 import { TokenService } from '@internal/utils';
 import { getProvider } from '../../utils/get-provider';
@@ -37,7 +44,7 @@ export const getBalances = async ({
         });
 
         const erc20Tokens = await getErc20BalancesFromGlacier({
-          customTokens,
+          customTokens: customTokens.filter(isERC20Token),
           glacierService,
           currency,
           chainId,
@@ -80,7 +87,7 @@ export const getBalances = async ({
           tokenService,
           address,
           currency,
-          tokens: allTokens,
+          tokens: allTokens.filter(isERC20Token),
         });
 
         return {
@@ -107,3 +114,7 @@ export const getBalances = async ({
 
   return filterBalances;
 };
+
+function isERC20Token(token: NetworkContractToken): token is ERC20Token {
+  return token.type === TokenType.ERC20;
+}

package/src/handlers/get-balances/glacier-balance-service/get-erc20-balances.test.ts

@@ -50,7 +50,6 @@ describe('get-erc20-balances', () => {
         balanceDisplayValue: '1',
         balanceInCurrency: 1000,
         priceInCurrency: 1000,
-        contractType: 'ERC-20',
         type: 'ERC20',
         change24: 0,
         marketCap: 0,

package/src/handlers/get-balances/glacier-balance-service/get-erc20-balances.ts

@@ -2,12 +2,13 @@ import { balanceToDisplayValue, bnToBig } from '@avalabs/utils-sdk';
 import {
   TokenType,
   type TokenWithBalanceERC20,
-  type NetworkContractToken,
   type TokenWithBalance,
+  type ERC20Token,
 } from '@avalabs/vm-module-types';
 import { CurrencyCode, Erc20TokenBalance } from '@avalabs/glacier-sdk';
 import BN from 'bn.js';
 import type { EvmGlacierService } from '../../../services/glacier-service/glacier-service';
+import { DEFAULT_DECIMALS } from '../../../constants';
 
 export const getErc20Balances = async ({
   glacierService,
@@ -20,7 +21,7 @@ export const getErc20Balances = async ({
   address: string;
   currency: string;
   chainId: number;
-  customTokens: NetworkContractToken[];
+  customTokens: ERC20Token[];
 }): Promise<Record<string, TokenWithBalance>> => {
   const tokensWithBalance: TokenWithBalanceERC20[] = [];
   /**
@@ -37,7 +38,9 @@ export const getErc20Balances = async ({
       pageToken: nextPageToken,
     });
 
-    tokensWithBalance.push(...convertErc20ToTokenWithBalance(response.erc20TokenBalances, Number(chainId)));
+    tokensWithBalance.push(
+      ...convertErc20TokenWithBalanceToTokenWithBalance(response.erc20TokenBalances, Number(chainId)),
+    );
     nextPageToken = response.nextPageToken;
   } while (nextPageToken);
 
@@ -47,7 +50,7 @@ export const getErc20Balances = async ({
    * tokens are only used for swap, bridge and tx parsing.
    */
   return [
-    ...convertNetworkTokenToTokenWithBalance(customTokens),
+    ...convertErc20TokenToTokenWithBalance(customTokens),
     ...tokensWithBalance, // this needs to be second in the list so it overwrites its zero balance counterpart if there is one
   ].reduce(
     (acc, token) => {
@@ -57,10 +60,11 @@ export const getErc20Balances = async ({
   );
 };
 
-const convertNetworkTokenToTokenWithBalance = (tokens: NetworkContractToken[]): TokenWithBalanceERC20[] => {
+const convertErc20TokenToTokenWithBalance = (tokens: ERC20Token[]): TokenWithBalanceERC20[] => {
   return tokens.map((token) => {
     return {
       ...token,
+      decimals: token.decimals ?? DEFAULT_DECIMALS,
       type: TokenType.ERC20,
       balance: new BN(0),
       balanceInCurrency: 0,
@@ -74,7 +78,7 @@ const convertNetworkTokenToTokenWithBalance = (tokens: NetworkContractToken[]):
   });
 };
 
-const convertErc20ToTokenWithBalance = (
+const convertErc20TokenWithBalanceToTokenWithBalance = (
   tokenBalances: Erc20TokenBalance[],
   chainId: number,
 ): TokenWithBalanceERC20[] => {
@@ -97,7 +101,6 @@ const convertErc20ToTokenWithBalance = (
       balanceDisplayValue,
       balanceInCurrency,
       priceInCurrency,
-      contractType: 'ERC-20',
       type: TokenType.ERC20,
       change24: 0,
       marketCap: 0,

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

@@ -28,7 +28,7 @@ describe('get-tokens', () => {
           address: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7',
           name: 'Wrapped AVAX',
           symbol: 'WAVAX',
-          contractType: 'ERC-20',
+          type: 'ERC20',
           chainId: 43114,
           decimals: 18,
         },
@@ -36,7 +36,7 @@ describe('get-tokens', () => {
           address: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
           name: 'USD Coin',
           symbol: 'USDC',
-          contractType: 'ERC-20',
+          type: 'ERC20',
           chainId: 43114,
           decimals: 6,
         },
@@ -58,7 +58,7 @@ describe('get-tokens', () => {
           address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
           name: 'Tether USD',
           symbol: 'USDT',
-          contractType: 'ERC-20',
+          type: 'ERC20',
           chainId: 1,
           decimals: 6,
         },
@@ -66,7 +66,7 @@ describe('get-tokens', () => {
           address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
           name: 'USDCoin',
           symbol: 'USDC',
-          contractType: 'ERC-20',
+          type: 'ERC20',
           chainId: 1,
           decimals: 6,
         },
@@ -74,7 +74,7 @@ describe('get-tokens', () => {
           address: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
           name: 'Wrapped BTC',
           symbol: 'WBTC',
-          contractType: 'ERC-20',
+          type: 'ERC20',
           chainId: 1,
           decimals: 8,
         },
@@ -82,7 +82,7 @@ describe('get-tokens', () => {
           address: '0x514910771AF9Ca656af840dff83E8264EcF986CA',
           name: 'ChainLink Token',
           symbol: 'LINK',
-          contractType: 'ERC-20',
+          type: 'ERC20',
           chainId: 1,
           decimals: 18,
         },

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from './module';
 export * from './types';
+export * from './handlers/eth-sign/utils/typeguards';

package/src/module.ts

@@ -20,6 +20,7 @@ import { ethSendTransaction } from './handlers/eth-send-transaction/eth-send-tra
 import { getBalances } from './handlers/get-balances/get-balances';
 import { getEnv } from './env';
 import { EvmGlacierService } from './services/glacier-service/glacier-service';
+import { ethSign } from './handlers/eth-sign/eth-sign';
 
 export class EvmModule implements Module {
   #glacierService: EvmGlacierService;
@@ -97,6 +98,19 @@ export class EvmModule implements Module {
           request,
           network,
           approvalController: this.#approvalController,
+          proxyApiUrl: this.#proxyApiUrl,
+        });
+      case RpcMethod.PERSONAL_SIGN:
+      case RpcMethod.ETH_SIGN:
+      case RpcMethod.SIGN_TYPED_DATA:
+      case RpcMethod.SIGN_TYPED_DATA_V1:
+      case RpcMethod.SIGN_TYPED_DATA_V3:
+      case RpcMethod.SIGN_TYPED_DATA_V4:
+        return ethSign({
+          request,
+          network,
+          approvalController: this.#approvalController,
+          proxyApiUrl: this.#proxyApiUrl,
         });
       default:
         return { error: rpcErrors.methodNotSupported(`Method ${request.method} not supported`) };

package/src/types.ts

@@ -14,3 +14,12 @@ export type TransactionParams = {
   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/parse-erc20-transaction-type.ts

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

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

@@ -0,0 +1,294 @@
+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;
+}) => {
+  const { validation, simulation } = await scanTransaction({
+    proxyApiUrl,
+    chainId,
+    params,
+    domain: dAppUrl,
+  });
+
+  let alert: Alert | undefined;
+  if (!validation || validation.result_type === 'Error' || validation.result_type === 'Warning') {
+    alert = {
+      type: AlertType.WARNING,
+      details: {
+        title: 'Suspicious Transaction',
+        description: 'Use caution, this transaction may be malicious.',
+      },
+    };
+  } else if (validation.result_type === 'Malicious') {
+    alert = {
+      type: AlertType.DANGER,
+      details: {
+        title: 'Scam Transaction',
+        description: 'This transaction is malicious, do not proceed.',
+        actionTitles: {
+          reject: 'Reject Transaction',
+          proceed: 'Proceed Anyway',
+        },
+      },
+    };
+  }
+
+  let balanceChange: BalanceChange | undefined;
+  let tokenApprovals: TokenApprovals | undefined;
+
+  if (simulation?.status === 'Success') {
+    tokenApprovals = processTokenApprovals(request, simulation.account_summary.exposures);
+    balanceChange = processBalanceChange(simulation.account_summary.assets_diffs);
+  }
+
+  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;
+}) => {
+  const { validation, simulation } = await scanJsonRpc({
+    proxyApiUrl,
+    chainId,
+    accountAddress,
+    data: data as Blockaid.Evm.JsonRpcScanParams.Data,
+    domain: dAppUrl,
+  });
+
+  let alert: Alert | undefined;
+  if (!validation || validation.result_type === 'Error' || validation.result_type === 'Warning') {
+    alert = {
+      type: AlertType.WARNING,
+      details: {
+        title: 'Suspicious Transaction',
+        description: 'Use caution, this transaction may be malicious.',
+      },
+    };
+  } else if (validation.result_type === 'Malicious') {
+    alert = {
+      type: AlertType.DANGER,
+      details: {
+        title: 'Scam Transaction',
+        description: 'This transaction is malicious, do not proceed.',
+        actionTitles: {
+          reject: 'Reject Transaction',
+          proceed: 'Proceed Anyway',
+        },
+      },
+    };
+  }
+
+  let balanceChange: BalanceChange | undefined;
+  let tokenApprovals: TokenApprovals | undefined;
+
+  if (simulation?.status === 'Success') {
+    tokenApprovals = processTokenApprovals(request, simulation.account_summary.exposures);
+    balanceChange = processBalanceChange(simulation.account_summary.assets_diffs);
+  }
+
+  return { alert, balanceChange, tokenApprovals };
+};