@docknetwork/wallet-sdk-wasm 0.4.19 → 0.4.21

package/src/services/credential/service.ts

@@ -8,14 +8,14 @@ import {
   WitnessUpdatePublicInfo,
   MembershipWitness,
 } from '@docknetwork/crypto-wasm-ts';
-import {
-  getDockRevIdFromCredential,
-} from '@docknetwork/sdk/utils/revocation';
+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 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';
@@ -27,19 +27,34 @@ import {
 } from './bound-check';
 import assert from 'assert';
 import axios from 'axios';
-import { getIsRevoked, getWitnessDetails } from './bbs-revocation';
-import { getPexRequiredAttributes } from './pex-helpers';
+import {getIsRevoked, getWitnessDetails} from './bbs-revocation';
+import {getPexRequiredAttributes} from './pex-helpers';
+import {didService} from '../dids/service';
 
 const pex: PEX = new PEX();
 
 export 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,
+      ))
+  );
+}
+
+export function isKvacCredential(credential) {
+  return (
+    typeof credential?.proof?.type === 'string' &&
+    credential.proof.type.toLowerCase().includes('bbdt16')
   );
 }
 
+export function isAnnonymousCredential(credential) {
+  return isBBSPlusCredential(credential) || isKvacCredential(credential);
+}
+
 class CredentialService {
   constructor() {
     this.name = serviceName;
@@ -50,8 +65,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);
@@ -90,19 +107,19 @@ 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();
     }
 
@@ -126,12 +143,12 @@ class CredentialService {
           result.verified = false;
           result.error = 'revocation check: the credential is revoked';
         }
-      } catch(err) {
+      } catch (err) {
         console.log('Unable to get revocation status');
         console.error(err);
       }
     }
-    
+
     return result;
   }
 
@@ -161,11 +178,91 @@ class CredentialService {
     return isBBSPlusCredential(credential);
   }
 
+  isKvacCredential(params) {
+    const {credential} = params;
+    return isKvacCredential(credential);
+  }
+
+  async acquireOIDCredential({
+    uri,
+    authorizationCode,
+    holderKeyDocument,
+  }: {
+    uri: string;
+    authorizationCode?: string;
+    holderKeyDocument: 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,
+      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,
@@ -177,7 +274,7 @@ class CredentialService {
     return bbsPlusPresentation.createPresentation();
   }
 
-  getAccumulatorId({ credential }) {
+  getAccumulatorId({credential}) {
     assert(!!credential, `credential is required`);
     if (!credential?.credentialStatus) {
       return null;
@@ -186,9 +283,9 @@ class CredentialService {
     return credential?.credentialStatus.id.replace('dock:accumulator:', '');
   }
 
-  async getAccumulatorData({ credential }) {
+  async getAccumulatorData({credential}) {
     assert(!!credential, `credential is required`);
-    const accumulatorId = await this.getAccumulatorId({ credential });
+    const accumulatorId = await this.getAccumulatorId({credential});
 
     if (!accumulatorId) {
       return null;
@@ -200,16 +297,20 @@ class CredentialService {
   /**
    * Fetch the latest accumulator witness updates for a given credential and membership witness
    * The witness is generated by the issuer when the credential is created and is stored in the wallet when the credential is imported
-   * 
-   * @param param0 
+   *
+   * @param param0
    */
-  async updateMembershipWitness({ credential, membershipWitnessJSON }) {
+  async updateMembershipWitness({credential, membershipWitnessJSON}) {
     const revocationId = credential.credentialStatus.revocationId;
-    const member = Accumulator.encodePositiveNumberAsAccumulatorMember(revocationId);
+    const member =
+      Accumulator.encodePositiveNumberAsAccumulatorMember(revocationId);
     let updates = [];
     try {
-      updates = await dock.accumulatorModule.getUpdatesFromBlock(accumulatorId, accumulator.lastModified);
-    } catch(err) {
+      updates = await dock.accumulatorModule.getUpdatesFromBlock(
+        accumulatorId,
+        accumulator.lastModified,
+      );
+    } catch (err) {
       if (err.code === -32000) {
         console.error(err);
         // "-32000: Client error: UnknownBlock: State already discarded for BlockId::Hash(<hash>)"
@@ -235,22 +336,29 @@ class CredentialService {
       }
     }
 
-    const queriedWitnessInfo = new WitnessUpdatePublicInfo(hexToU8a(updates[0].witnessUpdateInfo));
+    const queriedWitnessInfo = new WitnessUpdatePublicInfo(
+      hexToU8a(updates[0].witnessUpdateInfo),
+    );
     const witness = MembershipWitness.fromJSON(membershipWitnessJSON);
-    witness.updateUsingPublicInfoPostBatchUpdate(member, additions, removals, queriedWitnessInfo);
+    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,
       });
     }
@@ -258,7 +366,7 @@ class CredentialService {
     if (proofRequest && hasProvingKey(proofRequest)) {
       const {provingKey, provingKeyId} = await fetchProvingKey(proofRequest);
       descriptorBounds = applyEnforceBounds({
-        builder: bbsPlusPresentation.presBuilder,
+        builder: presentation.presBuilder,
         proofRequest,
         provingKey,
         provingKeyId,
@@ -268,35 +376,49 @@ class CredentialService {
 
     let pexRequiredAttributes = [];
     if (proofRequest?.request) {
-      pexRequiredAttributes = getPexRequiredAttributes(proofRequest.request, selectedCredentials);
+      pexRequiredAttributes = getPexRequiredAttributes(
+        proofRequest.request,
+        selectedCredentials,
+      );
     }
 
     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;
   }

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

@@ -24,4 +24,7 @@ export class DIDServiceRPC extends RpcService {
   getDidDockDocument(did) {
     return this.call('getDidDockDocument', did);
   }
+  createSignedJWT(params) {
+    return this.call('createSignedJWT', params);
+  }
 }

package/src/services/dids/service.ts

@@ -9,11 +9,43 @@ import {keyringService} from '../keyring/service';
 import {utilCryptoService} from '../util-crypto/service';
 import assert from 'assert';
 import {createNewDockDID} from '@docknetwork/sdk/utils/did';
-import {getDock} from '../dock/service';
+import {dockService, getDock} from '../dock/service';
 import {PublicKeySr25519} from '@docknetwork/sdk';
 import {DidKey, VerificationRelationship} from '@docknetwork/sdk/public-keys';
 import {Logger} from '../../core/logger';
 import {polkadotToKeydoc} from '../../core/polkadot-utils';
+import base64url from 'base64url';
+import { keyDocToKeypair } from '../credential/utils';
+import Ed25519Signature2020 from '@docknetwork/sdk/utils/vc/crypto/Ed25519Signature2020';
+import EcdsaSecp256k1Signature2019 from '@docknetwork/sdk/utils/vc/crypto/EcdsaSecp256k1Signature2019';
+
+async function getSignerKeypair(privateKeyDoc) {
+  const privateKey =
+    privateKeyDoc.keypair || keyDocToKeypair(privateKeyDoc, dockService.dock);
+
+  if (!privateKey.signer && privateKey.sign) {
+    privateKey.signer = () => ({sign: ({data}) => privateKey.sign(data)});
+  }
+
+  // ed25519 should use latest
+  if (privateKeyDoc.type.startsWith('Ed25519')) {
+    return new Ed25519Signature2020({
+      keypair: privateKey,
+      ...privateKeyDoc,
+    });
+  }
+
+  // HACK: for secp256k1 keyDocToKeypair returns an unusable class, wrap it in EcdsaSecp256k1Signature2019
+  // TODO: refactor so that keyDocToKeypair returns EcdsaSecp256k1Signature2019
+  if (privateKey.type === 'secp256k1') {
+    return new EcdsaSecp256k1Signature2019({
+      keypair: privateKey,
+      ...privateKeyDoc,
+    });
+  }
+
+  return privateKey;
+}
 
 class DIDService {
   name: string;
@@ -27,6 +59,8 @@ class DIDService {
     DIDService.prototype.generateKeyDoc,
     DIDService.prototype.registerDidDock,
     DIDService.prototype.getDidDockDocument,
+    DIDService.prototype.createSignedJWT,
+
   ];
   keypairToDIDKeyDocument(params: KeypairToDIDKeyDocumentParams) {
     validation.keypairToDIDKeyDocument(params);
@@ -60,6 +94,30 @@ class DIDService {
     return polkadotToKeydoc(keyring, params.controller);
   }
 
+  async createSignedJWT({
+    payload,
+    privateKeyDoc,
+    headerInput
+  }) {
+    const privateKey = await getSignerKeypair(privateKeyDoc);
+    const {sign} =
+      typeof privateKey.signer === 'function'
+        ? privateKey.signer()
+        : privateKey.signer;
+    const header = {
+      alg: privateKey.alg || 'EdDSA',
+      kid: privateKeyDoc.id,
+      ...headerInput,
+    };
+    const headerBase64URL = base64url(JSON.stringify(header));
+    const payloadBase64URL = base64url(JSON.stringify(payload));
+    const headerAndPayloadBase64URL = `${headerBase64URL}.${payloadBase64URL}`;
+    const signPayload = Buffer.from(headerAndPayloadBase64URL);
+  
+    const signature = await sign({data: signPayload});
+    return `${headerAndPayloadBase64URL}.${base64url.encode(signature)}`;
+  }
+
   async getDidDockDocument(did) {
     assert(!!did, 'DID is required');
     const dock = getDock();

package/src/services/edv/configs.ts

@@ -0,0 +1,23 @@
+// @ts-nocheck
+import assert from 'assert';
+
+export const validation = {
+  initialize(params: InitializeEDVParams) {
+    assert(!!params, 'params required');
+    assert(!!params.agreementKey, 'agreementKey required');
+    assert(!!params.hmacKey, 'hmac required');
+    assert(!!params.verificationKey, 'verificationKey required');
+    assert(!!params.envUrl, 'envUrl required');
+    assert(!!params.authKey, 'authKey required');
+  },
+};
+
+export const serviceName = 'edv';
+
+export type InitializeEDVParams = {
+  agreementKey: any,
+  hmacKey: any,
+  verificationKey: any,
+  edvUrl: string,
+  authKey: string,
+};

package/src/services/edv/hmac.ts

@@ -0,0 +1,101 @@
+import * as base64url from 'base64url-universal';
+import crypto from '@docknetwork/universal-wallet/crypto';
+
+export default class HMAC {
+  key: CryptoKey;
+  id: string;
+  type: string;
+  algorithm: string;
+
+  constructor({
+    id,
+    type,
+    algorithm,
+    key,
+  }: {
+    id: string;
+    type: string;
+    algorithm: string;
+    key: CryptoKey;
+  }) {
+    this.id = id;
+    this.type = type;
+    this.algorithm = algorithm;
+    this.key = key;
+  }
+
+  static async generateKey() {
+    const key = await crypto.subtle.generateKey(
+      {
+        name: 'HMAC',
+        hash: {name: 'SHA-256'},
+      },
+      true,
+      ['sign', 'verify'],
+    );
+
+    return key;
+  }
+
+  static async exportKey(key: CryptoKey) {
+    const rawKey = await crypto.subtle.exportKey('raw', key);
+    return base64url.encode(Buffer.from(rawKey));
+  }
+
+  static async importKey(encodedKey: string) {
+    const rawKey = base64url.decode(encodedKey);
+    const key = await crypto.subtle.importKey(
+      'raw',
+      rawKey,
+      {name: 'HMAC', hash: {name: 'SHA-256'}},
+      true,
+      ['sign', 'verify'],
+    );
+    
+
+    return key;
+  }
+  m;
+
+  static async create({
+    id = 'urn:hmac:cloud-wallet',
+    key,
+  }: {
+    id?: string;
+    key: CryptoKey | string;
+  }) {
+    let cryptoKey: CryptoKey;
+
+    if (typeof key === 'string') {
+      cryptoKey = await HMAC.importKey(key);
+    } else {
+      cryptoKey = key;
+    }
+
+    const type = 'Sha256HmacKey2019';
+    const algorithm = 'HS256';
+    return new HMAC({
+      id,
+      type,
+      algorithm,
+      key: cryptoKey,
+    });
+  }
+
+  async sign({data}: {data: Uint8Array | ArrayBuffer}) {
+    const signature = await crypto.subtle.sign('HMAC', this.key, data);
+
+    return base64url.encode(Buffer.from(signature));
+  }
+
+  async verify({
+    data,
+    signature,
+  }: {
+    data: Uint8Array | ArrayBuffer;
+    signature: string;
+  }) {
+    const decodedSignature = base64url.decode(signature);
+    return crypto.subtle.verify('HMAC', this.key, decodedSignature, data);
+  }
+}

package/src/services/edv/index.android.js

@@ -0,0 +1,3 @@
+import {EDVServiceRpc} from './service-rpc';
+
+export const edvService = new EDVServiceRpc();

package/src/services/edv/index.ios.js

@@ -0,0 +1,3 @@
+import {EDVServiceRpc} from './service-rpc';
+
+export const edvService = new EDVServiceRpc();

package/src/services/edv/index.js

@@ -0,0 +1 @@
+export {edvService} from './service';

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

@@ -0,0 +1,24 @@
+import {assertRpcService} from '../test-utils';
+import {validation} from './configs';
+import {edvService as service} from './service';
+import {EDVServiceRpc} from './service-rpc';
+
+describe('EDVService', () => {
+  it('ServiceRpc', () => {
+    assertRpcService(EDVServiceRpc, service, validation);
+  });
+
+  describe('service', () => {
+    beforeAll(async () => {});
+
+    describe('generateKeys', () => {
+      it('should generate EDV keys', async () => {
+        const keys = await service.generateKeys();
+
+        expect(keys.agreementKey).toBeDefined();
+        expect(keys.hmacKey).toBeDefined();
+        expect(keys.verificationKey).toBeDefined();
+      });
+    });
+  });
+});

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

@@ -0,0 +1,33 @@
+import {RpcService} from '../rpc-service-client';
+import {serviceName, InitializeEDVParams, validation} from './configs';
+
+export class EDVServiceRpc extends RpcService {
+  constructor() {
+    super(serviceName);
+  }
+
+  initialize(params: InitializeEDVParams) {
+    validation.initialize(params);
+    return this.call('initialize', params);
+  }
+
+  generateKeys() {
+    return this.call('generateKeys');
+  }
+
+  find(params: any) {
+    return this.call('find', params);
+  }
+
+  update(params: any) {
+    return this.call('update', params);
+  }
+
+  insert(params: any) {
+    return this.call('insert', params);
+  }
+
+  delete(params: any) {
+    return this.call('delete', params);
+  }
+}