@docknetwork/wallet-sdk-wasm 1.5.14 → 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,8 +115,11 @@ 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 (await this.isApiConnected()) {
@@ -82,17 +129,60 @@ export class BlockchainService {
     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) {
@@ -176,21 +273,41 @@ export class BlockchainService {
     });
   }
 
+  /**
+   * 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);
   }
   /**
-   *
-   * @returns
+   * 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;
 
@@ -200,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;