@docknetwork/wallet-sdk-wasm 1.5.10 → 1.5.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@docknetwork/wallet-sdk-wasm",
-    "version": "1.5.10",
+    "version": "1.5.14",
     "license": "https://github.com/docknetwork/react-native-sdk/LICENSE",
     "repository": {
         "type": "git",
@@ -19,13 +19,13 @@
         "p-limit": "2.3.0",
         "@astronautlabs/jsonpath": "^1.1.2",
         "@docknetwork/universal-wallet": "^2.0.1",
-        "@docknetwork/wallet-sdk-dids": "^1.5.10",
+        "@docknetwork/wallet-sdk-dids": "^1.5.14",
         "@cosmjs/proto-signing": "^0.32.4",
-        "@docknetwork/cheqd-blockchain-api": "0.36.1",
-        "@docknetwork/cheqd-blockchain-modules": "0.33.0",
+        "@docknetwork/cheqd-blockchain-api": "4.0.3",
+        "@docknetwork/cheqd-blockchain-modules": "4.0.3",
         "@scure/bip39": "^1.6.0",
         "@noble/hashes": "1.8.0",
-        "@docknetwork/credential-sdk": "0.50.0",
+        "@docknetwork/credential-sdk": "0.54.3",
         "@sphereon/oid4vci-client": "^0.16.0",
         "@sphereon/oid4vci-common": "^0.16.0",
         "axios": "^0.25.0",

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

@@ -40,4 +40,8 @@ export class BlockchainServiceRpc extends RpcService {
   getAddress(): Promise<string> {
     return this.call('getAddress');
   }
+
+  resolveDID(did: string): Promise<any> {
+    return this.call('resolveDID', did);
+  }
 }

package/src/services/blockchain/service.ts

@@ -75,7 +75,7 @@ export class BlockchainService {
    * @returns
    */
   async ensureBlockchainReady() {
-    if (this.isBlockchainReady) {
+    if (await this.isApiConnected()) {
       return;
     }
 
@@ -132,9 +132,7 @@ export class BlockchainService {
       });
       Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
     } catch (err) {
-      console.error(err);
-      debugger;
-      Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`);
+      Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`, err);
     }
 
 
@@ -178,6 +176,9 @@ export class BlockchainService {
     });
   }
 
+  async resolveDID(did: string) {
+    return this.resolver.resolve(did);
+  }
   /**
    *
    * @returns

package/src/services/credential/pex-helpers.js

@@ -60,6 +60,17 @@ function getAttributeName({field, selectedCredentials, index}) {
   return attributeName;
 }
 
+/**
+ * Convert PEX request to bounds for each descriptor
+ * @param {*} pexRequest - The PEX request object containing input descriptors and constraints
+ * @param {*} selectedCredentials  - Array of selected credentials corresponding to the input descriptors
+ * @param {*} removeFromRequest - if true, removes range proofs fields from the request. it might be dangerous if you will be using the proof request later
+ *  because it will not have the range proofs fields anymore.
+ * @returns {Array} - Array of bounds for each descriptor, where each bound is an object with attributeName, min, and max
+ * @throws {Error} - If a field path is missing or empty
+ * @throws {Error} - If an unsupported format or type is encountered
+ * @throws {Error} - If a selected credential is expected but not found at the given index
+ */
 export function pexToBounds(
   pexRequest,
   selectedCredentials = [],
@@ -162,6 +173,9 @@ export function pexToBounds(
             : formatMinimum
           : minimum;
 
+      const proofRequestMax = max;
+      const proofRequestMin = min;
+
       if (max === undefined && min === undefined) {
         return;
       }
@@ -236,6 +250,10 @@ export function pexToBounds(
         attributeName,
         min,
         max,
+        proofRequestMax,
+        proofRequestMin,
+        format,
+        type,
       });
     });
 
@@ -258,9 +276,10 @@ const attributesToSkip = [
   /^@context/,
   /^proof/,
   /^credentialSchema/,
+  /^issuanceDate/,
 ];
 
-const shouldSkipAttribute = attributeName =>
+export const shouldSkipAttribute = attributeName =>
   attributesToSkip.some(regex => regex.test(attributeName));
 
 export function getPexRequiredAttributes(pexRequest, selectedCredentials = []) {

package/src/services/credential/pex-helpers.test.js

@@ -230,6 +230,31 @@ describe('pex helpers', () => {
 
       expect(result).toEqual(['credentialSubject.id']);
     });
+
+    it('should skip issuanceDate', () => {
+      const result = getPexRequiredAttributes(
+        {
+          id: 'test-issuanceDate',
+          input_descriptors: [
+            {
+              constraints: {
+                fields: [
+                  {
+                    path: ['$.issuanceDate'],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+        [
+          {
+            issuanceDate: '2021-01-01',
+          },
+        ],
+      );
+      expect(result).toEqual([]);
+    });
   });
 
   describe('pexToBounds', () => {
@@ -278,11 +303,19 @@ describe('pex helpers', () => {
             attributeName: 'credentialSubject.age',
             min: 0,
             max: 10000000000,
+            proofRequestMax: undefined,
+            proofRequestMin: 0,
+            format: undefined,
+            type: 'number',
           },
           {
             attributeName: 'credentialSubject.dateOfBirth',
             min: new Date('2021-01-01'),
             max: new Date(884541351600000),
+            proofRequestMax: undefined,
+            proofRequestMin: '2021-01-01',
+            format: 'date',
+            type: undefined,
           },
         ],
       ]);
@@ -325,6 +358,10 @@ describe('pex helpers', () => {
             attributeName: 'credentialSubject.age',
             min: 0,
             max: 10000000000,
+            proofRequestMax: undefined,
+            proofRequestMin: 0,
+            format: undefined,
+            type: 'number',
           },
         ],
       ]);
@@ -361,6 +398,10 @@ describe('pex helpers', () => {
             attributeName: 'expirationDate',
             min: new Date('2021-01-01T00:00:00Z'),
             max: new Date('2022-01-01T00:00:00Z'),
+            proofRequestMax: '2022-01-01T00:00:00Z',
+            proofRequestMin: '2021-01-01T00:00:00Z',
+            format: 'date-time',
+            type: undefined,
           },
         ],
       ]);
@@ -398,6 +439,10 @@ describe('pex helpers', () => {
             attributeName: 'amount',
             min: 0,
             max: 100,
+            proofRequestMax: 100,
+            proofRequestMin: 0,
+            format: undefined,
+            type: 'number',
           },
         ],
       ]);
@@ -444,11 +489,19 @@ describe('pex helpers', () => {
             attributeName: 'startDate',
             min: new Date('2021-01-01'),
             max: new Date('2022-01-01'),
+            proofRequestMax: '2022-01-01',
+            proofRequestMin: '2021-01-01',
+            format: 'date',
+            type: undefined,
           },
           {
             attributeName: 'amount',
             min: 0,
             max: 100,
+            proofRequestMax: 100,
+            proofRequestMin: 0,
+            format: undefined,
+            type: 'number',
           },
         ],
       ]);
@@ -464,6 +517,67 @@ describe('pex helpers', () => {
       expect(bounds).toEqual([]);
     });
 
+    it('should preserve original proof request values in new metadata fields', () => {
+      const pexRequest = {
+        input_descriptors: [
+          {
+            constraints: {
+              fields: [
+                {
+                  filter: {
+                    type: 'number',
+                    minimum: 18,
+                    maximum: 65,
+                  },
+                  path: ['$.credentialSubject.age'],
+                },
+                {
+                  filter: {
+                    format: 'date',
+                    formatMinimum: '2020-01-01',
+                    formatMaximum: '2025-12-31',
+                  },
+                  path: ['$.credentialSubject.graduationDate'],
+                },
+              ],
+            },
+          },
+        ],
+      };
+
+      const bounds = pexToBounds(pexRequest, [
+        {
+          credentialSubject: {
+            age: 25,
+            graduationDate: '2023-06-15',
+          },
+        },
+      ]);
+
+      expect(bounds).toEqual([
+        [
+          {
+            attributeName: 'credentialSubject.age',
+            min: 18,
+            max: 65,
+            proofRequestMax: 65,
+            proofRequestMin: 18,
+            format: undefined,
+            type: 'number',
+          },
+          {
+            attributeName: 'credentialSubject.graduationDate',
+            min: new Date('2020-01-01'),
+            max: new Date('2025-12-31'),
+            proofRequestMax: '2025-12-31',
+            proofRequestMin: '2020-01-01',
+            format: 'date',
+            type: undefined,
+          },
+        ],
+      ]);
+    });
+
     it('should not have undefined attributeNames, exclude not found bounds', () => {
       const pexRequest = {
         id: '3cb2c1db-54d7-427a-a6a2-4b8f73a33700',

package/src/services/credential/service.ts

@@ -29,7 +29,7 @@ import {
 import assert from 'assert';
 import axios from 'axios';
 import {getIsRevoked, getWitnessDetails} from './bbs-revocation';
-import {getPexRequiredAttributes} from './pex-helpers';
+import {getPexRequiredAttributes, shouldSkipAttribute} from './pex-helpers';
 import {didService} from '../dids/service';
 
 const pex: PEX = new PEX();
@@ -397,7 +397,7 @@ class CredentialService {
         ? descriptorBounds[idx].map(bound => bound.attributeName)
         : [];
       const filteredAttributes = attributesToReveal.filter(
-        attribute => !attributesToSkip.includes(attribute),
+        attribute => !attributesToSkip.includes(attribute) && !shouldSkipAttribute(attribute),
       );
       const _pexRequiredAttributes = pexRequiredAttributes[idx] || [];
 

package/src/services/credential/utils.js

@@ -5,10 +5,10 @@ import {
   Bls12381BBDT16KeyPairDock2024,
 } from '@docknetwork/credential-sdk/vc/crypto';
 import {randomAsHex} from '@docknetwork/credential-sdk/utils';
-import x25519KeyAgreementKey2020 from '@digitalbazaar/x25519-key-agreement-key-2020';
-import x25519KeyAgreementKey2019 from '@digitalbazaar/x25519-key-agreement-key-2019';
-import ed25519VerificationKey2018 from '@digitalbazaar/ed25519-verification-key-2018';
-import ed25519VerificationKey2020 from '@digitalbazaar/ed25519-verification-key-2020';
+import {X25519KeyAgreementKey2020} from '@digitalbazaar/x25519-key-agreement-key-2020';
+import {X25519KeyAgreementKey2019} from '@digitalbazaar/x25519-key-agreement-key-2019';
+import {Ed25519VerificationKey2018} from '@digitalbazaar/ed25519-verification-key-2018';
+import {Ed25519VerificationKey2020} from '@digitalbazaar/ed25519-verification-key-2020';
 
 import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
 
@@ -62,13 +62,13 @@ export async function keyDocToKeypair(keyDoc) {
 
 const keyConstructors = {
   Ed25519VerificationKey2018: keypairOptions =>
-    new ed25519VerificationKey2018.Ed25519VerificationKey2018(keypairOptions),
+    new Ed25519VerificationKey2018(keypairOptions),
   Ed25519VerificationKey2020: keypairOptions =>
-    new ed25519VerificationKey2020.Ed25519VerificationKey2020(keypairOptions),
+    new Ed25519VerificationKey2020(keypairOptions),
   X25519KeyAgreementKey2019: keypairOptions =>
-    new x25519KeyAgreementKey2019.X25519KeyAgreementKey2019(keypairOptions),
+    new X25519KeyAgreementKey2019(keypairOptions),
   X25519KeyAgreementKey2020: keypairOptions =>
-    new x25519KeyAgreementKey2020.X25519KeyAgreementKey2020(keypairOptions),
+    new X25519KeyAgreementKey2020(keypairOptions),
 };
 
 export function getKeypairFromDoc(keypairOptions) {

package/src/services/dids/index.test.js

@@ -3,7 +3,6 @@ import {DIDServiceRPC} from './service-rpc';
 import {didService as service} from './service';
 import {validation} from './config';
 import {DIDKeyManager} from '@docknetwork/wallet-sdk-dids/src';
-import {blockchainService} from '../blockchain/service';
 import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
 
 describe('DID Service', () => {
@@ -93,19 +92,6 @@ describe('DID Service', () => {
     spy.mockReset();
   });
 
-  it('expect to get did document', async () => {
-    const document = 'document';
-    jest
-      .spyOn(blockchainService.modules.did, 'getDocument')
-      .mockResolvedValue(document);
-
-    const result = await service.getDidDockDocument(
-      'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQi',
-    );
-
-    expect(result).toStrictEqual(document);
-  });
-
   it('expect to generateKeyDoc without keyPair', async () => {
     const controller =
       'did:dock:5HL5XB7CHcHT2ZUKjY2SCJvDAK11qoa1exgfVnVTHRbmjJQ';
@@ -131,4 +117,41 @@ describe('DID Service', () => {
     expect(derivedKeyDoc.controller).toEqual(controller);
     expect(derivedKeyDoc.privateKeyMultibase).toBeDefined();
   });
+
+  it('expect to createSignedJWT', async () => {
+    const headerInput = {
+      typ: 'openid4vci-proof+jwt',
+      alg: 'EdDSA',
+      kid: 'did:key:z6MkjW3DVk4mXjnK8GUuK2SydyFg8oMJbUnHiVzzSz3N9iGM#z6MkjW3DVk4mXjnK8GUuK2SydyFg8oMJbUnHiVzzSz3N9iGM',
+    };
+
+    const payload = {
+      aud: 'https://api.truvera.io/openid/issuers/d044f3d3-0934-4f62-9b6f-6f06ae8f383e',
+      iat: 1750356930,
+      exp: 1750357590,
+      iss: 'dock.wallet',
+    };
+
+    const privateKeyDoc = {
+      controller: 'did:key:z6MkjW3DVk4mXjnK8GUuK2SydyFg8oMJbUnHiVzzSz3N9iGM',
+      type: 'Ed25519VerificationKey2018',
+      id: 'did:key:z6MkjW3DVk4mXjnK8GUuK2SydyFg8oMJbUnHiVzzSz3N9iGM#z6MkjW3DVk4mXjnK8GUuK2SydyFg8oMJbUnHiVzzSz3N9iGM',
+      publicKeyMultibase: 'z6MkjW3DVk4mXjnK8GUuK2SydyFg8oMJbUnHiVzzSz3N9iGM',
+      privateKeyMultibase:
+        'zruzuEmC9VrJ3JUcufskfX4qNKwqqrNDztqJsDp1dXXQFS8CkfEDqK1ZBgNXeWF9xGhAPeVVfV1vL5pVaHpXLU2JwXK',
+      privateKeyBase58:
+        'GLkPGM4hz3AhQkQA1y63PtxdA3GL4vJiWgYpnB4N1sFi2wzr2tDbc482igkKaDcAwbrhe92LKJygEHd5xmBJtvR',
+      publicKeyBase58: '63nAuVpLCCHr1meCdTV8nshgKE5TBbXw2V64ci5MEVUy',
+      '@context': ['https://w3id.org/wallet/v1'],
+    };
+
+    const signedJWT = await service.createSignedJWT({
+      payload,
+      privateKeyDoc,
+      headerInput,
+    });
+
+    expect(signedJWT).toBeDefined();
+    expect(signedJWT).toContain('.');
+  });
 });

package/src/services/dids/service-rpc.ts

@@ -21,9 +21,6 @@ export class DIDServiceRPC extends RpcService {
   deriveKeyDoc(params) {
     return this.call('deriveKeyDoc', params);
   }
-  getDidDockDocument(did) {
-    return this.call('getDidDockDocument', did);
-  }
   createSignedJWT(params) {
     return this.call('createSignedJWT', params);
   }

package/src/services/dids/service.ts

@@ -29,7 +29,7 @@ import { keypairToKeydoc } from './keypair-utils';
 
 async function getSignerKeypair(privateKeyDoc) {
   const privateKey =
-    privateKeyDoc.keypair || keyDocToKeypair(privateKeyDoc, blockchainService.dock);
+    privateKeyDoc.keypair || await keyDocToKeypair(privateKeyDoc);
 
   if (!privateKey.signer && privateKey.sign) {
     privateKey.signer = () => ({sign: ({data}) => privateKey.sign(data)});
@@ -66,7 +66,6 @@ class DIDService {
     DIDService.prototype.getDIDResolution,
     DIDService.prototype.generateKeyDoc,
     DIDService.prototype.deriveKeyDoc,
-    DIDService.prototype.getDidDockDocument,
     DIDService.prototype.createSignedJWT,
   ];
   keypairToDIDKeyDocument(params: KeypairToDIDKeyDocumentParams) {
@@ -114,13 +113,6 @@ class DIDService {
     const signature = await sign({data: signPayload});
     return `${headerAndPayloadBase64URL}.${base64url.encode(signature)}`;
   }
-
-  async getDidDockDocument(did) {
-    assert(!!did, 'DID is required');
-    const dock = blockchainService.dock;
-    const result = await blockchainService.modules.did.getDocument(did);
-    return result;
-  }
 }
 
 export const didService = new DIDService();

package/src/services/util-crypto/service-rpc.js

@@ -18,16 +18,11 @@ export class UtilCryptoServiceRpc extends RpcService {
     return this.call('mnemonicToMiniSecret', phrase);
   }
 
-  deriveValidate(uri: string): Promise<any> {
-    validation.deriveValidate(uri);
-    return this.call('deriveValidate', uri);
-  }
-
   isBase64(value: string): Promise<boolean> {
     return this.call('isBase64', value);
   }
 
-  getAddressPrefix(params: any): Promise<number | null> {
-    return this.call('getAddressPrefix', params);
+  hexToString(hex: string): Promise<string> {
+    return this.call('hexToString', hex);
   }
 }