feat: add new RPC starkNet_addAccount

packages/starknet-snap/src/config.ts

@@ -36,6 +36,9 @@ export type SnapConfig = {
       txnsInLastNumOfDays: number;
     };
   };
+  account: {
+    maxAccountToCreate: number;
+  };
 };
 
 export enum DataClient {
@@ -61,6 +64,10 @@ export const Config: SnapConfig = {
     },
   },
 
+  account: {
+    maxAccountToCreate: 2,
+  },
+
   // eslint-disable-next-line no-restricted-globals
   rpcApiKey: process.env.DIN_API_KEY ?? '',
 

packages/starknet-snap/src/index.tsx

@@ -37,6 +37,7 @@ import type {
   GetAddrFromStarkNameParams,
   GetTransactionStatusParams,
   ListTransactionsParams,
+  AddAccountParams,
 } from './rpcs';
 import {
   displayPrivateKey,
@@ -53,6 +54,7 @@ import {
   getAddrFromStarkName,
   getTransactionStatus,
   listTransactions,
+  addAccount,
 } from './rpcs';
 import { signDeployAccountTransaction } from './signDeployAccountTransaction';
 import type {
@@ -279,6 +281,11 @@ export const onRpcRequest: OnRpcRequestHandler = async ({
           apiParams.requestParams as unknown as GetAddrFromStarkNameParams,
         );
 
+      case RpcMethod.AddAccount:
+        return await addAccount.execute(
+          requestParams as unknown as AddAccountParams,
+        );
+
       default:
         throw new MethodNotFoundError() as unknown as Error;
     }

packages/starknet-snap/src/rpcs/__tests__/helper.ts

@@ -67,10 +67,17 @@ export async function setupAccountController({
     'deriveAccountByAddress',
   );
 
+  const deriveAccountByIndexSpy = jest.spyOn(
+    AccountService.prototype,
+    'deriveAccountByIndex',
+  );
+
   deriveAccountByAddressSpy.mockResolvedValue(account);
+  deriveAccountByIndexSpy.mockResolvedValue(account);
 
   return {
     deriveAccountByAddressSpy,
+    deriveAccountByIndexSpy,
     isRequireDeploySpy,
     isRequireUpgradeSpy,
     isDeploySpy,

packages/starknet-snap/src/rpcs/add-account.test.ts

@@ -0,0 +1,48 @@
+import type { constants } from 'starknet';
+
+import { STARKNET_SEPOLIA_TESTNET_NETWORK } from '../utils/constants';
+import { InvalidRequestParamsError } from '../utils/exceptions';
+import { setupAccountController } from './__tests__/helper';
+import { addAccount } from './add-account';
+import type { AddAccountParams } from './add-account';
+
+jest.mock('../utils/snap');
+jest.mock('../utils/logger');
+
+describe('AddAccountRpc', () => {
+  const network = STARKNET_SEPOLIA_TESTNET_NETWORK;
+
+  const setupAddAccountTest = async () => {
+    // Although `AddAccountRpc` does not inherit `AccountRpcController`,
+    // but we can still use `setupAccountController` to mock the `AccountService`.
+    const { account, deriveAccountByIndexSpy } = await setupAccountController(
+      {},
+    );
+
+    const request = {
+      chainId: network.chainId as unknown as constants.StarknetChainId,
+    };
+
+    return {
+      deriveAccountByIndexSpy,
+      account,
+      request,
+    };
+  };
+
+  it('add an `Account`', async () => {
+    const { account, request, deriveAccountByIndexSpy } =
+      await setupAddAccountTest();
+
+    const result = await addAccount.execute(request);
+
+    expect(result).toStrictEqual(await account.serialize());
+    expect(deriveAccountByIndexSpy).toHaveBeenCalled();
+  });
+
+  it('throws `InvalidRequestParamsError` when request parameter is not correct', async () => {
+    await expect(
+      addAccount.execute({} as unknown as AddAccountParams),
+    ).rejects.toThrow(InvalidRequestParamsError);
+  });
+});

packages/starknet-snap/src/rpcs/add-account.ts

@@ -0,0 +1,46 @@
+import { type Infer } from 'superstruct';
+
+import { BaseRequestStruct, AccountStruct } from '../utils';
+import { createAccountService } from '../utils/factory';
+import { ChainRpcController } from './abstract/chain-rpc-controller';
+
+export const AddAccountRequestStruct = BaseRequestStruct;
+
+export const AddAccountResponseStruct = AccountStruct;
+
+export type AddAccountParams = Infer<typeof AddAccountRequestStruct>;
+
+export type AddAccountResponse = Infer<typeof AddAccountResponseStruct>;
+
+/**
+ * The RPC handler to get a active account by network.
+ */
+export class AddAccountRpc extends ChainRpcController<
+  AddAccountParams,
+  AddAccountResponse
+> {
+  protected requestStruct = AddAccountRequestStruct;
+
+  protected responseStruct = AddAccountResponseStruct;
+
+  /**
+   * Execute the get active account request handler.
+   *
+   * @param params - The parameters of the request.
+   * @param params.chainId - The chain id of the network.
+   * @returns A promise that resolves to an active account.
+   */
+  protected async handleRequest(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    params: AddAccountParams,
+  ): Promise<AddAccountResponse> {
+    const accountService = createAccountService(this.network);
+
+    const account = await accountService.deriveAccountByIndex();
+
+    // TODO: after derive an account, we should store it as a active account.
+    return account.serialize() as unknown as AddAccountResponse;
+  }
+}
+
+export const addAccount = new AddAccountRpc();

packages/starknet-snap/src/rpcs/index.ts

@@ -12,3 +12,4 @@ export * from './watch-asset';
 export * from './get-addr-from-starkname';
 export * from './get-transaction-status';
 export * from './list-transactions';
+export * from './add-account';

packages/starknet-snap/src/state/__tests__/helper.ts

@@ -1,4 +1,4 @@
-import type { constants } from 'starknet';
+import { constants } from 'starknet';
 
 import { generateAccounts, type StarknetAccount } from '../../__tests__/helper';
 import type {
@@ -12,6 +12,7 @@ import {
   STRK_SEPOLIA_TESTNET,
 } from '../../utils/constants';
 import * as snapHelper from '../../utils/snap';
+import { AccountStateManager } from '../account-state-manager';
 import { NetworkStateManager } from '../network-state-manager';
 import { TransactionRequestStateManager } from '../request-state-manager';
 import { TokenStateManager } from '../token-state-manager';
@@ -27,6 +28,14 @@ export const mockAcccounts = async (
   return generateAccounts(chainId, cnt);
 };
 
+export const generateTestnetAccounts = async (count?: number) => {
+  return await mockAcccounts(constants.StarknetChainId.SN_SEPOLIA, count);
+};
+
+export const generateMainnetAccounts = async (count?: number) => {
+  return await mockAcccounts(constants.StarknetChainId.SN_MAIN, count);
+};
+
 export const mockState = async ({
   accounts,
   tokens,
@@ -47,7 +56,7 @@ export const mockState = async ({
   const getDataSpy = jest.spyOn(snapHelper, 'getStateData');
   const setDataSpy = jest.spyOn(snapHelper, 'setStateData');
   const state = {
-    accContracts: accounts,
+    accContracts: accounts ?? [],
     erc20Tokens: tokens ?? [],
     networks: networks ?? [],
     transactions: transactions ?? [],
@@ -78,6 +87,29 @@ export const mockTokenStateManager = () => {
   };
 };
 
+export const mockAccountStateManager = () => {
+  const getAccountSpy = jest.spyOn(AccountStateManager.prototype, 'getAccount');
+  const getNextIndexSpy = jest.spyOn(
+    AccountStateManager.prototype,
+    'getNextIndex',
+  );
+  const upsertAccountSpy = jest.spyOn(
+    AccountStateManager.prototype,
+    'upsertAccount',
+  );
+  const isMaxAccountLimitExceededSpy = jest.spyOn(
+    AccountStateManager.prototype,
+    'isMaxAccountLimitExceeded',
+  );
+
+  return {
+    getAccountSpy,
+    getNextIndexSpy,
+    upsertAccountSpy,
+    isMaxAccountLimitExceededSpy,
+  };
+};
+
 export const mockTransactionStateManager = () => {
   const removeTransactionsSpy = jest.spyOn(
     TransactionStateManager.prototype,