@docknetwork/wallet-sdk-core 0.4.19

package/src/network-resolver.ts

@@ -0,0 +1,122 @@
+import {
+  DataStore,
+  DocumentNetworkResolver,
+  DocumentResolverProps,
+  DocumentResolverResult,
+  WalletDocument,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {utilCryptoService} from '@docknetwork/wallet-sdk-wasm/src/services/util-crypto';
+
+type ResolverResult = string | null;
+
+export const dockDocumentNetworkResolver: DocumentNetworkResolver = async ({
+  document,
+  dataStore,
+}: DocumentResolverProps): Promise<DocumentResolverResult> => {
+  let networkId;
+  let isFallback = false;
+
+  for (const resolver of resolvers) {
+    networkId = await resolver({document, dataStore});
+
+    if (networkId) {
+      break;
+    }
+  }
+
+  if (!networkId) {
+    isFallback = true;
+    networkId = dataStore.networkId;
+  }
+
+  return {
+    networkId: networkId,
+    isFallback,
+  };
+};
+
+/**
+ *
+ * Given an Api URL, resolve the network ID
+ * For now it will be applied for creds and certs
+ * It can be extended to resolve other external URLs
+ *
+ */
+export function resolveApiNetwork({
+  url,
+  dataStore,
+}: {
+  url: string;
+  dataStore: DataStore;
+}) {
+  for (const network of dataStore.networks) {
+    for (const hostname of network.credentialHostnames) {
+      if (url.indexOf(hostname) > -1) {
+        return network.id;
+      }
+    }
+  }
+
+  return null;
+}
+
+export async function credentialResolver({
+  document,
+  dataStore,
+}: DocumentResolverProps): Promise<ResolverResult> {
+  if (!document) {
+    return null;
+  }
+
+  if (!document.type?.includes('VerifiableCredential')) {
+    return null;
+  }
+
+  // TODO: create fallback with DID resolution
+
+  return resolveApiNetwork({
+    url: document.id,
+    dataStore,
+  });
+}
+
+export async function didResolver({
+  document,
+  dataStore,
+}: DocumentResolverProps): Promise<ResolverResult> {
+  // TODO: Define DID resolver
+  return null;
+}
+
+export async function accountResolver({
+  document,
+  dataStore,
+}: DocumentResolverProps): Promise<ResolverResult> {
+  if (!document) {
+    return null;
+  }
+
+  const isAddress = Array.isArray(document.type) ? document.type.includes('Address') : document.type === 'Address';
+
+  if (!isAddress) {
+    return null;
+  }
+
+  const addressPrefixList = dataStore.networks.map(
+    network => network?.configs?.addressPrefix,
+  );
+
+  const addressPrefix = await utilCryptoService.getAddressPrefix({
+    address: document.id,
+    startPrefix: Math.min(...addressPrefixList),
+    endPrefix: Math.max(...addressPrefixList),
+  });
+
+  const network = dataStore.networks.find(
+    item => item.configs?.addressPrefix === addressPrefix,
+  );
+
+  return network?.id;
+}
+
+const resolvers = [credentialResolver, accountResolver, didResolver];

package/src/types.ts

@@ -0,0 +1,75 @@
+import {
+  DataStore,
+  DataStoreConfigs,
+  DocumentResolverResult,
+  WalletDocument,
+} from '@docknetwork/wallet-sdk-data-store/src/types';
+import {Accounts} from '@docknetwork/wallet-sdk-wasm/src/modules/accounts';
+import {EventEmitter} from 'events';
+
+export interface IV1Wallet {
+  accounts: Accounts;
+
+  getStatus: () => string;
+  setStatus: (status: string) => void;
+  eventManager: EventEmitter;
+  waitForEvent: (eventName: string) => Promise<any>;
+  resolveCorrelations: (id: string) => Promise<WalletDocument[]>;
+  query: ({
+    id,
+    type,
+  }?: {
+    id?: string;
+    type?: string;
+  }) => Promise<WalletDocument[]>;
+
+  ensureNetwork: () => Promise<void>;
+  sync: () => Promise<void>;
+  remove: (id: string) => Promise<void>;
+  create: (json: any) => Promise<WalletDocument>;
+  update: (json: any) => Promise<WalletDocument>;
+  upsert: (json: any) => Promise<WalletDocument>;
+  deleteWallet: () => Promise<void>;
+}
+
+export type IWallet = {
+  getDocumentById: (id: string) => Promise<WalletDocument>;
+  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>;
+  getDocumentCorrelations: (documentId: string) => Promise<WalletDocument[]>;
+  getAccountKeyPair: (accountId: string) => Promise<any>;
+  /**
+   * Remove document by id
+   * @param id
+   */
+  removeDocument: (id: string) => Promise<void>;
+  /**
+   * Import data from a Universal Wallet 2020 JSON
+   * https://w3c-ccg.github.io/universal-wallet-interop-spec/
+   *
+   * @param json
+   */
+  importUniversalWalletJSON: (json: any, password: string) => Promise<void>;
+  getDocumentsFromEncryptedWallet: (
+    json: any,
+    password: string,
+  ) => Promise<any>;
+  exportDocuments: (params: {documents: any; password: string}) => Promise<any>;
+  /**
+   * Create a Universal Wallet 2020 JSON representation of the wallet
+   * https://w3c-ccg.github.io/universal-wallet-interop-spec/
+   * @returns JSON representation of the wallet
+   */
+  exportUniversalWalletJSON: (password: string) => any;
+
+  setNetwork: (networkId: string) => Promise<void>;
+  getNetworkId: () => string;
+  resolveDocumentNetwork: (document: any) => Promise<DocumentResolverResult>;
+  dataStore: DataStore;
+} & IV1Wallet;
+
+export type CreateWalletProps = DataStoreConfigs & {};

package/src/v1-helpers.ts

@@ -0,0 +1,160 @@
+// TODO: [wallet-sdk] Cleanup wallet-sdk unnused wasm services https://dock-team.atlassian.net/browse/DCKA-1658
+import {IV1Wallet, IWallet} from './types';
+import {createAccountProvider} from './account-provider';
+import {WalletDocument} from '@docknetwork/wallet-sdk-data-store/src/types';
+import * as walletServiceConfigs from '@docknetwork/wallet-sdk-wasm/src/services/wallet/configs';
+import {keyringService} from '@docknetwork/wallet-sdk-wasm/src/services/keyring/index';
+import {walletService} from '@docknetwork/wallet-sdk-wasm/src/services/wallet';
+import {v4 as uuid} from 'uuid';
+import {EventEmitter} from 'events';
+
+export async function toV1Wallet(wallet: IWallet): Promise<IWallet> {
+  const accounts = await createAccountProvider({
+    wallet,
+  });
+
+  const v1Wallet = {
+    accounts: accounts,
+    create(json: any): Promise<WalletDocument> {
+      return wallet.addDocument(document);
+    },
+    deleteWallet(): Promise<void> {
+      return wallet.deleteWallet();
+    },
+    exportDocuments: (params: {documents: any}) => {
+      return walletService.exportDocuments(params);
+    },
+    ensureNetwork(): Promise<void> {
+      return Promise.resolve(undefined);
+    },
+    async query({
+      id,
+      type,
+    }: {id?: string; type?: string} | undefined): Promise<WalletDocument[]> {
+      if (id) {
+        return [await wallet.getDocumentById(id)].filter(item => !!item);
+      }
+
+      if (type) {
+        return wallet.getDocumentsByType(type);
+      }
+
+      return wallet.getAllDocuments();
+    },
+    remove(id: string): Promise<void> {
+      return wallet.removeDocument(id);
+    },
+    add(json: any): Promise<WalletDocument> {
+      return wallet.addDocument(json);
+    },
+    resolveCorrelations(id: string): Promise<WalletDocument[]> {
+      return wallet.getDocumentCorrelations(id);
+    },
+    sync(): Promise<void> {
+      return Promise.resolve(undefined);
+    },
+    update(json: any): Promise<WalletDocument> {
+      return wallet.updateDocument(json);
+    },
+    upsert(json: any): Promise<WalletDocument> {
+      return wallet.upsertDocument(json);
+    },
+  };
+
+  const newWallet = {
+    ...v1Wallet,
+    ...wallet,
+  };
+
+  (accounts as any).wallet = newWallet;
+
+  return newWallet;
+}
+
+export type KeypairType = 'sr25519' | 'ed25519' | 'ecdsa';
+
+/**
+ * Wallet service methods
+ * @param wallet
+ */
+export function toV1WalletService(wallet: IWallet) {
+  return {
+    getDocumentById: id => {
+      return wallet.getDocumentById(id);
+    },
+    // accounts are not required in a wallet
+    // Ideally should move this code to the accounts provider file
+    // and make account provider available on its own package
+    createAccountDocuments: async (params: {
+      name: string;
+      json?: string;
+      password?: string;
+      mnemonic?: string;
+      type?: KeypairType;
+      derivePath?: string;
+      hasBackup?: boolean;
+    }) => {
+      walletServiceConfigs.validation.createAccountDocuments(params);
+
+      const {
+        name,
+        type = 'sr25519',
+        derivePath,
+        mnemonic,
+        json,
+        password,
+        hasBackup
+      } = params;
+
+      const keyringJson = json
+        ? await keyringService.addFromJson({jsonData: json, password})
+        : await keyringService.getKeyringPairJSON({mnemonic, derivePath, type});
+      const correlations: any[] = [];
+
+      correlations.push({
+        '@context': ['https://w3id.org/wallet/v1'],
+        id: uuid(),
+        type: 'KeyringPair',
+        value: keyringJson,
+      });
+
+      correlations.push({
+        '@context': ['https://w3id.org/wallet/v1'],
+        id: uuid(),
+        type: 'Currency',
+        value: 0,
+        symbol: 'DOCK',
+      });
+
+      if (mnemonic) {
+        correlations.push({
+          '@context': ['https://w3id.org/wallet/v1'],
+          id: uuid(),
+          type: 'Mnemonic',
+          value: mnemonic,
+        });
+      }
+
+      const correlationsDocs = [];
+
+      for (let i = 0; i < correlations.length; i++) {
+        const doc = correlations[i];
+        const addedDoc = await wallet.addDocument(doc);
+        correlationsDocs.push(addedDoc);
+      }
+
+      const addressDocument = await wallet.addDocument({
+        '@context': ['https://w3id.org/wallet/v1'],
+        id: keyringJson.address,
+        type: 'Address',
+        value: keyringJson.address,
+        address: keyringJson.address,
+        name,
+        hasBackup,
+        correlation: correlations.map(doc => doc.id),
+      });
+
+      return [addressDocument, ...correlationsDocs];
+    },
+  };
+}

package/src/verification-controller.test.ts

@@ -0,0 +1,149 @@
+import {IWallet} from './types';
+import {
+  createVerificationController,
+  VerificationStatus,
+} from './verification-controller';
+import {createWallet} from './wallet';
+import customerCredentialJSON from './fixtures/customer-credential.json';
+import universityDegreeBBS from './fixtures/university-degree-bbs.json';
+import iiwCredential from './fixtures/iiw-credential.json';
+import iiwTemplate from './fixtures/iiw-template.json';
+import anyCredentialProofRequest from './fixtures/any-credential-proof-request.json';
+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';
+
+describe('Verification provider', () => {
+  let wallet: IWallet;
+  let didProvider: IDIDProvider;
+
+  beforeAll(async () => {
+    wallet = await createWallet({
+      databasePath: ':memory:',
+      defaultNetwork: 'testnet',
+    });
+
+    await wallet.waitForEvent(WalletEvents.networkConnected);
+
+    didProvider = createDIDProvider({
+      wallet,
+    });
+
+    await didProvider.ensureDID();
+
+    await wallet.addDocument(customerCredentialJSON);
+    await wallet.addDocument(universityDegreeBBS);
+    await wallet.addDocument(iiwCredential);
+  });
+
+  it('expect to create verification controller', async () => {
+    const controller = createVerificationController({
+      wallet,
+    });
+
+    await controller.start({
+      template: anyCredentialProofRequest,
+    });
+
+    const currentDID = await didProvider.getAll();
+
+    expect(controller.getSelectedDID()).toBe(currentDID[0].didDocument.id);
+    expect(controller.getStatus()).toEqual(
+      VerificationStatus.SelectingCredentials,
+    );
+    expect(controller.selectedCredentials.size).toEqual(0);
+    expect(controller.getTemplateJSON()).toEqual(anyCredentialProofRequest);
+    expect(controller.getFilteredCredentials()).toEqual([
+      customerCredentialJSON,
+      universityDegreeBBS,
+    ]);
+  });
+
+  it('expect to generate presentation for a selected credential', async () => {
+    const controller = createVerificationController({
+      wallet,
+      didProvider,
+    });
+
+    await controller.start({
+      template: anyCredentialProofRequest,
+    });
+
+    const credentials = controller.getFilteredCredentials();
+
+    // select the first credential in the filtered list
+    controller.selectedCredentials.set(credentials[0].id, {
+      credential: credentials[0],
+    });
+
+    const presentation = await controller.createPresentation();
+
+    expect(presentation.credentials[0]).toStrictEqual(credentials[0]);
+    expect(presentation.type).toEqual(['VerifiablePresentation']);
+
+    // validate the presentation
+    const result = await controller.evaluatePresentation(presentation);
+
+    expect(result.isValid).toBe(true);
+  });
+
+  it('expect to generate presentation iiw credential', async () => {
+    const controller = createVerificationController({
+      wallet,
+      didProvider,
+    });
+
+    await controller.start({
+      template: iiwTemplate,
+    });
+
+    const credentials = controller.getFilteredCredentials();
+    const selectedCredentialId = iiwCredential.id;
+    const selectedCredential = credentials.find(
+      item => item.id === selectedCredentialId,
+    );
+    // select the first credential in the filtered list
+    controller.selectedCredentials.set(selectedCredential.id, {
+      credential: selectedCredential,
+      attributesToReveal: [
+        'credentialSubject.holderName',
+        'credentialSubject.booleanYesNO',
+      ],
+    });
+
+    const presentation = await controller.createPresentation();
+
+    expect(presentation.credentials[0].id).toEqual(selectedCredential.id);
+    expect(presentation.type).toEqual(['VerifiablePresentation']);
+
+    // validate the presentation
+    const result = await controller.evaluatePresentation(presentation);
+
+    expect(result.isValid).toBe(true);
+  });
+
+  it('expect to generate presentation for a bbs credential, selecting specific attributes to share', async () => {
+    const controller = createVerificationController({
+      wallet,
+      didProvider,
+    });
+
+    await controller.start({
+      template: universityDegreeProofRequest,
+    });
+
+    const credentials = controller.getFilteredCredentials();
+
+    expect(credentials.length).toBe(1);
+    // select the first credential in the filtered list
+    controller.selectedCredentials.set(credentials[0].id, {
+      credential: credentials[0],
+      attributesToReveal: ['name', 'credentialSubject.dateOfBirth'],
+    });
+
+    const presentation = await controller.createPresentation();
+
+    const result = await controller.evaluatePresentation(presentation);
+    expect(result.isValid).toBe(true);
+  });
+});