@docknetwork/wallet-sdk-wasm 1.5.11 → 1.7.0

package/src/services/edv/service.ts

@@ -1,4 +1,12 @@
 // @ts-nocheck
+
+/**
+ * @module edv-service
+ * @description Encrypted Data Vault (EDV) service for the Wallet SDK.
+ * This module provides secure, encrypted storage functionality using EDV protocol,
+ * enabling privacy-preserving data storage with client-side encryption.
+ */
+
 import {InitializeEDVParams, serviceName} from './configs';
 import EDVHTTPStorageInterface from '@docknetwork/universal-wallet/storage/edv-http-storage';
 import HMAC from './hmac';
@@ -11,7 +19,10 @@ import {didService} from '@docknetwork/wallet-sdk-wasm/src/services/dids/service
 import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
 
 /**
- * EDVService
+ * Service class for managing Encrypted Data Vaults
+ * @class
+ * @description Provides methods for creating, managing, and interacting with
+ * encrypted data vaults for secure storage of sensitive wallet data
  */
 export class EDVService {
   storageInterface: EDVHTTPStorageInterface;
@@ -30,10 +41,33 @@ export class EDVService {
     EDVService.prototype.delete,
   ];
 
+  /**
+   * Creates a new EDVService instance
+   * @constructor
+   */
   constructor() {
     this.name = serviceName;
   }
 
+  /**
+   * Initializes the EDV service with encryption keys and connection parameters
+   * @param {InitializeEDVParams} params - Initialization parameters
+   * @param {Object} params.hmacKey - HMAC key for document indexing
+   * @param {Object} params.agreementKey - Key agreement key for encryption
+   * @param {Object} params.verificationKey - Verification key for authentication
+   * @param {string} params.edvUrl - URL of the EDV server
+   * @param {string} params.authKey - Authentication key for the EDV server
+   * @returns {Promise<void>}
+   * @throws {Error} If unable to create or connect to EDV
+   * @example
+   * await edvService.initialize({
+   *   hmacKey: hmacKeyData,
+   *   agreementKey: agreementKeyData,
+   *   verificationKey: verificationKeyData,
+   *   edvUrl: 'https://edv.example.com',
+   *   authKey: 'auth-token-123'
+   * });
+   */
   async initialize({
     hmacKey,
     agreementKey,
@@ -95,6 +129,21 @@ export class EDVService {
     });
   }
 
+  /**
+   * Generates new cryptographic keys for EDV operations
+   * @returns {Promise<Object>} Generated keys
+   * @returns {Object} returns.verificationKey - Ed25519 verification key for authentication
+   * @returns {Object} returns.agreementKey - X25519 key agreement key for encryption
+   * @returns {Object} returns.hmacKey - HMAC key for indexing
+   * @example
+   * const keys = await edvService.generateKeys();
+   * // Use keys for EDV initialization
+   * await edvService.initialize({
+   *   ...keys,
+   *   edvUrl: 'https://edv.example.com',
+   *   authKey: 'auth-token'
+   * });
+   */
   async generateKeys() {
     const keyPair = await didService.generateKeyDoc({});
 
@@ -111,6 +160,17 @@ export class EDVService {
     return {verificationKey, agreementKey, hmacKey};
   }
 
+  /**
+   * Derives cryptographic keys from a master key
+   * @param {Uint8Array} masterKey - Master key for derivation
+   * @returns {Promise<Object>} Derived keys
+   * @returns {Object} returns.verificationKey - Derived Ed25519 verification key
+   * @returns {Object} returns.agreementKey - Derived X25519 key agreement key
+   * @returns {Object} returns.hmacKey - Derived HMAC key
+   * @example
+   * const masterKey = new Uint8Array(32); // Your master key
+   * const keys = await edvService.deriveKeys(masterKey);
+   */
   async deriveKeys(masterKey: Uint8Array) {
     const {keyPair: pair} = new Ed25519Keypair(masterKey, 'seed');
 
@@ -126,18 +186,66 @@ export class EDVService {
     return { verificationKey, agreementKey, hmacKey };
   }
 
+  /**
+   * Gets the controller identifier for the current EDV
+   * @returns {Promise<string>} The controller DID or identifier
+   * @example
+   * const controller = await edvService.getController();
+   * console.log('EDV Controller:', controller);
+   */
   async getController() {
     return this.controller;
   }
 
+  /**
+   * Finds documents in the EDV based on query parameters
+   * @param {Object} params - Query parameters
+   * @param {Object} [params.equals] - Equality-based query conditions
+   * @param {boolean} [params.has] - Existence-based query conditions
+   * @param {number} [params.limit] - Maximum number of results
+   * @returns {Promise<Array>} Array of matching documents
+   * @example
+   * const documents = await edvService.find({
+   *   equals: { 'content.type': 'VerifiableCredential' },
+   *   limit: 10
+   * });
+   */
   find(params: any) {
     return this.storageInterface.find(params);
   }
 
+  /**
+   * Updates a document in the EDV
+   * @param {Object} params - Update parameters
+   * @param {string} params.id - Document ID to update
+   * @param {Object} params.content - New document content
+   * @returns {Promise<Object>} Updated document
+   * @example
+   * const updated = await edvService.update({
+   *   id: 'doc-123',
+   *   content: { ...existingContent, updated: true }
+   * });
+   */
   update(params: any) {
     return this.storageInterface.update(params);
   }
 
+  /**
+   * Inserts a new document into the EDV
+   * @param {Object} params - Insert parameters
+   * @param {string} params.id - Document ID
+   * @param {Object} params.content - Document content to store
+   * @returns {Promise<Object>} The inserted document
+   * @throws {Error} If insertion fails
+   * @example
+   * const document = await edvService.insert({
+   *   id: 'doc-456',
+   *   content: {
+   *     type: 'VerifiableCredential',
+   *     data: credentialData
+   *   }
+   * });
+   */
   insert(params: any) {
     this.insertQueue = this.insertQueue.then(() => {
       return this.storageInterface.insert(params).catch(error => {
@@ -148,9 +256,53 @@ export class EDVService {
     return this.insertQueue;
   }
 
+  /**
+   * Deletes a document from the EDV
+   * @param {Object} params - Deletion parameters
+   * @param {string} params.id - Document ID to delete
+   * @returns {Promise<boolean>} True if deletion successful
+   * @example
+   * const deleted = await edvService.delete({
+   *   id: 'doc-123'
+   * });
+   */
   delete(params: any) {
     return this.storageInterface.delete(params);
   }
 }
 
+/**
+ * Singleton instance of the EDV service
+ * @type {EDVService}
+ * @example
+ * import { edvService } from '@docknetwork/wallet-sdk-wasm/services/edv';
+ *
+ * // Generate keys and initialize
+ * const keys = await edvService.generateKeys();
+ * await edvService.initialize({
+ *   ...keys,
+ *   edvUrl: 'https://edv.example.com',
+ *   authKey: 'auth-token'
+ * });
+ *
+ * // Store encrypted data
+ * await edvService.insert({
+ *   id: 'credential-1',
+ *   content: {
+ *     type: 'VerifiableCredential',
+ *     data: credentialData
+ *   }
+ * });
+ *
+ * // Query encrypted data
+ * const credentials = await edvService.find({
+ *   equals: { 'content.type': 'VerifiableCredential' }
+ * });
+ *
+ * // Update encrypted data
+ * await edvService.update({
+ *   id: 'credential-1',
+ *   content: updatedData
+ * });
+ */
 export const edvService: EDVService = new EDVService();

package/src/services/relay-service/service.ts

@@ -1,3 +1,10 @@
+/**
+ * @module relay-service
+ * @description DIDComm message relay service for the Wallet SDK.
+ * This module provides functionality for sending, receiving, and managing DIDComm messages
+ * through a relay service, including push notification support.
+ */
+
 import {
   SendMessageParams,
   GetMessagesParams,
@@ -11,7 +18,10 @@ import {
 import {RelayService as relayServiceClient} from '@docknetwork/wallet-sdk-relay-service/src';
 
 /**
- * RelayService
+ * Service class for managing DIDComm message relay operations
+ * @class
+ * @description Provides methods for sending, receiving, and acknowledging DIDComm messages
+ * through a relay service infrastructure
  */
 export class RelayService {
   name: string;
@@ -25,40 +35,159 @@ export class RelayService {
     RelayService.prototype.signJwt,
   ];
 
+  /**
+   * Creates a new RelayService instance
+   * @constructor
+   */
   constructor() {
     this.name = serviceName;
   }
 
+  /**
+   * Sends a DIDComm message through the relay service
+   * @param {SendMessageParams} params - Message parameters
+   * @param {Object} params.keyPairDoc - Key pair document for message encryption
+   * @param {Object} params.message - The message payload to send
+   * @param {string} params.recipientDid - DID of the message recipient
+   * @param {string} [params.type] - Message type identifier
+   * @returns {Promise<Object>} Result of the send operation
+   * @throws {Error} If validation fails or sending fails
+   * @example
+   * const result = await relayService.sendMessage({
+   *   keyPairDoc: senderKeyPair,
+   *   message: { content: 'Hello' },
+   *   recipientDid: 'did:key:recipient123',
+   *   type: 'basic-message'
+   * });
+   */
   sendMessage(params: SendMessageParams) {
     validation.sendMessage(params);
     return relayServiceClient.sendMessage(params as any);
   }
 
+  /**
+   * Acknowledges receipt of messages from the relay service
+   * @param {AckMessagesParams} params - Acknowledgment parameters
+   * @param {string} params.did - DID acknowledging the messages
+   * @param {Array<string>} params.messageIds - Array of message IDs to acknowledge
+   * @returns {Promise<Object>} Result of the acknowledgment operation
+   * @example
+   * await relayService.ackMessages({
+   *   did: 'did:key:holder123',
+   *   messageIds: ['msg-1', 'msg-2']
+   * });
+   */
   ackMessages(params: AckMessagesParams) {
     return relayServiceClient.ackMessages(params);
   }
 
+  /**
+   * Resolves and decrypts a DIDComm message
+   * @param {ResolveDidcommMessageParams} params - Resolution parameters
+   * @param {Object} params.encryptedMessage - The encrypted message to resolve
+   * @param {Object} params.keyPairDoc - Key pair document for decryption
+   * @returns {Promise<Object>} The decrypted and resolved message
+   * @throws {Error} If validation fails or resolution fails
+   * @example
+   * const decrypted = await relayService.resolveDidcommMessage({
+   *   encryptedMessage: encryptedData,
+   *   keyPairDoc: recipientKeyPair
+   * });
+   */
   resolveDidcommMessage(params: ResolveDidcommMessageParams) {
     validation.resolveDidcommMessage(params);
     return relayServiceClient.resolveDidcommMessage(params);
   }
 
+  /**
+   * Signs a JWT using the provided key pair
+   * @param {ResolveDidcommMessageParams} params - Signing parameters
+   * @param {Object} params.payload - JWT payload to sign
+   * @param {Object} params.keyPairDoc - Key pair document for signing
+   * @returns {Promise<string>} The signed JWT token
+   * @throws {Error} If validation fails or signing fails
+   * @example
+   * const jwt = await relayService.signJwt({
+   *   payload: { sub: 'did:key:123', iat: Date.now() },
+   *   keyPairDoc: signerKeyPair
+   * });
+   */
   signJwt(params: ResolveDidcommMessageParams) {
     validation.signJwt(params);
     return relayServiceClient.signJwt(params);
   }
 
+  /**
+   * Retrieves messages from the relay service
+   * @param {GetMessagesParams} params - Retrieval parameters
+   * @param {Object} params.keyPairDocs - Key pair documents for decryption
+   * @param {number} [params.limit] - Maximum number of messages to retrieve
+   * @param {boolean} [params.skipMessageResolution] - Whether to skip message resolution
+   * @returns {Promise<Array>} Array of retrieved messages
+   * @throws {Error} If validation fails or retrieval fails
+   * @example
+   * const messages = await relayService.getMessages({
+   *   keyPairDocs: [keyPairDoc1, keyPairDoc2],
+   *   limit: 50,
+   *   skipMessageResolution: false
+   * });
+   */
   getMessages(params: GetMessagesParams) {
     validation.getMessages(params);
     return relayServiceClient.getMessages(params);
   }
 
+  /**
+   * Registers a DID for push notifications
+   * @param {RegisterDIDPushNotificationParams} params - Registration parameters
+   * @param {string} params.did - The DID to register for notifications
+   * @param {string} params.deviceToken - Device token for push notifications
+   * @param {string} [params.platform] - Platform identifier (ios, android, etc.)
+   * @returns {Promise<Object>} Result of the registration
+   * @throws {Error} If validation fails or registration fails
+   * @example
+   * await relayService.registerDIDPushNotification({
+   *   did: 'did:key:holder123',
+   *   deviceToken: 'fcm-token-123',
+   *   platform: 'android'
+   * });
+   */
   registerDIDPushNotification(params: RegisterDIDPushNotificationParams) {
     validation.registerDIDPushNotification(params);
     return relayServiceClient.registerDIDPushNotification(params);
   }
 }
 
+/**
+ * Low-level relay service client for direct API access
+ * @type {Object}
+ * @see {@link RelayService} - Higher-level service wrapper
+ */
 export {relayServiceClient};
 
+/**
+ * Singleton instance of the relay service
+ * @type {RelayService}
+ * @example
+ * import { relayService } from '@docknetwork/wallet-sdk-wasm/services/relay-service';
+ *
+ * // Send a DIDComm message
+ * await relayService.sendMessage({
+ *   keyPairDoc: senderKeyPair,
+ *   message: { type: 'greeting', content: 'Hello!' },
+ *   recipientDid: 'did:key:recipient123'
+ * });
+ *
+ * // Retrieve messages
+ * const messages = await relayService.getMessages({
+ *   keyPairDocs: [recipientKeyPair],
+ *   limit: 10
+ * });
+ *
+ * // Acknowledge messages
+ * await relayService.ackMessages({
+ *   did: 'did:key:recipient123',
+ *   messageIds: messages.map(m => m.id)
+ * });
+ */
 export const relayService: RelayService = new RelayService();

package/src/services/rpc-service-client.js

@@ -2,9 +2,6 @@ import assert from 'assert';
 import {rpcRequest} from '../rpc-client';
 
 export class RpcService {
-  serviceName: string;
-  sandbox: Boolean;
-
   constructor(serviceName) {
     assert(!!serviceName, 'serviceName is required');
 

package/src/services/storage/index.js

@@ -1 +1,15 @@
-export {storageService} from './service';
+import {storageService as _storageService} from './service';
+import {StorageServiceRpc} from './service-rpc';
+
+let storageService;
+
+if (typeof window !== 'undefined' && window.ReactNativeWebView) {
+  // Detect if we are running inside the webview
+  // then route the calls to the service-rpc
+  storageService = new StorageServiceRpc();
+} else {
+  // use the service directly for non-webview environments
+  storageService = _storageService;
+}
+
+export {storageService};

package/src/services/storage/service-rpc.js

@@ -5,15 +5,19 @@ export class StorageServiceRpc extends RpcService {
     super('storage');
   }
 
-  setItem(...args): Promise<any> {
+  setItem(...args) {
     return this.call('setItem', ...args);
   }
 
-  removeItem(...args): Promise<any> {
+  removeItem(...args) {
     return this.call('removeItem', ...args);
   }
 
-  getItem(...args): Promise<any> {
+  getItem(...args) {
     return this.call('getItem', ...args);
   }
+
+  getAllKeys() {
+    return this.call('getAllKeys');
+  }
 }

package/src/services/storage/service.ts

@@ -4,6 +4,7 @@ export class StorageService {
     StorageService.prototype.setItem,
     StorageService.prototype.getItem,
     StorageService.prototype.removeItem,
+    StorageService.prototype.getAllKeys,
   ];
 
   constructor() {
@@ -21,6 +22,10 @@ export class StorageService {
   getItem(...args): Promise<any> {
     return global.localStorage.getItem(...args);
   }
+
+  getAllKeys(): Promise<string[]> {
+    return Promise.resolve(Object.keys(global.localStorage));
+  }
 }
 
 export const storageService: StorageService = new StorageService();