@docknetwork/wallet-sdk-wasm 1.5.14 → 1.7.6

package/src/services/pex/tests/pex-service.test.js

@@ -647,4 +647,214 @@ describe('Pex Examples', () => {
       expect(result).not.toBe(template); // Ensure immutability
     });
   });
+
+  describe('isCredentialSelectionValid', () => {
+    const presentationDefinition = {
+      id: 'b4a4bcf5-56a6-4e1c-810f-f2161c295b27',
+      input_descriptors: [
+        {
+          id: 'Credential 1',
+          name: 'api test',
+          group: ['1'],
+          purpose: 'blah blah',
+          constraints: {
+            fields: [
+              {
+                path: ['$.credentialSubject.id'],
+                optional: true,
+              },
+              {
+                path: ['$.expirationDate'],
+                optional: true,
+              },
+              {
+                path: ['$.credentialSchema.id'],
+                filter: {
+                  const:
+                    'https://schema.truvera.io/BasicCredential-V2-1703777584571.json',
+                },
+              },
+            ],
+          },
+        },
+        {
+          id: 'Credential 2',
+          name: 'api test',
+          group: ['2'],
+          purpose: 'blah blah',
+          constraints: {
+            fields: [
+              {
+                path: ['$.credentialSubject.id'],
+                optional: true,
+              },
+              {
+                path: ['$.expirationDate'],
+                optional: true,
+              },
+              {
+                path: ['$.credentialSchema.id'],
+                filter: {
+                  const:
+                    'https://schema.truvera.io/UniversityDegree-V1-1703767509472.json',
+                },
+              },
+            ],
+          },
+        },
+      ],
+      submission_requirements: [
+        {
+          from: '1',
+          name: 'Multi Credential Request',
+          rule: 'pick',
+          count: 1,
+        },
+        {
+          from: '2',
+          name: 'Multi Credential Request',
+          rule: 'pick',
+          count: 1,
+        },
+      ],
+    };
+
+    const basicCredential1 = {
+      '@context': [
+        'https://www.w3.org/2018/credentials/v1',
+        'https://ld.truvera.io/credentials/extensions-v1',
+        {
+          BasicCredential: 'dk:BasicCredential',
+          dk: 'https://ld.truvera.io/credentials#',
+        },
+        'https://ld.truvera.io/credentials/prettyvc',
+      ],
+      id: 'https://creds.truvera.io/29224c9c87c87c5edfcbace893d99d009513a0548e855bcb793ea30e1c5f8ce8',
+      type: [
+        'VerifiableCredential',
+        'BasicCredential',
+        'PrettyVerifiableCredential',
+      ],
+      credentialSubject: {
+        id: 'did:key:z6Mktpass177BSFLMuCpNJzCyrLeAUs16XUmg15VLHCQsnhk',
+        name: 'Another Cred',
+      },
+      issuanceDate: '2025-11-25T13:44:36.365Z',
+      issuer: 'did:cheqd:testnet:c0890f1c-c7bb-4ea6-be7a-8c31404743b7',
+      credentialSchema: {
+        id: 'https://schema.truvera.io/BasicCredential-V2-1703777584571.json',
+        type: 'JsonSchemaValidator2018',
+      },
+      name: 'Another Cred',
+      proof: {
+        type: 'Ed25519Signature2018',
+        created: '2025-11-25T13:45:06Z',
+        verificationMethod:
+          'did:cheqd:testnet:c0890f1c-c7bb-4ea6-be7a-8c31404743b7#keys-1',
+        proofPurpose: 'assertionMethod',
+        jws: 'eyJhbGciOiJFZERTQSIsImI2NCI6ZmFsc2UsImNyaXQiOlsiYjY0Il19..x1EjlAHJwJFwKfXtbAegJ8xOycY5m47yvvOQm-0sLzzuvSjbSKerIkphQ8w5J0_MJONb-j1-UE0NWZ9quM4CAQ',
+      },
+    };
+
+    const basicCredential2 = {
+      '@context': [
+        'https://www.w3.org/2018/credentials/v1',
+        'https://ld.truvera.io/credentials/extensions-v1',
+        {
+          BasicCredential: 'dk:BasicCredential',
+          dk: 'https://ld.truvera.io/credentials#',
+        },
+        'https://ld.truvera.io/credentials/prettyvc',
+      ],
+      id: 'https://creds.truvera.io/86bdd6cc4d4915939bc2c11a0f8c7ebd64ef0872da02627ab9d7e6866fe2effb',
+      type: [
+        'VerifiableCredential',
+        'BasicCredential',
+        'PrettyVerifiableCredential',
+      ],
+      credentialSubject: {
+        name: 'test',
+      },
+      issuanceDate: '2025-11-25T13:42:02.877Z',
+      issuer: 'did:cheqd:testnet:c0890f1c-c7bb-4ea6-be7a-8c31404743b7',
+      credentialSchema: {
+        id: 'https://schema.truvera.io/BasicCredential-V2-1703777584571.json',
+        type: 'JsonSchemaValidator2018',
+      },
+      name: 'test',
+      proof: {
+        type: 'Ed25519Signature2018',
+        created: '2025-11-25T13:42:42Z',
+        verificationMethod:
+          'did:cheqd:testnet:c0890f1c-c7bb-4ea6-be7a-8c31404743b7#keys-1',
+        proofPurpose: 'assertionMethod',
+        jws: 'eyJhbGciOiJFZERTQSIsImI2NCI6ZmFsc2UsImNyaXQiOlsiYjY0Il19..R-cJhQlBr3TJS6ArSIBwLjLcQO-yuPZ5FUY5zGe6TYIJNm0teHFvgFHjg_-Y9VeuhLZprVNufXyqLoPSkTC7CQ',
+      },
+    };
+
+    const universityDegreeCredential = {
+      '@context': [
+        'https://www.w3.org/2018/credentials/v1',
+        'https://ld.truvera.io/credentials/extensions-v1',
+        {
+          UniversityDegree: 'dk:UniversityDegree',
+          additionalDistinctions: 'dk:additionalDistinctions',
+          awardedDate: 'dk:awardedDate',
+          dateOfBirth: 'dk:dateOfBirth',
+          degreeName: 'dk:degreeName',
+          degreeType: 'dk:degreeType',
+          dk: 'https://ld.truvera.io/credentials#',
+        },
+        'https://ld.truvera.io/credentials/prettyvc',
+      ],
+      id: 'https://creds.truvera.io/4343d71719d56e2a3461f24a522229f2c89a3bef68ad2664e1f48d70002034c4',
+      type: [
+        'VerifiableCredential',
+        'UniversityDegree',
+        'PrettyVerifiableCredential',
+      ],
+      credentialSubject: {
+        id: 'did:key:z6Mktpass177BSFLMuCpNJzCyrLeAUs16XUmg15VLHCQsnhk',
+        degreeName: 'testing',
+        degreeType: 'testing',
+        name: 'Tester',
+        awardedDate: '2025-11-20',
+        dateOfBirth: '2025-11-20',
+        additionalDistinctions: 'test',
+      },
+      issuanceDate: '2025-11-25T13:45:25.699Z',
+      issuer: 'did:cheqd:testnet:c0890f1c-c7bb-4ea6-be7a-8c31404743b7',
+      credentialSchema: {
+        id: 'https://schema.truvera.io/UniversityDegree-V1-1703767509472.json',
+        type: 'JsonSchemaValidator2018',
+      },
+      name: 'University Degree',
+      proof: {
+        type: 'Ed25519Signature2018',
+        created: '2025-11-25T13:46:09Z',
+        verificationMethod:
+          'did:cheqd:testnet:c0890f1c-c7bb-4ea6-be7a-8c31404743b7#keys-1',
+        proofPurpose: 'assertionMethod',
+        jws: 'eyJhbGciOiJFZERTQSIsImI2NCI6ZmFsc2UsImNyaXQiOlsiYjY0Il19..lb0SOlbNGZAEnGOqnaFg-fTSSOp-EWCMdMtKkjVasRkPjwAVSSK4VZmjis3Czdacbhl8VL0q3f6Ow4rge3eHDQ',
+      },
+    };
+
+    it('should return true if the credential selection is valid', () => {
+      expect(
+        pexService.isCredentialSelectionValid({
+          credentials: [basicCredential1, universityDegreeCredential],
+          presentationDefinition: presentationDefinition,
+        }),
+      ).toBe(true);
+    });
+
+    it('should return false if the credential selection is invalid', () => {
+      expect(
+        pexService.isCredentialSelectionValid({
+          credentials: [basicCredential1, basicCredential2],
+          presentationDefinition: presentationDefinition,
+        }),
+      ).toBe(false);
+    });
+  });
 });

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();