@docknetwork/wallet-sdk-core 0.4.19

package/src/credential-provider.ts

@@ -0,0 +1,272 @@
+import {credentialServiceRPC} from '@docknetwork/wallet-sdk-wasm/src/services/credential';
+import {IWallet} from './types';
+import assert from 'assert';
+import { dockService } from '@docknetwork/wallet-sdk-wasm/src/services/dock';
+
+export type Credential = any;
+
+export interface ICredentialProvider {
+  getCredentials(type?: string): Credential[];
+  getById(id: string): Credential;
+  getMembershipWitness(credential: any): Promise<any>;
+  isBBSPlusCredential(credential: any): boolean;
+  isValid(credential: any, forceFetch?: boolean): Promise<boolean>;
+  addCredential(credential: any): Promise<Credential>;
+  syncCredentialStatus(params: SyncCredentialStatusParams): Promise<CredentialStatusDocument[]>;
+  getCredentialStatus(credential: Credential): Promise<{status: string, error?: string}>;
+}
+
+export function isBBSPlusCredential(credential) {
+  return (
+    (typeof credential?.proof?.type === 'string' &&
+      credential.proof.type.includes('BBS+SignatureDock')) ||
+    (Array.isArray(credential['@context']) &&
+      credential['@context'].find(
+        context => context.bs && context.bs.indexOf('bbs') > -1,
+      ))
+  );
+}
+
+export function isCredentialExpired(credential) {
+  return !!credential.expirationDate && new Date(credential.expirationDate) < new Date();
+}
+
+/**
+ * Uses Dock SDK to verify a credential
+ * @param credential
+ * @returns
+ */
+export async function isValid({
+  credential,
+  wallet,
+}: {
+  credential: Credential;
+  wallet: IWallet;
+}) {
+  assert(!!credential, 'credential is required');
+
+  try {
+    if (isCredentialExpired(credential)) {
+      return {
+        status: CredentialStatus.Expired,
+      };
+    }
+
+    const membershipWitness = credential[ACUMM_WITNESS_PROP_KEY] || await getMembershipWitness({
+      credentialId: credential.id,
+      wallet,
+    });
+
+    delete credential[ACUMM_WITNESS_PROP_KEY];
+
+    const verificationResult = await credentialServiceRPC.verifyCredential({
+      credential,
+      membershipWitness,
+    });
+
+    const { verified, error }  = verificationResult;
+  
+    if (!verified) {
+      if (typeof error === 'string' && error.toLowerCase().includes('revocation')) {
+        return {
+          status: CredentialStatus.Revoked,
+          error,
+        };
+      }
+
+      return {
+        status: CredentialStatus.Invalid,
+        error: error,
+      };
+    }
+
+    return {
+      status: CredentialStatus.Verified,
+    };
+  } catch (err) {
+    console.error(err);
+
+    return {
+      status: CredentialStatus.Invalid,
+      error: err.toString(),
+    };
+  }
+}
+
+export const ACUMM_WITNESS_PROP_KEY = '$$accum__witness$$';
+
+export async function addCredential({wallet, credential}) {
+  const acummWitness = credential[ACUMM_WITNESS_PROP_KEY];
+
+  if (acummWitness) {
+    delete credential[ACUMM_WITNESS_PROP_KEY];
+  }
+
+  const response = await wallet.addDocument(credential);
+
+  if (acummWitness) {
+    await wallet.addDocument({
+      type: 'AccumulatorWitness',
+      id: `${credential.id}#witness`,
+      value: acummWitness,
+      initialWitness: acummWitness,
+    });
+  }
+
+  syncCredentialStatus({ wallet, credentialIds: [credential.id] });
+
+  return response;
+}
+
+async function getMembershipWitness({credentialId, wallet}) {
+  const document = await wallet.getDocumentById(`${credentialId}#witness`);
+  return document?.value;
+}
+
+
+export const CredentialStatus = {
+  Invalid: 'invalid',
+  Expired: 'expired',
+  Verified: 'verified',
+  Revoked: 'revoked',
+  Pending: 'pending',
+};
+
+type SyncCredentialStatusParams = {
+  // Optional credential IDs to sync
+  credentialIds?: string[],
+  // Skip the cache and re-fetch from the chain
+  forceFetch?: boolean,
+};
+
+type CredentialStatusDocument = {
+  id: string;
+  status: string;
+  error: string;
+}
+
+/**
+ * Fetch credential status from the chain and update the wallet
+ * Store a new document <credentialId>#status in the wallet
+ * Returns a list of CredentialStatusDocument
+ * 
+ * @param param0
+ * @returns CredentialStatusDocument[]
+ */
+async function syncCredentialStatus({ wallet, credentialIds, forceFetch }: SyncCredentialStatusParams & {
+  wallet: IWallet;
+} ): Promise<CredentialStatusDocument[]> {
+  let credentials;
+
+  if (credentialIds && credentialIds.length) {
+    credentials = await wallet.getDocumentsById(credentialIds);
+  } else {
+    credentials = await wallet.getDocumentsByType('VerifiableCredential');
+  }
+
+  let statusDocs = [];
+
+  let isApiConnected;
+  
+  for (const credential of credentials) {
+    let shouldFetch = !!forceFetch;
+    let statusDoc = await wallet.getDocumentById(`${credential.id}#status`);
+
+    if (!statusDoc) {
+      shouldFetch = true;
+      statusDoc = {
+        type: 'CredentialStatus',
+        id: `${credential.id}#status`,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        status: null,
+      };
+
+      await wallet.addDocument(statusDoc);
+    }
+
+    statusDocs.push(statusDoc);
+
+    if (!statusDoc.status || statusDoc.status === CredentialStatus.Pending) {
+      shouldFetch = true;
+    }
+
+    if (!shouldFetch) {
+      // check if latest fetch was more than 24 hours ago
+      const updatedAt = new Date(statusDoc.updatedAt);
+      const diff = new Date().getTime() - updatedAt.getTime();
+      const hours = Math.floor(diff / 1000 / 60 / 60);
+      if (hours > 24) {
+        shouldFetch = true;
+      }
+    }
+
+    if (!shouldFetch) {
+      continue;
+    }
+
+    if (!statusDoc.status) {
+      statusDoc.status = CredentialStatus.Pending;
+      statusDoc.updatedAt = new Date().toISOString();
+      await wallet.updateDocument(statusDoc);
+    }
+
+    if (!isApiConnected) {
+      await dockService.ensureDockReady();
+      isApiConnected = true;
+    }    
+
+    const result = await isValid({ credential, wallet });
+    statusDoc.status = result?.status
+    statusDoc.error = result?.error;
+    statusDoc.updatedAt = new Date().toISOString();
+
+    await wallet.updateDocument(statusDoc);
+  }
+
+  return statusDocs;
+}
+
+export function createCredentialProvider({
+  wallet,
+}: {
+  wallet: IWallet;
+}): ICredentialProvider {
+  function getCredentials(type: string = 'VerifiableCredential') {
+    return wallet.getDocumentsByType(type) as any;
+  }
+
+  return {
+    getCredentials,
+    getMembershipWitness: async (credentialId: string) =>
+      getMembershipWitness({credentialId, wallet}),
+    getById: (id: string) => wallet.getDocumentById(id),
+    isBBSPlusCredential,
+    isValid: async credential =>
+      isValid({
+        credential,
+        wallet,
+      }) as any,
+    getCredentialStatus: async (credential: Credential) => {
+      assert(!!credential, 'credential is required');
+
+      if (isCredentialExpired(credential)) {
+        return {
+          status: CredentialStatus.Expired,
+        };
+      }
+
+      const statusDoc = await wallet.getDocumentById(`${credential.id}#status`);
+
+      return {
+        status: statusDoc?.status || CredentialStatus.Pending,
+        error: statusDoc?.error,
+      }
+    },
+    syncCredentialStatus: async (props: SyncCredentialStatusParams) => {
+      return syncCredentialStatus({ wallet, ...props });
+    },
+    addCredential: credential => addCredential({wallet, credential}),
+    // TODO: move import credential from json or URL to this provider
+  };
+}

package/src/did-provider.test.ts

@@ -0,0 +1,203 @@
+import {IWallet} from './types';
+import {createWallet} from './wallet';
+import {createDIDock, createDIDKey, createDIDProvider, IDIDProvider} from './did-provider';
+import {createAccountProvider} from './account-provider';
+import {didServiceRPC} from '@docknetwork/wallet-sdk-wasm/src/services/dids';
+
+describe('DID Provider', () => {
+  let wallet: IWallet;
+  let didProvider: IDIDProvider;
+  let accountProvider;
+  const didBackupFile = {
+    '@context': [
+      'https://www.w3.org/2018/credentials/v1',
+      'https://w3id.org/wallet/v1',
+    ],
+    id: 'did:key:z6LSjTbRETJjUCDiQopbeCgZKRisy7mdchwiMBPTQktcibGh#encrypted-wallet',
+    type: ['VerifiableCredential', 'EncryptedWallet'],
+    issuer: 'did:key:z6LSjTbRETJjUCDiQopbeCgZKRisy7mdchwiMBPTQktcibGh',
+    issuanceDate: '2022-07-19T20:59:44.798Z',
+    credentialSubject: {
+      id: 'did:key:z6LSjTbRETJjUCDiQopbeCgZKRisy7mdchwiMBPTQktcibGh',
+      encryptedWalletContents: {
+        protected: 'eyJlbmMiOiJYQzIwUCJ9',
+        recipients: [
+          {
+            header: {
+              kid: 'did:key:z6LSjTbRETJjUCDiQopbeCgZKRisy7mdchwiMBPTQktcibGh#z6LSjTbRETJjUCDiQopbeCgZKRisy7mdchwiMBPTQktcibGh',
+              alg: 'ECDH-ES+A256KW',
+              epk: {
+                kty: 'OKP',
+                crv: 'X25519',
+                x: '-ABoa59NY2qVI66NZ8EbqxCwp02sft5onyKhfa2yfUU',
+              },
+              apu: '-ABoa59NY2qVI66NZ8EbqxCwp02sft5onyKhfa2yfUU',
+              apv: 'ZGlkOmtleTp6NkxTalRiUkVUSmpVQ0RpUW9wYmVDZ1pLUmlzeTdtZGNod2lNQlBUUWt0Y2liR2gjejZMU2pUYlJFVEpqVUNEaVFvcGJlQ2daS1Jpc3k3bWRjaHdpTUJQVFFrdGNpYkdo',
+            },
+            encrypted_key:
+              'Mmf6YGug9bL-L4bi2UwS9R8nUk6bJmgVKJvP2_a0BwsjxtxBN0ly6w',
+          },
+        ],
+        iv: '-u0i0V9ENM3rUwxj-Yv_7jd3veFLzVEO',
+        ciphertext:
+          'jahwvff1Afy19A9C4kP51nno-14Ea7m-omq39JGlG5_qmmEgrBcd0KsStpfDFKj4gMRR8izsALXqKz78vzhCRTd3RNa5rNOKbzfT3HALRkn1y7n6RlSRRZ0MKuBP9JVg49opLSqAIJ9j64Ebj2KhXALX6Wbv1h9FhAIhIxGkZJZDgKFQmpI54IGKS-J4_19gE2IcJrt7nYb_jXa9VwmmPbH-GDUFGVVbk3uoGCIcpxPSTiwEn7RSC2iSb_kARyOb7ft5546TKiODN-98QMV7lQTn4kZ59RqgC2w7rwDui85He_X21z0GcK9Ipkg5tRm5U7GNqzZtT3Ev952VOUW960istZ6s5gMpcngv0YMGBqnboYqHC3Uq22-ZRM7ya1ijJOi-UD0ozdGNrLs6kdAQWlvrGh7NAnpEdpBfxq_2CuxLZxTI8TGXfpXH39Njc_L3241AISN7HyTrHsoA2F0QIoIE6njMcxaqQy8OWeWYJD7jAhiWMCE-M5UGUbgJUB5BpUV4Q_hndQqL_c5YVf2Fbc98_8vVwtsUeqbMB97qgN3Pq3du00N7rJ7zs9SNuO3D_2A9KD9Y7tN7QywXA565HQC2k-OJpkVqsRDsihWpn3qtTMaSu0OKJS6rKeugSNE6VlsGFC_PoD_6qx3FpcAPsl5_3MDuE-aZBden_iMfUkdXKxZFrkYbc2bLMekoQwa3gfrjBc4EoN9aPbIux3dqS8nBS6-31UCIMkfEv6OmKmm0_wIm-CeMUM8BW9EgGk_9k9kOySZbTQ5VxwomOLWHundKCFTp_I3adoobUORpbxl9LivFqX0T47w5ktblOMUiTMSzgmI4WbGYrvi4otb33vH88aRc_WneCeoSuWFnCUih2R8xBNqhqIESIB1zTqYnVlaENTNZXIRfw7qSatT6i7pnkaBygp059LeBJCkG79V0yB_ZnNTHX3oTViHHNfFmTpeuT7puhWFBkgQnLzr0zdc03hyjVNA99BhR3dz1gjL3TP8TgaYG6LLS2h-6HeLYRX8uDi-SmVU1hIvWR11l6dbzcQrj4b5cjMbbHvyxaegaXCNB5LPLRxg03z1Z74faueBRfWb3l2z_slbAhmJK2KJe9evl47_Fd5RgVAjbxRqwwFAAyUtzKtyHGZhUN7lJrOFATl89mzpGNg0Qt3lTC7rfzCD0xFWruC7PZnw7lCI8aNsPnNMG-2En-JE1eTyMUyG9um7ernec_AUqqntf7JjvNbjQO_PBu6qsOAsaKWbx1DxgEOFa-LPT7NGzBPr13pMFjIoiOXmLUexAl_LuZyEJuyjtfijSepZ6pYEKPQvAFMyNFBO-Og-jRoHaw78mVsoNV2jURkVwDfFuTeA_it5Xk00zgRGra3z1WELN8r-VWBewlj69H7ui4GF0PWZNEG5nxxZbmmrZgvj-Zqv9oCKHC60El2jX2KMniXiBXW-wcoh5pqT4P4dMOqkLdtpOtFvdWW0cQBJEdGcccfWdd0NUIhr0pSL3tfJ5yPxke8kTpHuwIb7Dbb55nqYDpyU-3hdx1QJtTFcCT2EottF0XDx1nrmLM9t_ZpZRx06tOOhK-CQLYNouqaMkpIEuW-utycHuS6qW-dNX95b15r3z1wuLxBA7CxgjYHmswedWnvMNshEIcTLAAYHttSsUVRBVLNVllqKs9swEN2Klq1L0d8iW3KGkpiGfrPpVeobcwB9E2sPIZyjNPwxlQboVAU8evbuk6e4slGTJwnz0VvDpRDtqM9Kz0ndIcuaOoB9he57zi037Aup8C2G8_qATcBhka7SHfP8XJdlDjz7cU5ACl2Mt0FH1C6HPBJj_FKbWLxjPgM17vfeDqgI_R6Du05kTFpQuwyqtnXYk10bd-M50jIWfrlrX-pdSObjolCVEtuUt2lZvZahe0r2bg87Zbk3eFU9bI8eVtdosvSGtP9ZrKfe5BjrfMAC0XsKfWwoKT0JXznXD0Brw11PBQwsslusQOPI6HqskmmaE3NCkKB9a2Wnzs1eO1_Ompqbx_J7uoBphNMzlnrOQL74UVRifDqTFc_o0-rhp3EaXnlDnuOCbYwbOO7Ah3jX5OdU49Vnm-VHIB5_MAtYeEonVaMdSyXa1LXboy-LespvK9P7x1Zfnk5FW9SQCEa1cp7_dXD4h5ho7shKTzPLxbFShKQ_twsoP7JeMdZd1MNCtt_7B9Be-uRfGPwV2XQijME0xtq_8OMhbxFAJh-6MLVZqqKlDSw',
+        tag: 'kKoF2f10Da0kBqX2brBZug',
+      },
+    },
+  };
+  const password = 'test';
+
+  beforeEach(async () => {
+    wallet = await createWallet({
+      databasePath: ':memory:',
+    });
+    accountProvider = createAccountProvider({wallet});
+    didProvider = createDIDProvider({wallet});
+  });
+
+  describe('importDID', () => {
+    it('expect to import DID', async () => {
+      await didProvider.importDID({
+        encryptedJSONWallet: didBackupFile,
+        password,
+      });
+
+      const documents = await wallet.getAllDocuments();
+      const keyDocument = documents.find(
+        item => item.type === 'Ed25519VerificationKey2018',
+      );
+      const didResolution = documents.find(
+        item => item.type === 'DIDResolutionResponse',
+      );
+      expect(documents.length).toBe(4);
+      expect(didResolution).toBeDefined();
+      expect(keyDocument).toBeDefined();
+    });
+    it('expect to avoid duplicated DID', async () => {
+      await didProvider.importDID({
+        encryptedJSONWallet: didBackupFile,
+        password,
+      });
+
+      await expect(
+        didProvider.importDID({
+          encryptedJSONWallet: didBackupFile,
+          password,
+        }),
+      ).rejects.toThrowError('DID already exists in wallet');
+    });
+  });
+
+  describe('create DID Dock', () => {
+    it('expect to create a DID Dock', async () => {
+      const account = await accountProvider.create({
+        name: 'test',
+      });
+
+      jest.spyOn(didServiceRPC, 'registerDidDock').mockResolvedValueOnce({
+        dockDID: 'did:dock:abcde',
+        keyPairWalletId: account.address,
+      });
+
+      jest.spyOn(didServiceRPC, 'generateKeyDoc').mockResolvedValueOnce({
+        id: 'did:dock:abcde#key-1',
+        type: 'KeyDocument',
+      });
+
+      jest.spyOn(didServiceRPC, 'getDidDockDocument').mockResolvedValueOnce({
+        id: 'did:dock:abcde#key-2',
+        type: 'DidDocument',
+      });
+
+      await didProvider.createDIDock({
+        address: account.address,
+        name: 'Test DID',
+      });
+
+      const keyDocuments = await wallet.getDocumentsByType('KeyDocument');
+      const didDocument = await wallet.getDocumentsByType(
+        'DIDResolutionResponse',
+      );
+
+      expect(keyDocuments.length).toBe(1);
+      expect(didDocument.length).toBe(2);
+    });
+    it('expect to assert parameters', async () => {
+      await expect(
+        didProvider.createDIDock({
+          address: null,
+          name: 'Test DID',
+        }),
+      ).rejects.toThrowError('address is required');
+
+      await expect(
+        didProvider.createDIDock({
+          address: 'some-address',
+          name: '',
+        }),
+      ).rejects.toThrowError('name is required');
+
+      await expect(
+        createDIDock({
+          address: 'some-address',
+          name: 'Some name',
+          wallet: null,
+        }),
+      ).rejects.toThrowError('wallet is required');
+    });
+  });
+
+  describe('create DID Key', () => {
+    it('expect to create a DID Key', async () => {
+
+      jest.spyOn(didServiceRPC, 'generateKeyDoc').mockResolvedValueOnce({
+        id: 'did:key:abcde#key-1',
+        type: 'KeyDocument',
+      });
+
+      jest.spyOn(didServiceRPC, 'keypairToDIDKeyDocument').mockResolvedValueOnce({
+        didDocument: {
+          id: 'did:key:abcde#key-2',
+          type: 'DidDocument',
+        }
+      });
+
+      jest.spyOn(didServiceRPC, 'getDIDResolution').mockResolvedValueOnce({
+        id: new Date().getTime().toString(),
+        type: 'DIDResolutionResponse',
+        didDocument: {
+          id: 'did:key:abcde#key-2',
+          type: 'DidDocument',
+        },
+        correlation: [],
+      });
+
+      await didProvider.createDIDKey({
+        name: 'Test DID',
+      });
+
+      const keyDocuments = await wallet.getDocumentsByType('KeyDocument');
+      const didDocument = await wallet.getDocumentsByType(
+        'DIDResolutionResponse',
+      );
+
+      expect(keyDocuments.length).toBe(1);
+      expect(didDocument.length).toBe(2);
+    });
+    it('expect to assert parameters', async () => {
+
+      await expect(
+        didProvider.createDIDKey({
+          name: ''
+        }),
+      ).rejects.toThrowError('name is required');
+
+      await expect(
+        createDIDKey({
+          name: 'Some name',
+          wallet: null,
+        }),
+      ).rejects.toThrowError('wallet is required');
+    });
+  });
+});