chore: refactor

Author: xavier-brochard

packages/snap/src/core/handlers/onClientRequest/ClientRequestHandler.ts

@@ -1,10 +1,13 @@
-import { SnapError, type Json, type JsonRpcRequest } from '@metamask/snaps-sdk';
+import { type Json, type JsonRpcRequest } from '@metamask/snaps-sdk';
 import { assert, enums } from '@metamask/superstruct';
 
 import type { ILogger } from '../../utils/logger';
 import type { SignAndSendTransactionWithIntentUseCase } from './SignAndSendTransactionWithIntentUseCase';
 import type { ClientRequestUseCase } from './types';
-import { ClientRequestMethod } from './types';
+import {
+  ClientRequestMethod,
+  SignAndSendTransactionWithIntentParamsStruct,
+} from './types';
 
 export class ClientRequestHandler {
   readonly #methodToUseCase: Record<ClientRequestMethod, ClientRequestUseCase>;
@@ -31,18 +34,23 @@ export class ClientRequestHandler {
    * @returns The response to the JSON-RPC request.
    */
   async handle(request: JsonRpcRequest): Promise<Json> {
-    try {
-      this.#logger.log('[onClientRequest] Handling client request...', request);
-
-      const { method } = request;
-      assert(method, enums(Object.values(ClientRequestMethod)));
-
-      const useCase = this.#methodToUseCase[method];
-
-      return useCase.execute(request);
-    } catch (error: any) {
-      this.#logger.error(error, 'Error handling client request');
-      throw new SnapError(error);
+    this.#logger.log('[onClientRequest] Handling client request...', request);
+
+    const { method, params } = request;
+    assert(method, enums(Object.values(ClientRequestMethod)));
+
+    // Parse and validate parameters based on method
+    let parsedParams: any;
+    switch (method) {
+      case ClientRequestMethod.SignAndSendTransactionWithIntent:
+        assert(params, SignAndSendTransactionWithIntentParamsStruct);
+        parsedParams = params;
+        break;
+      default:
+        throw new Error(`Unsupported method: ${method}`);
     }
+
+    const useCase = this.#methodToUseCase[method];
+    return useCase.execute(parsedParams);
   }
 }

packages/snap/src/core/handlers/onClientRequest/SignAndSendTransactionWithIntentUseCase.ts

@@ -1,19 +1,18 @@
 import { SolMethod } from '@metamask/keyring-api';
-import { assert, literal, object } from '@metamask/superstruct';
-import type { Json, JsonRpcRequest } from '@metamask/utils';
+import { assert, object } from '@metamask/superstruct';
+import type { Json } from '@metamask/utils';
 
 import { Network } from '../../constants/solana';
 import type { WalletService } from '../../services/wallet/WalletService';
 import type { ILogger } from '../../utils/logger';
 import type { SolanaKeyring } from '../onKeyringRequest/Keyring';
-import type { ClientRequestUseCase } from './types';
-import {
-  ClientRequestMethod,
-  SignAndSendTransactionWithIntentParamsStruct,
+import type {
+  ClientRequestUseCase,
+  SignAndSendTransactionWithIntentParams,
 } from './types';
 
 export class SignAndSendTransactionWithIntentUseCase
-  implements ClientRequestUseCase
+  implements ClientRequestUseCase<SignAndSendTransactionWithIntentParams>
 {
   #keyring: SolanaKeyring;
 
@@ -36,27 +35,18 @@ export class SignAndSendTransactionWithIntentUseCase
    * This allows swap/bridge transactions to be executed without user confirmation
    * when they match a verified intent from the backend.
    *
-   * @param request - The JSON-RPC request containing the intent, transaction, and signature.
+   * @param params - The validated parameters containing intent, transaction, and signature.
    * @returns The transaction signature if successful.
    */
-  async execute(request: JsonRpcRequest): Promise<Json> {
+  async execute(params: SignAndSendTransactionWithIntentParams): Promise<Json> {
     this.#logger.log(
       '[SignAndSendTransactionWithIntentUseCase] execute',
-      request,
+      params,
     );
 
-    const { method, params } = request;
-
-    assert(
-      method,
-      literal(ClientRequestMethod.SignAndSendTransactionWithIntent),
-    );
-    assert(params, SignAndSendTransactionWithIntentParamsStruct);
-
     const { intent, tx, signature } = params;
 
-    // TODO: Implement signature verification
-    // This should verify that the backend signed the intent and transaction
+    // Verify that the backend signed the intent (and transaction?)
     // to ensure the transaction came from our backend and matches the user's intent
     const isValidSignature = await this.#verifyBackendSignature(
       intent,
@@ -68,8 +58,7 @@ export class SignAndSendTransactionWithIntentUseCase
       throw new Error('Invalid backend signature');
     }
 
-    // TODO: Implement transaction vs intent verification
-    // This should verify that the transaction actually performs the swap/bridge
+    // Verify that the transaction actually performs the swap/bridge
     // described in the intent (correct amounts, assets, etc.)
     const transactionMatchesIntent = await this.#verifyTransactionMatchesIntent(
       intent,
@@ -81,12 +70,11 @@ export class SignAndSendTransactionWithIntentUseCase
     }
 
     // Get the user's account
-    // For now, we'll use the first account, but this should be determined
-    // based on the intent's from address
-    const account = (await this.#keyring.listAccounts())[0];
+    // TODO: How do we know which account to use? For now, we'll use the first account
+    const account = (await this.#keyring.listAccounts())[0]; // TODO: We should move account CRUDs to an AccountService
     assert(account, object());
 
-    // TODO: Determine the correct network from the intent
+    // TODO: How do we know the correct network?
     // For now, defaulting to mainnet
     const scope: Network = Network.Mainnet;
 

packages/snap/src/core/handlers/onClientRequest/types.ts

@@ -1,8 +1,9 @@
-import { object, string, union } from '@metamask/superstruct';
-import type { Json, JsonRpcRequest } from '@metamask/utils';
+import type { Infer } from '@metamask/superstruct';
+import { object, string } from '@metamask/superstruct';
+import type { Json } from '@metamask/utils';
 import { CaipAssetTypeStruct } from '@metamask/utils';
 
-import { NetworkStruct, UuidStruct } from '../../validation/structs';
+import { Base64Struct, UuidStruct } from '../../validation/structs';
 
 export enum ClientRequestMethod {
   SignAndSendTransactionWithIntent = 'signAndSendTransactionWithIntent',
@@ -13,34 +14,24 @@ export const IntentStruct = object({
   timestamp: string(),
   from: object({
     asset: CaipAssetTypeStruct,
-    amount: string(), // Keep as string to preserve precision
+    amount: string(),
   }),
   to: object({
     asset: CaipAssetTypeStruct,
-    amount: string(), // Keep as string to preserve precision
+    amount: string(),
   }),
 });
 
 export const SignAndSendTransactionWithIntentParamsStruct = object({
   intent: IntentStruct,
-  tx: string(), // Base64 encoded transaction
-  signature: string(), // Backend signature for verification
+  tx: Base64Struct, // TODO: What type?
+  signature: string(), // TODO: What type?
 });
 
-export const SignAndSendTransactionWithIntentRequestStruct = object({
-  id: UuidStruct,
-  scope: NetworkStruct,
-  account: UuidStruct,
-  request: SignAndSendTransactionWithIntentParamsStruct,
-});
-
-export const ClientRequestStruct = object({
-  id: UuidStruct,
-  scope: NetworkStruct,
-  account: UuidStruct,
-  request: union([SignAndSendTransactionWithIntentRequestStruct]),
-});
+export type SignAndSendTransactionWithIntentParams = Infer<
+  typeof SignAndSendTransactionWithIntentParamsStruct
+>;
 
-export type ClientRequestUseCase = {
-  execute: (request: JsonRpcRequest) => Promise<Json>;
+export type ClientRequestUseCase<TParams = any> = {
+  execute: (params: TParams) => Promise<Json>;
 };