@avalabs/evm-module 0.0.23 → 0.1.1

package/src/handlers/eth-sign/eth-sign.test.ts

@@ -1,359 +0,0 @@
-import { ethSign } from './eth-sign';
-import { AlertType, NetworkVMType, RpcMethod } from '@avalabs/vm-module-types';
-import { rpcErrors } from '@metamask/rpc-errors';
-import Blockaid from '@blockaid/client';
-
-const PROXY_API_URL = 'https://proxy-api.avax.network';
-
-jest.mock('@blockaid/client', () => {
-  return jest.fn().mockImplementation(() => {
-    return {
-      evm: {
-        transaction: {
-          scan: jest.fn().mockResolvedValue({ validation: { result_type: 'Benign' } }),
-        },
-        jsonRpc: {
-          scan: jest.fn().mockResolvedValue({ validation: { result_type: 'Benign' } }),
-        },
-      },
-    };
-  });
-});
-
-jest.mock('./schemas/parse-request-params/parse-request-params', () => ({
-  parseRequestParams: jest.fn(),
-}));
-
-jest.mock('./utils/is-typed-data-valid', () => ({
-  isTypedDataValid: jest.fn(),
-}));
-
-jest.mock('ethers', () => ({
-  toUtf8String: jest.fn(),
-}));
-
-jest.mock('./utils/beautify-message/beautify-message', () => ({
-  beautifySimpleMessage: jest.fn(),
-  beautifyComplexMessage: jest.fn(),
-}));
-
-jest.mock('./utils/typeguards', () => ({
-  isTypedDataV1: jest.fn(),
-  isTypedData: jest.fn(),
-}));
-
-const mockParseRequestParams = require('./schemas/parse-request-params/parse-request-params').parseRequestParams;
-const mockIsTypedDataValid = require('./utils/is-typed-data-valid').isTypedDataValid;
-const mockToUtf8 = require('ethers').toUtf8String;
-const mockBeautifySimpleMessage = require('./utils/beautify-message/beautify-message').beautifySimpleMessage;
-const mockBeautifyComplexMessage = require('./utils/beautify-message/beautify-message').beautifyComplexMessage;
-const mockIsTypedDataV1 = require('./utils/typeguards').isTypedDataV1;
-
-const mockRequest = {
-  method: RpcMethod.ETH_SIGN,
-  params: ['0x123'],
-  dappInfo: {
-    name: 'Test DApp',
-    url: 'test-url',
-    icon: 'test-icon-uri',
-  },
-  requestId: 'requestId',
-  sessionId: 'sessionId',
-  chainId: 'eip155:1',
-};
-
-const mockNetwork = {
-  chainId: 1,
-  chainName: 'Ethereum',
-  logoUri: 'test-logo-uri',
-  rpcUrl: 'rpcUrl',
-  networkToken: {
-    name: 'ethereum',
-    symbol: 'ETH',
-    decimals: 18,
-  },
-  vmName: NetworkVMType.EVM,
-};
-
-const mockApprovalController = {
-  requestApproval: jest.fn(),
-  onTransactionConfirmed: jest.fn(),
-  onTransactionReverted: jest.fn(),
-};
-
-describe('ethSign', () => {
-  beforeEach(() => {
-    mockApprovalController.requestApproval.mockResolvedValue({ result: '0x1234' });
-    mockBeautifySimpleMessage.mockReturnValue('beautified simple message');
-    mockBeautifyComplexMessage.mockReturnValue('beautified complex message');
-  });
-
-  it('should return error when params are invalid', async () => {
-    mockParseRequestParams.mockReturnValueOnce({ success: false, error: 'Invalid params' });
-
-    const result = await ethSign({
-      request: mockRequest,
-      network: mockNetwork,
-      approvalController: mockApprovalController,
-      proxyApiUrl: PROXY_API_URL,
-    });
-
-    expect(result).toEqual({
-      success: false,
-      error: rpcErrors.invalidParams('Params are invalid'),
-    });
-  });
-
-  it.each([RpcMethod.SIGN_TYPED_DATA_V3, RpcMethod.SIGN_TYPED_DATA_V4])(
-    'should generate a warning banner for typed data validation failure for %s',
-    async (method) => {
-      mockParseRequestParams.mockReturnValueOnce({
-        success: true,
-        data: { method, data: {}, address: '0xabc' },
-      });
-      mockIsTypedDataValid.mockReturnValueOnce({ isValid: false, error: 'Invalid typed data' });
-
-      await ethSign({
-        request: { ...mockRequest, method },
-        network: mockNetwork,
-        approvalController: mockApprovalController,
-        proxyApiUrl: PROXY_API_URL,
-      });
-
-      expect(mockApprovalController.requestApproval).toHaveBeenCalledWith(
-        expect.objectContaining({
-          displayData: expect.objectContaining({
-            alert: {
-              type: AlertType.INFO,
-              details: {
-                title: 'Warning: Verify Message Content',
-                description: 'This message contains non-standard elements.',
-                detailedDescription: 'Invalid typed data',
-              },
-            },
-          }),
-        }),
-      );
-    },
-  );
-
-  it.each([
-    [
-      RpcMethod.ETH_SIGN,
-      'data',
-      'data',
-      "Signing this message can be dangerous. This signature could potentially perform any operation on your account's behalf, including granting complete control of your account and all of its assets to the requesting site. Only sign this message if you know what you're doing or completely trust the requesting site",
-    ],
-    [RpcMethod.PERSONAL_SIGN, 'data', 'data in utf8', undefined],
-    [RpcMethod.SIGN_TYPED_DATA, 'data', 'beautified simple message', undefined],
-    [RpcMethod.SIGN_TYPED_DATA_V1, 'data', 'beautified simple message', undefined],
-    [
-      RpcMethod.SIGN_TYPED_DATA_V3,
-      { types: {}, primaryType: '', message: 'test' },
-      'beautified complex message',
-      undefined,
-    ],
-    [
-      RpcMethod.SIGN_TYPED_DATA_V4,
-      { types: {}, primaryType: '', message: 'test' },
-      'beautified complex message',
-      undefined,
-    ],
-  ])(
-    'should generate signingData and displayData for %s',
-    async (method, inputData, expectedMessageDetails, expectedDisclaimer) => {
-      if (method === RpcMethod.SIGN_TYPED_DATA || method === RpcMethod.SIGN_TYPED_DATA_V1) {
-        mockIsTypedDataV1.mockReturnValueOnce(true);
-      }
-
-      mockParseRequestParams.mockReturnValueOnce({
-        success: true,
-        data: { method, data: inputData, address: '0xabc' },
-      });
-      mockIsTypedDataValid.mockReturnValueOnce({ isValid: true });
-      mockToUtf8.mockReturnValue('data in utf8');
-
-      await ethSign({
-        request: { ...mockRequest, method },
-        network: mockNetwork,
-        approvalController: mockApprovalController,
-        proxyApiUrl: PROXY_API_URL,
-      });
-
-      expect(mockApprovalController.requestApproval).toHaveBeenCalledWith({
-        displayData: {
-          title: 'Sign Message',
-          messageDetails: expectedMessageDetails,
-          account: '0xabc',
-          banner: undefined,
-          dAppInfo: {
-            action: 'Test DApp requests you to sign the following message',
-            logoUri: 'test-icon-uri',
-            name: 'Test DApp',
-          },
-          disclaimer: expectedDisclaimer,
-          network: {
-            chainId: 1,
-            logoUri: 'test-logo-uri',
-            name: 'Ethereum',
-          },
-          alert: undefined,
-          balanceChange: undefined,
-          tokenApprovals: undefined,
-        },
-        request: { ...mockRequest, method },
-        signingData: {
-          account: '0xabc',
-          chainId: 1,
-          data: inputData,
-          type: method,
-        },
-      });
-    },
-  );
-
-  it('should add alert object with Warning type to displayData when validation result is Warning', async () => {
-    testWithValidationResultType('Warning');
-  });
-
-  it('should add alert object with Warning type to displayData when validation result is Error', async () => {
-    testWithValidationResultType('Error');
-  });
-
-  it('should add alert object with Danger type to displayData when validation result is Malicious', async () => {
-    testWithValidationResultType('Malicious');
-  });
-
-  it('should add alert object with Warning type to displayData when schema validation error occurs in jsonRpc scan', async () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (Blockaid as any).mockImplementation(() => ({
-      evm: {
-        jsonRpc: {
-          scan: jest.fn().mockRejectedValue({ message: 'schema validation error' }),
-        },
-      },
-    }));
-
-    mockParseRequestParams.mockReturnValueOnce({
-      success: true,
-      data: { method: RpcMethod.ETH_SIGN, data: 'data', address: '0xabc' },
-    });
-
-    const result = await ethSign({
-      request: mockRequest,
-      network: mockNetwork,
-      approvalController: mockApprovalController,
-      proxyApiUrl: PROXY_API_URL,
-    });
-
-    expect(result).toEqual({ result: '0x1234' });
-    expect(mockApprovalController.requestApproval).toHaveBeenCalledWith(
-      expect.objectContaining({
-        displayData: expect.objectContaining({
-          alert: {
-            type: AlertType.WARNING,
-            details: {
-              title: 'Suspicious Transaction',
-              description: 'Use caution, this transaction may be malicious.',
-            },
-          },
-        }),
-      }),
-    );
-  });
-
-  it('should handle success case for approvalController.requestApproval', async () => {
-    mockParseRequestParams.mockReturnValueOnce({
-      success: true,
-      data: { method: RpcMethod.ETH_SIGN, data: 'data', address: '0xabc' },
-    });
-
-    const result = await ethSign({
-      request: mockRequest,
-      network: mockNetwork,
-      approvalController: mockApprovalController,
-      proxyApiUrl: PROXY_API_URL,
-    });
-
-    expect(result).toEqual({ result: '0x1234' });
-  });
-
-  it('should handle error case for approvalController.requestApproval', async () => {
-    mockParseRequestParams.mockReturnValueOnce({
-      success: true,
-      data: { method: RpcMethod.ETH_SIGN, data: 'data', address: '0xabc' },
-    });
-    mockApprovalController.requestApproval.mockResolvedValueOnce({ error: 'User denied message signature' });
-
-    const result = await ethSign({
-      request: mockRequest,
-      network: mockNetwork,
-      approvalController: mockApprovalController,
-      proxyApiUrl: PROXY_API_URL,
-    });
-
-    expect(result).toEqual({ error: 'User denied message signature' });
-  });
-});
-
-const testWithValidationResultType = async (resultType: 'Warning' | 'Error' | 'Malicious') => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  (Blockaid as any).mockImplementation(() => ({
-    evm: {
-      jsonRpc: {
-        scan: jest.fn().mockResolvedValue({
-          validation: { result_type: resultType },
-          simulation: { status: 'Success', account_summary: { exposures: [], assets_diffs: [] } },
-        }),
-      },
-    },
-  }));
-
-  mockParseRequestParams.mockReturnValueOnce({
-    success: true,
-    data: { method: RpcMethod.ETH_SIGN, data: 'data', address: '0xabc' },
-  });
-
-  const result = await ethSign({
-    request: mockRequest,
-    network: mockNetwork,
-    approvalController: mockApprovalController,
-    proxyApiUrl: PROXY_API_URL,
-  });
-
-  expect(result).toEqual({ result: '0x1234' });
-
-  if (resultType === 'Malicious') {
-    expect(mockApprovalController.requestApproval).toHaveBeenCalledWith(
-      expect.objectContaining({
-        displayData: expect.objectContaining({
-          alert: {
-            type: AlertType.DANGER,
-            details: {
-              title: 'Scam Transaction',
-              description: 'This transaction is malicious, do not proceed.',
-              actionTitles: {
-                reject: 'Reject Transaction',
-                proceed: 'Proceed Anyway',
-              },
-            },
-          },
-        }),
-      }),
-    );
-  } else {
-    expect(mockApprovalController.requestApproval).toHaveBeenCalledWith(
-      expect.objectContaining({
-        displayData: expect.objectContaining({
-          alert: {
-            type: AlertType.WARNING,
-            details: {
-              title: 'Suspicious Transaction',
-              description: 'Use caution, this transaction may be malicious.',
-            },
-          },
-        }),
-      }),
-    );
-  }
-};

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

@@ -1,158 +0,0 @@
-import {
-  type SigningData,
-  type Network,
-  type ApprovalController,
-  type DisplayData,
-  type RpcRequest,
-  RpcMethod,
-  type Alert,
-  AlertType,
-} from '@avalabs/vm-module-types';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { toUtf8String } from 'ethers';
-import { beautifySimpleMessage, beautifyComplexMessage } from './utils/beautify-message/beautify-message';
-import { parseRequestParams } from './schemas/parse-request-params/parse-request-params';
-import { isTypedDataV1 } from './utils/typeguards';
-import { isTypedDataValid } from './utils/is-typed-data-valid';
-import { processJsonRpcSimulation } from '../../utils/process-transaction-simulation';
-
-export const ethSign = async ({
-  request,
-  network,
-  approvalController,
-  proxyApiUrl,
-}: {
-  request: RpcRequest;
-  network: Network;
-  approvalController: ApprovalController;
-  proxyApiUrl: string;
-}) => {
-  const result = parseRequestParams({ method: request.method, params: request.params });
-
-  if (!result.success) {
-    console.error('invalid params', result.error);
-
-    return {
-      success: false,
-      error: rpcErrors.invalidParams('Params are invalid'),
-    };
-  }
-  const { method, data, address } = result.data;
-
-  // validate typed data
-  let typedDataValidationResult: ReturnType<typeof isTypedDataValid> | undefined;
-
-  if (method === RpcMethod.SIGN_TYPED_DATA_V3 || method === RpcMethod.SIGN_TYPED_DATA_V4) {
-    typedDataValidationResult = isTypedDataValid(data);
-  }
-
-  // generate display data and signing data
-  let signingData: SigningData | undefined;
-  let messageDetails: string | undefined;
-  let disclaimer: string | undefined;
-  let alert: Alert | undefined;
-
-  if (typedDataValidationResult && !typedDataValidationResult.isValid) {
-    alert = {
-      type: AlertType.INFO,
-      details: {
-        title: 'Warning: Verify Message Content',
-        description: 'This message contains non-standard elements.',
-        detailedDescription: (typedDataValidationResult.error as Error).toString(),
-      },
-    };
-  }
-
-  if (method === RpcMethod.ETH_SIGN) {
-    signingData = {
-      type: method,
-      account: address,
-      chainId: network.chainId,
-      data: data,
-    };
-
-    messageDetails = data;
-
-    disclaimer =
-      "Signing this message can be dangerous. This signature could potentially perform any operation on your account's behalf, including granting complete control of your account and all of its assets to the requesting site. Only sign this message if you know what you're doing or completely trust the requesting site";
-  } else if (method === RpcMethod.PERSONAL_SIGN) {
-    signingData = {
-      type: method,
-      account: address,
-      chainId: network.chainId,
-      data: data,
-    };
-
-    messageDetails = toUtf8String(data);
-  } else if (method === RpcMethod.SIGN_TYPED_DATA || method === RpcMethod.SIGN_TYPED_DATA_V1) {
-    signingData = {
-      type: method,
-      account: address,
-      chainId: network.chainId,
-      data: data,
-    };
-
-    messageDetails = isTypedDataV1(data) ? beautifySimpleMessage(data) : beautifyComplexMessage(data);
-  } else if (method === RpcMethod.SIGN_TYPED_DATA_V3 || method === RpcMethod.SIGN_TYPED_DATA_V4) {
-    signingData = {
-      type: method,
-      account: address,
-      chainId: network.chainId,
-      data: data,
-    };
-
-    const { types, primaryType, ...messageToDisplay } = data;
-    messageDetails = beautifyComplexMessage(messageToDisplay);
-  }
-
-  if (!signingData) {
-    return {
-      success: false,
-      error: rpcErrors.internal('Unable to generate signing data'),
-    };
-  }
-
-  const {
-    alert: prioritizedAlert,
-    balanceChange,
-    tokenApprovals,
-  } = await processJsonRpcSimulation({
-    request,
-    proxyApiUrl,
-    accountAddress: address,
-    chainId: network.chainId,
-    data: { method, params: request.params },
-    dAppUrl: request.dappInfo.url,
-  });
-
-  const displayData: DisplayData = {
-    title: 'Sign Message',
-    dAppInfo: {
-      name: request.dappInfo.name,
-      action: `${request.dappInfo.name} requests you to sign the following message`,
-      logoUri: request.dappInfo.icon,
-    },
-    network: {
-      chainId: network.chainId,
-      name: network.chainName,
-      logoUri: network.logoUri,
-    },
-    account: address,
-    messageDetails,
-    disclaimer,
-    alert: prioritizedAlert ?? alert,
-    balanceChange,
-    tokenApprovals,
-  };
-
-  // prompt user for approval
-  const response = await approvalController.requestApproval({ request, displayData, signingData });
-
-  if ('error' in response) {
-    return {
-      error: response.error,
-    };
-  }
-
-  return { result: response.result };
-};

package/src/handlers/eth-sign/schemas/eth-sign-typed-data.ts

@@ -1,65 +0,0 @@
-import { z } from 'zod';
-import { addressSchema } from './shared';
-import { RpcMethod } from '@avalabs/vm-module-types';
-
-/**
- * For the different eth_signTypedData methods, the payload differs based on the version.
- *
- * V1 is based upon [an early version of EIP-712](https://github.com/ethereum/EIPs/pull/712/commits/21abe254fe0452d8583d5b132b1d7be87c0439ca)
- * that lacked some later security improvements, and should generally be neglected in favor of
- * later versions.
- *
- * V3 is based on [EIP-712](https://eips.ethereum.org/EIPS/eip-712), except that arrays and
- * recursive data structures are not supported.
- *
- * V4 is based on [EIP-712](https://eips.ethereum.org/EIPS/eip-712), and includes full support of
- * arrays and recursive data structures.
- *
- * References:
- * - https://eips.ethereum.org/EIPS/eip-712#specification-of-the-eth_signtypeddata-json-rpc
- * - https://docs.metamask.io/guide/signing-data.html#signtypeddata-v4
- */
-const messageTypeSchema = z.object({ name: z.string(), type: z.string() });
-
-export const typedDataSchema = z.object({
-  types: z.object({ EIP712Domain: z.array(messageTypeSchema) }).catchall(z.array(messageTypeSchema)),
-  primaryType: z.string(),
-  domain: z.record(z.any()),
-  message: z.record(z.any()),
-});
-
-export const typedDataV1Schema = z
-  .array(
-    z.object({
-      type: z.string(),
-      name: z.string(),
-      value: z.union([z.string(), z.number(), z.boolean(), z.object({}).passthrough(), z.array(z.unknown()), z.null()]),
-    }),
-  )
-  .nonempty();
-
-export const combinedTypedDataSchema = typedDataSchema.or(typedDataV1Schema);
-
-const dataSchema = z.union([z.string().describe('data string'), typedDataSchema]);
-
-export const combinedDataSchema = z.union([z.string().describe('data string'), combinedTypedDataSchema]);
-
-export const ethSignTypedDataSchema = z.object({
-  method: z.literal(RpcMethod.SIGN_TYPED_DATA),
-  params: z.tuple([addressSchema, combinedDataSchema]),
-});
-
-export const ethSignTypedDataV1Schema = z.object({
-  method: z.literal(RpcMethod.SIGN_TYPED_DATA_V1),
-  params: z.tuple([addressSchema, combinedDataSchema]),
-});
-
-export const ethSignTypedDataV3Schema = z.object({
-  method: z.literal(RpcMethod.SIGN_TYPED_DATA_V3),
-  params: z.tuple([addressSchema, dataSchema]),
-});
-
-export const ethSignTypedDataV4Schema = z.object({
-  method: z.literal(RpcMethod.SIGN_TYPED_DATA_V4),
-  params: z.tuple([addressSchema, dataSchema]),
-});

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

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-import { addressSchema, messageSchema } from './shared';
-import { RpcMethod } from '@avalabs/vm-module-types';
-
-// https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign
-export const ethSignSchema = z.object({
-  method: z.literal(RpcMethod.ETH_SIGN),
-  params: z.tuple([addressSchema, messageSchema]),
-});

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

@@ -1,47 +0,0 @@
-export const typedData = {
-  types: {
-    EIP712Domain: [
-      { name: 'name', type: 'string' },
-      { name: 'version', type: 'string' },
-      { name: 'chainId', type: 'uint256' },
-      { name: 'verifyingContract', type: 'address' },
-    ],
-    Group: [
-      { name: 'name', type: 'string' },
-      { name: 'members', type: 'Person[]' },
-    ],
-    Mail: [
-      { name: 'from', type: 'Person' },
-      { name: 'to', type: 'Person[]' },
-      { name: 'contents', type: 'string' },
-    ],
-    Person: [
-      { name: 'name', type: 'string' },
-      { name: 'wallets', type: 'address[]' },
-    ],
-  },
-  primaryType: 'Mail',
-  domain: {
-    chainId: 43113,
-    name: 'Ether Mail',
-    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
-    version: '1',
-  },
-  message: {
-    contents: 'Hello, Bob!',
-    from: {
-      name: 'Cow',
-      wallets: ['0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826', '0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF'],
-    },
-    to: [
-      {
-        name: 'Bob',
-        wallets: [
-          '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
-          '0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57',
-          '0xB0B0b0b0b0b0B000000000000000000000000000',
-        ],
-      },
-    ],
-  },
-};