@docknetwork/wallet-sdk-wasm 1.5.14 → 1.7.6

package/src/services/blockchain/configs.ts

@@ -4,8 +4,7 @@ import assert from 'assert';
 export const validation = {};
 
 export type InitParams = {
-  substrateUrl: string,
-  cheqdApiUrl?: string,
+  cheqdApiUrl?: string | string[],
   networkId?: string,
   cheqdMnemonic?: string,
 };

package/src/services/blockchain/service-rpc.js

@@ -44,4 +44,16 @@ export class BlockchainServiceRpc extends RpcService {
   resolveDID(did: string): Promise<any> {
     return this.call('resolveDID', did);
   }
+
+  getCachedDIDs(): Promise<any> {
+    return this.call('getCachedDIDs');
+  }
+
+  getCacheEntry(did: string): Promise<any> {
+    return this.call('getCacheEntry', did);
+  }
+
+  clearCache(did?: string): Promise<any> {
+    return this.call('clearCache', did);
+  }
 }

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;
@@ -39,7 +60,17 @@ export class BlockchainService {
   cheqdApi;
   cheqdApiUrl;
   isBlockchainReady = false;
-  resolver: any;
+  private _resolver: any;
+
+  get resolver(): any {
+    return this._resolver;
+  }
+  /**
+   * 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,17 +81,35 @@ 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();
     this.cheqdModules = new CheqdCoreModules(this.cheqdApi);
     this.modules = new MultiApiCoreModules([this.cheqdModules]);
     this.emitter = new EventEmitter();
-    this.resolver = this.createDIDResolver();
+    // Blockchain is not ready yet, but we can use fallback resolvers
+    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 +120,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 +134,69 @@ export class BlockchainService {
     return once(this.emitter, BlockchainService.Events.BLOCKCHAIN_READY);
   }
 
-  createDIDResolver() {
-    return new AnyDIDResolver([
-      new DIDKeyResolver(),
-      new CoreResolver(this.modules),
+  
+  /**
+   * 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(isBlockchainReady: boolean) {
+    let resolvers = [
       new UniversalResolver(universalResolverUrl),
-    ]);
+      new DIDKeyResolver(),
+    ]
+
+    // Add blockchain resolvers if the blockchain is ready
+    if (isBlockchainReady) {
+      resolvers = [
+        new CoreResolver(this.modules),
+        ...resolvers
+      ]
+    }
+
+    const router = new AnyDIDResolver(resolvers);
+
+    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) {
@@ -127,16 +231,18 @@ export class BlockchainService {
     try {
       await this.cheqdApi.init({
         wallet,
-        url: checkdApiUrl,
+        urls: Array.isArray(checkdApiUrl) ? checkdApiUrl : [checkdApiUrl],
         network: cheqdNetworkId,
       });
       Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
     } catch (err) {
+      debugger
       Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`, err);
     }
 
 
-    this.resolver = this.createDIDResolver();
+    // Re-create the resolver with the new blockchain connection
+    this._resolver = this.createDIDResolver(true);
 
     if (
       process.env.NODE_ENV !== 'test' ||
@@ -151,8 +257,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 +274,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 +289,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();
   }
 
-  async getAddress() {
+  /**
+   * Gets the current Cheqd API URL
+   * @returns {Promise<string>} The Cheqd API URL
+   * @example
+   * const apiUrl = await blockchainService.getAddress();
+   */
+  async getAddress(): Promise<string | string[]> {
     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 +333,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/bound-check.ts

@@ -107,7 +107,7 @@ export function blobFromBase64(base64String: string): Uint8Array {
     /^data:application\/octet-stream;base64,/,
     '',
   );
-  return base64url.toBuffer(cleanedBase64);
+  return new Uint8Array(base64url.toBuffer(cleanedBase64));
 }
 
 export async function isBase64OrDataUrl(str: string): Promise<boolean> {

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;