@docknetwork/wallet-sdk-wasm 1.7.6 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@docknetwork/wallet-sdk-wasm",
-    "version": "1.7.6",
+    "version": "1.9.0",
     "license": "https://github.com/docknetwork/wallet-sdk/LICENSE",
     "repository": {
         "type": "git",
@@ -8,7 +8,6 @@
         "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",
         "docs": "node generate-docs.js",
@@ -21,12 +20,12 @@
         "@astronautlabs/jsonpath": "^1.1.2",
         "@cedar-policy/cedar-wasm": "^4.5.0",
         "@cosmjs/proto-signing": "^0.32.4",
-        "@docknetwork/cheqd-blockchain-api": "4.1.1",
-        "@docknetwork/cheqd-blockchain-modules": "4.0.8",
-        "@docknetwork/credential-sdk": "0.54.16",
+        "@docknetwork/cheqd-blockchain-api": "4.2.2",
+        "@docknetwork/cheqd-blockchain-modules": "4.0.9",
+        "@docknetwork/credential-sdk": "0.54.19",
         "@docknetwork/universal-wallet": "^2.0.1",
-        "@docknetwork/vc-delegation-engine": "1.0.3",
-        "@docknetwork/wallet-sdk-dids": "^1.7.6",
+        "@docknetwork/vc-delegation-engine": "1.0.4",
+        "@docknetwork/wallet-sdk-dids": "^1.9.0",
         "@noble/hashes": "1.8.0",
         "@scure/bip39": "^1.6.0",
         "@sd-jwt/crypto-nodejs": "^0.15.0",

package/rollup.config.mjs

@@ -20,6 +20,7 @@ export default async function () {
         typescript(),
       ],
       input: ['src/**/*.ts', 'src/**/*.js', '!src/**/*.test.ts', '!src/**/*.test.js', '!src/**/*.d.ts'],
+      external: ['assert'],
       output: [
         {
           dir: 'lib',

package/src/globals.d.ts

@@ -1,3 +1,6 @@
 // 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;
+declare global {
+  type CryptoKey = import('crypto').webcrypto.CryptoKey;
+}
+export {};

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

@@ -1,4 +1,5 @@
 import { storageService } from '../storage';
+import { normalizeDIDDocument } from './normalize-did-document';
 
 interface CacheEntry {
   value: any;
@@ -76,7 +77,7 @@ export class CachedDIDResolver {
     }
 
     console.log('Cache miss, resolving:', did);
-    const result = await this.router.resolve(did);
+    const result = normalizeDIDDocument(await this.router.resolve(did));
 
     await this.setCacheEntry(result.id, {
       value: result,
@@ -90,8 +91,8 @@ export class CachedDIDResolver {
   private async refreshInBackground(did: string): Promise<void> {
     try {
       console.log('Refreshing cache in background for:', did);
-      const result = await this.router.resolve(did);
-      
+      const result = normalizeDIDDocument(await this.router.resolve(did));
+
       await this.setCacheEntry(did, {
         value: result,
         id: did,

package/src/services/blockchain/normalize-did-document.ts

@@ -0,0 +1,73 @@
+// The universal resolver returns cheqd offchain (BBS+) keys as stringified
+// blobs in the relationship arrays instead of objects in verificationMethod,
+// leaving publicKeyBase58 unreachable. Lift them out, matching the on-chain
+// resolver's CheqdDIDDocument.toDIDDocument behaviour.
+
+const RELATIONSHIP_PROPS = [
+  'assertionMethod',
+  'authentication',
+  'capabilityInvocation',
+  'capabilityDelegation',
+  'keyAgreement',
+] as const;
+
+function parseInlineVerificationMethod(entry: string): any | null {
+  let parsed: unknown = entry;
+
+  // cheqd offchain keys are double-JSON-stringified, so unwrap up to twice.
+  for (let i = 0; i < 2 && typeof parsed === 'string'; i++) {
+    try {
+      parsed = JSON.parse(parsed);
+    } catch {
+      return null;
+    }
+  }
+
+  if (parsed && typeof parsed === 'object' && typeof (parsed as any).id === 'string') {
+    return parsed;
+  }
+
+  return null;
+}
+
+export function normalizeDIDDocument(doc: any): any {
+  if (!doc || typeof doc !== 'object') {
+    return doc;
+  }
+
+  const liftedMethods: any[] = [];
+
+  for (const prop of RELATIONSHIP_PROPS) {
+    if (!Array.isArray(doc[prop])) {
+      continue;
+    }
+
+    doc[prop] = doc[prop].map((entry: any) => {
+      if (typeof entry !== 'string') {
+        return entry;
+      }
+
+      const method = parseInlineVerificationMethod(entry);
+      if (!method) {
+        return entry;
+      }
+
+      liftedMethods.push(method);
+      return method.id;
+    });
+  }
+
+  if (liftedMethods.length) {
+    const existing = Array.isArray(doc.verificationMethod)
+      ? doc.verificationMethod
+      : [];
+    const existingIds = new Set(existing.map((method: any) => method?.id));
+    const newMethods = liftedMethods.filter(
+      method => !existingIds.has(method.id),
+    );
+
+    doc.verificationMethod = [...existing, ...newMethods];
+  }
+
+  return doc;
+}

package/src/services/blockchain/service.ts

@@ -236,11 +236,9 @@ export class BlockchainService {
       });
       Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
     } catch (err) {
-      debugger
       Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`, err);
     }
 
-
     // Re-create the resolver with the new blockchain connection
     this._resolver = this.createDIDResolver(true);
 

package/src/services/credential/bbs-revocation.test.js

@@ -0,0 +1,147 @@
+import {initializeWasm} from '@docknetwork/crypto-wasm-ts/lib/index';
+
+const {blockchainService} = require('../blockchain/service');
+const {
+  getWitnessDetails,
+  clearWitnessCache,
+  getWitnessCacheTTL,
+  setWitnessCacheTTL,
+} = require('./bbs-revocation');
+
+const mockAccumulatorResult = {
+  accumulated: {bytes: new Uint8Array([1, 2, 3])},
+  keyRef: ['key1', 1],
+  lastModified: 100,
+};
+
+const mockPublicKeyResult = {
+  bytes: new Uint8Array([4, 5, 6]),
+};
+
+const mockHistoryResult = {
+  updates: [{id: {toString: () => '1'}}],
+};
+
+const createCredential = (statusId = 'dock:accumulator:test-registry-1') => ({
+  credentialStatus: {
+    id: statusId,
+    revocationId: '42',
+  },
+});
+
+const membershipWitness = JSON.stringify({
+  witness: '0xaabbcc',
+  blockNo: '1',
+});
+
+describe('bbs-revocation witness cache', () => {
+  let originalModules;
+  let originalGetTypes;
+
+  beforeAll(async () => {
+    await initializeWasm();
+    originalModules = blockchainService.modules;
+    originalGetTypes = blockchainService.getTypesForDIDOrAccumulator;
+  });
+
+  afterAll(() => {
+    blockchainService.modules = originalModules;
+    blockchainService.getTypesForDIDOrAccumulator = originalGetTypes;
+  });
+
+  beforeEach(() => {
+    clearWitnessCache();
+    setWitnessCacheTTL(120_000); // Enable cache for unit tests
+
+    blockchainService.modules = {
+      accumulator: {
+        getAccumulator: jest.fn().mockResolvedValue(mockAccumulatorResult),
+        getPublicKey: jest.fn().mockResolvedValue(mockPublicKeyResult),
+        accumulatorHistory: jest.fn().mockResolvedValue(mockHistoryResult),
+      },
+    };
+
+    blockchainService.getTypesForDIDOrAccumulator = jest.fn().mockReturnValue({
+      AccumulatorId: {from: jest.fn().mockReturnValue('acc-id')},
+    });
+  });
+
+  it('should call blockchain on first request', async () => {
+    const credential = createCredential();
+    await getWitnessDetails(credential, membershipWitness);
+
+    expect(
+      blockchainService.modules.accumulator.getAccumulator,
+    ).toHaveBeenCalledTimes(1);
+    expect(
+      blockchainService.modules.accumulator.getPublicKey,
+    ).toHaveBeenCalledTimes(1);
+  });
+
+  it('should return cached result on second call with same credential', async () => {
+    const credential = createCredential();
+
+    const result1 = await getWitnessDetails(credential, membershipWitness);
+    const result2 = await getWitnessDetails(credential, membershipWitness);
+
+    expect(result1).toEqual(result2);
+    expect(
+      blockchainService.modules.accumulator.getAccumulator,
+    ).toHaveBeenCalledTimes(1);
+    expect(
+      blockchainService.modules.accumulator.getPublicKey,
+    ).toHaveBeenCalledTimes(1);
+  });
+
+  it('should not share cache between different credentials', async () => {
+    const credential1 = createCredential('dock:accumulator:registry-1');
+    const credential2 = createCredential('dock:accumulator:registry-2');
+
+    await getWitnessDetails(credential1, membershipWitness);
+    await getWitnessDetails(credential2, membershipWitness);
+
+    expect(
+      blockchainService.modules.accumulator.getAccumulator,
+    ).toHaveBeenCalledTimes(2);
+  });
+
+  it('should refresh cache after TTL expires', async () => {
+    const credential = createCredential();
+    const originalTTL = getWitnessCacheTTL();
+
+    await getWitnessDetails(credential, membershipWitness);
+
+    setWitnessCacheTTL(0); // expire immediately
+
+    await getWitnessDetails(credential, membershipWitness);
+
+    expect(
+      blockchainService.modules.accumulator.getAccumulator,
+    ).toHaveBeenCalledTimes(2);
+
+    setWitnessCacheTTL(originalTTL);
+  });
+
+  it('should clear cache when clearWitnessCache is called', async () => {
+    const credential = createCredential();
+
+    await getWitnessDetails(credential, membershipWitness);
+    clearWitnessCache();
+    await getWitnessDetails(credential, membershipWitness);
+
+    expect(
+      blockchainService.modules.accumulator.getAccumulator,
+    ).toHaveBeenCalledTimes(2);
+  });
+
+  it('should bypass cache when credential has no credentialStatus.id', async () => {
+    const credential = {credentialStatus: {id: undefined, revocationId: '42'}};
+
+    await getWitnessDetails(credential, membershipWitness);
+    await getWitnessDetails(credential, membershipWitness);
+
+    expect(
+      blockchainService.modules.accumulator.getAccumulator,
+    ).toHaveBeenCalledTimes(2);
+  });
+});

package/src/services/credential/bbs-revocation.ts

@@ -22,7 +22,14 @@ const trimHexID = id => {
   return id.substr(2);
 };
 
-export const getWitnessDetails = async (credential, _membershipWitness) => {
+const blockchainCache = new Map<string, {data: any; timestamp: number}>();
+let WITNESS_CACHE_TTL = 0; // Disabled — accumulator can change between cache time and verification
+
+export const getWitnessCacheTTL = () => WITNESS_CACHE_TTL;
+export const setWitnessCacheTTL = (ms: number) => { WITNESS_CACHE_TTL = ms; };
+export const clearWitnessCache = () => blockchainCache.clear();
+
+async function fetchBlockchainData(credential, _membershipWitness) {
   let witness = _membershipWitness;
   let blockNo;
 
@@ -34,7 +41,6 @@ export const getWitnessDetails = async (credential, _membershipWitness) => {
 
   const {credentialStatus} = credential;
   const registryId = credentialStatus?.id;
-  const revocationIndex = credentialStatus.revocationId;
 
   const queriedAccumulator =
     await blockchainService.modules.accumulator.getAccumulator(
@@ -46,22 +52,12 @@ export const getWitnessDetails = async (credential, _membershipWitness) => {
     throw new Error('Accumulator not found');
   }
 
-  const accumulator = PositiveAccumulator.fromAccumulated(
-    queriedAccumulator.accumulated.bytes,
-  );
-
-  const encodedRevId = Encoder.defaultEncodeFunc()(revocationIndex.toString());
-
   const publicKey = await blockchainService.modules.accumulator.getPublicKey(
     queriedAccumulator.keyRef[0],
     queriedAccumulator.keyRef[1],
   );
 
-  const params = dockAccumulatorParams();
-  const pk = new AccumulatorPublicKey(publicKey.bytes);
-
-  const membershipWitness = new VBMembershipWitness(hexToU8a(witness));
-
+  let updatedWitness = witness;
   try {
     const credentialStatusId = credential.credentialStatus.id;
     const accumulatorId = blockchainService
@@ -80,6 +76,10 @@ export const getWitnessDetails = async (credential, _membershipWitness) => {
     const nextBlockNo = history.updates[blockNoIndex + 1]?.id?.toString();
 
     if (nextBlockNo) {
+      const revocationIndex = credentialStatus.revocationId;
+      const encodedRevId = Encoder.defaultEncodeFunc()(revocationIndex.toString());
+      const membershipWitness = new VBMembershipWitness(hexToU8a(witness));
+
       await blockchainService.modules.accumulator.updateWitness(
         registryId,
         encodedRevId,
@@ -87,20 +87,67 @@ export const getWitnessDetails = async (credential, _membershipWitness) => {
         nextBlockNo,
         queriedAccumulator.lastModified,
       );
+      updatedWitness = witness;
     }
   } catch (err) {
     console.error(err);
   }
 
   return {
-    encodedRevId,
-    membershipWitness,
-    pk,
-    params,
-    accumulator,
+    accumulatedBytes: queriedAccumulator.accumulated.bytes,
+    publicKeyBytes: publicKey.bytes,
+    witness: updatedWitness,
+  };
+}
+
+export const getWitnessDetails = async (credential, _membershipWitness) => {
+  const cacheKey = credential?.credentialStatus?.id;
+  let rawData;
+
+  if (cacheKey) {
+    const cached = blockchainCache.get(cacheKey);
+    if (cached) {
+      if (Date.now() - cached.timestamp < WITNESS_CACHE_TTL) {
+        rawData = cached.data;
+      } else {
+        blockchainCache.delete(cacheKey);
+      }
+    }
+  }
+
+  if (!rawData) {
+    rawData = await fetchBlockchainData(credential, _membershipWitness);
+    if (cacheKey) {
+      blockchainCache.set(cacheKey, {data: rawData, timestamp: Date.now()});
+    }
+  }
+
+  const {credentialStatus} = credential;
+  const revocationIndex = credentialStatus.revocationId;
+
+  return {
+    encodedRevId: Encoder.defaultEncodeFunc()(revocationIndex.toString()),
+    membershipWitness: new VBMembershipWitness(hexToU8a(rawData.witness)),
+    pk: new AccumulatorPublicKey(rawData.publicKeyBytes),
+    params: dockAccumulatorParams(),
+    accumulator: PositiveAccumulator.fromAccumulated(rawData.accumulatedBytes),
   };
 };
 
+export const prefetchWitnessCache = async (credential, _membershipWitness) => {
+  const cacheKey = credential?.credentialStatus?.id;
+  if (!cacheKey || !_membershipWitness) {
+    return;
+  }
+
+  try {
+    const rawData = await fetchBlockchainData(credential, _membershipWitness);
+    blockchainCache.set(cacheKey, {data: rawData, timestamp: Date.now()});
+  } catch (err) {
+    console.warn('Failed to prefetch witness cache:', err.message);
+  }
+};
+
 export const getIsRevoked = async (credential, _membershipWitness) => {
   const {encodedRevId, membershipWitness, pk, params, accumulator} =
     await getWitnessDetails(credential, _membershipWitness);

package/src/services/credential/config.ts

@@ -40,6 +40,13 @@ export const validation = {
       'publicKeyBase58 is not present',
     );
   },
+  generatePresentationFromPex: params => {
+    const {credentials, pexRequest, challenge} = params;
+    assert(Array.isArray(credentials), 'invalid credentials');
+    assert(credentials.length > 0, 'no credential found');
+    assert(pexRequest, 'pexRequest is required');
+    assert(challenge, 'challenge is required');
+  },
   createPresentation: params => {
     const {credentials, keyDoc, challenge, id} = params;
     assert(typeof id === 'string', 'invalid id');