@docknetwork/wallet-sdk-wasm 1.5.14 → 1.7.0

package/lib/services/edv/service.mjs

@@ -23,7 +23,10 @@ import '../dids/keypair-utils.mjs';
 
 // @ts-nocheck
 /**
- * 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
  */
 class EDVService {
     storageInterface;
@@ -39,9 +42,32 @@ class EDVService {
         EDVService.prototype.insert,
         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, verificationKey, edvUrl, authKey, }) {
         const hmac = await HMAC.create({
             key: hmacKey,
@@ -89,6 +115,21 @@ class EDVService {
             attribute: 'content.type',
         });
     }
+    /**
+     * 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({});
         const verificationKey = await Ed25519VerificationKey2018.generate({
@@ -101,6 +142,17 @@ class EDVService {
         const hmacKey = await HMAC.exportKey(await HMAC.generateKey());
         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) {
         const { keyPair: pair } = new Ed25519Keypair(masterKey, 'seed');
         const keyPair = await didService.deriveKeyDoc({ pair });
@@ -110,15 +162,63 @@ class EDVService {
         const hmacKey = await HMAC.exportKey(await HMAC.deriveKey(masterKey));
         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) {
         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) {
         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) {
         this.insertQueue = this.insertQueue.then(() => {
             return this.storageInterface.insert(params).catch(error => {
@@ -128,10 +228,54 @@ 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) {
         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
+ * });
+ */
 const edvService = new EDVService();
 
 export { EDVService, edvService };

package/lib/services/index.js

@@ -20,6 +20,16 @@ require('../core/logger.js');
 require('../modules/event-manager.js');
 require('assert');
 require('@docknetwork/credential-sdk/types');
+require('./blockchain/cached-did-resolver.js');
+require('./storage/index.js');
+require('./storage/service-rpc.js');
+require('./rpc-service-client.js');
+require('../rpc-client.js');
+require('json-rpc-2.0');
+require('../core/crypto.js');
+require('crypto');
+require('../logger.js');
+require('../rpc-util.js');
 require('../wallet/memory-storage-wallet.js');
 require('@docknetwork/universal-wallet/storage-wallet');
 require('../wallet/memory-storage-interface.js');
@@ -55,6 +65,9 @@ require('@docknetwork/crypto-wasm-ts/lib/legosnark');
 require('./credential/pex-helpers.js');
 require('@astronautlabs/jsonpath');
 require('./credential/bbs-revocation.js');
+require('./credential/sd-jwt.js');
+require('@sd-jwt/sd-jwt-vc');
+require('@sd-jwt/crypto-nodejs');
 require('./relay-service/configs.js');
 require('@docknetwork/wallet-sdk-relay-service/lib');
 require('./pex/config.js');

package/lib/services/index.mjs

@@ -18,6 +18,16 @@ import '../core/logger.mjs';
 import '../modules/event-manager.mjs';
 import 'assert';
 import '@docknetwork/credential-sdk/types';
+import './blockchain/cached-did-resolver.mjs';
+import './storage/index.mjs';
+import './storage/service-rpc.mjs';
+import './rpc-service-client.mjs';
+import '../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../core/crypto.mjs';
+import 'crypto';
+import '../logger.mjs';
+import '../rpc-util.mjs';
 import '../wallet/memory-storage-wallet.mjs';
 import '@docknetwork/universal-wallet/storage-wallet';
 import '../wallet/memory-storage-interface.mjs';
@@ -53,6 +63,9 @@ import '@docknetwork/crypto-wasm-ts/lib/legosnark';
 import './credential/pex-helpers.mjs';
 import '@astronautlabs/jsonpath';
 import './credential/bbs-revocation.mjs';
+import './credential/sd-jwt.mjs';
+import '@sd-jwt/sd-jwt-vc';
+import '@sd-jwt/crypto-nodejs';
 import './relay-service/configs.mjs';
 import '@docknetwork/wallet-sdk-relay-service/lib';
 import './pex/config.mjs';

package/lib/services/relay-service/service.js

@@ -9,7 +9,16 @@ require('../../core/validation.js');
 require('../../types.js');
 
 /**
- * RelayService
+ * @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.
+ */
+/**
+ * Service class for managing DIDComm message relay operations
+ * @class
+ * @description Provides methods for sending, receiving, and acknowledging DIDComm messages
+ * through a relay service infrastructure
  */
 class RelayService {
     name;
@@ -21,33 +30,147 @@ class RelayService {
         RelayService.prototype.sendMessage,
         RelayService.prototype.signJwt,
     ];
+    /**
+     * Creates a new RelayService instance
+     * @constructor
+     */
     constructor() {
         this.name = services_relayService_configs.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) {
         services_relayService_configs.validation.sendMessage(params);
         return src.RelayService.sendMessage(params);
     }
+    /**
+     * 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) {
         return src.RelayService.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) {
         services_relayService_configs.validation.resolveDidcommMessage(params);
         return src.RelayService.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) {
         services_relayService_configs.validation.signJwt(params);
         return src.RelayService.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) {
         services_relayService_configs.validation.getMessages(params);
         return src.RelayService.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) {
         services_relayService_configs.validation.registerDIDPushNotification(params);
         return src.RelayService.registerDIDPushNotification(params);
     }
 }
+/**
+ * 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)
+ * });
+ */
 const relayService = new RelayService();
 
 Object.defineProperty(exports, 'relayServiceClient', {

package/lib/services/relay-service/service.mjs

@@ -6,7 +6,16 @@ import '../../core/validation.mjs';
 import '../../types.mjs';
 
 /**
- * RelayService
+ * @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.
+ */
+/**
+ * Service class for managing DIDComm message relay operations
+ * @class
+ * @description Provides methods for sending, receiving, and acknowledging DIDComm messages
+ * through a relay service infrastructure
  */
 class RelayService {
     name;
@@ -18,33 +27,147 @@ class RelayService {
         RelayService.prototype.sendMessage,
         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) {
         validation.sendMessage(params);
         return RelayService$1.sendMessage(params);
     }
+    /**
+     * 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) {
         return RelayService$1.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) {
         validation.resolveDidcommMessage(params);
         return RelayService$1.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) {
         validation.signJwt(params);
         return RelayService$1.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) {
         validation.getMessages(params);
         return RelayService$1.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) {
         validation.registerDIDPushNotification(params);
         return RelayService$1.registerDIDPushNotification(params);
     }
 }
+/**
+ * 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)
+ * });
+ */
 const relayService = new RelayService();
 
 export { RelayService, relayService };

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

@@ -16,9 +16,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
 
 class RpcService {
-                      
-                   
-
   constructor(serviceName) {
     assert__default["default"](!!serviceName, 'serviceName is required');
 

package/lib/services/rpc-service-client.mjs

@@ -8,9 +8,6 @@ import '../logger.mjs';
 import '../rpc-util.mjs';
 
 class RpcService {
-                      
-                   
-
   constructor(serviceName) {
     assert(!!serviceName, 'serviceName is required');
 

package/lib/services/storage/index.js

@@ -3,7 +3,24 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var services_storage_service = require('./service.js');
+var services_storage_serviceRpc = require('./service-rpc.js');
+require('../rpc-service-client.js');
+require('assert');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../core/logger.js');
+require('../../logger.js');
+require('../../rpc-util.js');
 
+exports.storageService = void 0;
 
-
-exports.storageService = services_storage_service.storageService;
+if (typeof window !== 'undefined' && window.ReactNativeWebView) {
+  // Detect if we are running inside the webview
+  // then route the calls to the service-rpc
+  exports.storageService = new services_storage_serviceRpc.StorageServiceRpc();
+} else {
+  // use the service directly for non-webview environments
+  exports.storageService = services_storage_service.storageService;
+}

package/lib/services/storage/index.mjs

@@ -1 +1,24 @@
-export { storageService } from './service.mjs';
+import { storageService as storageService$1 } from './service.mjs';
+import { StorageServiceRpc } from './service-rpc.mjs';
+import '../rpc-service-client.mjs';
+import 'assert';
+import '../../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../../core/crypto.mjs';
+import 'crypto';
+import '../../core/logger.mjs';
+import '../../logger.mjs';
+import '../../rpc-util.mjs';
+
+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$1;
+}
+
+export { storageService };

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

@@ -17,17 +17,21 @@ class StorageServiceRpc extends services_rpcServiceClient.RpcService {
     super('storage');
   }
 
-  setItem(...args)               {
+  setItem(...args) {
     return this.call('setItem', ...args);
   }
 
-  removeItem(...args)               {
+  removeItem(...args) {
     return this.call('removeItem', ...args);
   }
 
-  getItem(...args)               {
+  getItem(...args) {
     return this.call('getItem', ...args);
   }
+
+  getAllKeys() {
+    return this.call('getAllKeys');
+  }
 }
 
 exports.StorageServiceRpc = StorageServiceRpc;