@docknetwork/wallet-sdk-wasm 1.5.14 → 1.7.6

package/lib/services/edv/service.js

@@ -12,9 +12,10 @@ var keypairs = require('@docknetwork/universal-wallet/methods/keypairs');
 var logger = require('@docknetwork/wallet-sdk-data-store/lib/logger');
 var services_dids_service = require('../dids/service.js');
 var keypairs$1 = require('@docknetwork/credential-sdk/keypairs');
+var hkdf = require('futoin-hkdf');
+var crypto = require('@docknetwork/universal-wallet/crypto');
 require('assert');
 require('base64url-universal');
-require('@docknetwork/universal-wallet/crypto');
 require('@docknetwork/wallet-sdk-dids/lib');
 require('../dids/config.js');
 require('base64url');
@@ -28,10 +29,17 @@ require('../dids/keypair-utils.js');
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var EDVHTTPStorageInterface__default = /*#__PURE__*/_interopDefaultLegacy(EDVHTTPStorageInterface);
+var hkdf__default = /*#__PURE__*/_interopDefaultLegacy(hkdf);
+var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
 
 // @ts-nocheck
+const HKDF_LENGTH = 32;
+const HKDF_HASH = 'SHA-256';
 /**
- * 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;
@@ -46,10 +54,37 @@ class EDVService {
         EDVService.prototype.update,
         EDVService.prototype.insert,
         EDVService.prototype.delete,
+        EDVService.prototype.deriveBiometricKey,
+        EDVService.prototype.deriveBiometricEncryptionKey,
+        EDVService.prototype.encryptMasterKey,
+        EDVService.prototype.decryptMasterKey,
     ];
+    /**
+     * Creates a new EDVService instance
+     * @constructor
+     */
     constructor() {
         this.name = services_edv_configs.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 services_edv_hmac.create({
             key: hmacKey,
@@ -97,6 +132,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 services_dids_service.didService.generateKeyDoc({});
         const verificationKey = await ed25519VerificationKey2018.Ed25519VerificationKey2018.generate({
@@ -109,6 +159,17 @@ class EDVService {
         const hmacKey = await services_edv_hmac.exportKey(await services_edv_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 keypairs$1.Ed25519Keypair(masterKey, 'seed');
         const keyPair = await services_dids_service.didService.deriveKeyDoc({ pair });
@@ -118,15 +179,63 @@ class EDVService {
         const hmacKey = await services_edv_hmac.exportKey(await services_edv_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 => {
@@ -136,11 +245,126 @@ 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);
     }
+    /**
+     * Derives a key from biometric data using HKDF
+     * @param {Buffer} biometricData - Biometric data from provider
+     * @param {string} identifier - User's identifier as salt (email, phone number, etc.)
+     * @returns {Buffer} Derived key
+     * @example
+     * const key = edvService.deriveBiometricKey(biometricData, 'user@example.com');
+     */
+    deriveBiometricKey(biometricData, identifier) {
+        const salt = identifier;
+        return hkdf__default["default"](biometricData, HKDF_LENGTH, { salt, hash: HKDF_HASH });
+    }
+    /**
+     * Generates a key for encrypting/decrypting the master key
+     * @param {Buffer} biometricData - Biometric data from provider
+     * @param {string} identifier - User's identifier as salt (email, phone number, etc.)
+     * @returns {Promise<Object>} Encryption key and IV for AES encryption
+     * @returns {Buffer} returns.key - Encryption key
+     * @returns {Buffer} returns.iv - Initialization vector
+     * @example
+     * const { key, iv } = await edvService.deriveBiometricEncryptionKey(biometricData, 'user@example.com');
+     */
+    async deriveBiometricEncryptionKey(biometricData, identifier) {
+        const key = this.deriveBiometricKey(biometricData, identifier);
+        const randomBytes = crypto__default["default"].getRandomValues(new Uint8Array(16));
+        const iv = Buffer.from(randomBytes);
+        return {
+            key,
+            iv
+        };
+    }
+    /**
+     * Encrypts the master key using a key derived from biometric data
+     * @param {Uint8Array} masterKey - The CloudWalletVault master key to encrypt
+     * @param {Buffer} encryptionKey - Key derived from biometric data
+     * @param {Buffer} iv - Initialization vector
+     * @returns {Promise<Uint8Array>} Encrypted master key
+     * @example
+     * const encrypted = await edvService.encryptMasterKey(masterKey, encryptionKey, iv);
+     */
+    async encryptMasterKey(masterKey, encryptionKey, iv) {
+        const keyData = new Uint8Array(encryptionKey);
+        const ivData = new Uint8Array(iv);
+        const key = await crypto__default["default"].subtle.importKey('raw', keyData, { name: 'AES-GCM' }, false, ['encrypt']);
+        const encryptedBuffer = await crypto__default["default"].subtle.encrypt({ name: 'AES-GCM', iv: ivData }, key, masterKey);
+        return new Uint8Array(encryptedBuffer);
+    }
+    /**
+     * Decrypts the master key using biometric-derived key
+     * @param {Uint8Array} encryptedKey - The encrypted master key
+     * @param {Buffer} decryptionKey - Key derived from biometric data
+     * @param {Buffer} iv - Initialization vector
+     * @returns {Promise<Uint8Array>} The decrypted master key
+     * @throws {Error} If decryption fails
+     * @example
+     * const masterKey = await edvService.decryptMasterKey(encryptedKey, decryptionKey, iv);
+     */
+    async decryptMasterKey(encryptedKey, decryptionKey, iv) {
+        try {
+            const keyData = new Uint8Array(decryptionKey);
+            const ivData = new Uint8Array(iv);
+            const key = await crypto__default["default"].subtle.importKey('raw', keyData, { name: 'AES-GCM' }, false, ['decrypt']);
+            const decryptedBuffer = await crypto__default["default"].subtle.decrypt({ name: 'AES-GCM', iv: ivData }, key, encryptedKey);
+            return new Uint8Array(decryptedBuffer);
+        }
+        catch (error) {
+            throw new Error('Decryption failed: Invalid key or corrupted data');
+        }
+    }
 }
+/**
+ * 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();
 
 exports.EDVService = EDVService;
+exports.HKDF_HASH = HKDF_HASH;
+exports.HKDF_LENGTH = HKDF_LENGTH;
 exports.edvService = edvService;

package/lib/services/edv/service.mjs

@@ -8,9 +8,10 @@ import { getKeypairFromDoc } from '@docknetwork/universal-wallet/methods/keypair
 import { logger } from '@docknetwork/wallet-sdk-data-store/lib/logger';
 import { didService } from '../dids/service.mjs';
 import { Ed25519Keypair } from '@docknetwork/credential-sdk/keypairs';
+import hkdf from 'futoin-hkdf';
+import crypto from '@docknetwork/universal-wallet/crypto';
 import 'assert';
 import 'base64url-universal';
-import '@docknetwork/universal-wallet/crypto';
 import '@docknetwork/wallet-sdk-dids/lib';
 import '../dids/config.mjs';
 import 'base64url';
@@ -22,8 +23,13 @@ import '@digitalbazaar/x25519-key-agreement-key-2019';
 import '../dids/keypair-utils.mjs';
 
 // @ts-nocheck
+const HKDF_LENGTH = 32;
+const HKDF_HASH = 'SHA-256';
 /**
- * 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;
@@ -38,10 +44,37 @@ class EDVService {
         EDVService.prototype.update,
         EDVService.prototype.insert,
         EDVService.prototype.delete,
+        EDVService.prototype.deriveBiometricKey,
+        EDVService.prototype.deriveBiometricEncryptionKey,
+        EDVService.prototype.encryptMasterKey,
+        EDVService.prototype.decryptMasterKey,
     ];
+    /**
+     * 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 +122,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 +149,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 +169,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 +235,123 @@ 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);
     }
+    /**
+     * Derives a key from biometric data using HKDF
+     * @param {Buffer} biometricData - Biometric data from provider
+     * @param {string} identifier - User's identifier as salt (email, phone number, etc.)
+     * @returns {Buffer} Derived key
+     * @example
+     * const key = edvService.deriveBiometricKey(biometricData, 'user@example.com');
+     */
+    deriveBiometricKey(biometricData, identifier) {
+        const salt = identifier;
+        return hkdf(biometricData, HKDF_LENGTH, { salt, hash: HKDF_HASH });
+    }
+    /**
+     * Generates a key for encrypting/decrypting the master key
+     * @param {Buffer} biometricData - Biometric data from provider
+     * @param {string} identifier - User's identifier as salt (email, phone number, etc.)
+     * @returns {Promise<Object>} Encryption key and IV for AES encryption
+     * @returns {Buffer} returns.key - Encryption key
+     * @returns {Buffer} returns.iv - Initialization vector
+     * @example
+     * const { key, iv } = await edvService.deriveBiometricEncryptionKey(biometricData, 'user@example.com');
+     */
+    async deriveBiometricEncryptionKey(biometricData, identifier) {
+        const key = this.deriveBiometricKey(biometricData, identifier);
+        const randomBytes = crypto.getRandomValues(new Uint8Array(16));
+        const iv = Buffer.from(randomBytes);
+        return {
+            key,
+            iv
+        };
+    }
+    /**
+     * Encrypts the master key using a key derived from biometric data
+     * @param {Uint8Array} masterKey - The CloudWalletVault master key to encrypt
+     * @param {Buffer} encryptionKey - Key derived from biometric data
+     * @param {Buffer} iv - Initialization vector
+     * @returns {Promise<Uint8Array>} Encrypted master key
+     * @example
+     * const encrypted = await edvService.encryptMasterKey(masterKey, encryptionKey, iv);
+     */
+    async encryptMasterKey(masterKey, encryptionKey, iv) {
+        const keyData = new Uint8Array(encryptionKey);
+        const ivData = new Uint8Array(iv);
+        const key = await crypto.subtle.importKey('raw', keyData, { name: 'AES-GCM' }, false, ['encrypt']);
+        const encryptedBuffer = await crypto.subtle.encrypt({ name: 'AES-GCM', iv: ivData }, key, masterKey);
+        return new Uint8Array(encryptedBuffer);
+    }
+    /**
+     * Decrypts the master key using biometric-derived key
+     * @param {Uint8Array} encryptedKey - The encrypted master key
+     * @param {Buffer} decryptionKey - Key derived from biometric data
+     * @param {Buffer} iv - Initialization vector
+     * @returns {Promise<Uint8Array>} The decrypted master key
+     * @throws {Error} If decryption fails
+     * @example
+     * const masterKey = await edvService.decryptMasterKey(encryptedKey, decryptionKey, iv);
+     */
+    async decryptMasterKey(encryptedKey, decryptionKey, iv) {
+        try {
+            const keyData = new Uint8Array(decryptionKey);
+            const ivData = new Uint8Array(iv);
+            const key = await crypto.subtle.importKey('raw', keyData, { name: 'AES-GCM' }, false, ['decrypt']);
+            const decryptedBuffer = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: ivData }, key, encryptedKey);
+            return new Uint8Array(decryptedBuffer);
+        }
+        catch (error) {
+            throw new Error('Decryption failed: Invalid key or corrupted data');
+        }
+    }
 }
+/**
+ * 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 };
+export { EDVService, HKDF_HASH, HKDF_LENGTH, 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');
@@ -64,6 +77,7 @@ require('./edv/hmac.js');
 require('base64url-universal');
 require('@docknetwork/universal-wallet/crypto');
 require('@docknetwork/wallet-sdk-data-store/lib/logger');
+require('futoin-hkdf');
 
 var services = [
   services_blockchain_service.blockchainService,

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';
@@ -62,6 +75,7 @@ import './edv/hmac.mjs';
 import 'base64url-universal';
 import '@docknetwork/universal-wallet/crypto';
 import '@docknetwork/wallet-sdk-data-store/lib/logger';
+import 'futoin-hkdf';
 
 var services = [
   blockchainService,

package/lib/services/pex/config.js

@@ -15,6 +15,10 @@ const validation = {
         assert__default["default"](params.credentials, 'credentials is required');
         assert__default["default"](params.presentationDefinition, 'presentationDefinition is required');
     },
+    evaluateCredentials: (params) => {
+        assert__default["default"](params.credentials, 'credentials is required');
+        assert__default["default"](params.presentationDefinition, 'presentationDefinition is required');
+    },
     evaluatePresentation: (params) => {
         assert__default["default"](params.presentation, 'presentation is required');
         assert__default["default"](params.presentationDefinition, 'presentationDefinition is required');

package/lib/services/pex/config.mjs

@@ -7,6 +7,10 @@ const validation = {
         assert(params.credentials, 'credentials is required');
         assert(params.presentationDefinition, 'presentationDefinition is required');
     },
+    evaluateCredentials: (params) => {
+        assert(params.credentials, 'credentials is required');
+        assert(params.presentationDefinition, 'presentationDefinition is required');
+    },
     evaluatePresentation: (params) => {
         assert(params.presentation, 'presentation is required');
         assert(params.presentationDefinition, 'presentationDefinition is required');