@docknetwork/wallet-sdk-wasm 0.4.19 → 0.4.21

package/lib/services/credential/pex-helpers.mjs

@@ -49,8 +49,18 @@ function getAttributeName({field, selectedCredentials, index}) {
   return attributeName;
 }
 
-function pexToBounds(pexRequest, selectedCredentials = []) {
+function pexToBounds(
+  pexRequest,
+  selectedCredentials = [],
+  isRawBoundies = false,
+) {
   const descriptorBounds = [];
+  const [MIN_DATE_ADJ, MAX_DATE_ADJ, MIN_NUMBER_ADJ, MAX_NUMBER_ADJ] = [
+    MIN_DATE_PLACEHOLDER,
+    MAX_DATE_PLACEHOLDER,
+    MIN_NUMBER,
+    MAX_NUMBER,
+  ].map(value => (isRawBoundies ? undefined : value));
 
   // One list of bounds per descriptor/credential
   pexRequest.input_descriptors.forEach((inputDescriptor, index) => {
@@ -87,32 +97,34 @@ function pexToBounds(pexRequest, selectedCredentials = []) {
 
       // Get min/max bounds values, if using exclusive we must apply an epsilon so equality isnt true
       if (format === 'date-time' || format === 'date') {
-        max = new Date(max === undefined ? MAX_DATE_PLACEHOLDER : max);
-        min = new Date(min === undefined ? MIN_DATE_PLACEHOLDER : min);
+        max = max === undefined ? MAX_DATE_ADJ : max;
+        max = max ? new Date(max) : undefined;
+        min = min === undefined ? MIN_DATE_ADJ : min;
+        min = min ? new Date(min) : undefined;
       } else if (type === 'number') {
         max =
           max === undefined
-            ? MAX_NUMBER
-            : exclusiveMaximum === undefined
+            ? MAX_NUMBER_ADJ
+            : exclusiveMaximum === undefined || isRawBoundies
             ? max
             : max - EPSILON_NUMBER;
         min =
           min === undefined
-            ? MIN_NUMBER
-            : exclusiveMinimum === undefined
+            ? MIN_NUMBER_ADJ
+            : exclusiveMinimum === undefined || isRawBoundies
             ? min
             : min + EPSILON_NUMBER;
       } else if (type === 'integer') {
         max =
           max === undefined
-            ? MAX_NUMBER
-            : exclusiveMaximum === undefined
+            ? MAX_NUMBER_ADJ
+            : exclusiveMaximum === undefined || isRawBoundies
             ? max
             : max - EPSILON_INT;
         min =
           min === undefined
-            ? MIN_NUMBER
-            : exclusiveMinimum === undefined
+            ? MIN_NUMBER_ADJ
+            : exclusiveMinimum === undefined || isRawBoundies
             ? min
             : min + EPSILON_INT;
       } else {
@@ -131,6 +143,8 @@ function pexToBounds(pexRequest, selectedCredentials = []) {
         attributeName,
         min,
         max,
+        type,
+        format,
       });
     });
 
@@ -152,24 +166,37 @@ const shouldSkipAttribute = attributeName =>
   attributesToSkip.some(regex => regex.test(attributeName));
 
 function getPexRequiredAttributes(pexRequest, selectedCredentials = []) {
-  return pexRequest.input_descriptors.map((inputDescriptor, index) => {
-    return inputDescriptor.constraints.fields
-      .filter(field => {
-        if (field.filter) {
-          return false;
-        }
-
-        const paths = Array.isArray(field.path)
-          ? field.path.flatMap(singlePath =>
-              JSONPath.paths(selectedCredentials[index], singlePath),
-            )
-          : JSONPath.paths(selectedCredentials[index], field.path);
-
-        return paths.length !== 0;
-      })
-      .map(field => getAttributeName({field, selectedCredentials, index}))
-      .filter(attributeName => !shouldSkipAttribute(attributeName));
-  });
+  return pexRequest.input_descriptors
+    .map((inputDescriptor, index) => {
+      return inputDescriptor.constraints.fields
+        .filter(field => {
+          if (field.filter) {
+            return false;
+          }
+
+          try {
+            if (!selectedCredentials[index]) {
+              return false;
+            }
+
+            const paths = Array.isArray(field.path)
+              ? field.path.flatMap(singlePath =>
+                  JSONPath.paths(selectedCredentials[index], singlePath),
+                )
+              : JSONPath.paths(selectedCredentials[index], field.path);
+
+            return paths.length !== 0;
+          } catch (error) {
+            console.error(`Error in field ${field.path}: ${error.message}`);
+            return false;
+          }
+        })
+        .map(field => getAttributeName({field, selectedCredentials, index}))
+        .filter(attributeName => {
+          return !shouldSkipAttribute(attributeName);
+        });
+    })
+    .filter(requiredAttributes => requiredAttributes.length > 0);
 }
 
 export { EPSILON_INT, EPSILON_NUMBER, MAX_DATE_PLACEHOLDER, MAX_NUMBER, MIN_DATE_PLACEHOLDER, MIN_NUMBER, getPexRequiredAttributes, pexToBounds };

package/lib/services/credential/service-rpc.js

@@ -32,15 +32,21 @@ class CredentialServiceRPC extends services_rpcServiceClient.RpcService {
   async createBBSPresentation(params) {
     return this.call('createBBSPresentation', params);
   }
-  async deriveVCFromBBSPresentation(params) {
-    return this.call('deriveVCFromBBSPresentation', params);
+  async deriveVCFromPresentation(params) {
+    return this.call('deriveVCFromPresentation', params);
   }
   async isBBSPlusCredential(params) {
     return this.call('isBBSPlusCredential', params);
   }
+  async isKvacCredential(params) {
+    return this.call('isKvacCredential', params);
+  }
   async getAccumulatorId(params) {
     return this.call('getAccumulatorId', params);
   }
+  async acquireOIDCredential(params) {
+    return this.call('acquireOIDCredential', params);
+  }
 }
 
 exports.CredentialServiceRPC = CredentialServiceRPC;

package/lib/services/credential/service-rpc.mjs

@@ -28,15 +28,21 @@ class CredentialServiceRPC extends RpcService {
   async createBBSPresentation(params) {
     return this.call('createBBSPresentation', params);
   }
-  async deriveVCFromBBSPresentation(params) {
-    return this.call('deriveVCFromBBSPresentation', params);
+  async deriveVCFromPresentation(params) {
+    return this.call('deriveVCFromPresentation', params);
   }
   async isBBSPlusCredential(params) {
     return this.call('isBBSPlusCredential', params);
   }
+  async isKvacCredential(params) {
+    return this.call('isKvacCredential', params);
+  }
   async getAccumulatorId(params) {
     return this.call('getAccumulatorId', params);
   }
+  async acquireOIDCredential(params) {
+    return this.call('acquireOIDCredential', params);
+  }
 }
 
 export { CredentialServiceRPC };

package/lib/services/credential/service.js

@@ -4,11 +4,13 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var services_credential_config = require('./config.js');
 var cryptoWasmTs = require('@docknetwork/crypto-wasm-ts');
+var oid4vciClient = require('@sphereon/oid4vci-client');
+var oid4vciCommon = require('@sphereon/oid4vci-common');
 var VerifiableCredential = require('@docknetwork/sdk/verifiable-credential');
 var keypairs = require('@docknetwork/universal-wallet/methods/keypairs');
 var helpers = require('@docknetwork/sdk/utils/vc/helpers');
 var VerifiablePresentation = require('@docknetwork/sdk/verifiable-presentation');
-var BbsPlusPresentation = require('@docknetwork/sdk/presentation');
+var Presentation = require('@docknetwork/sdk/presentation');
 var credentials = require('@docknetwork/sdk/utils/vc/credentials');
 var pex$1 = require('@sphereon/pex');
 var services_credential_utils = require('./utils.js');
@@ -17,6 +19,7 @@ var services_credential_boundCheck = require('./bound-check.js');
 var assert = require('assert');
 var services_credential_bbsRevocation = require('./bbs-revocation.js');
 var services_credential_pexHelpers = require('./pex-helpers.js');
+var services_dids_service = require('../dids/service.js');
 require('base58-universal');
 require('@docknetwork/sdk/utils/misc');
 require('@polkadot/util-crypto');
@@ -32,20 +35,44 @@ require('../dock/configs.js');
 require('@docknetwork/crypto-wasm-ts/lib/legosnark');
 require('base64url');
 require('@astronautlabs/jsonpath');
+require('@docknetwork/wallet-sdk-dids/src');
+require('../dids/config.js');
+require('../keyring/service.js');
+require('@polkadot/keyring');
+require('../keyring/configs.js');
+require('../../core/validation.js');
+require('bignumber.js');
+require('../../types.js');
+require('../util-crypto/service.js');
+require('../util-crypto/configs.js');
+require('@docknetwork/sdk/utils/did');
+require('@docknetwork/sdk/public-keys');
+require('../../core/polkadot-utils.js');
+require('@polkadot/keyring/pair/decode');
+require('@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020');
+require('@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var VerifiableCredential__default = /*#__PURE__*/_interopDefaultLegacy(VerifiableCredential);
 var VerifiablePresentation__default = /*#__PURE__*/_interopDefaultLegacy(VerifiablePresentation);
-var BbsPlusPresentation__default = /*#__PURE__*/_interopDefaultLegacy(BbsPlusPresentation);
+var Presentation__default = /*#__PURE__*/_interopDefaultLegacy(Presentation);
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
 
 // @ts-nocheck
 const pex = new pex$1.PEX();
 function isBBSPlusCredential(credential) {
     return ((typeof credential?.proof?.type === 'string' &&
-        (credential.proof.type.includes('BBS+SignatureDock')) ||
-        (Array.isArray(credential['@context']) && credential['@context'].find(context => typeof context === 'string' && context.indexOf('bbs') > -1))));
+        credential.proof.type.includes('BBS+SignatureDock')) ||
+        (Array.isArray(credential['@context']) &&
+            credential['@context'].find(context => typeof context === 'string' && context.indexOf('bbs') > -1)));
+}
+function isKvacCredential(credential) {
+    return (typeof credential?.proof?.type === 'string' &&
+        credential.proof.type.toLowerCase().includes('bbdt16'));
+}
+function isAnnonymousCredential(credential) {
+    return isBBSPlusCredential(credential) || isKvacCredential(credential);
 }
 class CredentialService {
     constructor() {
@@ -57,8 +84,10 @@ class CredentialService {
         CredentialService.prototype.createPresentation,
         CredentialService.prototype.verifyCredential,
         CredentialService.prototype.createBBSPresentation,
-        CredentialService.prototype.deriveVCFromBBSPresentation,
+        CredentialService.prototype.deriveVCFromPresentation,
         CredentialService.prototype.isBBSPlusCredential,
+        CredentialService.prototype.isKvacCredential,
+        CredentialService.prototype.acquireOIDCredential,
     ];
     generateCredential(params = {}) {
         services_credential_config.validation.generateCredential(params);
@@ -93,16 +122,16 @@ class CredentialService {
         services_credential_config.validation.createPresentation(params);
         const { credentials, keyDoc, challenge, id, domain } = params;
         const vp = new VerifiablePresentation__default["default"](id);
-        let isBBS;
+        let shouldSkipSigning = false;
         for (const signedVC of credentials) {
             vp.addCredential(signedVC);
-            isBBS = isBBS || isBBSPlusCredential(signedVC);
+            shouldSkipSigning = shouldSkipSigning || isAnnonymousCredential(signedVC);
         }
-        if (!isBBS) {
+        if (!shouldSkipSigning) {
             vp.setHolder(keyDoc.controller);
         }
         keyDoc.keypair = services_credential_utils.keyDocToKeypair(keyDoc, services_dock_service.getDock());
-        if (isBBS) {
+        if (shouldSkipSigning) {
             return vp.toJSON();
         }
         return vp.sign(keyDoc, challenge, domain, services_dock_service.dockService.resolver);
@@ -144,10 +173,75 @@ class CredentialService {
         const { credential } = params;
         return isBBSPlusCredential(credential);
     }
+    isKvacCredential(params) {
+        const { credential } = params;
+        return isKvacCredential(credential);
+    }
+    async acquireOIDCredential({ uri, authorizationCode, holderKeyDocument, }) {
+        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 oid4vciClient.OpenID4VCIClientV1_0_13.fromURI({
+            uri: uri,
+            clientId: 'dock.wallet',
+            authorizationRequest: {
+                redirectUri: 'dock-wallet://credentials/callback',
+                clientId: 'dock.wallet',
+                scope: credentialOffer.credentials[0],
+            },
+        });
+        let code;
+        if (client.credentialOffer?.preAuthorizedCode) {
+            code = client.credentialOffer?.preAuthorizedCode;
+        }
+        else {
+            if (authorizationCode) {
+                code = authorizationCode;
+            }
+            else {
+                return {
+                    authorizationURL: client.authorizationURL,
+                };
+            }
+        }
+        await client.acquireAccessToken({
+            code,
+        });
+        try {
+            const response = await client.acquireCredentials({
+                credentialTypes,
+                proofCallbacks: {
+                    signCallback: async (args) => {
+                        // use service method here
+                        const jwt = await services_dids_service.didService.createSignedJWT({
+                            payload: args.payload,
+                            privateKeyDoc: holderKeyDocument,
+                            headerInput: args.header,
+                        });
+                        return jwt;
+                    },
+                },
+                format: format,
+                alg: oid4vciCommon.Alg.EdDSA,
+                kid: holderKeyDocument.id,
+            });
+            return {
+                credential: response.credential,
+            };
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
     async createBBSPresentation(params) {
         services_credential_config.validation.createBBSPresentation(params);
         const { credentials } = params;
-        const bbsPlusPresentation = new BbsPlusPresentation__default["default"]();
+        const bbsPlusPresentation = new Presentation__default["default"]();
         for (const { credential, attributesToReveal } of credentials) {
             const idx = await bbsPlusPresentation.addCredentialToPresent(credential, {
                 resolver: services_dock_service.dockService.resolver,
@@ -214,21 +308,21 @@ class CredentialService {
         witness.updateUsingPublicInfoPostBatchUpdate(member, additions, removals, queriedWitnessInfo);
         return witness.toJSON();
     }
-    async deriveVCFromBBSPresentation(params) {
-        services_credential_config.validation.deriveVCFromBBSPresentation(params);
+    async deriveVCFromPresentation(params) {
+        services_credential_config.validation.deriveVCFromPresentation(params);
         const { credentials, options = {}, proofRequest } = params;
-        const bbsPlusPresentation = new BbsPlusPresentation__default["default"]();
+        const presentation = new Presentation__default["default"]();
         const selectedCredentials = credentials.map(({ credential }) => credential);
         let descriptorBounds = [];
         for (const { credential } of credentials) {
-            await bbsPlusPresentation.addCredentialToPresent(credential, {
+            await presentation.addCredentialToPresent(credential, {
                 resolver: services_dock_service.dockService.resolver,
             });
         }
         if (proofRequest && services_credential_boundCheck.hasProvingKey(proofRequest)) {
             const { provingKey, provingKeyId } = await services_credential_boundCheck.fetchProvingKey(proofRequest);
             descriptorBounds = services_credential_boundCheck.applyEnforceBounds({
-                builder: bbsPlusPresentation.presBuilder,
+                builder: presentation.presBuilder,
                 proofRequest,
                 provingKey,
                 provingKeyId,
@@ -241,24 +335,26 @@ class CredentialService {
         }
         let idx = 0;
         for (const { attributesToReveal, witness, credential } of credentials) {
-            const attributesToSkip = descriptorBounds[idx] ? descriptorBounds[idx].map((bound) => bound.attributeName) : [];
-            const filteredAttributes = attributesToReveal.filter((attribute) => !attributesToSkip.includes(attribute));
+            const attributesToSkip = descriptorBounds[idx]
+                ? descriptorBounds[idx].map(bound => bound.attributeName)
+                : [];
+            const filteredAttributes = attributesToReveal.filter(attribute => !attributesToSkip.includes(attribute));
             const _pexRequiredAttributes = pexRequiredAttributes[idx] || [];
-            _pexRequiredAttributes.forEach((attr) => {
+            _pexRequiredAttributes.forEach(attr => {
                 if (!filteredAttributes.includes(attr)) {
                     filteredAttributes.push(attr);
                 }
             });
             if (Array.isArray(filteredAttributes) && filteredAttributes.length > 0) {
-                bbsPlusPresentation.addAttributeToReveal(idx, filteredAttributes);
+                presentation.addAttributeToReveal(idx, filteredAttributes);
             }
             if (witness) {
                 const details = await services_credential_bbsRevocation.getWitnessDetails(credential, witness);
-                bbsPlusPresentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
+                presentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
             }
             idx++;
         }
-        const credentialsFromPresentation = await bbsPlusPresentation.deriveCredentials(options);
+        const credentialsFromPresentation = await presentation.deriveCredentials(options);
         return credentialsFromPresentation;
     }
     async testRangeProof() {
@@ -268,4 +364,6 @@ class CredentialService {
 const credentialService = new CredentialService();
 
 exports.credentialService = credentialService;
+exports.isAnnonymousCredential = isAnnonymousCredential;
 exports.isBBSPlusCredential = isBBSPlusCredential;
+exports.isKvacCredential = isKvacCredential;

package/lib/services/credential/service.mjs

@@ -1,10 +1,12 @@
 import { serviceName, validation } from './config.mjs';
 import { Accumulator, WitnessUpdatePublicInfo, MembershipWitness } from '@docknetwork/crypto-wasm-ts';
+import { OpenID4VCIClientV1_0_13 } from '@sphereon/oid4vci-client';
+import { Alg } from '@sphereon/oid4vci-common';
 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 BbsPlusPresentation from '@docknetwork/sdk/presentation';
+import Presentation from '@docknetwork/sdk/presentation';
 import { verifyCredential } from '@docknetwork/sdk/utils/vc/credentials';
 import { PEX } from '@sphereon/pex';
 import { keyDocToKeypair } from './utils.mjs';
@@ -13,6 +15,7 @@ import { hasProvingKey, fetchProvingKey, applyEnforceBounds } from './bound-chec
 import assert from 'assert';
 import { getIsRevoked, getWitnessDetails } from './bbs-revocation.mjs';
 import { getPexRequiredAttributes } from './pex-helpers.mjs';
+import { didService } from '../dids/service.mjs';
 import 'base58-universal';
 import '@docknetwork/sdk/utils/misc';
 import '@polkadot/util-crypto';
@@ -28,13 +31,37 @@ import '../dock/configs.mjs';
 import '@docknetwork/crypto-wasm-ts/lib/legosnark';
 import 'base64url';
 import '@astronautlabs/jsonpath';
+import '@docknetwork/wallet-sdk-dids/src';
+import '../dids/config.mjs';
+import '../keyring/service.mjs';
+import '@polkadot/keyring';
+import '../keyring/configs.mjs';
+import '../../core/validation.mjs';
+import 'bignumber.js';
+import '../../types.mjs';
+import '../util-crypto/service.mjs';
+import '../util-crypto/configs.mjs';
+import '@docknetwork/sdk/utils/did';
+import '@docknetwork/sdk/public-keys';
+import '../../core/polkadot-utils.mjs';
+import '@polkadot/keyring/pair/decode';
+import '@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020';
+import '@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019';
 
 // @ts-nocheck
 const pex = new PEX();
 function isBBSPlusCredential(credential) {
     return ((typeof credential?.proof?.type === 'string' &&
-        (credential.proof.type.includes('BBS+SignatureDock')) ||
-        (Array.isArray(credential['@context']) && credential['@context'].find(context => typeof context === 'string' && context.indexOf('bbs') > -1))));
+        credential.proof.type.includes('BBS+SignatureDock')) ||
+        (Array.isArray(credential['@context']) &&
+            credential['@context'].find(context => typeof context === 'string' && context.indexOf('bbs') > -1)));
+}
+function isKvacCredential(credential) {
+    return (typeof credential?.proof?.type === 'string' &&
+        credential.proof.type.toLowerCase().includes('bbdt16'));
+}
+function isAnnonymousCredential(credential) {
+    return isBBSPlusCredential(credential) || isKvacCredential(credential);
 }
 class CredentialService {
     constructor() {
@@ -46,8 +73,10 @@ class CredentialService {
         CredentialService.prototype.createPresentation,
         CredentialService.prototype.verifyCredential,
         CredentialService.prototype.createBBSPresentation,
-        CredentialService.prototype.deriveVCFromBBSPresentation,
+        CredentialService.prototype.deriveVCFromPresentation,
         CredentialService.prototype.isBBSPlusCredential,
+        CredentialService.prototype.isKvacCredential,
+        CredentialService.prototype.acquireOIDCredential,
     ];
     generateCredential(params = {}) {
         validation.generateCredential(params);
@@ -82,16 +111,16 @@ class CredentialService {
         validation.createPresentation(params);
         const { credentials, keyDoc, challenge, id, domain } = params;
         const vp = new VerifiablePresentation(id);
-        let isBBS;
+        let shouldSkipSigning = false;
         for (const signedVC of credentials) {
             vp.addCredential(signedVC);
-            isBBS = isBBS || isBBSPlusCredential(signedVC);
+            shouldSkipSigning = shouldSkipSigning || isAnnonymousCredential(signedVC);
         }
-        if (!isBBS) {
+        if (!shouldSkipSigning) {
             vp.setHolder(keyDoc.controller);
         }
         keyDoc.keypair = keyDocToKeypair(keyDoc, getDock());
-        if (isBBS) {
+        if (shouldSkipSigning) {
             return vp.toJSON();
         }
         return vp.sign(keyDoc, challenge, domain, dockService.resolver);
@@ -133,10 +162,75 @@ class CredentialService {
         const { credential } = params;
         return isBBSPlusCredential(credential);
     }
+    isKvacCredential(params) {
+        const { credential } = params;
+        return isKvacCredential(credential);
+    }
+    async acquireOIDCredential({ uri, authorizationCode, holderKeyDocument, }) {
+        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,
+            clientId: 'dock.wallet',
+            authorizationRequest: {
+                redirectUri: 'dock-wallet://credentials/callback',
+                clientId: 'dock.wallet',
+                scope: credentialOffer.credentials[0],
+            },
+        });
+        let code;
+        if (client.credentialOffer?.preAuthorizedCode) {
+            code = client.credentialOffer?.preAuthorizedCode;
+        }
+        else {
+            if (authorizationCode) {
+                code = authorizationCode;
+            }
+            else {
+                return {
+                    authorizationURL: client.authorizationURL,
+                };
+            }
+        }
+        await client.acquireAccessToken({
+            code,
+        });
+        try {
+            const response = await client.acquireCredentials({
+                credentialTypes,
+                proofCallbacks: {
+                    signCallback: async (args) => {
+                        // use service method here
+                        const jwt = await didService.createSignedJWT({
+                            payload: args.payload,
+                            privateKeyDoc: holderKeyDocument,
+                            headerInput: args.header,
+                        });
+                        return jwt;
+                    },
+                },
+                format: format,
+                alg: Alg.EdDSA,
+                kid: holderKeyDocument.id,
+            });
+            return {
+                credential: response.credential,
+            };
+        }
+        catch (err) {
+            console.error(err);
+        }
+    }
     async createBBSPresentation(params) {
         validation.createBBSPresentation(params);
         const { credentials } = params;
-        const bbsPlusPresentation = new BbsPlusPresentation();
+        const bbsPlusPresentation = new Presentation();
         for (const { credential, attributesToReveal } of credentials) {
             const idx = await bbsPlusPresentation.addCredentialToPresent(credential, {
                 resolver: dockService.resolver,
@@ -203,21 +297,21 @@ class CredentialService {
         witness.updateUsingPublicInfoPostBatchUpdate(member, additions, removals, queriedWitnessInfo);
         return witness.toJSON();
     }
-    async deriveVCFromBBSPresentation(params) {
-        validation.deriveVCFromBBSPresentation(params);
+    async deriveVCFromPresentation(params) {
+        validation.deriveVCFromPresentation(params);
         const { credentials, options = {}, proofRequest } = params;
-        const bbsPlusPresentation = new BbsPlusPresentation();
+        const presentation = new Presentation();
         const selectedCredentials = credentials.map(({ credential }) => credential);
         let descriptorBounds = [];
         for (const { credential } of credentials) {
-            await bbsPlusPresentation.addCredentialToPresent(credential, {
+            await presentation.addCredentialToPresent(credential, {
                 resolver: dockService.resolver,
             });
         }
         if (proofRequest && hasProvingKey(proofRequest)) {
             const { provingKey, provingKeyId } = await fetchProvingKey(proofRequest);
             descriptorBounds = applyEnforceBounds({
-                builder: bbsPlusPresentation.presBuilder,
+                builder: presentation.presBuilder,
                 proofRequest,
                 provingKey,
                 provingKeyId,
@@ -230,24 +324,26 @@ class CredentialService {
         }
         let idx = 0;
         for (const { attributesToReveal, witness, credential } of credentials) {
-            const attributesToSkip = descriptorBounds[idx] ? descriptorBounds[idx].map((bound) => bound.attributeName) : [];
-            const filteredAttributes = attributesToReveal.filter((attribute) => !attributesToSkip.includes(attribute));
+            const attributesToSkip = descriptorBounds[idx]
+                ? descriptorBounds[idx].map(bound => bound.attributeName)
+                : [];
+            const filteredAttributes = attributesToReveal.filter(attribute => !attributesToSkip.includes(attribute));
             const _pexRequiredAttributes = pexRequiredAttributes[idx] || [];
-            _pexRequiredAttributes.forEach((attr) => {
+            _pexRequiredAttributes.forEach(attr => {
                 if (!filteredAttributes.includes(attr)) {
                     filteredAttributes.push(attr);
                 }
             });
             if (Array.isArray(filteredAttributes) && filteredAttributes.length > 0) {
-                bbsPlusPresentation.addAttributeToReveal(idx, filteredAttributes);
+                presentation.addAttributeToReveal(idx, filteredAttributes);
             }
             if (witness) {
                 const details = await getWitnessDetails(credential, witness);
-                bbsPlusPresentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
+                presentation.presBuilder.addAccumInfoForCredStatus(idx, details.membershipWitness, details.accumulator.accumulated, details.pk, details.params);
             }
             idx++;
         }
-        const credentialsFromPresentation = await bbsPlusPresentation.deriveCredentials(options);
+        const credentialsFromPresentation = await presentation.deriveCredentials(options);
         return credentialsFromPresentation;
     }
     async testRangeProof() {
@@ -256,4 +352,4 @@ class CredentialService {
 }
 const credentialService = new CredentialService();
 
-export { credentialService, isBBSPlusCredential };
+export { credentialService, isAnnonymousCredential, isBBSPlusCredential, isKvacCredential };