@docknetwork/wallet-sdk-core 0.4.19

package/src/fixtures/university-degree-bbs.json

@@ -0,0 +1,57 @@
+{
+  "@context": [
+    "https://www.w3.org/2018/credentials/v1",
+    {
+      "dk": "https://ld.dock.io/credentials#",
+      "UniversityDegree": "dk:UniversityDegree",
+      "degreeName": "dk:degreeName",
+      "degreeType": "dk:degreeType",
+      "dateEarned": "dk:dateEarned",
+      "name": "dk:name",
+      "email": "dk:email",
+      "dateOfBirth": "dk:dateOfBirth",
+      "description": "dk:description",
+      "logo": "dk:logo"
+    }
+  ],
+  "id": "https://creds-testnet.dock.io/cc2e0be92a9533ca68466ad011ea916216fedac6473d17b1bd0fc3a01b623b09",
+  "type": [
+    "VerifiableCredential",
+    "UniversityDegree"
+  ],
+  "credentialSubject": {
+    "id": "recipient id",
+    "degreeName": "degree name",
+    "degreeType": "degree type",
+    "dateEarned": "2023-02-07",
+    "name": "full name",
+    "email": "email@email.com",
+    "dateOfBirth": "2023-02-08"
+  },
+  "issuanceDate": "2023-02-06T11:15:19.995Z",
+  "name": "University Degree",
+  "proof": {
+    "@context": [
+      {
+        "sec": "https://w3id.org/security#",
+        "proof": {
+          "@id": "sec:proof",
+          "@type": "@id",
+          "@container": "@graph"
+        }
+      },
+      "https://ld.dock.io/security/bbs/v1"
+    ],
+    "type": "Bls12381BBS+SignatureDock2022",
+    "created": "2023-02-06T11:42:24Z",
+    "verificationMethod": "did:dock:5GAFgFX6dUMYzZKiRKHvV4nK92X64D5ekfy3WVpNEeMUnu38#keys-2",
+    "proofPurpose": "assertionMethod",
+    "proofValue": "znokfKbFLiBqTjuZVkg3FGftrogKGm47DKDSNRjwqd8SBQiw7iqeYpTdapL9cRGhax4R9pVwrDicWrm4P9fAmAAVjSHz79jZGnX9AVWesbn7HFssbguZgx2ZzXS6ySyfPfDa8qhUuMsepV6oDcydhEA4Hd"
+  },
+  "issuer": {
+    "name": "My New DID",
+    "description": "",
+    "logo": "",
+    "id": "did:dock:5GAFgFX6dUMYzZKiRKHvV4nK92X64D5ekfy3WVpNEeMUnu38"
+  }
+}

package/src/fixtures/university-degree-proof-request.json

@@ -0,0 +1,32 @@
+{
+  "qr": "https://creds-testnet.dock.io/proof/6de279ba-caf3-4979-a067-553284b40767",
+  "id": "6de279ba-caf3-4979-a067-553284b40767",
+  "name": "University Degree Credential",
+  "nonce": "b75fab9a5006216173500bfd3df5d0c5",
+  "created": "2023-08-09T20:19:46.278Z",
+  "updated": "2023-08-09T20:19:46.278Z",
+  "verified": false,
+  "response_url": "https://api-testnet.dock.io/proof-requests/6de279ba-caf3-4979-a067-553284b40767/send-presentation",
+  "request": {
+    "id": "6de279ba-caf3-4979-a067-553284b40767",
+    "input_descriptors": [
+      {
+        "id": "Credential 1",
+        "name": "University Degree Credential",
+        "purpose": "Any University Degree Credential",
+        "constraints": {
+          "fields": [
+            {
+              "path": ["$.name"],
+              "filter": {
+                "type": "string",
+                "pattern": "University Degree"
+              }
+            }
+          ]
+        }
+      }
+    ]
+  },
+  "type": "proof-request"
+}

package/src/helpers.ts

@@ -0,0 +1,61 @@
+import axios from 'axios';
+import assert from 'assert';
+
+// Sentry implementation will be injected by the wallet-app
+let sentryCaptureException: any = error => {
+  console.error(error);
+};
+
+export function setSentryCaptureException(impl: any) {
+  sentryCaptureException = impl;
+}
+
+export function captureException(error) {
+  if (sentryCaptureException) {
+    sentryCaptureException(error);
+  }
+}
+
+
+export const WalletDocumentTypes = {
+  // This is used to store encrypted DIDComm messasges recieved from relay service
+  DIDCommMessage: 'DIDCommMessage',
+};
+
+function isURL(str) {
+  try {
+    // eslint-disable-next-line no-new
+    new URL(str);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+export function getJSONFromURL(url: string) {
+  return axios
+    .get(url)
+    .then(res => res.data)
+    .catch(err => {
+      console.error(`Error fetching ${url}`, err);
+    });
+}
+
+export function getJSON(jsonOrURL: string | any) {
+  assert(!!jsonOrURL, 'jsonOrURL is required');
+
+  if (typeof jsonOrURL === 'object') {
+    return jsonOrURL;
+  }
+
+  if (typeof jsonOrURL === 'string') {
+    if (isURL(jsonOrURL)) {
+      console.log(`Fetching ${jsonOrURL}`);
+      return getJSONFromURL(jsonOrURL);
+    } else {
+      return JSON.parse(jsonOrURL);
+    }
+  }
+
+  throw new Error(`Invalid data ${jsonOrURL}`);
+}

package/src/message-provider.test.ts

@@ -0,0 +1,115 @@
+import {IDIDProvider, createDIDProvider} from './did-provider';
+import {IMessageProvider, createMessageProvider} from './message-provider';
+import {IWallet, createWallet} from './wallet';
+
+describe('MessageProvider', () => {
+  let messageProvider: IMessageProvider;
+  let wallet: IWallet;
+  let didProvider: IDIDProvider;
+  let relayService: any;
+  let didCommMessages = [
+    {
+      _id: '651e965410fc3fcfffdd17f1',
+      to: 'did:key:z6MkoQzWru66w91EH7U9Xsv5eYXQabw9U3ZJd5GkatMWkmZT',
+      from: 'did:key:z6MkoQzWru66w91EH7U9Xsv5eYXQabw9U3ZJd5GkatMWkmZT',
+      msg: '<encrypted-message>',
+    },
+    {
+      _id: '951e965410fc3fcfffdd17f1',
+      to: 'did:key:z6MkoQzWru66w91EH7U9Xsv5eYXQabw9U3ZJd5GkatMWkmZT',
+      from: 'did:key:z6MkoQzWru66w91EH7U9Xsv5eYXQabw9U3ZJd5GkatMWkmZT',
+      msg: '<encrypted-message>',
+    },
+  ];
+
+  beforeEach(async () => {
+    relayService = {
+      sendMessage: jest.fn(),
+      getMessages: jest.fn().mockResolvedValue(didCommMessages),
+      resolveDidcommMessage: jest.fn().mockImplementation(({ message }) => message),
+    };
+
+    wallet = await createWallet({
+      databasePath: ':memory:',
+    });
+    didProvider = createDIDProvider({
+      wallet,
+    });
+    didProvider.getDIDKeyPairs = jest.fn().mockResolvedValue([{controller: "someDid"}])
+    messageProvider = createMessageProvider({
+      wallet,
+      didProvider,
+      relayService,
+    });
+  });
+
+  it('should fetch messages and store encrypted data in the wallet', async () => {
+    const messages = await messageProvider.fetchMessages();
+    expect(messages).toEqual(didCommMessages);
+
+    for(let message of didCommMessages) {
+      const walletMessage = await wallet.getDocumentById(message._id);
+      expect(walletMessage.encryptedMessage).toEqual(message);
+    }
+  });
+
+  it('should decrypt encrypted messages in the wallet', async () => {
+    jest.spyOn(wallet.eventManager, 'emit').mockReset();
+
+    await messageProvider.fetchMessages()
+    await messageProvider.processDIDCommMessages();
+
+    expect(wallet.eventManager.emit).toHaveBeenCalledWith('didcomm-messages-received', didCommMessages);
+    expect(wallet.eventManager.emit).toHaveBeenCalledWith('didcomm-message-decrypted', {"decryptedMessage": didCommMessages[0], "messageId": didCommMessages[0]._id});
+  });
+
+
+  it('should handle errors when fetching messages', async () => {
+    relayService.getMessages.mockRejectedValue(new Error('Fetching failed'));
+    
+    await expect(messageProvider.fetchMessages()).rejects.toThrow('Failed to fetch messages: Fetching failed');
+  });
+
+  it('should handle errors when sending messages', async () => {
+    relayService.sendMessage.mockRejectedValue(new Error('Sending failed'));
+    
+    await expect(
+      messageProvider.sendMessage({
+        did: 'someDid',
+        message: 'someMessage',
+        recipientDid: 'recipientDid',
+      })
+    ).rejects.toThrow('Failed to send message: Sending failed');
+  });
+
+  // it('should handle errors when processing DIDComm messages', async () => {
+  //   relayService.resolveDidcommMessage.mockRejectedValue(new Error('Decryption failed'));
+    
+  //   await expect(messageProvider.processDIDCommMessages()).rejects.toThrow('Failed to process DIDComm messages: Decryption failed');
+  // });
+
+  it('should skip did that fail lookup when processing DIDComm messages', async () => {
+    jest.spyOn(wallet.eventManager, 'emit').mockReset();
+    const messageProvider2 = createMessageProvider({
+      wallet,
+      didProvider,
+      relayService: {
+        ...relayService,
+        resolveDidcommMessage: jest.fn().mockRejectedValueOnce(new Error('A DID document lookup was successful, but the DID in question does not exist. This is different from a network error.')).mockImplementation(({ message }) => message),
+      },
+    });
+
+    await messageProvider2.fetchMessages()
+    await messageProvider2.processDIDCommMessages();
+
+    expect(wallet.eventManager.emit).toHaveBeenCalledWith('didcomm-messages-received', didCommMessages);
+    expect(wallet.eventManager.emit).toHaveBeenCalledWith('didcomm-message-decrypted', {"decryptedMessage": didCommMessages[1], "messageId": didCommMessages[1]._id});
+  });
+
+  it('should handle errors when marking messages as read', async () => {
+    await messageProvider.fetchMessages();
+    wallet.removeDocument = jest.fn().mockRejectedValue(new Error('Removal failed'));
+    
+    await expect(messageProvider.markMessageAsRead('651e965410fc3fcfffdd17f1')).rejects.toThrow('Failed to mark message as read: Removal failed');
+  });
+});

package/src/message-provider.ts

@@ -0,0 +1,221 @@
+import {IDIDProvider} from './did-provider';
+import {WalletDocumentTypes, captureException} from './helpers';
+import {IWallet} from './types';
+import {relayService as defaultRelayService} from '@docknetwork/wallet-sdk-wasm/src/services/relay-service';
+
+const FETCH_MESSAGE_LIMIT = 10;
+
+export interface IMessageProvider {
+  sendMessage: (message: any) => Promise<void>;
+  fetchMessages: () => Promise<void>;
+  processDIDCommMessages: () => Promise<void>;
+  startAutoFetch: (timeout?: number) => () => void;
+  addMessageListener: (handler: () => void) => () => void;
+  waitForMessage: () => Promise<any>;
+  markMessageAsRead: (messageId: string) => Promise<void>;
+  clearCache: () => Promise<void>;
+}
+
+async function getKeyPairDocs(didProvider: IDIDProvider, did?: string) {
+  try {
+    const keyPairDocs = await didProvider.getDIDKeyPairs();
+    if (did) {
+      return keyPairDocs.find(doc => doc.controller === did);
+    }
+    return keyPairDocs;
+  } catch (error) {
+    throw new Error(`Failed to get key pair docs: ${error.message}`);
+  }
+}
+
+export function createMessageProvider({
+  wallet,
+  didProvider,
+  relayService = defaultRelayService,
+}: {
+  wallet: IWallet;
+  didProvider: IDIDProvider;
+  relayService?: any;
+}) {
+  async function markMessageAsRead(messageId: string) {
+    try {
+      const message = await wallet.getDocumentById(messageId);
+
+      if (message.type !== WalletDocumentTypes.DIDCommMessage) {
+        throw new Error(
+          `Document with id ${messageId} is not a DIDCommMessage`,
+        );
+      }
+
+      await wallet.removeDocument(messageId);
+    } catch (error) {
+      captureException(error);
+      throw new Error(`Failed to mark message as read: ${error.message}`);
+    }
+  }
+
+  async function processDIDCommMessages(limit = 1) {
+    try {
+      const messages = await wallet.getDocumentsByType(
+        WalletDocumentTypes.DIDCommMessage,
+      );
+      const keyPairDocs = await getKeyPairDocs(didProvider);
+      let count = 0;
+      for (const message of messages) {
+        if (count >= limit) {
+          return;
+        }
+        try {
+          if (!message.encryptedMessage) {
+            await wallet.removeDocument(message.id);
+            throw new Error(
+              `Message with payload ${JSON.stringify(message)} is invalid`,
+            );
+          }
+          const decryptedMessage = await relayService.resolveDidcommMessage({
+            keyPairDocs,
+            message: message.encryptedMessage,
+          });
+          wallet.eventManager.emit('didcomm-message-decrypted', {
+            decryptedMessage,
+            messageId: 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
+            // decrypt the message remove the message from the wallet
+            await wallet.removeDocument(message.id);
+          }
+          captureException(err);
+        }
+      }
+    } catch (error) {
+      captureException(error);
+      throw new Error(`Failed to process DIDComm messages: ${error.message}`);
+    }
+  }
+
+  async function fetchMessages() {
+    try {
+      const keyPairDocs = await getKeyPairDocs(didProvider);
+      const encryptedMessages = await relayService.getMessages({
+        keyPairDocs,
+        limit: FETCH_MESSAGE_LIMIT,
+        skipMessageResolution: true,
+      });
+
+      if (encryptedMessages.length) {
+        console.log(`Fetched ${encryptedMessages.length} messages`);
+      }
+
+      for (const message of encryptedMessages) {
+        try {
+          await wallet.addDocument({
+            id: message._id,
+            type: WalletDocumentTypes.DIDCommMessage,
+            encryptedMessage: message,
+          });
+        } catch (err) {
+          // this message will be lost if it fails to be stored in the wallet
+          captureException(err);
+        }
+      }
+
+      if (encryptedMessages.length > 0) {
+        wallet.eventManager.emit(
+          'didcomm-messages-received',
+          encryptedMessages,
+        );
+      }
+
+      return encryptedMessages;
+    } catch (error) {
+      captureException(error);
+      throw new Error(`Failed to fetch messages: ${error.message}`);
+    }
+  }
+
+
+  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,
+      );
+  };
+
+  let listnerIntervalId = null;
+
+  return {
+    async sendMessage({
+      did,
+      recipientDid,
+      message,
+      // didcomm message parameters
+      from,
+      to,
+      body,
+      type,
+    }) {
+
+      // TODO: rename relay service parameters to make it easier to understand
+      if (from) {
+        did = from;
+      }
+
+      if (to) {
+        recipientDid = to;
+      }
+
+      if (!message && body) {
+        message = body;
+      }
+
+      try {
+        const keyPairDoc = await getKeyPairDocs(didProvider, did);
+        if (!keyPairDoc) {
+          throw new Error(`${did} not found in didDocs`);
+        }
+        await relayService.sendMessage({keyPairDoc, message, recipientDid, type});
+      } catch (error) {
+        captureException(error);
+        throw new Error(`Failed to send message: ${error.message}`);
+      }
+    },
+    waitForMessage() {
+      return new Promise((resolve: any) => {
+        let removeListener = addMessageListener(async (message) => {
+          removeListener();
+          await resolve(message);
+        })
+      });
+    },
+    startAutoFetch(timeout = 2000) {
+      clearInterval(listnerIntervalId);
+      listnerIntervalId = setInterval(async () => {
+        await fetchMessages();
+        await processDIDCommMessages();
+      }, timeout);
+
+      return () => clearInterval(listnerIntervalId);
+    },
+    clearCache: async () => {
+      return Promise.all((await wallet.getDocumentsByType(WalletDocumentTypes.DIDCommMessage)).map(document => {
+        markMessageAsRead(document.id);
+        return wallet.removeDocument(document.id);
+      }));
+    },
+    fetchMessages,
+    addMessageListener,
+    processDIDCommMessages,
+    markMessageAsRead,
+  };
+}

package/src/messages/message-helpers.ts

@@ -0,0 +1,125 @@
+/**
+ * DIDComm Message helpers
+ * Check https://identity.foundation/didcomm-messaging/spec/#out-of-band-messages for more details
+ */
+
+export const MessageTypes = {
+  Invitation: 'https://didcomm.org/out-of-band/2.0/invitation',
+  RequestPresentation:
+    'https://didcomm.org/present-proof/1.0/request-presentation',
+  Presentation: 'https://didcomm.org/present-proof/1.0/presentation',
+  Ack: 'https://didcomm.org/ack/1.0/ack',
+  IssuerDirect: 'https://didcomm.org/issue-credential/2.0/issue-credential',
+  Basic: 'https://didcomm.org/basicmessage/1.0/message',
+  IssueWithData: 'https://didcomm.org/issue-credential/2.0/offer-credential',
+};
+
+export const Goals = {
+  WalletToWalletVerification: 'wallet-to-wallet-verification',
+  PresentationAckFromVerifier: 'presentation-ack-from-verifier',
+};
+
+/**
+ *
+ * @return OOB message to start a wallet to wallet verification flow
+ * The holder will scan it as QR code and should have the context to start the verification flow
+ *
+ */
+export function buildVerificationFlowInviteMessage({verifierDID, proofRequestId}) {
+  return {
+    type: MessageTypes.Invitation,
+    from: verifierDID,
+    body: {
+      goal_code: Goals.WalletToWalletVerification,
+      goal: 'Invite for a Wallet to Wallet Verification',
+      proofRequestId: proofRequestId,
+    },
+  };
+}
+
+/**
+ * Sender: Verifier
+ * OOB message to request a verifiable presentation from the holder
+ */
+export function buildRequestVerifiablePresentationMessage({
+  verifierDID,
+  holderDID,
+  proofRequest,
+  proofRequestId
+}) {
+  return {
+    type: MessageTypes.RequestPresentation,
+    from: verifierDID,
+    to: holderDID,
+    body: {
+      proofRequest,
+      proofRequestId,
+    },
+  };
+}
+
+/**
+ * Sender: Holder
+ * Start a wallet to wallet verification flow
+ */
+export function buildAckWalletToWalletVerificationMessage({
+  holderDID,
+  verifierDID,
+  proofRequestId,
+}) {
+  return {
+    type: MessageTypes.Ack,
+    from: holderDID,
+    to: verifierDID,
+    body: {
+      goal_code: Goals.WalletToWalletVerification,
+      goal: 'Ack for for a Wallet to Wallet Verification invite',
+      proofRequestId: proofRequestId,
+    },
+  };
+}
+
+
+/**
+ * Sender: Holder
+ * Send a verifiable presentation to the verifier
+ */
+export function buildVerifiablePresentationMessage({
+  verifierDID,
+  holderDID,
+  proofRequestId,
+  presentation,
+}) {
+  return {
+    type: MessageTypes.Presentation,
+    from: verifierDID,
+    to: holderDID,
+    body: {
+      proofRequestId,
+      presentation,
+    },
+  };
+}
+
+/**
+ * Sender: Verifier
+ * Sends an the presentation result to the holder
+ */
+export function buildVerifiablePresentationAckMessage({
+  verifierDID,
+  holderDID,
+  proofRequestId,
+  presentationResult,
+}) {
+  return {
+    type: MessageTypes.Ack,
+    from: verifierDID,
+    to: holderDID,
+    body: {
+      goal_code: Goals.PresentationAckFromVerifier,
+      goal: 'Verifier is sending an Ack for a presentation sent by the holder',
+      proofRequestId,
+      presentationResult,
+    },
+  };
+}