refactor(storage-service): use unknown instead of generic types

Since there's no schema validation, using generics gives false type safety.
- setItem now accepts value: unknown
- getItem now returns Promise<unknown>
- Callers must validate/cast the returned data
- Updated JSDoc examples to show casting pattern

packages/storage-service/src/StorageService.test.ts

@@ -118,10 +118,7 @@ describe('StorageService', () => {
       const { service } = getService();
 
       await service.setItem('TestController', 'testKey', { data: 'test' });
-      const result = await service.getItem<{ data: string }>(
-        'TestController',
-        'testKey',
-      );
+      const result = await service.getItem('TestController', 'testKey');
 
       expect(result).toStrictEqual({ data: 'test' });
     });
@@ -174,7 +171,7 @@ describe('StorageService', () => {
       const { service } = getService();
 
       await service.setItem('TestController', 'string', 'simple string');
-      const result = await service.getItem<string>('TestController', 'string');
+      const result = await service.getItem('TestController', 'string');
 
       expect(result).toBe('simple string');
     });
@@ -183,7 +180,7 @@ describe('StorageService', () => {
       const { service } = getService();
 
       await service.setItem('TestController', 'number', 42);
-      const result = await service.getItem<number>('TestController', 'number');
+      const result = await service.getItem('TestController', 'number');
 
       expect(result).toBe(42);
     });
@@ -193,7 +190,7 @@ describe('StorageService', () => {
       const array = [1, 2, 3];
 
       await service.setItem('TestController', 'array', array);
-      const result = await service.getItem<number[]>('TestController', 'array');
+      const result = await service.getItem('TestController', 'array');
 
       expect(result).toStrictEqual(array);
     });
@@ -466,7 +463,7 @@ describe('StorageService', () => {
       expect(keys).toHaveLength(5);
 
       // Retrieve specific snap source code
-      const bitcoinSource = await service.getItem<string>(
+      const bitcoinSource = await service.getItem(
         'SnapController',
         'npm:@metamask/bitcoin-wallet-snap:sourceCode',
       );

packages/storage-service/src/StorageService.ts

@@ -46,11 +46,12 @@ import { SERVICE_NAME } from './types';
  *   }
  *
  *   async getSnapSourceCode(snapId: string): Promise<string | null> {
- *     return await this.messenger.call(
+ *     const result = await this.messenger.call(
  *       'StorageService:getItem',
  *       'SnapController',
  *       `${snapId}:sourceCode`,
  *     );
+ *     return result as string | null; // Caller must validate/cast
  *   }
  * }
  * ```
@@ -159,11 +160,10 @@ export class StorageService {
    * @param namespace - Controller namespace (e.g., 'SnapController').
    * @param key - Storage key (e.g., 'npm:@metamask/example-snap:sourceCode').
    * @param value - Data to store (should be 100KB+ for optimal use).
-   * @template T - The type of the value being stored.
    */
-  async setItem<T>(namespace: string, key: string, value: T): Promise<void> {
+  async setItem(namespace: string, key: string, value: unknown): Promise<void> {
     // Adapter handles serialization and wrapping with metadata
-    await this.#storage.setItem(namespace, key, value as never);
+    await this.#storage.setItem(namespace, key, value);
 
     // Publish event so other controllers can react to changes
     // Event type: StorageService:itemSet:namespace
@@ -178,15 +178,16 @@ export class StorageService {
   /**
    * Retrieve data from storage.
    *
+   * Returns `unknown` since there's no schema validation.
+   * Callers should validate or cast the result to the expected type.
+   *
    * @param namespace - Controller namespace (e.g., 'SnapController').
    * @param key - Storage key (e.g., 'npm:@metamask/example-snap:sourceCode').
-   * @returns Parsed data or null if not found.
-   * @template T - The type of the value being retrieved.
+   * @returns Parsed data or null if not found. Type is `unknown` - caller must validate.
    */
-  async getItem<T>(namespace: string, key: string): Promise<T | null> {
+  async getItem(namespace: string, key: string): Promise<unknown> {
     // Adapter handles deserialization and unwrapping
-    const result = await this.#storage.getItem(namespace, key);
-    return result as T | null;
+    return await this.#storage.getItem(namespace, key);
   }
 
   /**

packages/storage-service/src/types.ts

@@ -118,15 +118,17 @@ export const STORAGE_KEY_PREFIX = 'storageService:';
  */
 export type StorageServiceSetItemAction = {
   type: `${typeof SERVICE_NAME}:setItem`;
-  handler: <T>(namespace: string, key: string, value: T) => Promise<void>;
+  handler: (namespace: string, key: string, value: unknown) => Promise<void>;
 };
 
 /**
  * Action for retrieving data from the storage service.
+ * Returns `unknown` since there's no schema validation.
+ * Callers should validate/cast the result.
  */
 export type StorageServiceGetItemAction = {
   type: `${typeof SERVICE_NAME}:getItem`;
-  handler: <T>(namespace: string, key: string) => Promise<T | null>;
+  handler: (namespace: string, key: string) => Promise<unknown>;
 };
 
 /**