@docknetwork/wallet-sdk-core 0.4.19

package/src/verification-controller.ts

@@ -0,0 +1,276 @@
+import {getJSON} from './helpers';
+import {pexService} from '@docknetwork/wallet-sdk-wasm/src/services/pex';
+import {credentialServiceRPC} from '@docknetwork/wallet-sdk-wasm/src/services/credential';
+import {
+  createCredentialProvider,
+  ICredentialProvider,
+} from './credential-provider';
+import {IWallet} from './types';
+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',
+  LoadingTemplate = 'LoadingTemplate',
+  Filtering = 'Filtering',
+  FetchingProvingKey = 'FetchingProvingKey',
+  Error = 'Error',
+  NoCredentialsInTheWallet = 'NoCredentialsInTheWallet',
+  SelectingCredentials = 'SelectingCredentials',
+}
+
+function isRangeProofTemplate(templateJSON) {
+  return templateJSON.proving_key;
+}
+
+type CredentialId = string;
+type CredentialSelection = {
+  credential: any;
+  attributesToReveal?: string[];
+};
+type CredentialSelectionMap = Map<CredentialId, CredentialSelection>;
+
+export function createVerificationController({
+  wallet,
+  credentialProvider,
+  didProvider,
+}: {
+  wallet: IWallet;
+  credentialProvider?: ICredentialProvider;
+  didProvider?: IDIDProvider;
+}) {
+  const emitter = new EventEmitter();
+  let templateJSON = null;
+  let status = VerificationStatus.Started;
+  /**
+   * Extra data to give better context to the current state
+   * Can be used to show error messages, or more specific information about the state
+   */
+  let statusData = null;
+  let filteredCredentials = [];
+  let selectedCredentials: CredentialSelectionMap = new Map();
+  let selectedDID = null;
+  let provingKey = null;
+
+  if (!credentialProvider) {
+    credentialProvider = createCredentialProvider({wallet});
+  }
+
+  if (!didProvider) {
+    didProvider = createDIDProvider({wallet});
+  }
+
+  async function fetchProvingKey(templateJSON: any) {
+    if (templateJSON.proving_key) {
+      setState(VerificationStatus.FetchingProvingKey);
+      try {
+        provingKey = await axios
+          .get(templateJSON.proving_key)
+          .then(res => res.data);
+      } catch (err) {
+        setState(VerificationStatus.Error, {
+          message: 'failed_to_fetch_proving_key',
+        });
+
+        throw err;
+      }
+    }
+  }
+
+  async function start({template}: {template: string | any}) {
+    setState(VerificationStatus.LoadingTemplate);
+
+    // check for dids
+    const dids = await didProvider.getAll();
+
+    if (!dids.length) {
+      setState(VerificationStatus.Error, {
+        message: 'no_dids_in_the_wallet',
+      });
+      throw new Error('No DIDs in the wallet');
+    }
+
+    // the application needs to verify if there are more DIDs available, and allow the user to change this selection before creating a presentation
+    selectedDID = dids[0].didDocument.id;
+    templateJSON = await getJSON(template);
+
+    await fetchProvingKey(templateJSON);
+    await loadCredentials();
+
+    setState(VerificationStatus.SelectingCredentials);
+  }
+
+  function setState(_status: VerificationStatus, data?: any) {
+    status = _status;
+    statusData = data;
+    emitter.emit(_status, data);
+  }
+
+  async function loadCredentials() {
+    setState(VerificationStatus.Filtering);
+
+    // get wallet credentials and apply pex filter
+    const allCredentials = await credentialProvider.getCredentials();
+
+    if (!allCredentials.length) {
+      setState(VerificationStatus.NoCredentialsInTheWallet);
+      return;
+    }
+
+    try {
+      const result = await pexService.filterCredentials({
+        credentials: allCredentials,
+        presentationDefinition: getPresentationDefinition(),
+        holderDIDs: [],
+      });
+
+      filteredCredentials = result.verifiableCredential;
+    } catch (err) {
+      console.error(
+        `Unable to filter credentials using the template: \n ${JSON.stringify(
+          templateJSON,
+          null,
+          2,
+        )}`,
+      );
+      console.error(err);
+
+      setState(VerificationStatus.Error);
+      throw err;
+    }
+  }
+
+  function getPresentationDefinition() {
+    return templateJSON.request;
+  }
+
+  async function isBBSPlusCredential(credential) {
+    return credentialServiceRPC.isBBSPlusCredential({credential});
+  }
+
+  async function createPresentation() {
+    assert(!!selectedDID, 'No DID selected');
+    assert(!!selectedCredentials.size, 'No credentials selected');
+
+    if (isRangeProofTemplate(templateJSON)) {
+      // TODO: Implement proving key usage for range-proofs
+      assert(!!provingKey, 'No proving key found');
+    }
+
+    const credentials = [];
+
+    for (const credentialSelection of selectedCredentials.values()) {
+      const isBBS = await isBBSPlusCredential(credentialSelection.credential);
+
+      if (!isBBS) {
+        credentials.push(credentialSelection.credential);
+      } else {
+        // derive BBS credential
+        const derivedCredentials =
+          await credentialServiceRPC.deriveVCFromBBSPresentation({
+            proofRequest: templateJSON,
+            
+            credentials: [
+              {
+                credential: credentialSelection.credential,
+                witness: await credentialProvider.getMembershipWitness(credentialSelection.credential.id),
+                attributesToReveal: [
+                  ...(credentialSelection.attributesToReveal || []),
+                  'id',
+                ],
+              },
+            ],
+          });
+
+        console.log('Credential derived');
+
+        credentials.push(derivedCredentials[0]);
+      }
+    }
+
+    const didKeyPairList = await didProvider.getDIDKeyPairs();
+    const keyDoc = didKeyPairList.find(doc => doc.controller === selectedDID);
+
+    assert(keyDoc, `No key pair found for the selected DID ${selectedDID}`);
+
+    const presentation = await credentialServiceRPC.createPresentation({
+      credentials,
+      challenge: templateJSON.nonce,
+      keyDoc,
+      id: keyDoc.controller.startsWith('did:key:')
+        ? keyDoc.id
+        : `${keyDoc.controller}#keys-1`,
+      domain: 'dock.io',
+    });
+
+    return presentation;
+  }
+
+  /**
+   * Filtered credentials
+   */
+  function getFilteredCredentials() {
+    return filteredCredentials;
+  }
+
+  function getStatus() {
+    return status;
+  }
+
+  function getStatusData() {
+    return statusData;
+  }
+
+  function setSelectedDID(did: string) {
+    selectedDID = did;
+  }
+
+  /**
+   * Use pex to evaluate presentation
+   *
+   * @param presentation
+   */
+  function evaluatePresentation(presentation) {
+    const definition = getPresentationDefinition();
+    const result = credentialServiceRPC.evaluatePresentation({
+      presentation,
+      presentationDefinition: definition,
+    });
+
+    return {
+      isValid: result.errors.length === 0,
+      errors: result.errors,
+      warnings: result.warnings,
+    };
+  }
+
+  function submitPresentation(presentation) {
+    return axios
+      .post(templateJSON.response_url, presentation)
+      .then(res => res.data);
+  }
+
+  return {
+    emitter,
+    selectedCredentials,
+    getStatus,
+    getStatusData,
+    submitPresentation,
+    getSelectedDID() {
+      return selectedDID;
+    },
+    setSelectedDID,
+    start,
+    isBBSPlusCredential,
+    loadCredentials,
+    getFilteredCredentials,
+    createPresentation,
+    evaluatePresentation,
+    getTemplateJSON() {
+      return templateJSON;
+    },
+  };
+}

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

@@ -0,0 +1,216 @@
+import assert from 'assert';
+import {IDIDProvider} from '../did-provider';
+import {
+  Goals,
+  MessageTypes,
+  buildAckWalletToWalletVerificationMessage,
+  buildVerificationFlowInviteMessage,
+  buildRequestVerifiablePresentationMessage,
+  buildVerifiablePresentationAckMessage,
+  buildVerifiablePresentationMessage,
+} from '../messages/message-helpers';
+import {IWallet} from '../types';
+import {IMessageProvider} from '../message-provider';
+import {logger} from '@docknetwork/wallet-sdk-data-store/src/logger';
+
+const ProofRequestTemplateType = 'ProofRequestTemplate';
+
+export interface IWalletToWalletVerificationProvider {
+  getInvitationOOBMessage: ({templateId}: {templateId: string}) => Promise<any>;
+  setProofRequestHandler: (
+    handler: (proofRequest: any) => any,
+  ) => Promise<void>;
+  setPresentationHandler: (
+    handler: (presentation: any, proofRequest: any) => any,
+  ) => Promise<void>;
+  setPresentationAckHandler: (
+    handler: (proofRequest: any) => any,
+  ) => Promise<void>;
+  addProofRequestTemplate: (proofRequestTemplate: any) => Promise<any>;
+  getProofRequestTemplates: () => Promise<any[]>;
+  handleMessage: (message: any) => Promise<boolean>;
+}
+
+export function createWalletToWalletVerificationProvider({
+  wallet,
+  didProvider,
+  messageProvider,
+}: {
+  wallet: IWallet;
+  didProvider: IDIDProvider;
+  messageProvider: IMessageProvider;
+}): IWalletToWalletVerificationProvider {
+  // Should be used by the HOLDER to create a presentation for the verifier
+  let proofRequestHandler;
+  // Should be used by the VERIFIER verify a presentation received by the holder
+  let presentationHandler;
+  // Can be used by the HOLDER to render the verification results sent by the verifier
+  let presentationAckHandler;
+
+  return {
+    getInvitationOOBMessage: async ({templateId}) => {
+      const defaultDID = await didProvider.getDefaultDID();
+      const template = await wallet.getDocumentById(templateId);
+
+      assert(!!template, `Template with id ${templateId} not found`);
+
+      return buildVerificationFlowInviteMessage({
+        proofRequestId: templateId,
+        verifierDID: defaultDID,
+      });
+    },
+    setProofRequestHandler: async (handler: (proofRequest: any) => any) => {
+      proofRequestHandler = handler;
+    },
+    setPresentationHandler: async (handler: (presentation: any, proofRequest: any) => any) => {
+      presentationHandler = handler;
+    },
+    setPresentationAckHandler: async (handler: (proofRequest: any) => any) => {
+      presentationAckHandler = handler;
+    },
+    addProofRequestTemplate: async (proofRequestTemplate: any) => {
+      assert(
+        !!proofRequestTemplate.input_descriptors,
+        'Input descriptions are required',
+      );
+      return wallet.addDocument({
+        type: ProofRequestTemplateType,
+        template: proofRequestTemplate,
+      });
+    },
+    getProofRequestTemplates: async () => {
+      return wallet.getDocumentsByType(ProofRequestTemplateType);
+    },
+    handleMessage: async (message: any) => {
+      logger.debug('Received message');
+      logger.debug(message);
+      if (
+        message.type === MessageTypes.Invitation &&
+        message?.body?.goal_code === Goals.WalletToWalletVerification
+      ) {
+        // Received a verification invitation from the verifier
+        // Sends back an ack message to the verifier
+        const defaultDID = await didProvider.getDefaultDID();
+        logger.debug('Received invitation');
+        logger.debug('Sending ack message to the verifier');
+        messageProvider.sendMessage(
+          buildAckWalletToWalletVerificationMessage({
+            holderDID: defaultDID,
+            proofRequestId: message.body.proofRequestId,
+            verifierDID: message.from,
+          }),
+        );
+        return true;
+      }
+
+      // The holder sent an ack message to the verifier invite
+      // Now the verifier knows the holder did and can offer a proof request
+      if (
+        message.type === MessageTypes.Ack &&
+        message?.body?.goal_code === Goals.WalletToWalletVerification
+      ) {
+        async function process() {
+          logger.debug(message);
+          const templateId = message.body.proofRequestId;
+          assert(!!templateId, 'Template ID not found in ack message');
+          const defaultDID = await didProvider.getDefaultDID();
+          const proofRequestTemplate = await wallet.getDocumentById(templateId);
+
+          assert(!!proofRequestTemplate, 'Proof request template not found');
+
+          logger.debug('Sending proof request to the holder');
+
+          const proofRequest = proofRequestTemplate.template;
+
+          assert(!!proofRequest, 'Proof request not found');
+
+          messageProvider.sendMessage(
+            buildRequestVerifiablePresentationMessage({
+              proofRequestId: templateId,
+              proofRequest: proofRequestTemplate.template,
+              holderDID: message.from,
+              verifierDID: defaultDID,
+            }),
+          );
+        }
+
+        process();
+
+        return true;
+      }
+
+      // The holder received a proof request from the verifier
+      if (message.type === MessageTypes.RequestPresentation) {
+        logger.debug('Received proof request from the verifier');
+
+        assert(!!proofRequestHandler, 'No proof request handler set');
+
+        logger.debug(
+          'Waiting for proofRequest handler to return a presentation',
+        );
+        Promise.resolve(proofRequestHandler(message.body.proofRequest)).then(
+          async presentation => {
+            logger.debug('Presentation received from handler');
+            const defaultDID = await didProvider.getDefaultDID();
+            logger.debug('Sending presentation to the verifier');
+            messageProvider.sendMessage(
+              buildVerifiablePresentationMessage({
+                holderDID: defaultDID,
+                presentation,
+                proofRequestId: message.body.proofRequestId,
+                verifierDID: message.from,
+              }),
+            );
+          },
+        );
+
+        return true;
+      }
+
+      // The verifier received a presentation from the holder
+      if (message.type === MessageTypes.Presentation) {
+        logger.debug('Received presentation from the holder');
+
+        const proofRequestTemplate = await wallet.getDocumentById(message.body.proofRequestId);
+        const proofRequest = proofRequestTemplate?.template;
+
+        assert(!!proofRequest, 'Proof request template not found');
+
+        logger.debug(
+          'Waiting for presentation handler to return a presentation',
+        );
+        assert(!!presentationHandler, 'No presentation handler set');
+        
+        Promise.resolve(presentationHandler(message.body.presentation, proofRequest)).then(
+          async presentationResult => {
+            const defaultDID = await didProvider.getDefaultDID();
+            logger.debug('Sending presentation ack to the holder');
+            messageProvider.sendMessage(
+              buildVerifiablePresentationAckMessage({
+                holderDID: message.from,
+                presentationResult,
+                proofRequestId: message.body.proofRequestId,
+                verifierDID: defaultDID,
+              }),
+            );
+          },
+        );
+
+        return true;
+      }
+
+      // The holder received a presentation ack from the verifier
+      if (
+        message.type === MessageTypes.Ack &&
+        message.body.goal_code === Goals.PresentationAckFromVerifier
+      ) {
+        logger.debug('Received presentation ack from the verifier');
+        logger.debug('Presentation ack received');
+        if (presentationAckHandler) {
+          presentationAckHandler(message.body.presentationResult);
+        }
+        return true;
+      }
+    },
+  };
+}

package/src/wallet-wasm.ts

@@ -0,0 +1,74 @@
+import {keyringService} from '@docknetwork/wallet-sdk-wasm/src/services/keyring';
+import {utilCryptoService} from '@docknetwork/wallet-sdk-wasm/src/services/util-crypto';
+import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock';
+
+import {IWallet} from './types';
+import {Network} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {WalletEvents} from '@docknetwork/wallet-sdk-wasm/src/modules/wallet';
+import { captureException } from './helpers';
+
+function isSubstrateNetwork(network: Network) {
+  return !!network.configs.substrateUrl;
+}
+
+/**
+ * Update existing substrate network connection
+ * Compare connected substrate connection with the current walle network
+ * Disconnect and Establish a new connection if the network is different
+ */
+export async function handleSubstrateNetworkChange(
+  wallet: IWallet,
+): Promise<void> {
+  const currentSubstrateAddress = await dockService.getAddress();
+  const substrateNetworkId = wallet.dataStore.networks.find(
+    network => network.configs.substrateUrl === currentSubstrateAddress,
+  )?.id;
+  const currentNetworkId = wallet.dataStore.network?.id;
+
+  if (substrateNetworkId === currentNetworkId) {
+    return;
+  }
+
+  await dockService.disconnect();
+  await setSubstrateNetwork(wallet);
+}
+
+export async function setSubstrateNetwork(wallet: IWallet) {
+  const network = wallet.dataStore.network;
+  const networkConfigs = network.configs;
+
+  await keyringService.initialize({
+    ss58Format: networkConfigs.addressPrefix,
+  });
+
+  dockService
+    .init({
+      address: networkConfigs.substrateUrl,
+    })
+    .then(() => {
+      wallet.eventManager.emit(WalletEvents.networkConnected);
+    })
+    .catch(err => {
+      captureException(new Error('Unable to connect to substrate node'));
+      captureException(err);
+      console.error(err);
+      wallet.eventManager.emit(WalletEvents.networkError, err);
+    });
+}
+
+export async function initWalletWasm(wallet: IWallet) {
+  await utilCryptoService.cryptoWaitReady();
+  const network = wallet.dataStore.network;
+
+  if (isSubstrateNetwork(network)) {
+    await setSubstrateNetwork(wallet);
+
+    wallet.eventManager.on(WalletEvents.networkUpdated, async () => {
+      handleSubstrateNetworkChange(wallet);
+    });
+  }
+
+  wallet.setStatus('ready');
+
+  wallet.eventManager.emit(WalletEvents.ready);
+}

package/src/wallet.test.ts

@@ -0,0 +1,72 @@
+import {createDIDProvider} from './did-provider';
+import {createWallet, ensureDocumentContext, IWallet} from './wallet';
+
+describe('Wallet', () => {
+  let wallet: IWallet;
+
+  beforeEach(async () => {
+    wallet = await createWallet({
+      databasePath: ':memory:',
+    });
+  });
+
+  it('expect to create a wallet', async () => {
+    expect(wallet).toBeDefined();
+    expect(wallet.dataStore).toBeDefined();
+  });
+
+  it('expect to add missing @context on documents', () => {
+    const documents = [
+      {
+        id: 1,
+      },
+      {
+        id: 2,
+        '@context': 'test',
+      },
+    ];
+
+    const result = documents.map(ensureDocumentContext);
+
+    expect(result[0]['@context']).toStrictEqual(['https://w3id.org/wallet/v1']);
+    expect(result[1]['@context']).toEqual('test');
+  });
+
+  it('expect to create default dids', async () => {
+    const mainnetDIDs = await createDIDProvider({wallet}).getAll();
+    expect(mainnetDIDs.length).toBe(1);
+    await wallet.setNetwork('testnet');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    const testnetDIDs = await createDIDProvider({wallet}).getAll();
+    expect(testnetDIDs.length).toBe(1);
+    expect(mainnetDIDs[0]).not.toEqual(testnetDIDs[0]);
+  });
+
+  describe('document CRUD', () => {
+    const mockDocument = {
+      id: 'test',
+      type: 'VerifiableCredential',
+    };
+
+    beforeEach(async () => {
+      await wallet.addDocument(mockDocument);
+    });
+
+    it('expect to get a document by id', async () => {
+      const result = await wallet.getDocumentById(mockDocument.id);
+      expect(result.id).toEqual(mockDocument.id);
+      expect(result).toStrictEqual(mockDocument);
+    });
+
+    it('expect to get document by type', async () => {
+      const result = await wallet.getDocumentsByType(mockDocument.type);
+      expect(result[0]).toStrictEqual(mockDocument);
+    });
+
+    it('expect to remove a document', async () => {
+      await wallet.removeDocument(mockDocument.id);
+      const result = await wallet.getDocumentById(mockDocument.id);
+      expect(result).toBeNull();
+    });
+  });
+});