refine(DeclareContract): revamp RPC starkNet_declareContract

packages/starknet-snap/src/index.ts

@@ -9,7 +9,6 @@ import { panel, text, MethodNotFoundError } from '@metamask/snaps-sdk';
 import { addNetwork } from './addNetwork';
 import { Config } from './config';
 import { createAccount } from './createAccount';
-import { declareContract } from './declareContract';
 import { estimateAccDeployFee } from './estimateAccountDeployFee';
 import { estimateFees } from './estimateFees';
 import { extractPublicKey } from './extractPublicKey';
@@ -35,12 +34,14 @@ import type {
   VerifySignatureParams,
   SwitchNetworkParams,
   GetDeploymentDataParams,
+  DeclareContractParams,
   WatchAssetParams,
 } from './rpcs';
 import {
   displayPrivateKey,
   estimateFee,
   executeTxn,
+  declareContract,
   signMessage,
   signTransaction,
   signDeclareTransaction,
@@ -276,9 +277,8 @@ export const onRpcRequest: OnRpcRequestHandler = async ({ request }) => {
         );
 
       case 'starkNet_declareContract':
-        apiParams.keyDeriver = await getAddressKeyDeriver(snap);
-        return await declareContract(
-          apiParams as unknown as ApiParamsWithKeyDeriver,
+        return await declareContract.execute(
+          apiParams as unknown as DeclareContractParams,
         );
 
       case 'starkNet_getStarkName':

packages/starknet-snap/src/rpcs/declare-contract.test.ts

@@ -0,0 +1,272 @@
+import { BigNumber, utils } from 'ethers';
+import type { Abi } from 'starknet';
+import { constants } from 'starknet';
+import type { Infer } from 'superstruct';
+
+import { toJson, type DeclareContractPayloadStruct } from '../utils';
+import { STARKNET_SEPOLIA_TESTNET_NETWORK } from '../utils/constants';
+import {
+  UserRejectedOpError,
+  InvalidRequestParamsError,
+  UnknownError,
+} from '../utils/exceptions';
+import * as starknetUtils from '../utils/starknetUtils';
+import {
+  mockAccount,
+  prepareConfirmDialog,
+  prepareMockAccount,
+} from './__tests__/helper';
+import { declareContract } from './declare-contract';
+import type { DeclareContractResponse } from './declare-contract';
+
+jest.mock('../utils/snap');
+jest.mock('../utils/logger');
+
+type DeclareContractPayload = Infer<typeof DeclareContractPayloadStruct>;
+
+// Helper function to generate the expected DeclareContractPayload
+const generateExpectedDeclareTransactionPayload =
+  (): DeclareContractPayload => ({
+    compiledClassHash: '0xcompiledClassHash',
+    classHash: '0xclassHash',
+    contract: {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      sierra_program: ['0x1', '0x2'],
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      contract_class_version: '1.0.0',
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      entry_points_by_type: {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        CONSTRUCTOR: [{ selector: '0xconstructorSelector', function_idx: 0 }],
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        EXTERNAL: [{ selector: '0xexternalSelector', function_idx: 1 }],
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        L1_HANDLER: [{ selector: '0xhandlerSelector', function_idx: 2 }],
+      },
+      abi: '[{"type":"function","name":"transfer"}]' as unknown as Abi,
+    },
+  });
+
+const prepareMockDeclareContract = async (
+  transactionHash: string,
+  payload: DeclareContractPayload,
+  details: any,
+) => {
+  const state = {
+    accContracts: [],
+    erc20Tokens: [],
+    networks: [STARKNET_SEPOLIA_TESTNET_NETWORK],
+    transactions: [],
+  };
+  const { confirmDialogSpy } = prepareConfirmDialog();
+
+  const account = await mockAccount(constants.StarknetChainId.SN_SEPOLIA);
+  prepareMockAccount(account, state);
+
+  const request = {
+    chainId: state.networks[0].chainId as unknown as constants.StarknetChainId,
+    address: account.address,
+    payload,
+    details,
+  };
+
+  const declareContractRespMock: DeclareContractResponse = {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    transaction_hash: transactionHash,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    class_hash: '0x123456789abcdef',
+  };
+
+  const declareContractUtilSpy = jest.spyOn(starknetUtils, 'declareContract');
+  declareContractUtilSpy.mockResolvedValue(declareContractRespMock);
+
+  return {
+    network: state.networks[0],
+    account,
+    request,
+    confirmDialogSpy,
+    declareContractRespMock,
+    declareContractUtilSpy,
+  };
+};
+
+describe('DeclareContractRpc', () => {
+  it('declares a contract correctly if user confirms the dialog', async () => {
+    const payload = generateExpectedDeclareTransactionPayload();
+    const details = { maxFee: BigNumber.from(1000000000000000).toString() };
+    const transactionHash = '0x123';
+
+    const {
+      account,
+      request,
+      declareContractRespMock,
+      confirmDialogSpy,
+      declareContractUtilSpy,
+    } = await prepareMockDeclareContract(transactionHash, payload, details);
+
+    confirmDialogSpy.mockResolvedValue(true);
+
+    const result = await declareContract.execute(request);
+
+    expect(result).toStrictEqual(declareContractRespMock);
+    expect(declareContractUtilSpy).toHaveBeenCalledWith(
+      STARKNET_SEPOLIA_TESTNET_NETWORK,
+      account.address,
+      account.privateKey,
+      request.payload,
+      request.details,
+    );
+  });
+
+  it('throws UserRejectedOpError if user cancels the dialog', async () => {
+    const payload = generateExpectedDeclareTransactionPayload();
+    const details = { maxFee: BigNumber.from(1000000000000000).toString() };
+    const transactionHash = '0x123';
+
+    const { request, confirmDialogSpy } = await prepareMockDeclareContract(
+      transactionHash,
+      payload,
+      details,
+    );
+    confirmDialogSpy.mockResolvedValue(false);
+
+    await expect(declareContract.execute(request)).rejects.toThrow(
+      UserRejectedOpError,
+    );
+  });
+
+  it('throws `InvalidRequestParamsError` when request parameter is not correct', async () => {
+    await expect(declareContract.execute({} as unknown as any)).rejects.toThrow(
+      InvalidRequestParamsError,
+    );
+  });
+
+  it.each([
+    {
+      testCase: 'class_hash is missing',
+      declareContractRespMock: {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        transaction_hash: '0x123',
+      },
+    },
+    {
+      testCase: 'transaction_hash is missing',
+      declareContractRespMock: {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        class_hash: '0x123456789abcdef',
+      },
+    },
+    {
+      testCase: 'empty object is returned',
+      declareContractRespMock: {},
+    },
+  ])(
+    'throws `Unknown Error` when $testCase',
+    async ({ declareContractRespMock }) => {
+      const payload = generateExpectedDeclareTransactionPayload();
+      const details = { maxFee: BigNumber.from(1000000000000000).toString() };
+      const transactionHash = '0x123';
+
+      const { request, declareContractUtilSpy } =
+        await prepareMockDeclareContract(transactionHash, payload, details);
+
+      declareContractUtilSpy.mockResolvedValue(
+        declareContractRespMock as unknown as DeclareContractResponse,
+      );
+
+      await expect(declareContract.execute(request)).rejects.toThrow(
+        UnknownError,
+      );
+    },
+  );
+
+  it('renders confirmation dialog', async () => {
+    const payload = generateExpectedDeclareTransactionPayload();
+    const details = { maxFee: BigNumber.from(1000000000000000).toString() };
+    // Convert maxFee to ETH from Wei
+    const maxFeeInEth = utils.formatUnits(details.maxFee, 'ether');
+    const transactionHash = '0x123';
+
+    const { request, confirmDialogSpy, account } =
+      await prepareMockDeclareContract(transactionHash, payload, details);
+
+    await declareContract.execute(request);
+
+    const calls = confirmDialogSpy.mock.calls[0][0];
+    expect(calls).toStrictEqual([
+      {
+        type: 'heading',
+        value: 'Do you want to sign this transaction?',
+      },
+      {
+        type: 'row',
+        label: 'Signer Address',
+        value: {
+          value: account.address,
+          markdown: false,
+          type: 'text',
+        },
+      },
+      {
+        type: 'divider',
+      },
+      {
+        type: 'row',
+        label: 'Network',
+        value: {
+          value: STARKNET_SEPOLIA_TESTNET_NETWORK.name,
+          markdown: false,
+          type: 'text',
+        },
+      },
+      {
+        type: 'divider',
+      },
+      {
+        type: 'row',
+        label: 'Contract',
+        value: {
+          value: toJson(payload.contract),
+          markdown: false,
+          type: 'text',
+        },
+      },
+      {
+        type: 'divider',
+      },
+      {
+        type: 'row',
+        label: 'Compiled Class Hash',
+        value: {
+          value: payload.compiledClassHash,
+          markdown: false,
+          type: 'text',
+        },
+      },
+      {
+        type: 'divider',
+      },
+      {
+        type: 'row',
+        label: 'Class Hash',
+        value: {
+          value: payload.classHash,
+          markdown: false,
+          type: 'text',
+        },
+      },
+      {
+        type: 'divider',
+      },
+      {
+        type: 'row',
+        label: 'Max Fee (ETH)',
+        value: {
+          value: maxFeeInEth,
+          markdown: false,
+          type: 'text',
+        },
+      },
+    ]);
+  });
+});