@docknetwork/wallet-sdk-wasm 1.5.14 → 1.7.6

package/lib/wallet/rpc-storage-interface.js

@@ -2,8 +2,18 @@
 
 var StorageInterface = require('@docknetwork/universal-wallet/storage/storage-interface');
 var uuid = require('uuid');
-var services_storage_service = require('../services/storage/service.js');
+var services_storage_index = require('../services/storage/index.js');
 var core_logger = require('../core/logger.js');
+require('../services/storage/service.js');
+require('../services/storage/service-rpc.js');
+require('../services/rpc-service-client.js');
+require('assert');
+require('../rpc-client.js');
+require('json-rpc-2.0');
+require('../core/crypto.js');
+require('crypto');
+require('../logger.js');
+require('../rpc-util.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -25,7 +35,7 @@ class RpcStorageInterface extends StorageInterface__default["default"] {
     let data;
     try {
       core_logger.Logger.debug(`Wallet: Loading storage from ${directory}`);
-      data = await services_storage_service.storageService.getItem(directory);
+      data = await services_storage_index.storageService.getItem(directory);
 
       this.documents = typeof data === 'string' ? JSON.parse(data) : data;
 
@@ -47,7 +57,7 @@ class RpcStorageInterface extends StorageInterface__default["default"] {
   }
 
   updateLocalStorage() {
-    services_storage_service.storageService.setItem(this.directory, JSON.stringify(this.documents));
+    services_storage_index.storageService.setItem(this.directory, JSON.stringify(this.documents));
   }
 
   async get({id}) {

package/lib/wallet/rpc-storage-interface.mjs

@@ -1,7 +1,17 @@
 import StorageInterface from '@docknetwork/universal-wallet/storage/storage-interface';
 import { v4 } from 'uuid';
-import { storageService } from '../services/storage/service.mjs';
+import { storageService } from '../services/storage/index.mjs';
 import { Logger } from '../core/logger.mjs';
+import '../services/storage/service.mjs';
+import '../services/storage/service-rpc.mjs';
+import '../services/rpc-service-client.mjs';
+import 'assert';
+import '../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../core/crypto.mjs';
+import 'crypto';
+import '../logger.mjs';
+import '../rpc-util.mjs';
 
 function generateDocumentId() {
   return `doc:${v4()}`;

package/lib/wallet/rpc-storage-wallet.js

@@ -4,8 +4,18 @@ var StorageWallet = require('@docknetwork/universal-wallet/storage-wallet');
 var wallet_rpcStorageInterface = require('./rpc-storage-interface.js');
 require('@docknetwork/universal-wallet/storage/storage-interface');
 require('uuid');
+require('../services/storage/index.js');
 require('../services/storage/service.js');
+require('../services/storage/service-rpc.js');
+require('../services/rpc-service-client.js');
+require('assert');
+require('../rpc-client.js');
+require('json-rpc-2.0');
+require('../core/crypto.js');
+require('crypto');
 require('../core/logger.js');
+require('../logger.js');
+require('../rpc-util.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 

package/lib/wallet/rpc-storage-wallet.mjs

@@ -2,8 +2,18 @@ import StorageWallet from '@docknetwork/universal-wallet/storage-wallet';
 import RpcStorageInterface from './rpc-storage-interface.mjs';
 import '@docknetwork/universal-wallet/storage/storage-interface';
 import 'uuid';
+import '../services/storage/index.mjs';
 import '../services/storage/service.mjs';
+import '../services/storage/service-rpc.mjs';
+import '../services/rpc-service-client.mjs';
+import 'assert';
+import '../rpc-client.mjs';
+import 'json-rpc-2.0';
+import '../core/crypto.mjs';
+import 'crypto';
 import '../core/logger.mjs';
+import '../logger.mjs';
+import '../rpc-util.mjs';
 
 class RpcWallet extends StorageWallet {
   constructor(id, storageOptions = {}) {

package/package.json

@@ -1,46 +1,59 @@
 {
     "name": "@docknetwork/wallet-sdk-wasm",
-    "version": "1.5.14",
-    "license": "https://github.com/docknetwork/react-native-sdk/LICENSE",
+    "version": "1.7.6",
+    "license": "https://github.com/docknetwork/wallet-sdk/LICENSE",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/docknetwork/react-native-sdk.git",
+        "url": "git+https://github.com/docknetwork/wallet-sdk.git",
         "directory": "packages/wasm"
     },
     "scripts": {
         "prepublishOnly": "npm run build",
         "build:babel": "rm -rf lib && NODE_ENV=production babel src/ --out-dir lib --copy-files",
-        "build": "rm -rf lib && rollup -c && node ../../scripts/fix-build-imports.js ./lib"
+        "build": "rm -rf lib && rollup -c && node ../../scripts/fix-build-imports.js ./lib",
+        "docs": "node generate-docs.js",
+        "docs:jsdoc": "jsdoc -c jsdoc.conf.json -r src/"
     },
     "resolutions": {
         "p-limit": "2.3.0"
     },
     "dependencies": {
-        "p-limit": "2.3.0",
         "@astronautlabs/jsonpath": "^1.1.2",
-        "@docknetwork/universal-wallet": "^2.0.1",
-        "@docknetwork/wallet-sdk-dids": "^1.5.14",
+        "@cedar-policy/cedar-wasm": "^4.5.0",
         "@cosmjs/proto-signing": "^0.32.4",
-        "@docknetwork/cheqd-blockchain-api": "4.0.3",
-        "@docknetwork/cheqd-blockchain-modules": "4.0.3",
-        "@scure/bip39": "^1.6.0",
+        "@docknetwork/cheqd-blockchain-api": "4.1.1",
+        "@docknetwork/cheqd-blockchain-modules": "4.0.8",
+        "@docknetwork/credential-sdk": "0.54.16",
+        "@docknetwork/universal-wallet": "^2.0.1",
+        "@docknetwork/vc-delegation-engine": "1.0.3",
+        "@docknetwork/wallet-sdk-dids": "^1.7.6",
         "@noble/hashes": "1.8.0",
-        "@docknetwork/credential-sdk": "0.54.3",
+        "@scure/bip39": "^1.6.0",
+        "@sd-jwt/crypto-nodejs": "^0.15.0",
+        "@sd-jwt/sd-jwt-vc": "^0.15.1",
         "@sphereon/oid4vci-client": "^0.16.0",
         "@sphereon/oid4vci-common": "^0.16.0",
+        "@sphereon/pex": "^1.1.4",
         "axios": "^0.25.0",
+        "axios-retry": "^3.2.5",
+        "base64url": "^3.0.1",
+        "cwait": "1.1.2",
+        "futoin-hkdf": "^1.5.3",
         "json-rpc-2.0": "^0.2.16",
+        "jsonld": "^6.0.0",
+        "p-limit": "2.3.0",
         "uuid": "^8.3.2",
-        "winston": "^3.3.3",
-        "cwait": "1.1.2",
-        "axios-retry": "^3.2.5",
-        "@sphereon/pex": "^1.1.4"
+        "winston": "^3.3.3"
     },
     "devDependencies": {
         "@babel/node": "^7.16.0",
-        "sinon": "^12.0.1",
         "jest": "29.6.1",
+        "sinon": "^12.0.1",
         "ts-jest": "29.1.0",
         "typescript": "^5.0.4"
+    },
+    "overrides": {
+        "@digitalbazaar/http-client": "^3.4.1",
+        "base58-universal": "2.0.0"
     }
 }

package/rollup.config.mjs

@@ -1,14 +1,16 @@
 import json from '@rollup/plugin-json';
-import multiInput from 'rollup-plugin-multi-input';
+import _multiInput from 'rollup-plugin-multi-input';
 import commonjs from '@rollup/plugin-commonjs';
 import flow from 'rollup-plugin-flow';
 import typescript from '@rollup/plugin-typescript';
 
+const multiInput = _multiInput.default || _multiInput;
+
 export default async function () {
   return [
     {
       plugins: [
-        multiInput.default(),
+        multiInput(),
         json(),
         flow({
           all: true,
@@ -17,7 +19,7 @@ export default async function () {
         commonjs(),
         typescript(),
       ],
-      input: ['src/**/*.ts', 'src/**/*.js', '!src/**/*.test.ts', '!src/**/*.test.js'],
+      input: ['src/**/*.ts', 'src/**/*.js', '!src/**/*.test.ts', '!src/**/*.test.js', '!src/**/*.d.ts'],
       output: [
         {
           dir: 'lib',

package/src/globals.d.ts

@@ -0,0 +1,3 @@
+// CryptoKey is available globally in Node.js 15+ but TypeScript needs
+// the DOM lib to recognize it. Declare it here to avoid pulling in all DOM types.
+type CryptoKey = import('crypto').webcrypto.CryptoKey;

package/src/modules/network-manager.ts

@@ -3,35 +3,36 @@ import assert from 'assert';
 
 export type NetworkInfo = {
   name: string,
-  substrateUrl: string | string[],
-  addressPrefix: number,
-  cheqdApiUrl: string,
+  cheqdApiUrl: string | string[],
 };
 
 export type NetworkId = 'mainnet' | 'testnet' | 'local' | 'custom';
 
-export const SUBSTRATE_NETWORKS : Record<NetworkId, NetworkInfo> = {
+export const BLOCKCHAIN_NETWORKS : Record<NetworkId, NetworkInfo> = {
   mainnet: {
     name: 'Cheqd Mainnet',
-    substrateUrl: null,
-    addressPrefix: 22,
-    cheqdApiUrl: 'https://mainnet.cheqd.docknode.io',
+    cheqdApiUrl: [
+      'https://mainnet.cheqd.docknode.io',
+      'https://rpc.cheqd.net',
+    ],
   },
   testnet: {
     name: 'Cheqd Testnet',
-    substrateUrl: null,
-    addressPrefix: 21,
-    cheqdApiUrl: 'https://testnet.cheqd.docknode.io',
+    cheqdApiUrl: [
+      'https://testnet.cheqd.docknode.io',
+      'https://api.cheqd.network',
+    ],
   },
   local: {
     name: 'Local Node',
-    substrateUrl: 'ws://127.0.0.1:9944',
-    addressPrefix: 21,
+    cheqdApiUrl: [
+      'http://localhost:8080',
+    ],
   },
 };
 
 function getNetworkInfo(networkId): NetworkInfo {
-  const networkInfo = SUBSTRATE_NETWORKS[networkId];
+  const networkInfo = BLOCKCHAIN_NETWORKS[networkId];
 
   assert(!!networkInfo, `Network ${networkId} not found`);
 
@@ -57,7 +58,7 @@ export class NetworkManager {
    * @param {string} networkId
    */
   setNetworkId(networkId: NetworkId) {
-    assert(!!SUBSTRATE_NETWORKS[networkId], `invalid networkId ${networkId}`);
+    assert(!!BLOCKCHAIN_NETWORKS[networkId], `invalid networkId ${networkId}`);
 
     this.networkId = networkId;
   }

package/src/services/blockchain/cached-did-resolver.test.ts

@@ -0,0 +1,288 @@
+import { CachedDIDResolver } from './cached-did-resolver';
+import { storageService } from '../storage';
+
+const mockStorageService = {
+  getItem: jest.fn(),
+  setItem: jest.fn(),
+  removeItem: jest.fn(),
+  getAllKeys: jest.fn(),
+};
+
+jest.mock('../storage', () => ({
+  storageService: mockStorageService,
+}));
+
+const mockRouter = {
+  resolve: jest.fn(),
+  supports: jest.fn(),
+};
+
+describe('CachedDIDResolver', () => {
+  let resolver: CachedDIDResolver;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockStorageService.getItem.mockResolvedValue(null);
+    mockStorageService.getAllKeys.mockResolvedValue([]);
+    resolver = new CachedDIDResolver(mockRouter);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with default TTL', () => {
+      expect(resolver).toBeDefined();
+    });
+
+    it('should initialize with custom TTL', () => {
+      const customTtl = 60000; // 1 minute
+      const resolverWithCustomTtl = new CachedDIDResolver(mockRouter, { ttl: customTtl });
+      expect(resolverWithCustomTtl).toBeDefined();
+    });
+  });
+
+  describe('resolve', () => {
+    const testDid = 'did:example:123';
+    const testResult = { id: testDid, publicKey: [] };
+
+    it('should resolve DID and cache the result on cache miss', async () => {
+      mockRouter.resolve.mockResolvedValue(testResult);
+      mockStorageService.getItem.mockResolvedValue(null);
+
+      const result = await resolver.resolve(testDid);
+
+      expect(mockRouter.resolve).toHaveBeenCalledWith(testDid);
+      expect(result).toEqual(testResult);
+      expect(mockStorageService.setItem).toHaveBeenCalledWith(
+        `did-cache:${testDid}`,
+        JSON.stringify({
+          value: testResult,
+          id: testDid,
+          timestamp: expect.any(Number),
+        })
+      );
+    });
+
+    it('should use result.id for cache key instead of input did', async () => {
+      const inputDid = 'did:example:input';
+      const resultDid = 'did:example:resolved';
+      const testResultWithDifferentId = { id: resultDid, publicKey: [] };
+
+      mockRouter.resolve.mockResolvedValue(testResultWithDifferentId);
+      mockStorageService.getItem.mockResolvedValue(null);
+
+      const result = await resolver.resolve(inputDid);
+
+      expect(result).toEqual(testResultWithDifferentId);
+      // Should use result.id (resultDid) for the cache key, not inputDid
+      expect(mockStorageService.setItem).toHaveBeenCalledWith(
+        `did-cache:${resultDid}`,
+        JSON.stringify({
+          value: testResultWithDifferentId,
+          id: resultDid,
+          timestamp: expect.any(Number),
+        })
+      );
+    });
+
+    it('should return cached result on cache hit', async () => {
+      const cachedData = {
+        value: testResult,
+        id: testDid,
+        timestamp: Date.now(),
+      };
+
+      mockStorageService.getItem.mockResolvedValue(JSON.stringify(cachedData));
+
+      const result = await resolver.resolve(testDid);
+
+      expect(result).toEqual(testResult);
+      expect(mockRouter.resolve).not.toHaveBeenCalled();
+    });
+
+    it('should return stale value immediately and refresh in background when cache entry is expired', async () => {
+      const expiredTimestamp = Date.now() - (8 * 24 * 60 * 60 * 1000); // 8 days ago (expired)
+      const staleResult = { id: testDid, publicKey: [], stale: true };
+      const freshResult = { id: testDid, publicKey: [], fresh: true };
+
+      const cachedData = {
+        value: staleResult,
+        id: testDid,
+        timestamp: expiredTimestamp,
+      };
+
+      mockStorageService.getItem.mockResolvedValue(JSON.stringify(cachedData));
+      mockRouter.resolve.mockResolvedValue(freshResult);
+
+      const result = await resolver.resolve(testDid);
+
+      // Should return stale value immediately
+      expect(result).toEqual(staleResult);
+
+      // Background refresh should be triggered (not awaited)
+      // Give it time to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(mockRouter.resolve).toHaveBeenCalledWith(testDid);
+      expect(mockStorageService.setItem).toHaveBeenCalledWith(
+        `did-cache:${testDid}`,
+        JSON.stringify({
+          value: freshResult,
+          id: testDid,
+          timestamp: expect.any(Number),
+        })
+      );
+    });
+
+    it('should handle corrupted cache data gracefully', async () => {
+      const testDid = 'did:example:corrupted';
+      const testResult = { id: testDid, publicKey: [] };
+
+      // Return invalid JSON from storage
+      mockStorageService.getItem.mockResolvedValue('invalid json {');
+      mockRouter.resolve.mockResolvedValue(testResult);
+
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+
+      const result = await resolver.resolve(testDid);
+
+      expect(consoleSpy).toHaveBeenCalledWith('Error parsing cache entry:', expect.any(Error));
+      expect(mockRouter.resolve).toHaveBeenCalledWith(testDid);
+      expect(result).toEqual(testResult);
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('getCachedDIDs', () => {
+    it('should return empty array when no cached DIDs exist', async () => {
+      mockStorageService.getAllKeys.mockResolvedValue([]);
+
+      const cachedDIDs = await resolver.getCachedDIDs();
+
+      expect(cachedDIDs).toEqual([]);
+      expect(mockStorageService.getAllKeys).toHaveBeenCalled();
+    });
+
+    it('should return list of cached DIDs', async () => {
+      const allKeys = [
+        'did-cache:did:example:123',
+        'did-cache:did:example:456',
+        'did-cache:did:dock:789',
+        'other-key:something',
+        'user-preference:theme',
+      ];
+
+      mockStorageService.getAllKeys.mockResolvedValue(allKeys);
+
+      const cachedDIDs = await resolver.getCachedDIDs();
+
+      expect(cachedDIDs).toEqual([
+        'did:example:123',
+        'did:example:456',
+        'did:dock:789',
+      ]);
+      expect(mockStorageService.getAllKeys).toHaveBeenCalled();
+    });
+
+    it('should handle empty storage correctly', async () => {
+      mockStorageService.getAllKeys.mockResolvedValue([]);
+
+      const cachedDIDs = await resolver.getCachedDIDs();
+
+      expect(cachedDIDs).toEqual([]);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('should clear specific DID from cache', async () => {
+      const didToRemove = 'did:example:123';
+
+      await resolver.clearCache(didToRemove);
+
+      expect(mockStorageService.removeItem).toHaveBeenCalledWith(`did-cache:${didToRemove}`);
+      expect(mockStorageService.removeItem).toHaveBeenCalledTimes(1);
+    });
+
+    it('should clear entire cache when no DID specified', async () => {
+      const allKeys = [
+        'did-cache:did:example:123',
+        'did-cache:did:example:456',
+        'other-key:something',
+      ];
+
+      mockStorageService.getAllKeys.mockResolvedValue(allKeys);
+
+      await resolver.clearCache();
+
+      expect(mockStorageService.getAllKeys).toHaveBeenCalled();
+      expect(mockStorageService.removeItem).toHaveBeenCalledWith('did-cache:did:example:123');
+      expect(mockStorageService.removeItem).toHaveBeenCalledWith('did-cache:did:example:456');
+      expect(mockStorageService.removeItem).not.toHaveBeenCalledWith('other-key:something');
+      expect(mockStorageService.removeItem).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle clearing cache when no cached entries exist', async () => {
+      mockStorageService.getAllKeys.mockResolvedValue([]);
+
+      await resolver.clearCache();
+
+      expect(mockStorageService.getAllKeys).toHaveBeenCalled();
+      expect(mockStorageService.removeItem).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('supports', () => {
+    it('should delegate to router supports method', () => {
+      const testId = 'did:example:123';
+      mockRouter.supports.mockReturnValue(true);
+
+      const result = resolver.supports(testId);
+
+      expect(mockRouter.supports).toHaveBeenCalledWith(testId);
+      expect(result).toBe(true);
+    });
+
+    it('should return false when router does not support DID', () => {
+      const testId = 'did:unsupported:123';
+      mockRouter.supports.mockReturnValue(false);
+
+      const result = resolver.supports(testId);
+
+      expect(mockRouter.supports).toHaveBeenCalledWith(testId);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('background refresh', () => {
+    it('should handle background refresh failure gracefully', async () => {
+      const testDid = 'did:example:refresh-fail';
+      const expiredTimestamp = Date.now() - (8 * 24 * 60 * 60 * 1000);
+      const staleResult = { id: testDid, publicKey: [] };
+
+      const cachedData = {
+        value: staleResult,
+        id: testDid,
+        timestamp: expiredTimestamp,
+      };
+
+      mockStorageService.getItem.mockResolvedValue(JSON.stringify(cachedData));
+      mockRouter.resolve.mockRejectedValue(new Error('Network error'));
+
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+
+      const result = await resolver.resolve(testDid);
+
+      expect(result).toEqual(staleResult);
+
+      // Wait for background refresh to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Background refresh failed for:',
+        testDid,
+        expect.any(Error)
+      );
+
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/src/services/blockchain/cached-did-resolver.ts

@@ -0,0 +1,126 @@
+import { storageService } from '../storage';
+
+interface CacheEntry {
+  value: any;
+  id: string;
+  timestamp: number;
+}
+
+interface CacheOptions {
+  ttl?: number;
+}
+
+interface DIDResolver {
+  resolve(did: string): Promise<any>;
+  supports(id: string): boolean;
+}
+
+export class CachedDIDResolver {
+  private router: DIDResolver;
+  private ttl: number;
+  private readonly CACHE_PREFIX = 'did-cache:';
+
+  constructor(router: DIDResolver, cacheOptions: CacheOptions = {}) {
+    this.router = router;
+    // 1 hour default
+    this.ttl = cacheOptions.ttl || 60 * 60 * 1000;
+  }
+
+  private getCacheKey(did: string): string {
+    return `${this.CACHE_PREFIX}${did}`;
+  }
+  
+
+  private async getCacheEntry(did: string): Promise<CacheEntry | null> {
+    const key = this.getCacheKey(did);
+    const data = await storageService.getItem(key);
+
+    try {
+      return data ? JSON.parse(data) : null;
+    } catch (error) {
+      console.error('Error parsing cache entry:', error);
+      return null;
+    }
+  }
+
+  private async setCacheEntry(did: string, entry: CacheEntry): Promise<void> {
+    const key = this.getCacheKey(did);
+    await storageService.setItem(key, JSON.stringify(entry));
+  }
+
+  async getCachedDIDs(): Promise<string[]> {
+    const allKeys = await storageService.getAllKeys();
+    const cachedDIDs: string[] = [];
+    
+    allKeys.forEach(key => {
+      if (key.startsWith(this.CACHE_PREFIX)) {
+        cachedDIDs.push(key.replace(this.CACHE_PREFIX, ''));
+      }
+    });
+    
+    return cachedDIDs;
+  }
+
+  async resolve(did: string): Promise<any> {
+    const cached = await this.getCacheEntry(did);
+
+    if (cached) {
+      if (Date.now() - cached.timestamp < this.ttl) {
+        console.log('Cache hit for:', did);
+        return cached.value;
+      } else {
+        console.log('Cache expired for:', did, 'returning stale value and refreshing in background');
+        this.refreshInBackground(did);
+        return cached.value;
+      }
+    }
+
+    console.log('Cache miss, resolving:', did);
+    const result = await this.router.resolve(did);
+
+    await this.setCacheEntry(result.id, {
+      value: result,
+      id: result.id,
+      timestamp: Date.now()
+    });
+
+    return result;
+  }
+
+  private async refreshInBackground(did: string): Promise<void> {
+    try {
+      console.log('Refreshing cache in background for:', did);
+      const result = await this.router.resolve(did);
+      
+      await this.setCacheEntry(did, {
+        value: result,
+        id: did,
+        timestamp: Date.now()
+      });
+
+      console.log('Background refresh completed for:', did);
+    } catch (error) {
+      console.warn('Background refresh failed for:', did, error);
+    }
+  }
+
+  /**
+   * if the did is provided, it will remove the specific did from the cache
+   * otherwise, it will clear the entire cache
+   * @param did
+   */
+  async clearCache(did?: string): Promise<void> {
+    if (did) {
+      const key = this.getCacheKey(did);
+      await storageService.removeItem(key);
+    } else {
+      const allKeys = await storageService.getAllKeys();
+      const cacheKeys = allKeys.filter(key => key.startsWith(this.CACHE_PREFIX));
+      await Promise.all(cacheKeys.map(key => storageService.removeItem(key)));
+    }
+  }
+
+  supports(id: string): boolean {
+    return this.router.supports(id);
+  }
+}