Support calling wallet_requestExecutionPermissions directly on the walletApi

Author: jeffsmale90

packages/delegation-toolkit/src/experimental/erc7715RequestExecutionPermissionsAction.ts

@@ -11,7 +11,7 @@ import type {
 } from '@metamask/7715-permission-types';
 import { isHex, toHex, type Address } from 'viem';
 
-import type { SnapClient } from './snapsAuthorization.js';
+import type { MetaMaskExtensionClient } from './snapsAuthorization.js';
 
 type PermissionParameter = {
   type: string;
@@ -125,38 +125,50 @@ export type RequestExecutionPermissionsReturnType = PermissionResponse<
  * @template Signer - The type of the signer, either an Address or Account.
  * @param client - The client to use for the request.
  * @param parameters - The permissions requests to grant.
- * @param kernelSnapId - The ID of the kernel snap to invoke, defaults to 'npm:@metamask/permissions-kernel-snap'.
+ * @param kernelSnapId - The ID of the kernel snap to invoke, undefined to request via the wallet RPC method.
  * @returns A promise that resolves to the permission responses.
  * @description
  * This function formats the permissions requests and invokes the wallet snap to grant permissions.
  * It will throw an error if the permissions could not be granted.
  */
 export async function erc7715RequestExecutionPermissionsAction(
-  client: SnapClient,
+  client: MetaMaskExtensionClient,
   parameters: RequestExecutionPermissionsParameters,
-  kernelSnapId = 'npm:@metamask/permissions-kernel-snap',
+  kernelSnapId: string | undefined,
 ): Promise<RequestExecutionPermissionsReturnType> {
-  const formattedParameters = parameters.map(formatPermissionsRequest);
-
-  const result = await client.request(
-    {
-      method: 'wallet_invokeSnap',
-      params: {
-        snapId: kernelSnapId,
-        request: {
-          method: 'wallet_requestExecutionPermissions',
-          params: formattedParameters,
+  const formattedPermissionRequest = parameters.map(formatPermissionsRequest);
+
+  let result: PermissionResponse<AccountSigner, PermissionTypes>[] | null;
+
+  if (kernelSnapId) {
+    result = await client.request(
+      {
+        method: 'wallet_invokeSnap',
+        params: {
+          snapId: kernelSnapId,
+          request: {
+            method: 'wallet_requestExecutionPermissions',
+            params: formattedPermissionRequest,
+          },
         },
       },
-    },
-    { retryCount: 0 },
-  );
+      { retryCount: 0 },
+    );
+  } else {
+    result = await client.request(
+      {
+        method: 'wallet_requestExecutionPermissions',
+        params: formattedPermissionRequest,
+      },
+      { retryCount: 0 },
+    );
+  }
 
-  if (result === null) {
+  if (!result) {
     throw new Error('Failed to grant permissions');
   }
 
-  return result as any as RequestExecutionPermissionsReturnType;
+  return result;
 }
 
 /**

packages/delegation-toolkit/src/experimental/index.ts

@@ -12,7 +12,7 @@ import {
 import { erc7715RequestExecutionPermissionsAction } from './erc7715RequestExecutionPermissionsAction';
 import type { RequestExecutionPermissionsParameters } from './erc7715RequestExecutionPermissionsAction';
 import { ensureSnapsAuthorized } from './snapsAuthorization';
-import type { SnapClient } from './snapsAuthorization';
+import type { MetaMaskExtensionClient } from './snapsAuthorization';
 
 export {
   erc7715RequestExecutionPermissionsAction as requestExecutionPermissions,
@@ -27,20 +27,48 @@ export {
   type DelegationStorageConfig,
 } from './delegationStorage';
 
+type Erc7715ProviderConfig = {
+  useWalletMethod: boolean;
+  snapIds?: {
+    kernelSnapId?: string;
+    providerSnapId?: string;
+  };
+};
+
 export const erc7715ProviderActions =
-  (snapIds?: { kernelSnapId: string; providerSnapId: string }) =>
+  (erc7715ProviderConfig: Erc7715ProviderConfig = { useWalletMethod: false }) =>
   (client: Client) => ({
     requestExecutionPermissions: async (
       parameters: RequestExecutionPermissionsParameters,
     ) => {
-      if (!(await ensureSnapsAuthorized(client as SnapClient, snapIds))) {
-        throw new Error('Snaps not authorized');
+      const { useWalletMethod, snapIds } = erc7715ProviderConfig;
+
+      let kernelSnapId: string | undefined;
+
+      if (!useWalletMethod) {
+        kernelSnapId =
+          snapIds?.kernelSnapId ?? 'npm:@metamask/permissions-kernel-snap';
+
+        const snapIdsToAuthorize = {
+          kernelSnapId,
+          providerSnapId:
+            snapIds?.providerSnapId ?? 'npm:@metamask/gator-permissions-snap',
+        };
+
+        if (
+          !(await ensureSnapsAuthorized(
+            client as MetaMaskExtensionClient,
+            snapIdsToAuthorize,
+          ))
+        ) {
+          throw new Error('Snaps not authorized');
+        }
       }
 
       return erc7715RequestExecutionPermissionsAction(
-        client as SnapClient,
+        client as MetaMaskExtensionClient,
         parameters,
-        snapIds?.kernelSnapId,
+        kernelSnapId,
       );
     },
   });

packages/delegation-toolkit/src/experimental/snapsAuthorization.ts

@@ -1,3 +1,9 @@
+import type {
+  AccountSigner,
+  PermissionRequest,
+  PermissionResponse,
+  PermissionTypes,
+} from '@metamask/7715-permission-types';
 import type { Account, Chain, Client, RpcSchema, Transport } from 'viem';
 
 /**
@@ -14,14 +20,14 @@ export type SnapAuthorizations = Record<
 >;
 
 /**
- * RPC schema for MetaMask Snap-related methods.
+ * RPC schema for MetaMask related methods.
  *
  * Extends the base RPC schema with methods specific to interacting with Snaps:
  * - `wallet_invokeSnap`: Invokes a method on a specific Snap.
  * - `wallet_getSnaps`: Retrieves all installed Snaps and their authorization status.
  * - `wallet_requestSnaps`: Requests permission to use specific Snaps.
  */
-export type SnapRpcSchema = RpcSchema &
+export type MetaMaskExtensionSchema = RpcSchema &
   [
     {
       // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -53,6 +59,14 @@ export type SnapRpcSchema = RpcSchema &
       // eslint-disable-next-line @typescript-eslint/naming-convention
       ReturnType: SnapAuthorizations;
     },
+    {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Method: 'wallet_requestExecutionPermissions';
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Params: PermissionRequest<AccountSigner, PermissionTypes>[];
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      ReturnType: PermissionResponse<AccountSigner, PermissionTypes>[];
+    },
   ];
 
 /**
@@ -62,11 +76,11 @@ export type SnapRpcSchema = RpcSchema &
  * the standard Viem client interface, with added type safety for
  * Snap-specific methods.
  */
-export type SnapClient = Client<
+export type MetaMaskExtensionClient = Client<
   Transport,
   Chain | undefined,
   Account | undefined,
-  SnapRpcSchema
+  MetaMaskExtensionSchema
 >;
 
 /**
@@ -94,7 +108,7 @@ const isSnapAuthorized = (
  * @param snapId - The ID of the snap to re-authorize.
  * @returns A promise that resolves to a boolean indicating whether the snap was re-authorized.
  */
-const reAuthorize = async (client: SnapClient, snapId: string) => {
+const reAuthorize = async (client: MetaMaskExtensionClient, snapId: string) => {
   const newAuthorizations = await client.request({
     method: 'wallet_requestSnaps',
     params: {
@@ -118,14 +132,12 @@ const reAuthorize = async (client: SnapClient, snapId: string) => {
  * It returns true only if both snaps are successfully authorized.
  */
 export async function ensureSnapsAuthorized(
-  client: SnapClient,
-  snapIds?: { kernelSnapId: string; providerSnapId: string },
+  client: MetaMaskExtensionClient,
+  {
+    kernelSnapId,
+    providerSnapId,
+  }: { kernelSnapId: string; providerSnapId: string },
 ) {
-  const kernelSnapId =
-    snapIds?.kernelSnapId ?? 'npm:@metamask/permissions-kernel-snap';
-  const providerSnapId =
-    snapIds?.providerSnapId ?? 'npm:@metamask/gator-permissions-snap';
-
   const existingAuthorizations = await client.request({
     method: 'wallet_getSnaps',
     params: {} as Record<string, never>,