@docknetwork/wallet-sdk-wasm 1.5.11 → 1.7.0

package/src/services/blockchain/service.ts

@@ -1,5 +1,12 @@
 // @ts-nocheck
 
+/**
+ * @module blockchain-service
+ * @description Blockchain connectivity and DID resolution service for the Wallet SDK.
+ * This module provides functionality for connecting to Cheqd blockchain, resolving DIDs,
+ * and managing accumulator-related operations.
+ */
+
 import {DirectSecp256k1HdWallet} from '@cosmjs/proto-signing';
 import {CheqdAPI} from '@docknetwork/cheqd-blockchain-api';
 import {CheqdCoreModules} from '@docknetwork/cheqd-blockchain-modules';
@@ -18,6 +25,10 @@ import {once} from '../../modules/event-manager';
 import {utilCryptoService} from '../util-crypto';
 import {InitParams} from './configs';
 
+/**
+ * Universal resolver URL for DID resolution fallback
+ * @constant {string}
+ */
 export const universalResolverUrl = 'https://uniresolver.truvera.io';
 
 import {
@@ -25,13 +36,23 @@ import {
   AccumulatorId,
   AccumulatorPublicKey,
 } from '@docknetwork/credential-sdk/types';
+import { CachedDIDResolver } from './cached-did-resolver';
 
+/**
+ * Resolver that accepts any DID method using wildcard matching
+ * @class
+ * @extends ResolverRouter
+ * @private
+ */
 class AnyDIDResolver extends ResolverRouter {
   method = WILDCARD;
 }
 
 /**
- *
+ * Main blockchain service class for managing blockchain connections and DID resolution
+ * @class
+ * @description Provides methods for connecting to Cheqd blockchain, resolving DIDs,
+ * and managing blockchain-related operations
  */
 export class BlockchainService {
   dock;
@@ -40,6 +61,12 @@ export class BlockchainService {
   cheqdApiUrl;
   isBlockchainReady = false;
   resolver: any;
+  /**
+   * Event names emitted by the blockchain service
+   * @static
+   * @readonly
+   * @property {string} BLOCKCHAIN_READY - Emitted when blockchain connection is established
+   */
   static Events = {
     BLOCKCHAIN_READY: 'blockchain-ready',
   };
@@ -50,8 +77,16 @@ export class BlockchainService {
     BlockchainService.prototype.init,
     BlockchainService.prototype.isApiConnected,
     BlockchainService.prototype.getAddress,
+    BlockchainService.prototype.resolveDID,
+    BlockchainService.prototype.getCachedDIDs,
+    BlockchainService.prototype.clearCache,
+    BlockchainService.prototype.getCacheEntry,
   ];
 
+  /**
+   * Creates a new BlockchainService instance
+   * @constructor
+   */
   constructor() {
     this.name = 'blockchain';
     this.cheqdApi = new CheqdAPI();
@@ -61,6 +96,15 @@ export class BlockchainService {
     this.resolver = this.createDIDResolver();
   }
 
+  /**
+   * Gets the types and modules needed for DID or accumulator operations
+   * @param {string} didOrRegistryId - DID or registry identifier
+   * @returns {Object} Object containing accumulator-related types and modules
+   * @returns {typeof AccumulatorPublicKey} returns.PublicKey - Accumulator public key type
+   * @returns {typeof AccumulatorId} returns.AccumulatorId - Accumulator ID type
+   * @returns {typeof AccumulatorCommon} returns.AccumulatorCommon - Common accumulator type
+   * @returns {Object} returns.AccumulatorModule - Accumulator module instance
+   */
   getTypesForDIDOrAccumulator(didOrRegistryId) {
     return {
         PublicKey: AccumulatorPublicKey,
@@ -71,28 +115,74 @@ export class BlockchainService {
   }
 
   /**
-   *
-   * @returns
+   * Ensures the blockchain connection is ready before proceeding
+   * @returns {Promise<void>} Resolves when blockchain is ready
+   * @example
+   * await blockchainService.ensureBlockchainReady();
+   * // Blockchain is now connected and ready
    */
   async ensureBlockchainReady() {
-    if (this.isBlockchainReady) {
+    if (await this.isApiConnected()) {
       return;
     }
 
     return once(this.emitter, BlockchainService.Events.BLOCKCHAIN_READY);
   }
 
+  
+  /**
+   * Gets the cached DIDs
+   * @returns {Promise<string[]>} Cached DIDs
+   */
+  getCachedDIDs() {
+    return this.resolver.getCachedDIDs();
+  }
+
+  /**
+   * Gets the cached DID resolution data
+   * @param {string} did - The DID to get the cache entry for
+   * @returns {Promise<any>} Cached DID resolution data
+   */
+  getCacheEntry(did) {
+    return this.resolver.getCacheEntry(did);
+  }
+
+  /**
+   * Clears cached data for a specific DID
+   * @param {string} did - The DID to clear from cache
+   * @returns {void}
+   */
+  clearCache(did) {
+    return this.resolver.clearCache(did);
+  }
+
+  /**
+   * Creates a DID resolver with caching support
+   * @private
+   * @returns {CachedDIDResolver} Cached DID resolver instance
+   */
   createDIDResolver() {
-    return new AnyDIDResolver([
+    const router = new AnyDIDResolver([
       new DIDKeyResolver(),
       new CoreResolver(this.modules),
       new UniversalResolver(universalResolverUrl),
     ]);
+
+    return new CachedDIDResolver(router);
   }
   /**
-   *
-   * @param {*} params
-   * @returns
+   * Initializes the blockchain service with connection parameters
+   * @param {InitParams} params - Initialization parameters
+   * @param {string} params.cheqdApiUrl - URL of the Cheqd API endpoint
+   * @param {string} [params.networkId] - Cheqd network identifier
+   * @param {string} [params.cheqdMnemonic] - Mnemonic for Cheqd wallet (auto-generated if not provided)
+   * @returns {Promise<boolean>} True if initialization successful
+   * @throws {Error} If cheqdApiUrl is not provided
+   * @example
+   * await blockchainService.init({
+   *   cheqdApiUrl: 'https://api.cheqd.network',
+   *   networkId: 'mainnet'
+   * });
    */
   async init(params: InitParams) {
     if (!params?.cheqdApiUrl) {
@@ -151,8 +241,10 @@ export class BlockchainService {
   }
 
   /**
-   *
-   * @returns
+   * Disconnects from the blockchain
+   * @returns {Promise<void>} Resolves when disconnection is complete
+   * @example
+   * await blockchainService.disconnect();
    */
   async disconnect() {
     let result;
@@ -166,6 +258,11 @@ export class BlockchainService {
     return result;
   }
 
+  /**
+   * Waits for the blockchain to be ready
+   * @returns {Promise<void>} Resolves when blockchain is ready
+   * @private
+   */
   async waitBlockchainReady() {
     return new Promise(resolve => {
       if (this.isBlockchainReady) {
@@ -177,17 +274,40 @@ export class BlockchainService {
   }
 
   /**
-   *
-   * @returns
+   * Resolves a DID to its document
+   * @param {string} did - The DID to resolve
+   * @returns {Promise<Object>} The resolved DID document
+   * @example
+   * const didDoc = await blockchainService.resolveDID('did:key:z6Mk...');
+   */
+  async resolveDID(did: string) {
+    return this.resolver.resolve(did);
+  }
+  /**
+   * Checks if the blockchain API is connected
+   * @returns {Promise<boolean>} True if connected, false otherwise
+   * @example
+   * const isConnected = await blockchainService.isApiConnected();
    */
   async isApiConnected() {
     return this.cheqdApi.isInitialized();
   }
 
+  /**
+   * Gets the current Cheqd API URL
+   * @returns {Promise<string>} The Cheqd API URL
+   * @example
+   * const apiUrl = await blockchainService.getAddress();
+   */
   async getAddress() {
     return this.cheqdApiUrl;
   }
 
+  /**
+   * Sets the blockchain ready state and emits events
+   * @private
+   * @param {boolean} isBlockchainReady - Whether blockchain is ready
+   */
   _setBlockchainReady(isBlockchainReady) {
     this.isBlockchainReady = isBlockchainReady;
 
@@ -197,4 +317,18 @@ export class BlockchainService {
   }
 }
 
+/**
+ * Singleton instance of the blockchain service
+ * @type {BlockchainService}
+ * @example
+ * import { blockchainService } from '@docknetwork/wallet-sdk-wasm/services/blockchain';
+ *
+ * // Initialize the service
+ * await blockchainService.init({
+ *   cheqdApiUrl: 'https://api.cheqd.network'
+ * });
+ *
+ * // Resolve a DID
+ * const didDoc = await blockchainService.resolveDID('did:key:z6Mk...');
+ */
 export const blockchainService: BlockchainService = new BlockchainService();

package/src/services/credential/config.ts

@@ -12,7 +12,13 @@ export const validation = {
   },
   verifyCredential: params => {
     const {credential} = params;
-    assert(typeof credential === 'object', 'invalid credential');
+    assert(
+      typeof credential === 'object' || typeof credential === 'string',
+      'invalid credential',
+    );
+    if (typeof credential === 'object') {
+      assert(Object.keys(credential).length > 0, 'invalid credential');
+    }
   },
   createBBSPresentation: params => {
     const {credentials} = params;

package/src/services/credential/pex-helpers.js

@@ -60,6 +60,17 @@ function getAttributeName({field, selectedCredentials, index}) {
   return attributeName;
 }
 
+/**
+ * Convert PEX request to bounds for each descriptor
+ * @param {*} pexRequest - The PEX request object containing input descriptors and constraints
+ * @param {*} selectedCredentials  - Array of selected credentials corresponding to the input descriptors
+ * @param {*} removeFromRequest - if true, removes range proofs fields from the request. it might be dangerous if you will be using the proof request later
+ *  because it will not have the range proofs fields anymore.
+ * @returns {Array} - Array of bounds for each descriptor, where each bound is an object with attributeName, min, and max
+ * @throws {Error} - If a field path is missing or empty
+ * @throws {Error} - If an unsupported format or type is encountered
+ * @throws {Error} - If a selected credential is expected but not found at the given index
+ */
 export function pexToBounds(
   pexRequest,
   selectedCredentials = [],
@@ -162,6 +173,9 @@ export function pexToBounds(
             : formatMinimum
           : minimum;
 
+      const proofRequestMax = max;
+      const proofRequestMin = min;
+
       if (max === undefined && min === undefined) {
         return;
       }
@@ -236,6 +250,10 @@ export function pexToBounds(
         attributeName,
         min,
         max,
+        proofRequestMax,
+        proofRequestMin,
+        format,
+        type,
       });
     });
 
@@ -258,9 +276,10 @@ const attributesToSkip = [
   /^@context/,
   /^proof/,
   /^credentialSchema/,
+  /^issuanceDate/,
 ];
 
-const shouldSkipAttribute = attributeName =>
+export const shouldSkipAttribute = attributeName =>
   attributesToSkip.some(regex => regex.test(attributeName));
 
 export function getPexRequiredAttributes(pexRequest, selectedCredentials = []) {

package/src/services/credential/pex-helpers.test.js

@@ -230,6 +230,31 @@ describe('pex helpers', () => {
 
       expect(result).toEqual(['credentialSubject.id']);
     });
+
+    it('should skip issuanceDate', () => {
+      const result = getPexRequiredAttributes(
+        {
+          id: 'test-issuanceDate',
+          input_descriptors: [
+            {
+              constraints: {
+                fields: [
+                  {
+                    path: ['$.issuanceDate'],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+        [
+          {
+            issuanceDate: '2021-01-01',
+          },
+        ],
+      );
+      expect(result).toEqual([]);
+    });
   });
 
   describe('pexToBounds', () => {
@@ -278,11 +303,19 @@ describe('pex helpers', () => {
             attributeName: 'credentialSubject.age',
             min: 0,
             max: 10000000000,
+            proofRequestMax: undefined,
+            proofRequestMin: 0,
+            format: undefined,
+            type: 'number',
           },
           {
             attributeName: 'credentialSubject.dateOfBirth',
             min: new Date('2021-01-01'),
             max: new Date(884541351600000),
+            proofRequestMax: undefined,
+            proofRequestMin: '2021-01-01',
+            format: 'date',
+            type: undefined,
           },
         ],
       ]);
@@ -325,6 +358,10 @@ describe('pex helpers', () => {
             attributeName: 'credentialSubject.age',
             min: 0,
             max: 10000000000,
+            proofRequestMax: undefined,
+            proofRequestMin: 0,
+            format: undefined,
+            type: 'number',
           },
         ],
       ]);
@@ -361,6 +398,10 @@ describe('pex helpers', () => {
             attributeName: 'expirationDate',
             min: new Date('2021-01-01T00:00:00Z'),
             max: new Date('2022-01-01T00:00:00Z'),
+            proofRequestMax: '2022-01-01T00:00:00Z',
+            proofRequestMin: '2021-01-01T00:00:00Z',
+            format: 'date-time',
+            type: undefined,
           },
         ],
       ]);
@@ -398,6 +439,10 @@ describe('pex helpers', () => {
             attributeName: 'amount',
             min: 0,
             max: 100,
+            proofRequestMax: 100,
+            proofRequestMin: 0,
+            format: undefined,
+            type: 'number',
           },
         ],
       ]);
@@ -444,11 +489,19 @@ describe('pex helpers', () => {
             attributeName: 'startDate',
             min: new Date('2021-01-01'),
             max: new Date('2022-01-01'),
+            proofRequestMax: '2022-01-01',
+            proofRequestMin: '2021-01-01',
+            format: 'date',
+            type: undefined,
           },
           {
             attributeName: 'amount',
             min: 0,
             max: 100,
+            proofRequestMax: 100,
+            proofRequestMin: 0,
+            format: undefined,
+            type: 'number',
           },
         ],
       ]);
@@ -464,6 +517,67 @@ describe('pex helpers', () => {
       expect(bounds).toEqual([]);
     });
 
+    it('should preserve original proof request values in new metadata fields', () => {
+      const pexRequest = {
+        input_descriptors: [
+          {
+            constraints: {
+              fields: [
+                {
+                  filter: {
+                    type: 'number',
+                    minimum: 18,
+                    maximum: 65,
+                  },
+                  path: ['$.credentialSubject.age'],
+                },
+                {
+                  filter: {
+                    format: 'date',
+                    formatMinimum: '2020-01-01',
+                    formatMaximum: '2025-12-31',
+                  },
+                  path: ['$.credentialSubject.graduationDate'],
+                },
+              ],
+            },
+          },
+        ],
+      };
+
+      const bounds = pexToBounds(pexRequest, [
+        {
+          credentialSubject: {
+            age: 25,
+            graduationDate: '2023-06-15',
+          },
+        },
+      ]);
+
+      expect(bounds).toEqual([
+        [
+          {
+            attributeName: 'credentialSubject.age',
+            min: 18,
+            max: 65,
+            proofRequestMax: 65,
+            proofRequestMin: 18,
+            format: undefined,
+            type: 'number',
+          },
+          {
+            attributeName: 'credentialSubject.graduationDate',
+            min: new Date('2020-01-01'),
+            max: new Date('2025-12-31'),
+            proofRequestMax: '2025-12-31',
+            proofRequestMin: '2020-01-01',
+            format: 'date',
+            type: undefined,
+          },
+        ],
+      ]);
+    });
+
     it('should not have undefined attributeNames, exclude not found bounds', () => {
       const pexRequest = {
         id: '3cb2c1db-54d7-427a-a6a2-4b8f73a33700',