wip: Add DeviceController

packages/snaps-controllers/src/devices/DeviceController.ts

@@ -0,0 +1,90 @@
+import type {
+  RestrictedControllerMessenger,
+  ControllerGetStateAction,
+  ControllerStateChangeEvent,
+} from '@metamask/base-controller';
+import { BaseController } from '@metamask/base-controller';
+import type { GetPermissions } from '@metamask/permission-controller';
+
+import type { DeleteInterface } from '../interface';
+import type { GetAllSnaps, HandleSnapRequest } from '../snaps';
+import type {
+  TransactionControllerUnapprovedTransactionAddedEvent,
+  SignatureStateChange,
+  TransactionControllerTransactionStatusUpdatedEvent,
+} from '../types';
+
+const controllerName = 'DeviceController';
+
+export type DeviceControllerAllowedActions =
+  | HandleSnapRequest
+  | GetAllSnaps
+  | GetPermissions
+  | DeleteInterface;
+
+export type DeviceControllerGetStateAction = ControllerGetStateAction<
+  typeof controllerName,
+  DeviceControllerState
+>;
+
+export type DeviceControllerActions = DeviceControllerGetStateAction;
+
+export type DeviceControllerStateChangeEvent = ControllerStateChangeEvent<
+  typeof controllerName,
+  DeviceControllerState
+>;
+
+export type DeviceControllerEvents = DeviceControllerStateChangeEvent;
+
+export type DeviceControllerAllowedEvents =
+  | TransactionControllerUnapprovedTransactionAddedEvent
+  | TransactionControllerTransactionStatusUpdatedEvent
+  | SignatureStateChange;
+
+export type DeviceControllerMessenger = RestrictedControllerMessenger<
+  typeof controllerName,
+  DeviceControllerActions | DeviceControllerAllowedActions,
+  DeviceControllerEvents | DeviceControllerAllowedEvents,
+  DeviceControllerAllowedActions['type'],
+  DeviceControllerAllowedEvents['type']
+>;
+
+export type Device = {};
+
+export type DeviceControllerState = {
+  devices: Record<string, Device>;
+};
+
+export type DeviceControllerArgs = {
+  messenger: DeviceControllerMessenger;
+  state?: DeviceControllerState;
+};
+/**
+ * Controller for managing access to devices for Snaps.
+ */
+export class DeviceController extends BaseController<
+  typeof controllerName,
+  DeviceControllerState,
+  DeviceControllerMessenger
+> {
+  constructor({ messenger, state }: DeviceControllerArgs) {
+    super({
+      messenger,
+      metadata: {
+        devices: { persist: true, anonymous: false },
+      },
+      name: controllerName,
+      state: { ...state, devices: {} },
+    });
+  }
+
+  async requestDevices() {
+    const devices = await (navigator as any).hid.requestDevice({ filters: [] });
+    return devices;
+  }
+
+  async getDevices() {
+    const devices = await (navigator as any).hid.getDevices();
+    return devices;
+  }
+}

packages/snaps-controllers/src/devices/index.ts

@@ -0,0 +1 @@
+export * from './DeviceController';

packages/snaps-controllers/src/index.ts

@@ -5,3 +5,4 @@ export * from './utils';
 export * from './cronjob';
 export * from './interface';
 export * from './insights';
+export * from './devices';

packages/snaps-rpc-methods/src/permitted/handlers.ts

@@ -1,5 +1,6 @@
 import { createInterfaceHandler } from './createInterface';
 import { providerRequestHandler } from './experimentalProviderRequest';
+import { providerRequestHandler as requestDeviceHandler } from './requestDevice';
 import { getAllSnapsHandler } from './getAllSnaps';
 import { getClientStatusHandler } from './getClientStatus';
 import { getCurrencyRateHandler } from './getCurrencyRate';
@@ -12,6 +13,7 @@ import { requestSnapsHandler } from './requestSnaps';
 import { resolveInterfaceHandler } from './resolveInterface';
 import { updateInterfaceHandler } from './updateInterface';
 
+
 /* eslint-disable @typescript-eslint/naming-convention */
 export const methodHandlers = {
   wallet_getAllSnaps: getAllSnapsHandler,
@@ -27,6 +29,7 @@ export const methodHandlers = {
   snap_resolveInterface: resolveInterfaceHandler,
   snap_getCurrencyRate: getCurrencyRateHandler,
   snap_experimentalProviderRequest: providerRequestHandler,
+  snap_requestDevice: requestDeviceHandler,
 };
 /* eslint-enable @typescript-eslint/naming-convention */
 

packages/snaps-rpc-methods/src/permitted/requestDevice.ts

@@ -0,0 +1,65 @@
+import type { JsonRpcEngineEndCallback } from '@metamask/json-rpc-engine';
+import type { PermittedHandlerExport } from '@metamask/permission-controller';
+import type {
+  JsonRpcRequest,
+  ProviderRequestParams,
+  ProviderRequestResult,
+} from '@metamask/snaps-sdk';
+import { type InferMatching } from '@metamask/snaps-utils';
+import { object, optional, string, type } from '@metamask/superstruct';
+import {
+  type PendingJsonRpcResponse,
+  CaipChainIdStruct,
+  JsonRpcParamsStruct,
+} from '@metamask/utils';
+
+import type { MethodHooksObject } from '../utils';
+
+const hookNames: MethodHooksObject<ProviderRequestMethodHooks> = {
+  requestDevices: true,
+};
+
+export type ProviderRequestMethodHooks = {
+  requestDevices: () => any;
+};
+
+export const providerRequestHandler: PermittedHandlerExport<
+  ProviderRequestMethodHooks,
+  ProviderRequestParameters,
+  ProviderRequestResult
+> = {
+  methodNames: ['snap_requestDevice'],
+  implementation: providerRequestImplementation,
+  hookNames,
+};
+
+const ProviderRequestParametersStruct = object({
+  chainId: CaipChainIdStruct,
+  request: type({
+    method: string(),
+    params: optional(JsonRpcParamsStruct),
+  }),
+});
+
+export type ProviderRequestParameters = InferMatching<
+  typeof ProviderRequestParametersStruct,
+  ProviderRequestParams
+>;
+
+async function providerRequestImplementation(
+  req: JsonRpcRequest<ProviderRequestParams>,
+  res: PendingJsonRpcResponse<ProviderRequestResult>,
+  _next: unknown,
+  end: JsonRpcEngineEndCallback,
+  { requestDevices }: ProviderRequestMethodHooks,
+): Promise<void> {
+  const { params } = req;
+
+  try {
+    res.result = await requestDevices();
+  } catch (error) {
+    return end(error);
+  }
+
+  return end();
+}