@docknetwork/wallet-sdk-wasm 1.5.14 → 1.7.6

package/lib/services/blockchain/service.js

@@ -13,19 +13,43 @@ var core_logger = require('../../core/logger.js');
 var modules_eventManager = require('../../modules/event-manager.js');
 var services_utilCrypto_service = require('../util-crypto/service.js');
 var types = require('@docknetwork/credential-sdk/types');
+var services_blockchain_cachedDidResolver = require('./cached-did-resolver.js');
 require('assert');
 require('@docknetwork/credential-sdk/utils');
 require('@scure/bip39');
 require('@scure/bip39/wordlists/english');
 require('../util-crypto/configs.js');
+require('../storage/index.js');
+require('../storage/service.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');
 
 // @ts-nocheck
+/**
+ * Universal resolver URL for DID resolution fallback
+ * @constant {string}
+ */
 const universalResolverUrl = 'https://uniresolver.truvera.io';
+/**
+ * Resolver that accepts any DID method using wildcard matching
+ * @class
+ * @extends ResolverRouter
+ * @private
+ */
 class AnyDIDResolver extends resolver.ResolverRouter {
     method = resolver.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
  */
 class BlockchainService {
     dock;
@@ -33,7 +57,16 @@ class BlockchainService {
     cheqdApi;
     cheqdApiUrl;
     isBlockchainReady = false;
-    resolver;
+    _resolver;
+    get resolver() {
+        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',
     };
@@ -43,15 +76,33 @@ 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 cheqdBlockchainApi.CheqdAPI();
         this.cheqdModules = new cheqdBlockchainModules.CheqdCoreModules(this.cheqdApi);
         this.modules = new modules.MultiApiCoreModules([this.cheqdModules]);
         this.emitter = new events.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: types.AccumulatorPublicKey,
@@ -61,8 +112,11 @@ 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()) {
@@ -70,17 +124,62 @@ class BlockchainService {
         }
         return modules_eventManager.once(this.emitter, BlockchainService.Events.BLOCKCHAIN_READY);
     }
-    createDIDResolver() {
-        return new AnyDIDResolver([
-            new resolver.DIDKeyResolver(),
-            new resolver.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) {
+        let resolvers = [
             new resolver.UniversalResolver(universalResolverUrl),
-        ]);
+            new resolver.DIDKeyResolver(),
+        ];
+        // Add blockchain resolvers if the blockchain is ready
+        if (isBlockchainReady) {
+            resolvers = [
+                new resolver.CoreResolver(this.modules),
+                ...resolvers
+            ];
+        }
+        const router = new AnyDIDResolver(resolvers);
+        return new services_blockchain_cachedDidResolver.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) {
         if (!params?.cheqdApiUrl) {
@@ -105,15 +204,17 @@ class BlockchainService {
         try {
             await this.cheqdApi.init({
                 wallet,
-                url: checkdApiUrl,
+                urls: Array.isArray(checkdApiUrl) ? checkdApiUrl : [checkdApiUrl],
                 network: cheqdNetworkId,
             });
             core_logger.Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
         }
         catch (err) {
+            debugger;
             core_logger.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' ||
             process.env.API_MOCK_DISABLED === 'true') {
             await index.initializeWasm();
@@ -122,8 +223,10 @@ class BlockchainService {
         return true;
     }
     /**
-     *
-     * @returns
+     * Disconnects from the blockchain
+     * @returns {Promise<void>} Resolves when disconnection is complete
+     * @example
+     * await blockchainService.disconnect();
      */
     async disconnect() {
         let result;
@@ -133,6 +236,11 @@ class BlockchainService {
         this._setBlockchainReady(false);
         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) {
@@ -143,19 +251,39 @@ 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) {
         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;
         if (isBlockchainReady) {
@@ -163,6 +291,20 @@ 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...');
+ */
 const blockchainService = new BlockchainService();
 
 exports.BlockchainService = BlockchainService;

package/lib/services/blockchain/service.mjs

@@ -2,26 +2,50 @@ import { DirectSecp256k1HdWallet } from '@cosmjs/proto-signing';
 import { CheqdAPI } from '@docknetwork/cheqd-blockchain-api';
 import { CheqdCoreModules } from '@docknetwork/cheqd-blockchain-modules';
 import { MultiApiCoreModules } from '@docknetwork/credential-sdk/modules';
-import { DIDKeyResolver, CoreResolver, UniversalResolver, ResolverRouter, WILDCARD } from '@docknetwork/credential-sdk/resolver';
+import { UniversalResolver, DIDKeyResolver, CoreResolver, ResolverRouter, WILDCARD } from '@docknetwork/credential-sdk/resolver';
 import { initializeWasm } from '@docknetwork/crypto-wasm-ts/lib/index';
 import { EventEmitter } from 'events';
 import { Logger } from '../../core/logger.mjs';
 import { once } from '../../modules/event-manager.mjs';
 import { utilCryptoService } from '../util-crypto/service.mjs';
 import { AccumulatorPublicKey, AccumulatorId, AccumulatorCommon } from '@docknetwork/credential-sdk/types';
+import { CachedDIDResolver } from './cached-did-resolver.mjs';
 import 'assert';
 import '@docknetwork/credential-sdk/utils';
 import '@scure/bip39';
 import '@scure/bip39/wordlists/english';
 import '../util-crypto/configs.mjs';
+import '../storage/index.mjs';
+import '../storage/service.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';
 
 // @ts-nocheck
+/**
+ * Universal resolver URL for DID resolution fallback
+ * @constant {string}
+ */
 const universalResolverUrl = 'https://uniresolver.truvera.io';
+/**
+ * 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
  */
 class BlockchainService {
     dock;
@@ -29,7 +53,16 @@ class BlockchainService {
     cheqdApi;
     cheqdApiUrl;
     isBlockchainReady = false;
-    resolver;
+    _resolver;
+    get resolver() {
+        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',
     };
@@ -39,15 +72,33 @@ 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,
@@ -57,8 +108,11 @@ 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()) {
@@ -66,17 +120,62 @@ 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) {
+        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) {
         if (!params?.cheqdApiUrl) {
@@ -101,15 +200,17 @@ 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' ||
             process.env.API_MOCK_DISABLED === 'true') {
             await initializeWasm();
@@ -118,8 +219,10 @@ class BlockchainService {
         return true;
     }
     /**
-     *
-     * @returns
+     * Disconnects from the blockchain
+     * @returns {Promise<void>} Resolves when disconnection is complete
+     * @example
+     * await blockchainService.disconnect();
      */
     async disconnect() {
         let result;
@@ -129,6 +232,11 @@ class BlockchainService {
         this._setBlockchainReady(false);
         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) {
@@ -139,19 +247,39 @@ 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) {
         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;
         if (isBlockchainReady) {
@@ -159,6 +287,20 @@ 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...');
+ */
 const blockchainService = new BlockchainService();
 
 export { BlockchainService, blockchainService, universalResolverUrl };

package/lib/services/credential/bbs-revocation.js

@@ -20,6 +20,17 @@ require('@scure/bip39');
 require('@scure/bip39/wordlists/english');
 require('../util-crypto/configs.js');
 require('@docknetwork/credential-sdk/types');
+require('../blockchain/cached-did-resolver.js');
+require('../storage/index.js');
+require('../storage/service.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');
 
 const getWitnessDetails = async (credential, _membershipWitness) => {
     let witness = _membershipWitness;

package/lib/services/credential/bbs-revocation.mjs

@@ -16,6 +16,17 @@ import '@scure/bip39';
 import '@scure/bip39/wordlists/english';
 import '../util-crypto/configs.mjs';
 import '@docknetwork/credential-sdk/types';
+import '../blockchain/cached-did-resolver.mjs';
+import '../storage/index.mjs';
+import '../storage/service.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';
 
 const getWitnessDetails = async (credential, _membershipWitness) => {
     let witness = _membershipWitness;

package/lib/services/credential/bound-check.js

@@ -48,7 +48,7 @@ async function fetchBlobFromUrl(url) {
 }
 function blobFromBase64(base64String) {
     const cleanedBase64 = base64String.replace(/^data:application\/octet-stream;base64,/, '');
-    return base64url__default["default"].toBuffer(cleanedBase64);
+    return new Uint8Array(base64url__default["default"].toBuffer(cleanedBase64));
 }
 async function isBase64OrDataUrl(str) {
     return ((await services_utilCrypto_service.utilCryptoService.isBase64(str)) ||

package/lib/services/credential/bound-check.mjs

@@ -40,7 +40,7 @@ async function fetchBlobFromUrl(url) {
 }
 function blobFromBase64(base64String) {
     const cleanedBase64 = base64String.replace(/^data:application\/octet-stream;base64,/, '');
-    return base64url.toBuffer(cleanedBase64);
+    return new Uint8Array(base64url.toBuffer(cleanedBase64));
 }
 async function isBase64OrDataUrl(str) {
     return ((await utilCryptoService.isBase64(str)) ||

package/lib/services/credential/config.js

@@ -20,7 +20,10 @@ const validation = {
     },
     verifyCredential: params => {
         const { credential } = params;
-        assert__default["default"](typeof credential === 'object', 'invalid credential');
+        assert__default["default"](typeof credential === 'object' || typeof credential === 'string', 'invalid credential');
+        if (typeof credential === 'object') {
+            assert__default["default"](Object.keys(credential).length > 0, 'invalid credential');
+        }
     },
     createBBSPresentation: params => {
         const { credentials } = params;

package/lib/services/credential/config.mjs

@@ -12,7 +12,10 @@ 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;