@docknetwork/wallet-sdk-core 0.4.19 → 1.4.0

package/src/message-provider.ts

@@ -1,3 +1,4 @@
+import {logger} from '@docknetwork/wallet-sdk-data-store/src/logger';
 import {IDIDProvider} from './did-provider';
 import {WalletDocumentTypes, captureException} from './helpers';
 import {IWallet} from './types';
@@ -14,6 +15,7 @@ export interface IMessageProvider {
   waitForMessage: () => Promise<any>;
   markMessageAsRead: (messageId: string) => Promise<void>;
   clearCache: () => Promise<void>;
+  processMessageRecurrentJob: () => Promise<void>;
 }
 
 async function getKeyPairDocs(didProvider: IDIDProvider, did?: string) {
@@ -50,15 +52,30 @@ export function createMessageProvider({
       await wallet.removeDocument(messageId);
     } catch (error) {
       captureException(error);
-      throw new Error(`Failed to mark message as read: ${error.message}`);
+      console.error(`Failed to mark message as read: ${error.message}`);
     }
   }
 
+  let processingLock = false;
   async function processDIDCommMessages(limit = 1) {
+    if (processingLock) {
+      return;
+    }
+
+    processingLock = true;
     try {
+      const processMessagesStartTime = Date.now();
       const messages = await wallet.getDocumentsByType(
         WalletDocumentTypes.DIDCommMessage,
       );
+
+      if (messages.length === 0) {
+        return;
+      }
+
+      logger.debug('Processing DIDComm messages');
+      
+
       const keyPairDocs = await getKeyPairDocs(didProvider);
       let count = 0;
       for (const message of messages) {
@@ -80,8 +97,8 @@ export function createMessageProvider({
             decryptedMessage,
             messageId: message.id,
           });
+          await markMessageAsRead(message.id);
           count++;
-          // the wallet app will call markMessageAsRead after the message is processed
         } catch (err) {
           if (err.message?.includes('the DID in question does not exist')) {
             // the DID lookup failed (a testnet credential was issued to a mainnet did), so we can't
@@ -91,43 +108,84 @@ export function createMessageProvider({
           captureException(err);
         }
       }
+      logger.performance('Processed messages', processMessagesStartTime);
     } catch (error) {
       captureException(error);
       throw new Error(`Failed to process DIDComm messages: ${error.message}`);
+    } finally {
+      processingLock = false;
     }
   }
 
+  let recentlyFetchedMessages = [];
+
   async function fetchMessages() {
     try {
+      logger.debug('Fetching messages');
+      const fetchMessagesStartTime = Date.now();
       const keyPairDocs = await getKeyPairDocs(didProvider);
-      const encryptedMessages = await relayService.getMessages({
+      let encryptedMessages = await relayService.getMessages({
         keyPairDocs,
         limit: FETCH_MESSAGE_LIMIT,
         skipMessageResolution: true,
       });
+      const messageIdsPerDid = {};
 
-      if (encryptedMessages.length) {
-        console.log(`Fetched ${encryptedMessages.length} messages`);
+      encryptedMessages = encryptedMessages.filter(
+        message => !recentlyFetchedMessages.includes(message._id),
+      );
+
+      if (!encryptedMessages.length) {
+        return;
       }
 
+      console.log(`Fetched ${encryptedMessages.length} messages`);
+
       for (const message of encryptedMessages) {
         try {
+          if (!messageIdsPerDid[message.to]) {
+            messageIdsPerDid[message.to] = [];
+          }
+
+          messageIdsPerDid[message.to].push(message._id);
+
           await wallet.addDocument({
             id: message._id,
             type: WalletDocumentTypes.DIDCommMessage,
             encryptedMessage: message,
           });
+
+          recentlyFetchedMessages.push(message._id);
         } catch (err) {
           // this message will be lost if it fails to be stored in the wallet
           captureException(err);
         }
       }
 
+      for (const [did, messageIds] of Object.entries(messageIdsPerDid)) {
+        logger.debug(`Acknowledging messages for ${did}`);
+        let startTime = new Date().getTime();
+        relayService
+          .ackMessages({
+            did,
+            messageIds,
+          })
+          .then(() => {
+            logger.performance('Acknowledged messages', startTime);
+          })
+          .catch(err => {
+            console.error('Failed to ack messages', err.message);
+          });
+      }
+
       if (encryptedMessages.length > 0) {
         wallet.eventManager.emit(
           'didcomm-messages-received',
           encryptedMessages,
         );
+
+        logger.debug(`Received ${encryptedMessages.length} messages`);
+        logger.performance('Fetched messages', fetchMessagesStartTime);
       }
 
       return encryptedMessages;
@@ -137,22 +195,27 @@ export function createMessageProvider({
     }
   }
 
-
   function addMessageListener(handler) {
     const listener = async message => {
       await Promise.resolve(handler(message.decryptedMessage));
-      await markMessageAsRead(message.messageId);
     };
 
     wallet.eventManager.addListener('didcomm-message-decrypted', listener);
     return () =>
-      wallet.eventManager.removeListener(
-        'didcomm-message-decrypted',
-        listener,
-      );
-  };
+      wallet.eventManager.removeListener('didcomm-message-decrypted', listener);
+  }
 
-  let listnerIntervalId = null;
+  let listenerIntervalId = null;
+
+  const processMessageInterval = 3000;
+
+  async function processMessageRecurrentJob() {
+    try {
+      await processDIDCommMessages();
+    } finally {
+      setTimeout(processMessageRecurrentJob, processMessageInterval);
+    }
+  }
 
   return {
     async sendMessage({
@@ -165,7 +228,6 @@ export function createMessageProvider({
       body,
       type,
     }) {
-
       // TODO: rename relay service parameters to make it easier to understand
       if (from) {
         did = from;
@@ -184,7 +246,12 @@ export function createMessageProvider({
         if (!keyPairDoc) {
           throw new Error(`${did} not found in didDocs`);
         }
-        await relayService.sendMessage({keyPairDoc, message, recipientDid, type});
+        await relayService.sendMessage({
+          keyPairDoc,
+          message,
+          recipientDid,
+          type,
+        });
       } catch (error) {
         captureException(error);
         throw new Error(`Failed to send message: ${error.message}`);
@@ -192,30 +259,35 @@ export function createMessageProvider({
     },
     waitForMessage() {
       return new Promise((resolve: any) => {
-        let removeListener = addMessageListener(async (message) => {
+        let removeListener = addMessageListener(async message => {
           removeListener();
           await resolve(message);
-        })
+        });
       });
     },
     startAutoFetch(timeout = 2000) {
-      clearInterval(listnerIntervalId);
-      listnerIntervalId = setInterval(async () => {
+      clearInterval(listenerIntervalId);
+      listenerIntervalId = setInterval(async () => {
         await fetchMessages();
         await processDIDCommMessages();
       }, timeout);
 
-      return () => clearInterval(listnerIntervalId);
+      return () => clearInterval(listenerIntervalId);
     },
     clearCache: async () => {
-      return Promise.all((await wallet.getDocumentsByType(WalletDocumentTypes.DIDCommMessage)).map(document => {
-        markMessageAsRead(document.id);
-        return wallet.removeDocument(document.id);
-      }));
+      return Promise.all(
+        (
+          await wallet.getDocumentsByType(WalletDocumentTypes.DIDCommMessage)
+        ).map(document => {
+          markMessageAsRead(document.id);
+          return wallet.removeDocument(document.id);
+        }),
+      );
     },
     fetchMessages,
     addMessageListener,
     processDIDCommMessages,
+    processMessageRecurrentJob,
     markMessageAsRead,
-  };
+  } as any;
 }

package/src/messages/message-helpers.test.ts

@@ -0,0 +1,15 @@
+import {buildVerifiablePresentationMessage} from './message-helpers';
+
+describe('message-helpers', () => {
+  it('should build a verifiable presentation message from the holder to the verifier', () => {
+    const message = buildVerifiablePresentationMessage({
+      holderDID: 'holderDID',
+      verifierDID: 'verifierDID',
+      presentation: 'presentation',
+      proofRequestId: 'proofRequestId',
+    });
+
+    expect(message.from).toBe('holderDID');
+    expect(message.to).toBe('verifierDID');
+  });
+});

package/src/messages/message-helpers.ts

@@ -92,8 +92,8 @@ export function buildVerifiablePresentationMessage({
 }) {
   return {
     type: MessageTypes.Presentation,
-    from: verifierDID,
-    to: holderDID,
+    from: holderDID,
+    to: verifierDID,
     body: {
       proofRequestId,
       presentation,

package/src/network-resolver.test.ts

@@ -3,23 +3,27 @@ import {
   accountResolver,
   credentialResolver,
   dockDocumentNetworkResolver,
+  proofRequestResolver,
   resolveApiNetwork,
 } from './network-resolver';
+import {createDataStore} from '@docknetwork/wallet-sdk-data-store-typeorm/src';
 
 describe('Wallet', () => {
   let wallet: IWallet;
 
   beforeEach(async () => {
     wallet = await createWallet({
-      databasePath: ':memory:',
-      documentNetworkResolver: dockDocumentNetworkResolver,
+      dataStore: await createDataStore({
+        databasePath: ':memory:',
+        documentNetworkResolver: dockDocumentNetworkResolver,
+      }),
     });
   });
 
   it('resolveApiNetwork', () => {
     expect(
       resolveApiNetwork({
-        url: 'https://creds-staging.dock.io/proof/0bb39274-4ef1-4e7f-ab8d-d91d8926d9af',
+        url: 'https://creds-example.dock.io/proof/0bb39274-4ef1-4e7f-ab8d-d91d8926d9af',
         dataStore: wallet.dataStore,
       }),
     ).toBe('testnet');
@@ -104,7 +108,7 @@ describe('Wallet', () => {
     it('expect to resolve credential to testnet', async () => {
       const result = await credentialResolver({
         document: {
-          id: 'https://creds-staging.dock.io/d39b15fe997004db702c9faaf98f9fd619cdf40088549648fb288ea679b53e23?_ga=2.46968743.1402343540.1684360698-1482908456.1677577177',
+          id: 'https://creds-example.dock.io/d39b15fe997004db702c9faaf98f9fd619cdf40088549648fb288ea679b53e23?_ga=2.46968743.1402343540.1684360698-1482908456.1677577177',
           type: ['VerifiableCredential'],
         },
         dataStore: wallet.dataStore,
@@ -139,4 +143,69 @@ describe('Wallet', () => {
       expect(result).toBe('mainnet');
     });
   });
+
+  describe('proofRequestResolver', () => {
+    it('should detect a testnet proof request', async () => {
+      let result = await dockDocumentNetworkResolver({
+        document: {
+          qr: 'https://creds-testnet.dock.io/proof/4970377a-6283-46d8-b95e-db99b011e48c',
+          id: '4970377a-6283-46d8-b95e-db99b011e48c',
+          response_url:
+            'https://api-testnet.dock.io/proof-requests/4970377a-6283-46d8-b95e-db99b011e48c/send-presentation',
+          type: 'proof-request',
+        },
+        dataStore: wallet.dataStore,
+      });
+
+      expect(result.networkId).toBe('testnet');
+      expect(result.resolver).toBe(proofRequestResolver);
+
+      result = await dockDocumentNetworkResolver({
+        document: {
+          qr: 'https://creds-testnet.dock.io/proof/4970377a-6283-46d8-b95e-db99b011e48c',
+          id: '4970377a-6283-46d8-b95e-db99b011e48c',
+          response_url:
+            'https://api-testnet.dock.io/proof-requests/4970377a-6283-46d8-b95e-db99b011e48c/send-presentation',
+          type: 'proof-request',
+        },
+        dataStore: wallet.dataStore,
+      });
+
+      expect(result.networkId).toBe('testnet');
+    });
+
+    it('should detect a mainnet proof request', async () => {
+      const result = await dockDocumentNetworkResolver({
+        document: {
+          qr: 'https://creds.dock.io/proof/4970377a-6283-46d8-b95e-db99b011e48c',
+          id: '4970377a-6283-46d8-b95e-db99b011e48c',
+          response_url:
+            'https://api-testnet.dock.io/proof-requests/4970377a-6283-46d8-b95e-db99b011e48c/send-presentation',
+          type: 'proof-request',
+        },
+        dataStore: wallet.dataStore,
+      });
+
+      expect(result.networkId).toBe('mainnet');
+      expect(result.resolver).toBe(proofRequestResolver);
+    });
+
+    it('should fallback to current network', async () => {
+      await wallet.setNetwork('mainnet');
+
+      const result = await dockDocumentNetworkResolver({
+        document: {
+          qr: 'https://something.dock.io/proof/4970377a-6283-46d8-b95e-db99b011e48c',
+          id: '4970377a-6283-46d8-b95e-db99b011e48c',
+          response_url:
+            'https://something.dock.io/proof-requests/4970377a-6283-46d8-b95e-db99b011e48c/send-presentation',
+          type: 'proof-request',
+        },
+        dataStore: wallet.dataStore,
+      });
+
+      expect(result.networkId).toBe('mainnet');
+      expect(result.isFallback).toBe(true);
+    });
+  });
 });

package/src/network-resolver.ts

@@ -15,10 +15,10 @@ export const dockDocumentNetworkResolver: DocumentNetworkResolver = async ({
 }: DocumentResolverProps): Promise<DocumentResolverResult> => {
   let networkId;
   let isFallback = false;
-
+  let currentResolver;
   for (const resolver of resolvers) {
     networkId = await resolver({document, dataStore});
-
+    currentResolver = resolver;
     if (networkId) {
       break;
     }
@@ -32,6 +32,7 @@ export const dockDocumentNetworkResolver: DocumentNetworkResolver = async ({
   return {
     networkId: networkId,
     isFallback,
+    resolver: currentResolver,
   };
 };
 
@@ -51,8 +52,14 @@ export function resolveApiNetwork({
 }) {
   for (const network of dataStore.networks) {
     for (const hostname of network.credentialHostnames) {
-      if (url.indexOf(hostname) > -1) {
-        return network.id;
+      if (hostname instanceof RegExp) {
+        if (hostname.test(url)) {
+          return network.id;
+        }
+      } else {
+        if (url.indexOf(hostname) > -1) {
+          return network.id;
+        }
       }
     }
   }
@@ -80,6 +87,27 @@ export async function credentialResolver({
   });
 }
 
+export async function proofRequestResolver({
+  document,
+  dataStore,
+}: DocumentResolverProps): Promise<ResolverResult> {
+  if (!document) {
+    return null;
+  }
+
+  const isProofRequest =
+    document.type === 'proof-request' && document.qr;
+
+  if (!isProofRequest) {
+    return null;
+  }
+
+  return resolveApiNetwork({
+    url: document.qr,
+    dataStore,
+  });
+}
+
 export async function didResolver({
   document,
   dataStore,
@@ -96,7 +124,9 @@ export async function accountResolver({
     return null;
   }
 
-  const isAddress = Array.isArray(document.type) ? document.type.includes('Address') : document.type === 'Address';
+  const isAddress = Array.isArray(document.type)
+    ? document.type.includes('Address')
+    : document.type === 'Address';
 
   if (!isAddress) {
     return null;
@@ -119,4 +149,9 @@ export async function accountResolver({
   return network?.id;
 }
 
-const resolvers = [credentialResolver, accountResolver, didResolver];
+const resolvers = [
+  credentialResolver,
+  accountResolver,
+  didResolver,
+  proofRequestResolver,
+];

package/src/types.ts

@@ -37,16 +37,16 @@ export type IWallet = {
   getDocumentsById: (idList: string[]) => Promise<WalletDocument[]>;
   getDocumentsByType: (type: string) => Promise<WalletDocument[]>;
   getAllDocuments: () => Promise<WalletDocument[]>;
-  addDocument: (json: any) => Promise<WalletDocument>;
-  upsertDocument: (json: any) => Promise<WalletDocument>;
-  updateDocument: (json: any) => Promise<WalletDocument>;
+  addDocument: (json: any, options?: any) => Promise<WalletDocument>;
+  upsertDocument: (json: any, options?: any) => Promise<WalletDocument>;
+  updateDocument: (json: any, options?: any) => Promise<WalletDocument>;
   getDocumentCorrelations: (documentId: string) => Promise<WalletDocument[]>;
   getAccountKeyPair: (accountId: string) => Promise<any>;
   /**
    * Remove document by id
    * @param id
    */
-  removeDocument: (id: string) => Promise<void>;
+  removeDocument: (id: string, options?: any) => Promise<void>;
   /**
    * Import data from a Universal Wallet 2020 JSON
    * https://w3c-ccg.github.io/universal-wallet-interop-spec/
@@ -72,4 +72,10 @@ export type IWallet = {
   dataStore: DataStore;
 } & IV1Wallet;
 
-export type CreateWalletProps = DataStoreConfigs & {};
+export type CrateWalletWithDataStore = {
+  
+}
+
+export type CreateWalletProps = {
+  dataStore: DataStore;
+}

package/src/v1-helpers.ts

@@ -41,11 +41,11 @@ export async function toV1Wallet(wallet: IWallet): Promise<IWallet> {
 
       return wallet.getAllDocuments();
     },
-    remove(id: string): Promise<void> {
+    remove(id: string, options: any): Promise<void> {
       return wallet.removeDocument(id);
     },
-    add(json: any): Promise<WalletDocument> {
-      return wallet.addDocument(json);
+    add(json: any, options): Promise<WalletDocument> {
+      return wallet.addDocument(json, options);
     },
     resolveCorrelations(id: string): Promise<WalletDocument[]> {
       return wallet.getDocumentCorrelations(id);
@@ -53,8 +53,8 @@ export async function toV1Wallet(wallet: IWallet): Promise<IWallet> {
     sync(): Promise<void> {
       return Promise.resolve(undefined);
     },
-    update(json: any): Promise<WalletDocument> {
-      return wallet.updateDocument(json);
+    update(json: any, options): Promise<WalletDocument> {
+      return wallet.updateDocument(json, options);
     },
     upsert(json: any): Promise<WalletDocument> {
       return wallet.upsertDocument(json);
@@ -80,7 +80,7 @@ export type KeypairType = 'sr25519' | 'ed25519' | 'ecdsa';
 export function toV1WalletService(wallet: IWallet) {
   return {
     getDocumentById: id => {
-      return wallet.getDocumentById(id);
+      return wallet.dataStore.documents.getDocumentById(id);
     },
     // accounts are not required in a wallet
     // Ideally should move this code to the accounts provider file

package/src/verification-controller.test.ts

@@ -12,6 +12,8 @@ import anyCredentialProofRequest from './fixtures/any-credential-proof-request.j
 import universityDegreeProofRequest from './fixtures/university-degree-proof-request.json';
 import {createDIDProvider, IDIDProvider} from './did-provider';
 import {WalletEvents} from '@docknetwork/wallet-sdk-wasm/src/modules/wallet';
+import {replaceResponseURL} from './helpers';
+import {createDataStore} from '@docknetwork/wallet-sdk-data-store-typeorm/src';
 
 describe('Verification provider', () => {
   let wallet: IWallet;
@@ -19,8 +21,10 @@ describe('Verification provider', () => {
 
   beforeAll(async () => {
     wallet = await createWallet({
-      databasePath: ':memory:',
-      defaultNetwork: 'testnet',
+      dataStore: await createDataStore({
+        databasePath: ':memory:',
+        defaultNetwork: 'testnet',
+      }),
     });
 
     await wallet.waitForEvent(WalletEvents.networkConnected);
@@ -93,8 +97,9 @@ describe('Verification provider', () => {
       didProvider,
     });
 
+    const updatedTemplate = replaceResponseURL(iiwTemplate);
     await controller.start({
-      template: iiwTemplate,
+      template: updatedTemplate,
     });
 
     const credentials = controller.getFilteredCredentials();

package/src/verification-controller.ts

@@ -10,7 +10,6 @@ import {EventEmitter} from 'events';
 import axios from 'axios';
 import assert from 'assert';
 import {createDIDProvider, IDIDProvider} from './did-provider';
-import { getWallet } from '@docknetwork/wallet-sdk-data-store/src/entities/wallet.entity';
 
 export enum VerificationStatus {
   Started = 'Started',
@@ -151,6 +150,10 @@ export function createVerificationController({
     return credentialServiceRPC.isBBSPlusCredential({credential});
   }
 
+  async function isKvacCredential(credential) {
+    return credentialServiceRPC.isKvacCredential({credential});
+  }
+
   async function createPresentation() {
     assert(!!selectedDID, 'No DID selected');
     assert(!!selectedCredentials.size, 'No credentials selected');
@@ -164,13 +167,12 @@ export function createVerificationController({
 
     for (const credentialSelection of selectedCredentials.values()) {
       const isBBS = await isBBSPlusCredential(credentialSelection.credential);
+      const isKVAC = await isKvacCredential(credentialSelection.credential);
 
-      if (!isBBS) {
-        credentials.push(credentialSelection.credential);
-      } else {
-        // derive BBS credential
+      if (isBBS || isKVAC) {
+        // derive credential
         const derivedCredentials =
-          await credentialServiceRPC.deriveVCFromBBSPresentation({
+          await credentialServiceRPC.deriveVCFromPresentation({
             proofRequest: templateJSON,
             
             credentials: [
@@ -188,6 +190,8 @@ export function createVerificationController({
         console.log('Credential derived');
 
         credentials.push(derivedCredentials[0]);
+      } else {
+        credentials.push(credentialSelection.credential);
       }
     }
 

package/src/wallet-to-wallet-verification/walletToWalletVerificationProvider.ts

@@ -12,6 +12,7 @@ import {
 import {IWallet} from '../types';
 import {IMessageProvider} from '../message-provider';
 import {logger} from '@docknetwork/wallet-sdk-data-store/src/logger';
+import { EventEmitter } from 'events';
 
 const ProofRequestTemplateType = 'ProofRequestTemplate';
 
@@ -29,6 +30,12 @@ export interface IWalletToWalletVerificationProvider {
   addProofRequestTemplate: (proofRequestTemplate: any) => Promise<any>;
   getProofRequestTemplates: () => Promise<any[]>;
   handleMessage: (message: any) => Promise<boolean>;
+  eventEmitter: EventEmitter;
+}
+
+export const Events = {
+  VerifierFlowStarted: 'VerifierFlowStarted',
+  HolderFlowStarted: 'HolderFlowStarted',
 }
 
 export function createWalletToWalletVerificationProvider({
@@ -47,7 +54,10 @@ export function createWalletToWalletVerificationProvider({
   // Can be used by the HOLDER to render the verification results sent by the verifier
   let presentationAckHandler;
 
+  const eventEmitter = new EventEmitter();
+
   return {
+    eventEmitter,
     getInvitationOOBMessage: async ({templateId}) => {
       const defaultDID = await didProvider.getDefaultDID();
       const template = await wallet.getDocumentById(templateId);
@@ -100,6 +110,9 @@ export function createWalletToWalletVerificationProvider({
             verifierDID: message.from,
           }),
         );
+
+        eventEmitter.emit(Events.HolderFlowStarted);
+
         return true;
       }
 
@@ -132,6 +145,8 @@ export function createWalletToWalletVerificationProvider({
               verifierDID: defaultDID,
             }),
           );
+
+          eventEmitter.emit(Events.VerifierFlowStarted);
         }
 
         process();

package/src/wallet-wasm.ts

@@ -64,7 +64,7 @@ export async function initWalletWasm(wallet: IWallet) {
     await setSubstrateNetwork(wallet);
 
     wallet.eventManager.on(WalletEvents.networkUpdated, async () => {
-      handleSubstrateNetworkChange(wallet);
+      handleSubstrateNetworkChange(wallet).catch(err => console.error(err));
     });
   }