@avalabs/evm-module 0.0.0-workspaces-20240716185307 → 0.0.2

package/src/handlers/eth-send-transaction/eth-send-transaction.test.ts

@@ -1,350 +0,0 @@
-import { ethSendTransaction } from './eth-send-transaction';
-import { parseRequestParams } from './schema';
-import { estimateGasLimit } from '../../utils/estimate-gas-limit';
-import { getNonce } from '../../utils/get-nonce';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { RpcMethod, type ApprovalController, type Network } from '@avalabs/vm-module-types';
-import { ZodError } from 'zod';
-import { getProvider } from '../../utils/get-provider';
-
-const mockGetProvider = getProvider as jest.MockedFunction<typeof getProvider>;
-
-const PROXY_API_URL = 'https://proxy-api.avax.network';
-
-jest.mock('./schema');
-jest.mock('../../utils/estimate-gas-limit');
-jest.mock('../../utils/get-nonce');
-jest.mock('../../utils/get-provider');
-jest.mock('@blockaid/client', () => {
-  return jest.fn().mockImplementation(() => {
-    return {
-      evm: {
-        transaction: {
-          scan: jest.fn().mockResolvedValue({ validation: { result_type: 'Success' } }),
-        },
-        jsonRpc: {
-          scan: jest.fn(),
-        },
-      },
-    };
-  });
-});
-
-const mockOnTransactionConfirmed = jest.fn();
-const mockOnTransactionReverted = jest.fn();
-const mockApprovalController: jest.Mocked<ApprovalController> = {
-  requestApproval: jest.fn(),
-  onTransactionConfirmed: mockOnTransactionConfirmed,
-  onTransactionReverted: mockOnTransactionReverted,
-};
-
-const mockParseRequestParams = parseRequestParams as jest.MockedFunction<typeof parseRequestParams>;
-const mockEstimateGasLimit = estimateGasLimit as jest.MockedFunction<typeof estimateGasLimit>;
-const mockGetNonce = getNonce as jest.MockedFunction<typeof getNonce>;
-const mockSend = jest.fn();
-const mockWaitForTransaction = jest.fn();
-
-const mockProvider = {
-  send: mockSend,
-  waitForTransaction: mockWaitForTransaction,
-};
-
-// @ts-expect-error missing properties
-mockGetProvider.mockReturnValue(mockProvider);
-const testNetwork: Network = {
-  isTestnet: false,
-  chainId: 1,
-  chainName: 'chainName',
-  rpcUrl: 'rpcUrl',
-  logoUri: 'logoUri',
-  utilityAddresses: { multicall: 'multiContractAddress' },
-  networkToken: {
-    name: 'Ethereum',
-    symbol: 'ETH',
-    decimals: 9,
-    description: 'Ethereum Token',
-    logoUri: 'some logo uri',
-  },
-};
-
-const testParams = { from: '0xfrom', to: '0xto', data: '0xdata', value: '0xvalue', nonce: '12', gas: '0x5208' };
-
-const testRequestParams = () => ({
-  request: {
-    requestId: '1',
-    sessionId: '2',
-    method: RpcMethod.ETH_SEND_TRANSACTION,
-    chainId: 'eip155:1',
-    dappInfo: { url: 'https://example.com', name: 'dapp', icon: 'icon' },
-    params: [testParams],
-  },
-  network: testNetwork,
-  approvalController: mockApprovalController,
-  proxyApiUrl: PROXY_API_URL,
-});
-
-const displayData = {
-  title: 'Approve Transaction',
-  network: {
-    chainId: testNetwork.chainId,
-    name: testNetwork.chainName,
-    logoUri: testNetwork.logoUri,
-  },
-  transactionDetails: {
-    website: 'example.com',
-    from: '0xfrom',
-    to: '0xto',
-    data: '0xdata',
-  },
-  networkFeeSelector: true,
-};
-
-const signingData = {
-  type: 'evm_transaction',
-  account: '0xfrom',
-  chainId: 1,
-  data: {
-    type: 2,
-    nonce: 12,
-    gasLimit: 21000,
-    to: '0xto',
-    from: '0xfrom',
-    data: '0xdata',
-    value: '0xvalue',
-  },
-};
-
-const testTxHash = '0xtxhash';
-
-describe('eth_sendTransaction handler', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    mockParseRequestParams.mockReturnValue({
-      success: true,
-      data: [testParams],
-    });
-
-    mockApprovalController.requestApproval.mockResolvedValue({ result: testTxHash });
-  });
-
-  it('should return error if request params are invalid', async () => {
-    mockParseRequestParams.mockReturnValue({
-      success: false,
-      error: new Error('Invalid params') as ZodError,
-    });
-
-    const response = await ethSendTransaction(testRequestParams());
-
-    expect(response).toEqual({
-      error: rpcErrors.invalidParams('Transaction params are invalid'),
-    });
-  });
-
-  it('should calculate gas limit if not provided', async () => {
-    mockParseRequestParams.mockReturnValue({
-      success: true,
-      data: [{ from: '0xfrom', to: '0xto', data: '0xdata', value: '0xvalue', nonce: '12' }],
-    });
-    mockEstimateGasLimit.mockResolvedValue(21000);
-
-    const requestParams = testRequestParams();
-
-    await ethSendTransaction(requestParams);
-
-    expect(mockGetProvider).toHaveBeenCalledWith({
-      chainId: 1,
-      chainName: 'chainName',
-      rpcUrl: 'rpcUrl',
-      multiContractAddress: 'multiContractAddress',
-      pollingInterval: 1000,
-    });
-
-    expect(mockEstimateGasLimit).toHaveBeenCalledWith({
-      provider: mockProvider,
-      transactionParams: { from: '0xfrom', to: '0xto', data: '0xdata', value: '0xvalue' },
-    });
-
-    expect(mockApprovalController.requestApproval).toHaveBeenCalledWith({
-      request: requestParams.request,
-      displayData,
-      signingData,
-    });
-  });
-
-  it('should calculate nonce if not provided', async () => {
-    mockParseRequestParams.mockReturnValue({
-      success: true,
-      data: [{ from: '0xfrom', to: '0xto', data: '0xdata', value: '0xvalue', gas: '0x5208' }],
-    });
-    mockGetNonce.mockResolvedValue(12);
-
-    const requestParams = testRequestParams();
-    await ethSendTransaction(requestParams);
-
-    expect(mockGetProvider).toHaveBeenCalledWith({
-      chainId: 1,
-      chainName: 'chainName',
-      rpcUrl: 'rpcUrl',
-      multiContractAddress: 'multiContractAddress',
-      pollingInterval: 1000,
-    });
-
-    expect(mockGetNonce).toHaveBeenCalledWith({
-      provider: mockProvider,
-      from: '0xfrom',
-    });
-
-    expect(mockApprovalController.requestApproval).toHaveBeenCalledWith({
-      request: requestParams.request,
-      displayData,
-      signingData,
-    });
-  });
-
-  it('should calculate both gas and nonce if not provided', async () => {
-    mockParseRequestParams.mockReturnValue({
-      success: true,
-      data: [{ from: '0xfrom', to: '0xto', data: '0xdata', value: '0xvalue' }],
-    });
-    mockGetNonce.mockResolvedValue(12);
-    mockEstimateGasLimit.mockResolvedValue(21000);
-
-    const requestParams = testRequestParams();
-    await ethSendTransaction(requestParams);
-
-    expect(mockGetProvider).toHaveBeenCalledWith({
-      chainId: 1,
-      chainName: 'chainName',
-      rpcUrl: 'rpcUrl',
-      multiContractAddress: 'multiContractAddress',
-      pollingInterval: 1000,
-    });
-
-    expect(mockGetNonce).toHaveBeenCalledWith({
-      provider: mockProvider,
-      from: '0xfrom',
-    });
-
-    expect(mockEstimateGasLimit).toHaveBeenCalledWith({
-      provider: mockProvider,
-      transactionParams: { from: '0xfrom', to: '0xto', data: '0xdata', value: '0xvalue' },
-    });
-
-    expect(mockApprovalController.requestApproval).toHaveBeenCalledWith({
-      request: requestParams.request,
-      displayData,
-      signingData,
-    });
-  });
-
-  it('should return error if gas limit calculation fails', async () => {
-    mockParseRequestParams.mockReturnValue({
-      success: true,
-      data: [{ from: '0xfrom', to: '0xto', data: '0xdata', value: '0xvalue', nonce: '12' }],
-    });
-
-    mockEstimateGasLimit.mockRejectedValue(new Error('gas calculation error'));
-
-    const requestParams = testRequestParams();
-    const response = await ethSendTransaction(requestParams);
-
-    expect(response).toEqual({
-      error: rpcErrors.internal('Unable to calculate gas limit'),
-    });
-  });
-
-  it('should return error if nonce calculation fails', async () => {
-    mockParseRequestParams.mockReturnValue({
-      success: true,
-      data: [{ from: '0xfrom', to: '0xto', data: '0xdata', value: '0xvalue', gas: '0x5208' }],
-    });
-    mockGetNonce.mockRejectedValue(new Error('Nonce calculation error'));
-
-    const requestParams = testRequestParams();
-    const response = await ethSendTransaction(requestParams);
-
-    expect(response).toEqual({
-      error: rpcErrors.internal('Unable to calculate nonce'),
-    });
-  });
-
-  describe('approval succeeds', () => {
-    beforeEach(() => {
-      jest.clearAllMocks();
-
-      mockApprovalController.requestApproval.mockResolvedValue({ result: testTxHash });
-      mockSend.mockResolvedValue(testTxHash);
-    });
-
-    it('should broadcast the signed transaction and return transaction hash', async () => {
-      const requestParams = testRequestParams();
-      const response = await ethSendTransaction(requestParams);
-
-      expect(mockGetProvider).toHaveBeenCalledWith({
-        chainId: 1,
-        chainName: 'chainName',
-        rpcUrl: 'rpcUrl',
-        multiContractAddress: 'multiContractAddress',
-        pollingInterval: 1000,
-      });
-
-      expect(mockSend).toHaveBeenCalledWith('eth_sendRawTransaction', [testTxHash]);
-
-      expect(response).toStrictEqual({ result: testTxHash });
-    });
-
-    it('should notify when transaction is confirmed', async () => {
-      mockWaitForTransaction.mockResolvedValue({ status: 1 });
-
-      const requestParams = testRequestParams();
-      const response = await ethSendTransaction(requestParams);
-
-      expect(mockGetProvider).toHaveBeenCalledWith({
-        chainId: 1,
-        chainName: 'chainName',
-        rpcUrl: 'rpcUrl',
-        multiContractAddress: 'multiContractAddress',
-        pollingInterval: 1000,
-      });
-
-      expect(response).toStrictEqual({ result: testTxHash });
-
-      expect(mockWaitForTransaction).toHaveBeenCalledWith(testTxHash);
-
-      expect(mockOnTransactionConfirmed).toHaveBeenCalledWith(testTxHash);
-    });
-
-    it('should notify when transaction is reverted', async () => {
-      mockWaitForTransaction.mockResolvedValue({ status: 0 });
-
-      const requestParams = testRequestParams();
-      const response = await ethSendTransaction(requestParams);
-
-      expect(mockGetProvider).toHaveBeenCalledWith({
-        chainId: 1,
-        chainName: 'chainName',
-        rpcUrl: 'rpcUrl',
-        multiContractAddress: 'multiContractAddress',
-        pollingInterval: 1000,
-      });
-
-      expect(response).toStrictEqual({ result: testTxHash });
-
-      expect(mockWaitForTransaction).toHaveBeenCalledWith(testTxHash);
-
-      expect(mockOnTransactionReverted).toHaveBeenCalledWith(testTxHash);
-    });
-  });
-
-  describe('approval fails', () => {
-    it('should return error', async () => {
-      mockApprovalController.requestApproval.mockResolvedValue({ error: rpcErrors.internal('something went wrong') });
-
-      const requestParams = testRequestParams();
-      const response = await ethSendTransaction(requestParams);
-
-      expect(response).toStrictEqual({ error: rpcErrors.internal('something went wrong') });
-    });
-  });
-});

package/src/handlers/eth-send-transaction/eth-send-transaction.ts

@@ -1,183 +0,0 @@
-import {
-  type Network,
-  type Hex,
-  type RpcRequest,
-  type ApprovalController,
-  type DisplayData,
-  type SigningData,
-  SigningDataType,
-} from '@avalabs/vm-module-types';
-import { parseRequestParams } from './schema';
-import { estimateGasLimit } from '../../utils/estimate-gas-limit';
-import { getNonce } from '../../utils/get-nonce';
-import { rpcErrors } from '@metamask/rpc-errors';
-import { getProvider } from '../../utils/get-provider';
-import type { JsonRpcBatchInternal } from '@avalabs/wallets-sdk';
-import { simulateTransaction } from '../../utils/transaction-simulation';
-import { parseERC20TransactionType } from '../../utils/parse-erc20-transaction-type';
-
-export const ethSendTransaction = async ({
-  request,
-  network,
-  approvalController,
-  proxyApiUrl,
-}: {
-  request: RpcRequest;
-  network: Network;
-  approvalController: ApprovalController;
-  proxyApiUrl: string;
-}) => {
-  const { dappInfo, params } = request;
-
-  // validate params
-  const result = parseRequestParams(params);
-
-  if (!result.success) {
-    console.error(result.error);
-    return {
-      error: rpcErrors.invalidParams('Transaction params are invalid'),
-    };
-  }
-
-  const transaction = result.data[0];
-
-  if (!transaction) {
-    return {
-      error: rpcErrors.invalidParams('Transaction params are invalid'),
-    };
-  }
-
-  const provider = getProvider({
-    chainId: network.chainId,
-    chainName: network.chainName,
-    rpcUrl: network.rpcUrl,
-    multiContractAddress: network.utilityAddresses?.multicall,
-    pollingInterval: 1000,
-  });
-
-  // calculate gas limit if not provided/invalid
-  if (!transaction.gas || Number(transaction.gas) < 0) {
-    try {
-      const gasLimit = await estimateGasLimit({
-        transactionParams: {
-          from: transaction.from,
-          to: transaction.to,
-          data: transaction.data,
-          value: transaction.value,
-        },
-        provider,
-      });
-
-      transaction.gas = '0x' + gasLimit.toString(16);
-    } catch (error) {
-      return {
-        error: rpcErrors.internal('Unable to calculate gas limit'),
-      };
-    }
-  }
-
-  // calculate nonce if not provided
-  if (!transaction.nonce) {
-    try {
-      const nonce = await getNonce({
-        from: transaction.from,
-        provider,
-      });
-      transaction.nonce = String(nonce);
-    } catch (error) {
-      return {
-        error: rpcErrors.internal('Unable to calculate nonce'),
-      };
-    }
-  }
-
-  const transactionType = parseERC20TransactionType(transaction);
-
-  const { transactionValidation, transactionSimulation } = await simulateTransaction({
-    proxyApiUrl,
-    chainId: network.chainId,
-    params: transaction,
-    dAppUrl: request.dappInfo.url,
-  });
-
-  // generate display and signing data
-  // TODO adjust title for different transaction types
-  // https://ava-labs.atlassian.net/browse/CP-8870
-  const displayData: DisplayData = {
-    title: 'Approve Transaction',
-    network: {
-      chainId: network.chainId,
-      name: network.chainName,
-      logoUri: network.logoUri,
-    },
-    transactionDetails: {
-      website: new URL(dappInfo.url).hostname,
-      from: transaction.from,
-      to: transaction.to,
-      data: transaction.data,
-      type: transactionType,
-    },
-    networkFeeSelector: true,
-    transactionValidation,
-    transactionSimulation,
-  };
-
-  const signingData: SigningData = {
-    type: SigningDataType.EVM_TRANSACTION,
-    account: transaction.from,
-    chainId: network.chainId,
-    data: {
-      type: 2, // hardcoding to 2 for now as we only support EIP-1559
-      nonce: Number(transaction.nonce),
-      gasLimit: Number(transaction.gas),
-      to: transaction.to,
-      from: transaction.from,
-      data: transaction.data,
-      value: transaction.value,
-      chainId: transaction.chainId,
-    },
-  };
-
-  // prompt user for approval
-  const response = await approvalController.requestApproval({ request, displayData, signingData });
-
-  if ('error' in response) {
-    return {
-      error: response.error,
-    };
-  }
-
-  // broadcast the signed transaction
-  const txHash = await provider.send('eth_sendRawTransaction', [response.result]);
-
-  waitForTransactionReceipt({
-    provider,
-    txHash,
-    onTransactionConfirmed: approvalController.onTransactionConfirmed,
-    onTransactionReverted: approvalController.onTransactionReverted,
-  });
-
-  return { result: txHash };
-};
-
-const waitForTransactionReceipt = async ({
-  provider,
-  txHash,
-  onTransactionConfirmed,
-  onTransactionReverted,
-}: {
-  provider: JsonRpcBatchInternal;
-  txHash: Hex;
-  onTransactionConfirmed: (txHash: Hex) => void;
-  onTransactionReverted: (txHash: Hex) => void;
-}) => {
-  const receipt = await provider.waitForTransaction(txHash);
-
-  const success = receipt?.status === 1; // 1 indicates success, 0 indicates revert
-
-  if (success) {
-    onTransactionConfirmed(txHash);
-  } else {
-    onTransactionReverted(txHash);
-  }
-};