@docknetwork/wallet-sdk-wasm 1.4.0 → 1.5.0

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

@@ -196,6 +196,40 @@ describe('pex helpers', () => {
       ]);
       expect(result.length).toBe(1);
     });
+
+    it('should not include fields marked as optional', () => {
+      const result = getPexRequiredAttributes(
+        {
+          id: 'test-optional',
+          input_descriptors: [
+            {
+              id: 'Credential Optional',
+              constraints: {
+                fields: [
+                  {
+                    path: ['$.credentialSubject.id'],
+                  },
+                  {
+                    path: ['$.credentialSubject.optionalField'],
+                    optional: true,
+                  },
+                ],
+              },
+            },
+          ],
+        },
+        [
+          {
+            credentialSubject: {
+              id: 'abc',
+              optionalField: 'shouldNotAppear',
+            },
+          },
+        ],
+      )[0];
+
+      expect(result).toEqual(['credentialSubject.id']);
+    });
   });
 
   describe('pexToBounds', () => {
@@ -210,14 +244,14 @@ describe('pex helpers', () => {
                     type: 'number',
                     minimum: 0,
                   },
-                  path: ['$.age'],
+                  path: ['$.credentialSubject.age'],
                 },
                 {
                   filter: {
                     format: 'date',
                     minimum: '2021-01-01',
                   },
-                  path: ['$.dateOfBirth'],
+                  path: ['$.credentialSubject.dateOfBirth'],
                 },
               ],
             },
@@ -225,23 +259,30 @@ describe('pex helpers', () => {
         ],
       };
 
-      const bounds = pexToBounds(pexRequest);
+      const bounds = pexToBounds(pexRequest, [
+        {
+          credentialSubject: {
+            age: 10000000000,
+          },
+        },
+        {
+          credentialSubject: {
+            dateOfBirth: '2021-01-01',
+          },
+        },
+      ]);
 
       expect(bounds).toEqual([
         [
           {
-            attributeName: 'age',
+            attributeName: 'credentialSubject.age',
             min: 0,
-            max: 1000000000000000000,
-            type: 'number',
-            format: undefined,
+            max: 10000000000,
           },
           {
-            attributeName: 'dateOfBirth',
+            attributeName: 'credentialSubject.dateOfBirth',
             min: new Date('2021-01-01'),
             max: new Date(884541351600000),
-            type: undefined,
-            format: 'date',
           },
         ],
       ]);
@@ -258,7 +299,7 @@ describe('pex helpers', () => {
                     type: 'number',
                     minimum: 0,
                   },
-                  path: ['$.age'],
+                  path: ['$.credentialSubject.age'],
                 },
               ],
             },
@@ -266,16 +307,24 @@ describe('pex helpers', () => {
         ],
       };
 
-      const bounds = pexToBounds(pexRequest, [], true);
+      const bounds = pexToBounds(
+        pexRequest,
+        [
+          {
+            credentialSubject: {
+              age: 2,
+            },
+          },
+        ],
+        true,
+      );
 
       expect(bounds).toEqual([
         [
           {
-            attributeName: 'age',
+            attributeName: 'credentialSubject.age',
             min: 0,
-            max: undefined,
-            type: 'number',
-            format: undefined,
+            max: 10000000000,
           },
         ],
       ]);
@@ -300,7 +349,11 @@ describe('pex helpers', () => {
         ],
       };
 
-      const bounds = pexToBounds(pexRequest);
+      const bounds = pexToBounds(pexRequest, [
+        {
+          expirationDate: '2021-01-01',
+        },
+      ]);
 
       expect(bounds).toEqual([
         [
@@ -308,8 +361,6 @@ describe('pex helpers', () => {
             attributeName: 'expirationDate',
             min: new Date('2021-01-01T00:00:00Z'),
             max: new Date('2022-01-01T00:00:00Z'),
-            type: undefined,
-            format: 'date-time',
           },
         ],
       ]);
@@ -335,7 +386,11 @@ describe('pex helpers', () => {
         ],
       };
 
-      const bounds = pexToBounds(pexRequest);
+      const bounds = pexToBounds(pexRequest, [
+        {
+          amount: 10,
+        },
+      ]);
 
       expect(bounds).toEqual([
         [
@@ -343,8 +398,6 @@ describe('pex helpers', () => {
             attributeName: 'amount',
             min: 0,
             max: 100,
-            type: 'number',
-            format: undefined,
           },
         ],
       ]);
@@ -378,7 +431,12 @@ describe('pex helpers', () => {
         ],
       };
 
-      const bounds = pexToBounds(pexRequest);
+      const bounds = pexToBounds(pexRequest, [
+        {
+          amount: 10,
+          date: '2021-01-01',
+        },
+      ]);
 
       expect(bounds).toEqual([
         [
@@ -386,15 +444,11 @@ describe('pex helpers', () => {
             attributeName: 'startDate',
             min: new Date('2021-01-01'),
             max: new Date('2022-01-01'),
-            type: undefined,
-            format: 'date',
           },
           {
             attributeName: 'amount',
             min: 0,
             max: 100,
-            type: 'number',
-            format: undefined,
           },
         ],
       ]);
@@ -409,5 +463,208 @@ describe('pex helpers', () => {
 
       expect(bounds).toEqual([]);
     });
+
+    it('should not have undefined attributeNames, exclude not found bounds', () => {
+      const pexRequest = {
+        id: '3cb2c1db-54d7-427a-a6a2-4b8f73a33700',
+        input_descriptors: [
+          {
+            id: 'Credential 1',
+            name: 'Mortgage Application Qualification',
+            group: ['A'],
+            purpose:
+              'Proof of assets (>100k), employment, and credit score (>800)',
+            constraints: {
+              fields: [
+                {
+                  path: ['$.credentialSubject.id'],
+                  optional: true,
+                },
+                {
+                  path: ['$.credentialSchema.id'],
+                  filter: {
+                    const:
+                      'https://schema.dock.io/ProofOfEmployment-V1-1703767227542.json',
+                  },
+                },
+                {
+                  path: ['$.expirationDate', '$.vc.expirationDate'],
+                  filter: {
+                    type: 'string',
+                    format: 'date-time',
+                    formatMinimum: '2024-12-10T00:00:00.000Z',
+                  },
+                  optional: true,
+                  predicate: 'required',
+                },
+              ],
+            },
+          },
+          {
+            id: 'Credential 2',
+            name: 'Mortgage Application Qualification',
+            group: ['A'],
+            purpose:
+              'Proof of assets (>100k), employment, and credit score (>800)',
+            constraints: {
+              fields: [
+                {
+                  path: ['$.credentialSubject.id'],
+                  optional: true,
+                },
+                {
+                  path: ['$.expirationDate'],
+                  optional: true,
+                },
+                {
+                  path: ['$.credentialSchema.id'],
+                  filter: {
+                    const:
+                      'https://schema.dock.io/CreditScore-V1-1732907844039.json',
+                  },
+                },
+                {
+                  path: ['$.credentialSubject.creditScore'],
+                  filter: {
+                    type: 'number',
+                    minimum: 800,
+                  },
+                  predicate: 'required',
+                },
+              ],
+            },
+          },
+          {
+            id: 'Credential 3',
+            name: 'Mortgage Application Qualification',
+            group: ['A'],
+            purpose:
+              'Proof of assets (>100k), employment, and credit score (>800)',
+            constraints: {
+              fields: [
+                {
+                  path: ['$.credentialSubject.id'],
+                  optional: true,
+                },
+                {
+                  path: ['$.expirationDate'],
+                  optional: true,
+                },
+                {
+                  path: ['$.credentialSchema.id'],
+                  filter: {
+                    const:
+                      'https://schema.dock.io/ProofOfAssets-V1-1733843536548.json',
+                  },
+                },
+                {
+                  path: ['$.credentialSubject.sIN'],
+                  optional: true,
+                },
+                {
+                  path: ['$.credentialSubject.name'],
+                  optional: true,
+                },
+                {
+                  path: ['$.credentialSubject.propertiesOwned'],
+                  filter: {
+                    type: 'number',
+                    minimum: 1,
+                  },
+                  predicate: 'required',
+                },
+                {
+                  path: ['$.credentialSubject.totalPropertyAssetValue'],
+                  filter: {
+                    type: 'number',
+                    minimum: 100000,
+                  },
+                  predicate: 'required',
+                },
+              ],
+            },
+          },
+        ],
+        submission_requirements: [
+          {
+            from: 'A',
+            name: 'Multi Credential Request',
+            rule: 'pick',
+            count: 1,
+          },
+        ],
+      };
+
+      const bounds = pexToBounds(pexRequest, [
+        {
+          '@context': [
+            'https://www.w3.org/2018/credentials/v1',
+            'https://ld.dock.io/credentials/extensions-v1',
+            'https://ld.dock.io/security/bbs23/v1',
+            {
+              CreditScore: 'dk:CreditScore',
+              bankruptcies: 'dk:bankruptcies',
+              creditScore: 'dk:creditScore',
+              dk: 'https://ld.dock.io/credentials#',
+            },
+          ],
+          credentialStatus: {
+            id: 'dock:accumulator:0xb803980eb9433bb5d5d433f60c08fcd17e82eb2eb8ae3ac88fef79a3fb2f5fd9',
+            type: 'DockVBAccumulator2022',
+            revocationCheck: 'membership',
+            revocationId: '7',
+          },
+          id: 'https://creds-testnet.dock.io/15ca3b92504514756671ab5377ef23f7407f1c26c692b60363c97ba4775abab3',
+          type: ['VerifiableCredential', 'CreditScore'],
+          credentialSubject: {
+            name: 'tester',
+            creditScore: 800,
+            bankruptcies: 0,
+          },
+          issuanceDate: '2024-12-13T12:43:20.925Z',
+          issuer: {
+            name: 'CIBC',
+            description: 'CIBC - a bank',
+            logo: 'https://img.dock.io/e5715cbf78f2222924f5fe4e109d76a5',
+            id: 'did:dock:5CwdfTvda68vfdLu4yxNRFHuhdiXDzqLxw5TkoMfX6sC784a',
+          },
+          credentialSchema: {
+            id: 'https://schema.dock.io/CreditScore-V1-1732907844039.json',
+            type: 'JsonSchemaValidator2018',
+            details:
+              '{"jsonSchema":{"$id":"https://schema.dock.io/CreditScore-V1-1732907844039.json","$schema":"http://json-schema.org/draft-07/schema#","additionalProperties":true,"description":"Proof of Credit","name":"Credit Score","properties":{"@context":{"type":"string"},"credentialSchema":{"properties":{"details":{"type":"string"},"id":{"type":"string"},"type":{"type":"string"},"version":{"type":"string"}},"type":"object"},"credentialStatus":{"properties":{"id":{"type":"string"},"revocationCheck":{"type":"string"},"revocationId":{"type":"string"},"type":{"type":"string"}},"type":"object"},"credentialSubject":{"properties":{"bankruptcies":{"description":"How many times have you declared bankruptcy","title":"Bankruptcies","type":"integer"},"creditScore":{"description":"","title":"Credit Score","type":"number"},"name":{"description":"Name of individual","title":"Name","type":"string"}},"required":["creditScore","bankruptcies","name"],"type":"object"},"cryptoVersion":{"type":"string"},"id":{"type":"string"},"issuanceDate":{"format":"date-time","type":"string"},"issuer":{"properties":{"description":{"type":"string"},"id":{"type":"string"},"logo":{"type":"string"},"name":{"type":"string"}},"type":"object"},"name":{"type":"string"},"proof":{"properties":{"@context":{"items":[{"properties":{"proof":{"properties":{"@container":{"type":"string"},"@id":{"type":"string"},"@type":{"type":"string"}},"type":"object"},"sec":{"type":"string"}},"type":"object"},{"type":"string"}],"type":"array"},"created":{"format":"date-time","type":"string"},"proofPurpose":{"type":"string"},"type":{"type":"string"},"verificationMethod":{"type":"string"}},"type":"object"},"type":{"type":"string"}},"type":"object"},"parsingOptions":{"defaultDecimalPlaces":4,"defaultMinimumDate":-17592186044415,"defaultMinimumInteger":-4294967295,"useDefaults":true}}',
+            version: '0.4.0',
+          },
+          name: 'Credit Score',
+          cryptoVersion: '0.6.0',
+          proof: {
+            '@context': [
+              {
+                sec: 'https://w3id.org/security#',
+                proof: {
+                  '@id': 'sec:proof',
+                  '@type': '@id',
+                  '@container': '@graph',
+                },
+              },
+              'https://ld.dock.io/security/bbs23/v1',
+            ],
+            type: 'Bls12381BBSSignatureDock2023',
+            created: '2024-12-13T12:43:42Z',
+            verificationMethod:
+              'did:dock:5CwdfTvda68vfdLu4yxNRFHuhdiXDzqLxw5TkoMfX6sC784a#keys-2',
+            proofPurpose: 'assertionMethod',
+            proofValue:
+              'z2PyUbLtaHuMbrdJagELMtFqroKXSoxtMaKLshc3PvT7VXpCHWWeeDMkvGf8MoKjjhNfwGPEXn9zYZuyZv7JGETWXs2TU2aSaKAHkvcmnVXcu8D',
+          },
+        },
+      ]);
+
+      bounds.forEach(() => {
+        expect(
+          bounds[0].every(bound => bound.attributeName !== undefined),
+        ).toBe(true);
+      });
+    });
   });
 });

package/src/services/credential/service.ts

@@ -2,24 +2,24 @@
 import {serviceName, validation} from './config';
 import {
   Accumulator,
-  PositiveAccumulator,
-  dockAccumulatorParams,
   VB_ACCUMULATOR_22 as AccumulatorType,
   WitnessUpdatePublicInfo,
   MembershipWitness,
 } from '@docknetwork/crypto-wasm-ts';
 import {OpenID4VCIClientV1_0_13} from '@sphereon/oid4vci-client';
 import {Alg} from '@sphereon/oid4vci-common';
-import {getDockRevIdFromCredential} from '@docknetwork/sdk/utils/revocation';
-import VerifiableCredential from '@docknetwork/sdk/verifiable-credential';
 import {getKeypairFromDoc} from '@docknetwork/universal-wallet/methods/keypairs';
-import {getSuiteFromKeyDoc} from '@docknetwork/sdk/utils/vc/helpers';
-import VerifiablePresentation from '@docknetwork/sdk/verifiable-presentation';
-import Presentation from '@docknetwork/sdk/presentation';
-import {verifyCredential} from '@docknetwork/sdk/utils/vc/credentials';
+import {
+  VerifiablePresentation,
+  Presentation,
+  verifyCredential,
+  verifyPresentation,
+  VerifiableCredential,
+  getSuiteFromKeyDoc,
+} from '@docknetwork/credential-sdk/vc';
 import {PEX} from '@sphereon/pex';
 import {keyDocToKeypair} from './utils';
-import {dockService, getDock} from '../dock/service';
+import {blockchainService, getDock} from '../blockchain/service';
 import {
   applyEnforceBounds,
   hasProvingKey,
@@ -117,20 +117,25 @@ class CredentialService {
       vp.setHolder(keyDoc.controller);
     }
 
-    keyDoc.keypair = keyDocToKeypair(keyDoc, getDock());
+    keyDoc.keypair = keyDocToKeypair(keyDoc, blockchainService.dock);
 
     if (shouldSkipSigning) {
       return vp.toJSON();
     }
 
-    return vp.sign(keyDoc, challenge, domain, dockService.resolver);
+    return vp.sign(keyDoc, challenge, domain, blockchainService.resolver);
+  }
+
+  async verifyPresentation({ presentation, options }: any) {
+    return verifyPresentation(presentation, options);
   }
+
   async verifyCredential(params) {
     validation.verifyCredential(params);
     const {credential, membershipWitness} = params;
     const result = await verifyCredential(credential, {
-      resolver: dockService.resolver,
-      revocationApi: {dock: getDock()},
+      resolver: blockchainService.resolver,
+      revocationApi: {dock: blockchainService.dock},
     });
 
     const {credentialStatus} = credential;
@@ -191,15 +196,9 @@ class CredentialService {
     uri: string;
     authorizationCode?: string;
     holderKeyDocument: any;
-  }) {
+  }): Promise<any> {
     const searchParams = new URL(uri).searchParams;
     const params = new URLSearchParams(searchParams);
-    const credentialOfferEncoded = params.get('credential_offer');
-    const credentialOfferDecoded = decodeURIComponent(credentialOfferEncoded);
-    const credentialOffer = JSON.parse(credentialOfferDecoded);
-    const scope = credentialOffer.credentials[0];
-    const format = 'ldp_vc';
-    const credentialTypes = scope.replace('ldp_vc:', '');
 
     const client = await OpenID4VCIClientV1_0_13.fromURI({
       uri: uri,
@@ -207,10 +206,14 @@ class CredentialService {
       authorizationRequest: {
         redirectUri: 'dock-wallet://credentials/callback',
         clientId: 'dock.wallet',
-        scope: credentialOffer.credentials[0],
       },
     });
 
+    const format = 'ldp_vc';
+    const { scope }  = client.getCredentialsSupported()[0];
+    const scopeSplit = scope.split(':');
+    const credentialTypes = scopeSplit[scopeSplit.length - 1];
+
     let code;
 
     if (client.credentialOffer?.preAuthorizedCode) {
@@ -229,7 +232,6 @@ class CredentialService {
       code,
     });
 
-
     try {
       const response = await client.acquireCredentials({
         credentialTypes,
@@ -245,6 +247,7 @@ class CredentialService {
             return jwt;
           },
         },
+        context: 'truverawallet',
         format: format,
         alg: Alg.EdDSA,
         kid: holderKeyDocument.id,
@@ -265,7 +268,7 @@ class CredentialService {
     const bbsPlusPresentation = new Presentation();
     for (const {credential, attributesToReveal} of credentials) {
       const idx = await bbsPlusPresentation.addCredentialToPresent(credential, {
-        resolver: dockService.resolver,
+        resolver: blockchainService.resolver,
       });
       if (Array.isArray(attributesToReveal) && attributesToReveal.length > 0) {
         await bbsPlusPresentation.addAttributeToReveal(idx, attributesToReveal);
@@ -280,7 +283,7 @@ class CredentialService {
       return null;
     }
 
-    return credential?.credentialStatus.id.replace('dock:accumulator:', '');
+    return credential?.credentialStatus.id;
   }
 
   async getAccumulatorData({credential}) {
@@ -291,7 +294,10 @@ class CredentialService {
       return null;
     }
 
-    return getDock().accumulatorModule.getAccumulator(accumulatorId, false);
+    return blockchainService.dock.accumulatorModule.getAccumulator(
+      accumulatorId,
+      false,
+    );
   }
 
   /**
@@ -359,7 +365,7 @@ class CredentialService {
 
     for (const {credential} of credentials) {
       await presentation.addCredentialToPresent(credential, {
-        resolver: dockService.resolver,
+        resolver: blockchainService.resolver,
       });
     }
 
@@ -404,10 +410,21 @@ class CredentialService {
 
       if (witness) {
         const details = await getWitnessDetails(credential, witness);
+        const chainModule =
+          credential.credentialStatus.id.indexOf('dock:accumulator') === 0
+            ? blockchainService.modules.accumulator.modules[0]
+            : blockchainService.modules.accumulator.modules[
+                blockchainService.modules.accumulator.modules.length - 1
+              ];
+        const accumulatorModuleClass = chainModule.constructor;
+
         presentation.presBuilder.addAccumInfoForCredStatus(
           idx,
           details.membershipWitness,
-          details.accumulator.accumulated,
+          accumulatorModuleClass.accumulatedFromHex(
+            details.accumulator.accumulated,
+            AccumulatorType.VBPos,
+          ),
           details.pk,
           details.params,
         );

package/src/services/credential/utils.js

@@ -1,14 +1,7 @@
 import * as bs58 from 'base58-universal';
-import {generateEcdsaSecp256k1Keypair} from '@docknetwork/sdk/utils/misc';
-import {randomAsHex} from '@polkadot/util-crypto';
-import {u8aToHex} from '@polkadot/util';
-import Bls12381G2KeyPairDock2022 from '@docknetwork/sdk/utils/vc/crypto/Bls12381G2KeyPairDock2022';
-function createSecp256k1Keypair(privateKeyHex) {
-  const pk = privateKeyHex || randomAsHex(32);
-  const kp = generateEcdsaSecp256k1Keypair(pk);
-  kp.pk = pk;
-  return kp;
-}
+import {Bls12381G2KeyPairDock2022} from '@docknetwork/credential-sdk/vc/crypto';
+import {getKeyring} from '../keyring/service';
+
 const docToKeyMap = {
   Sr25519VerificationKey2020: 'sr25519',
   Ed25519VerificationKey2018: 'ed25519',
@@ -25,9 +18,7 @@ export function keyDocToKeypair(keyDoc, dock) {
   const privateKeyEncoded = privateKeyBase58 || privateKeyMultibase.substr(1);
   const privateKeyBytes = bs58.decode(privateKeyEncoded);
 
-  if (type === 'EcdsaSecp256k1VerificationKey2019') {
-    return createSecp256k1Keypair(u8aToHex(privateKeyBytes));
-  } else if (type === 'Bls12381G2VerificationKeyDock2022') {
+  if (type === 'Bls12381G2VerificationKeyDock2022') {
     return new Bls12381G2KeyPairDock2022(keyDoc);
   } else {
     const publicKeyEncoded = publicKeyBase58 || publicKeyMultibase.substr(1);
@@ -36,7 +27,7 @@ export function keyDocToKeypair(keyDoc, dock) {
       throw new Error(`Unsupported key type: ${type}`);
     }
 
-    return dock.keyring.createFromPair(
+    return getKeyring().createFromPair(
       {
         publicKey: bs58.decode(publicKeyEncoded),
         secretKey: privateKeyBytes,

package/src/services/dids/config.ts

@@ -23,6 +23,16 @@ export const validation = {
       assert(typeof type === 'string', 'invalid type');
     }
   },
+
+  deriveKeyDoc: ({ pair, type }: DeriveKeyDocParams) => {
+    assert(typeof pair === 'object', 'invalid pair');
+    assert(pair.publicKey instanceof Uint8Array, 'invalid publicKey');
+    assert(pair.secretKey instanceof Uint8Array, 'invalid secretKey');
+
+    if (type) {
+      assert(typeof type === 'string', 'invalid type');
+    }
+  },
 };
 
 export type KeypairToDIDKeyDocumentParams = {
@@ -39,3 +49,8 @@ export type GenerateKeyDocParams = {
   derivePath: string;
   keyPairJSON: any;
 };
+
+export type DeriveKeyDocParams = {
+  pair: any;
+  type: string;
+};