@avalabs/evm-module 0.0.15 → 0.0.17

package/src/handlers/eth-sign/schemas/parse-request-params/parse-request-params.test.ts

@@ -0,0 +1,284 @@
+import { parseRequestParams } from './parse-request-params';
+import { RpcMethod } from '@avalabs/vm-module-types';
+import { typedData as testTypedData } from './fixture';
+
+const testAddress = '0x4e3F23eA4E5D483B5aD5dF0A6233dEEA093EFFD2';
+const testData = '0x123';
+
+describe('parseRequestParams', () => {
+  describe('PERSONAL_SIGN', () => {
+    it('parses with password correctly', () => {
+      const params = {
+        method: RpcMethod.PERSONAL_SIGN,
+        params: [testData, testAddress, 'password'],
+      };
+
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data).toEqual({
+        data: testData,
+        address: testAddress,
+        method: RpcMethod.PERSONAL_SIGN,
+      });
+    });
+
+    it('parses without password correctly', () => {
+      const params = {
+        method: RpcMethod.PERSONAL_SIGN,
+        params: [testData, testAddress],
+      };
+
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data).toEqual({
+        data: testData,
+        address: testAddress,
+        method: RpcMethod.PERSONAL_SIGN,
+      });
+    });
+
+    it('fails for invalid params', () => {
+      const params = {
+        method: RpcMethod.PERSONAL_SIGN,
+        params: [],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+  });
+
+  describe('ETH_SIGN', () => {
+    it('parses correctly', () => {
+      const params = {
+        method: RpcMethod.ETH_SIGN,
+        params: [testAddress, testData],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data).toEqual({
+        data: testData,
+        address: testAddress,
+        method: RpcMethod.ETH_SIGN,
+      });
+    });
+
+    it('fails for invalid params', () => {
+      const params = {
+        method: RpcMethod.ETH_SIGN,
+        params: [],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+  });
+
+  describe('SIGN_TYPED_DATA', () => {
+    it('parses with valid JSON string correctly', () => {
+      const testObject = [{ type: 'string', name: 'message', value: 'Hello' }];
+      const validJson = JSON.stringify(testObject);
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA,
+        params: [testAddress, validJson],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data?.address).toEqual(testAddress);
+      expect(result.data?.method).toEqual(RpcMethod.SIGN_TYPED_DATA);
+      expect(result.data?.data).toEqual(testObject);
+    });
+
+    it('parses with valid object correctly', () => {
+      const validObject = [{ type: 'string', name: 'message', value: 'Hello' }];
+
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA,
+        params: [testAddress, validObject],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data?.address).toEqual(testAddress);
+      expect(result.data?.method).toEqual(RpcMethod.SIGN_TYPED_DATA);
+      expect(result.data?.data).toEqual(validObject);
+    });
+
+    it('fails with invalid JSON string', () => {
+      const invalidJson = "{ 'message': 'Hello' }";
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA,
+        params: [testAddress, invalidJson],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+
+    it('fails with invalid object', () => {
+      const invalidObject = [{ type: 'string', name: 'message' }]; // missing value
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA,
+        params: [testAddress, invalidObject],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+  });
+
+  describe('SIGN_TYPED_DATA_V1', () => {
+    it('parses with valid JSON string correctly', () => {
+      const testObject = [{ type: 'string', name: 'message', value: 'Hello' }];
+      const validJson = JSON.stringify(testObject);
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V1,
+        params: [testAddress, validJson],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data?.address).toEqual(testAddress);
+      expect(result.data?.method).toEqual(RpcMethod.SIGN_TYPED_DATA_V1);
+      expect(result.data?.data).toEqual(testObject);
+    });
+
+    it('parses with valid object correctly', () => {
+      const validObject = [{ type: 'string', name: 'message', value: 'Hello' }];
+
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V1,
+        params: [testAddress, validObject],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data?.address).toEqual(testAddress);
+      expect(result.data?.method).toEqual(RpcMethod.SIGN_TYPED_DATA_V1);
+      expect(result.data?.data).toEqual(validObject);
+    });
+
+    it('fails with invalid JSON string', () => {
+      const invalidJson = "{ 'message': 'Hello' }";
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V1,
+        params: [testAddress, invalidJson],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+
+    it('fails with invalid object', () => {
+      const invalidObject = [{ type: 'string', name: 'message' }]; // missing value
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V1,
+        params: [testAddress, invalidObject],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+  });
+
+  describe('SIGN_TYPED_DATA_V3', () => {
+    it('parses with valid JSON string correctly', () => {
+      const testObject = testTypedData;
+      const validJson = JSON.stringify(testObject);
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V3,
+        params: [testAddress, validJson],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data?.address).toEqual(testAddress);
+      expect(result.data?.method).toEqual(RpcMethod.SIGN_TYPED_DATA_V3);
+      expect(result.data?.data).toEqual(testObject);
+    });
+
+    it('parses with valid object correctly', () => {
+      const validObject = testTypedData;
+
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V3,
+        params: [testAddress, validObject],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data?.address).toEqual(testAddress);
+      expect(result.data?.method).toEqual(RpcMethod.SIGN_TYPED_DATA_V3);
+      expect(result.data?.data).toEqual(validObject);
+    });
+
+    it('fails with invalid JSON string', () => {
+      const invalidJson = "{ 'message': 'Hello' }";
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V3,
+        params: [testAddress, invalidJson],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+
+    it('fails with invalid object', () => {
+      const invalidObject = [{ type: 'string', name: 'message' }];
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V3,
+        params: [testAddress, invalidObject],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+  });
+
+  describe('SIGN_TYPED_DATA_V4', () => {
+    it('parses with valid JSON string correctly', () => {
+      const testObject = testTypedData;
+      const validJson = JSON.stringify(testObject);
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V4,
+        params: [testAddress, validJson],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data?.address).toEqual(testAddress);
+      expect(result.data?.method).toEqual(RpcMethod.SIGN_TYPED_DATA_V4);
+      expect(result.data?.data).toEqual(testObject);
+    });
+
+    it('parses with valid object correctly', () => {
+      const validObject = testTypedData;
+
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V4,
+        params: [testAddress, validObject],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeTruthy();
+      expect(result.data?.address).toEqual(testAddress);
+      expect(result.data?.method).toEqual(RpcMethod.SIGN_TYPED_DATA_V4);
+      expect(result.data?.data).toEqual(validObject);
+    });
+
+    it('fails with invalid JSON string', () => {
+      const invalidJson = "{ 'message': 'Hello' }";
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V4,
+        params: [testAddress, invalidJson],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+
+    it('fails with invalid object', () => {
+      const invalidObject = [{ type: 'string', name: 'message' }];
+      const params = {
+        method: RpcMethod.SIGN_TYPED_DATA_V4,
+        params: [testAddress, invalidObject],
+      };
+      const result = parseRequestParams(params);
+      expect(result.success).toBeFalsy();
+    });
+  });
+
+  it('fails for unsupported method', () => {
+    const params = {
+      method: 'UNSUPPORTED_METHOD',
+      params: [testAddress, testData],
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result = parseRequestParams(params as any);
+    expect(result.success).toBeFalsy();
+  });
+});

package/src/handlers/eth-sign/schemas/parse-request-params/parse-request-params.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { ethSignSchema } from '../eth-sign';
+import {
+  combinedTypedDataSchema,
+  ethSignTypedDataSchema,
+  ethSignTypedDataV1Schema,
+  ethSignTypedDataV3Schema,
+  ethSignTypedDataV4Schema,
+  typedDataSchema,
+} from '../eth-sign-typed-data';
+import { personalSignSchema } from '../personal-sign';
+import { RpcMethod } from '@avalabs/vm-module-types';
+
+const paramsSchema = z
+  .discriminatedUnion('method', [
+    personalSignSchema,
+    ethSignSchema,
+    ethSignTypedDataSchema,
+    ethSignTypedDataV1Schema,
+    ethSignTypedDataV3Schema,
+    ethSignTypedDataV4Schema,
+  ])
+  .transform((value, ctx) => {
+    const { method, params } = value;
+
+    switch (method) {
+      case RpcMethod.PERSONAL_SIGN:
+        return {
+          data: params[0],
+          address: params[1],
+          method,
+        };
+      case RpcMethod.ETH_SIGN:
+        return {
+          data: params[1],
+          address: params[0],
+          method,
+        };
+      case RpcMethod.SIGN_TYPED_DATA:
+      case RpcMethod.SIGN_TYPED_DATA_V1: {
+        const address = params[0];
+        const data = params[1];
+
+        if (typeof data !== 'string') return { data, address, method };
+
+        try {
+          const parsed = JSON.parse(data);
+          const result = combinedTypedDataSchema.parse(parsed);
+
+          return {
+            data: result,
+            address,
+            method,
+          };
+        } catch (e) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'param is not a valid json',
+          });
+
+          return z.NEVER;
+        }
+      }
+      case RpcMethod.SIGN_TYPED_DATA_V3:
+      case RpcMethod.SIGN_TYPED_DATA_V4: {
+        const address = params[0];
+        const data = params[1];
+
+        if (typeof data !== 'string') return { data, address, method };
+
+        try {
+          const parsed = JSON.parse(data);
+          const result = typedDataSchema.parse(parsed);
+
+          return {
+            data: result,
+            address,
+            method,
+          };
+        } catch (e) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'param is not a valid json',
+          });
+
+          return z.NEVER;
+        }
+      }
+    }
+  });
+
+export function parseRequestParams(params: { method: RpcMethod; params: unknown }) {
+  return paramsSchema.safeParse(params);
+}

package/src/handlers/eth-sign/schemas/personal-sign.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { addressSchema, messageSchema } from './shared';
+import { RpcMethod } from '@avalabs/vm-module-types';
+
+// https://github.com/ethereum/go-ethereum/pull/2940
+export const personalSignSchema = z.object({
+  method: z.literal(RpcMethod.PERSONAL_SIGN),
+  params: z.union([
+    z.tuple([messageSchema, addressSchema]),
+    z.tuple([messageSchema, addressSchema, z.string().optional().describe('password')]),
+  ]),
+});

package/src/handlers/eth-sign/schemas/shared.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const messageSchema = z.string().describe('message');
+
+export const addressSchema = z.string().describe('address');

package/src/handlers/eth-sign/utils/beautify-message/beautify-message.test.ts

@@ -0,0 +1,29 @@
+import { beautifyComplexMessage, beautifySimpleMessage } from './beautify-message';
+
+describe('beautifySimpleMessage', () => {
+  it('should correctly format a simple message (typed data v1)', () => {
+    const input = [
+      { name: 'Name', type: 'string', value: 'John Doe' },
+      { name: 'Age', type: 'number', value: 30 },
+    ];
+    const expectedOutput = `Name:\n𝗝𝗼𝗵𝗻 𝗗𝗼𝗲\n\nAge:\n𝟯𝟬\n\n`;
+    expect(beautifySimpleMessage(input)).toEqual(expectedOutput);
+  });
+});
+
+describe('beautifyComplexMessage', () => {
+  it('should correctly format a complex message', () => {
+    const input = {
+      domain: { name: 'TestDomain', id: '123' },
+      message: {
+        title: 'TestTitle',
+        details: {
+          date: '2023-04-01',
+          items: ['item1', 'item2'],
+        },
+      },
+    };
+    const expectedOutput = `Domain\n  name: 𝗧𝗲𝘀𝘁𝗗𝗼𝗺𝗮𝗶𝗻\n  id: 𝟭𝟮𝟯\n\nMessage\n  title: 𝗧𝗲𝘀𝘁𝗧𝗶𝘁𝗹𝗲\n  details: \n    date: 𝟮𝟬𝟮𝟯-𝟬𝟰-𝟬𝟭\n    items: \n      0: 𝗶𝘁𝗲𝗺𝟭\n      1: 𝗶𝘁𝗲𝗺𝟮\n`;
+    expect(beautifyComplexMessage(input)).toEqual(expectedOutput);
+  });
+});

package/src/handlers/eth-sign/utils/beautify-message/beautify-message.ts

@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const beautifyComplexMessage = (data: { domain: Record<string, any>; message: Record<string, any> }) => {
+  let result = '';
+
+  result += 'Domain\n';
+  for (const key in data.domain) {
+    result += `  ${key}: ${toUnicodeBold(String(data.domain[key]))}\n`;
+  }
+
+  result += '\nMessage\n';
+  for (const key in data.message) {
+    if (typeof data.message[key] === 'object' && !Array.isArray(data.message[key])) {
+      result += `  ${key}: \n`;
+      for (const subKey in data.message[key]) {
+        if (Array.isArray(data.message[key][subKey])) {
+          result += `    ${subKey}: \n`;
+          data.message[key][subKey].forEach((item: any, index: number) => {
+            result += `      ${index}: ${toUnicodeBold(item)}\n`;
+          });
+        } else {
+          result += `    ${subKey}: ${toUnicodeBold(String(data.message[key][subKey]))}\n`;
+        }
+      }
+    } else if (Array.isArray(data.message[key])) {
+      result += `  ${key}: \n`;
+      data.message[key].forEach((item: any, index: number) => {
+        result += `     ${index}: \n`;
+        for (const subKey in item) {
+          if (Array.isArray(item[subKey])) {
+            result += `     ${subKey}: \n`;
+            item[subKey].forEach((item: any, index: number) => {
+              result += `      ${index}: ${toUnicodeBold(item)}\n`;
+            });
+          } else {
+            result += `     ${subKey}: ${toUnicodeBold(String(item[subKey]))}\n`;
+          }
+        }
+      });
+    } else {
+      result += `  ${key}: ${toUnicodeBold(String(data.message[key]))}\n`;
+    }
+  }
+
+  return result;
+};
+
+export const beautifySimpleMessage = (
+  data: {
+    name: string;
+    type: string;
+    value: any;
+  }[],
+) => {
+  let result = '';
+
+  data.forEach((item) => {
+    result += `${item.name}:\n`;
+    result += `${toUnicodeBold(String(item.value))}\n\n`;
+  });
+
+  return result;
+};
+
+const toUnicodeBold = (str: string) => {
+  const boldMap: Record<string, string> = {
+    '0': '𝟬',
+    '1': '𝟭',
+    '2': '𝟮',
+    '3': '𝟯',
+    '4': '𝟰',
+    '5': '𝟱',
+    '6': '𝟲',
+    '7': '𝟳',
+    '8': '𝟴',
+    '9': '𝟵',
+    a: '𝗮',
+    b: '𝗯',
+    c: '𝗰',
+    d: '𝗱',
+    e: '𝗲',
+    f: '𝗳',
+    g: '𝗴',
+    h: '𝗵',
+    i: '𝗶',
+    j: '𝗷',
+    k: '𝗸',
+    l: '𝗹',
+    m: '𝗺',
+    n: '𝗻',
+    o: '𝗼',
+    p: '𝗽',
+    q: '𝗾',
+    r: '𝗿',
+    s: '𝘀',
+    t: '𝘁',
+    u: '𝘂',
+    v: '𝘃',
+    w: '𝘄',
+    x: '𝘅',
+    y: '𝘆',
+    z: '𝘇',
+    A: '𝗔',
+    B: '𝗕',
+    C: '𝗖',
+    D: '𝗗',
+    E: '𝗘',
+    F: '𝗙',
+    G: '𝗚',
+    H: '𝗛',
+    I: '𝗜',
+    J: '𝗝',
+    K: '𝗞',
+    L: '𝗟',
+    M: '𝗠',
+    N: '𝗡',
+    O: '𝗢',
+    P: '𝗣',
+    Q: '𝗤',
+    R: '𝗥',
+    S: '𝗦',
+    T: '𝗧',
+    U: '𝗨',
+    V: '𝗩',
+    W: '𝗪',
+    X: '𝗫',
+    Y: '𝗬',
+    Z: '𝗭',
+  };
+
+  return str
+    .split('')
+    .map((char) => boldMap[char] || char)
+    .join('');
+};

package/src/handlers/eth-sign/utils/is-typed-data-valid.ts

@@ -0,0 +1,26 @@
+import { type TypedData, type MessageTypes } from '@avalabs/vm-module-types';
+import { TypedDataEncoder } from 'ethers';
+
+type Result = { isValid: true } | { isValid: false; error: unknown };
+
+export const isTypedDataValid = (data: TypedData<MessageTypes>): Result => {
+  try {
+    // getPayload verifies the types and the content of the message throwing an error if the data is not valid.
+    // We don't want to immediately reject the request even if there are errors for compatiblity reasons.
+    // dApps tend to make small mistakes in the message format like leaving the verifyingContract emptry,
+    // in which cases we should be able to continue just like other wallets do (even if it's technically incorrect).
+
+    // remove EIP712Domain from types since ethers.js handles it separately
+    const { EIP712Domain, ...types } = data.types;
+    TypedDataEncoder.getPayload(data.domain, types, data.message);
+
+    return {
+      isValid: true,
+    };
+  } catch (e) {
+    return {
+      isValid: false,
+      error: e,
+    };
+  }
+};

package/src/handlers/eth-sign/utils/typeguards.ts

@@ -0,0 +1,10 @@
+import type { TypedDataV1, TypedData, MessageTypes } from '@avalabs/vm-module-types';
+import { typedDataSchema, typedDataV1Schema } from '../schemas/eth-sign-typed-data';
+
+export const isTypedDataV1 = (data: unknown): data is TypedDataV1 => {
+  return typedDataV1Schema.safeParse(data).success;
+};
+
+export const isTypedData = (data: unknown): data is TypedData<MessageTypes> => {
+  return typedDataSchema.safeParse(data).success;
+};

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

@@ -1,6 +1,7 @@
 import { BN } from 'bn.js';
 import { getErc20Balances } from './get-erc20-balances';
 import { ethers } from 'ethers';
+import { TokenType } from '@avalabs/vm-module-types';
 
 describe('get-erc20-balances', () => {
   it('should return erc20 token balances', async () => {
@@ -18,7 +19,7 @@ describe('get-erc20-balances', () => {
           symbol: 'ETH',
           decimals: 18,
           logoUri: 'https://example.com/logo.png',
-          contractType: 'ERC-20',
+          type: TokenType.ERC20,
         },
       ],
       provider: {
@@ -67,7 +68,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/evm-balance-service/get-erc20-balances.ts

@@ -1,13 +1,11 @@
 import { numberToBN, bnToBig, balanceToDisplayValue } from '@avalabs/utils-sdk';
-import { TokenType, type Network, type NetworkContractToken, type TokenWithBalance } from '@avalabs/vm-module-types';
+import { TokenType, type ERC20Token, type Network, type TokenWithBalance } from '@avalabs/vm-module-types';
 import { ethers, type Provider } from 'ethers';
 import ERC20 from '@openzeppelin/contracts/build/contracts/ERC20.json';
 import type { TokenService } from '@internal/utils';
 import { VsCurrencyType } from '@avalabs/coingecko-sdk';
 import BN from 'bn.js';
 
-const DEFAULT_DECIMALS = 18;
-
 export const getErc20Balances = async ({
   provider,
   tokenService,
@@ -20,7 +18,7 @@ export const getErc20Balances = async ({
   tokenService: TokenService;
   address: string;
   currency: string;
-  tokens: NetworkContractToken[];
+  tokens: ERC20Token[];
   network: Network;
 }): Promise<Record<string, TokenWithBalance>> => {
   const coingeckoPlatformId = network.pricingProviders?.coingecko.assetPlatformId;
@@ -31,7 +29,7 @@ export const getErc20Balances = async ({
     tokens.map(async (token) => {
       const contract = new ethers.Contract(token.address, ERC20.abi, provider);
       const balanceBig = await contract.balanceOf?.(userAddress);
-      const balance = new BN(balanceBig) || numberToBN(0, token.decimals || DEFAULT_DECIMALS);
+      const balance = new BN(balanceBig) || numberToBN(0, token.decimals);
 
       const tokenWithBalance = {
         ...token,
@@ -41,7 +39,7 @@ export const getErc20Balances = async ({
       return tokenWithBalance;
     }),
   ).then((res) => {
-    return res.reduce<(NetworkContractToken & { balance: BN })[]>((acc, result) => {
+    return res.reduce<(ERC20Token & { balance: BN })[]>((acc, result) => {
       return result.status === 'fulfilled' && !result.value.balance.isZero() ? [...acc, result.value] : acc;
     }, []);
   });