@procivis/one-react-native-components 0.1.63 → 0.2.54

package/src/utils/hooks/core/core-context.tsx

@@ -0,0 +1,101 @@
+import { initializeCore, ONECore } from '@procivis/react-native-one-core';
+import React, {
+  createContext,
+  FC,
+  PropsWithChildren,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+} from 'react';
+
+import { reportException } from '../../reporting';
+import { useCreateTrustAnchor } from './trust-entity';
+
+interface ContextValue {
+  core: ONECore;
+  organisationId: string;
+  initialize: (force?: boolean) => Promise<ONECore>;
+}
+
+const defaultContextValue: ContextValue = {
+  core: {} as ONECore,
+  organisationId: '11111111-2222-3333-a444-ffffffffffff',
+  initialize: () => Promise.reject(),
+};
+
+export type ONECoreContextProviderProps = {
+  config?: Record<string, unknown>;
+  organisationId?: string;
+  publisherReference: string;
+};
+
+const ONECoreContext = createContext<ContextValue>(defaultContextValue);
+
+export const ONECoreContextProvider: FC<PropsWithChildren<ONECoreContextProviderProps>> = ({
+  children,
+  organisationId = '11111111-2222-3333-a444-ffffffffffff',
+  publisherReference,
+  config,
+}) => {
+  const [core, setCore] = useState<ONECore>();
+  const createTrustAnchor = useCreateTrustAnchor(publisherReference);
+
+  const initialize = useCallback(
+    async (force?: boolean) => {
+      if (core && !force) {
+        return core;
+      }
+
+      try {
+        const coreInstance = await initializeCore(config);
+        setCore(coreInstance);
+        return coreInstance;
+      } catch (e) {
+        reportException(e, 'Failed to initialize core');
+        throw e;
+      }
+    },
+    [core, config],
+  );
+
+  useEffect(
+    () => {
+      const corePromise = initialize();
+      return () => {
+        corePromise
+          .then((c) => c?.uninitialize(false))
+          .catch((e) => {
+            reportException(e, 'Core uninitialization error');
+          });
+      };
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [],
+  );
+
+  useEffect(() => {
+    if (!core) {
+      return;
+    }
+    createTrustAnchor(core).catch(() => {});
+  }, [core, createTrustAnchor]);
+
+  const contextValue = useMemo(
+    () => ({
+      core: core ?? defaultContextValue.core,
+      organisationId,
+      initialize,
+    }),
+    [core, initialize, organisationId],
+  );
+
+  if (!core) {
+    return null;
+  }
+
+  return <ONECoreContext.Provider value={contextValue}>{children}</ONECoreContext.Provider>;
+};
+
+export const useONECore = () => useContext(ONECoreContext);

package/src/utils/hooks/core/core-init.ts

@@ -0,0 +1,92 @@
+import { ONECore, OneError } from '@procivis/react-native-one-core';
+import { useCallback } from 'react';
+
+import { reportException } from '../../reporting';
+import { useONECore } from './core-context';
+import { OneErrorCode } from './error-code';
+
+export const SW_DID_NAME_PREFIX = 'holder-did-sw-key';
+export const HW_DID_NAME_PREFIX = 'holder-did-hw-key';
+
+const generateHwDid = async (core: ONECore, organisationId: string) => {
+  const hwKeyId = await core
+    .generateKey({
+      keyParams: {},
+      keyType: 'ES256',
+      name: 'holder-key-hw',
+      organisationId,
+      storageParams: {},
+      storageType: 'SECURE_ELEMENT',
+    })
+    .catch((e) => {
+      // ignore if HW keys not supported by device
+      if (e instanceof OneError && e.code === OneErrorCode.KeyStorageNotSupported) {
+        return null;
+      }
+      throw e;
+    });
+
+  if (hwKeyId) {
+    return core.createDid({
+      didMethod: 'KEY',
+      keys: {
+        assertionMethod: [hwKeyId],
+        authentication: [hwKeyId],
+        capabilityDelegation: [hwKeyId],
+        capabilityInvocation: [hwKeyId],
+        keyAgreement: [hwKeyId],
+      },
+      name: HW_DID_NAME_PREFIX,
+      organisationId,
+      params: {},
+    });
+  }
+
+  return null;
+};
+
+const generateSwDid = async (core: ONECore, organisationId: string) => {
+  const swKeyId = await core.generateKey({
+    keyParams: {},
+    keyType: 'EDDSA',
+    name: 'holder-key-sw',
+    organisationId,
+    storageParams: {},
+    storageType: 'INTERNAL',
+  });
+
+  return core.createDid({
+    didMethod: 'KEY',
+    keys: {
+      assertionMethod: [swKeyId],
+      authentication: [swKeyId],
+      capabilityDelegation: [swKeyId],
+      capabilityInvocation: [swKeyId],
+      keyAgreement: [swKeyId],
+    },
+    name: SW_DID_NAME_PREFIX,
+    organisationId,
+    params: {},
+  });
+};
+
+// create base local identifiers in the wallet
+export const useInitializeONECoreIdentifiers = () => {
+  const { core, organisationId } = useONECore();
+
+  return useCallback(async () => {
+    return await core
+      .createOrganisation(organisationId)
+      .catch((e) => {
+        if (e instanceof OneError && e.code === OneErrorCode.OrganisationAlreadyExists) {
+          return;
+        }
+        throw e;
+      })
+      .then(() => Promise.all([generateHwDid(core, organisationId), generateSwDid(core, organisationId)]))
+      .catch((err) => {
+        reportException(err, 'Failed to create base identifiers');
+        throw err;
+      });
+  }, [core, organisationId]);
+};

package/src/utils/hooks/core/credential-schemas.ts

@@ -0,0 +1,110 @@
+import { CredentialSchemaListQuery, ImportCredentialSchemaRequestSchema } from '@procivis/react-native-one-core';
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from 'react-query';
+
+import { getQueryKeyFromCredentialSchemaListQueryParams } from '../../parsers/query';
+import { useHTTPClient } from '../http/client';
+import { useONECore } from './core-context';
+import { HISTORY_LIST_QUERY_KEY } from './history';
+
+const PAGE_SIZE = 10;
+export const CREDENTIAL_SCHEMA_LIST_QUERY_KEY = 'credential-schema-list';
+export const CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY = 'credential-schema-detail';
+export const CREDENTIAL_SCHEMA_PREVIEW_QUERY_KEY = 'credential-schema-preview';
+export const CREDENTIAL_SCHEMA_SHARE_QUERY_KEY = 'credential-schema-share';
+
+export const useCredentialSchemas = (queryParams?: Partial<CredentialSchemaListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useInfiniteQuery(
+    [CREDENTIAL_SCHEMA_LIST_QUERY_KEY, ...getQueryKeyFromCredentialSchemaListQueryParams(queryParams)],
+    ({ pageParam = 0 }) =>
+      core
+        .getCredentialSchemas({
+          organisationId,
+          page: pageParam,
+          pageSize: PAGE_SIZE,
+          ...queryParams,
+        })
+        .then(({ values }) => values),
+    {
+      getNextPageParam: (lastPage, allPages) => (lastPage.length === PAGE_SIZE ? allPages.length : undefined),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCredentialSchemaPreview = (url: string) => {
+  const httpClient = useHTTPClient();
+
+  return useQuery(
+    [CREDENTIAL_SCHEMA_PREVIEW_QUERY_KEY, url],
+    () =>
+      httpClient.get(url).then((response) => {
+        if (!response.ok) {
+          throw response.originalError;
+        }
+        return response.data as ImportCredentialSchemaRequestSchema;
+      }),
+    {
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCredentialSchemaAccept = () => {
+  const queryClient = useQueryClient();
+  const { core, organisationId } = useONECore();
+
+  return useMutation(
+    async (schema: ImportCredentialSchemaRequestSchema) =>
+      core.importCredentialSchema({
+        organisationId,
+        schema,
+      }),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(CREDENTIAL_SCHEMA_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useCredentialSchemaDetail = (credentialId: string | undefined, active = true) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY, credentialId],
+    () => (credentialId ? core.getCredentialSchema(credentialId) : undefined),
+    {
+      enabled: active && Boolean(credentialId),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCredentialSchemaDelete = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (credentialSchemaId: string) => core.deleteCredentialSchema(credentialSchemaId), {
+    onSuccess: async (_, credentialId) => {
+      await queryClient.invalidateQueries(CREDENTIAL_SCHEMA_LIST_QUERY_KEY);
+      await queryClient.invalidateQueries([CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY, credentialId]);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useShareCredentialSchema = (schemaId?: string) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [CREDENTIAL_SCHEMA_SHARE_QUERY_KEY, schemaId],
+    () => (schemaId ? core.shareCredentialSchema(schemaId) : Promise.reject()),
+    {
+      enabled: Boolean(schemaId),
+      keepPreviousData: true,
+    },
+  );
+};

package/src/utils/hooks/core/credentials.ts

@@ -0,0 +1,171 @@
+import {
+  BypassCache,
+  CredentialListQuery,
+  CredentialStateEnum,
+  InvitationResult,
+  OneError,
+} from '@procivis/react-native-one-core';
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from 'react-query';
+
+import { getQueryKeyFromCredentialListQueryParams } from '../../parsers/query';
+import { useONECore } from './core-context';
+import { CREDENTIAL_SCHEMA_LIST_QUERY_KEY } from './credential-schemas';
+import { OneErrorCode } from './error-code';
+import { HISTORY_LIST_QUERY_KEY } from './history';
+
+const PAGE_SIZE = 20;
+const CREDENTIAL_LIST_QUERY_KEY = 'credential-list';
+const CREDENTIAL_LIST_PAGED_QUERY_KEY = 'credential-list-paged';
+const CREDENTIAL_DETAIL_QUERY_KEY = 'credential-detail';
+
+export const useCredentials = (queryParams?: Partial<CredentialListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useQuery(
+    [CREDENTIAL_LIST_QUERY_KEY, ...getQueryKeyFromCredentialListQueryParams(queryParams)],
+    async () => {
+      const { values } = await core.getCredentials({
+        organisationId,
+        page: 0,
+        // TODO: workaround pagination for now, until it's supported by UI
+        pageSize: 10000,
+        status: [CredentialStateEnum.ACCEPTED, CredentialStateEnum.SUSPENDED, CredentialStateEnum.REVOKED],
+        ...queryParams,
+      });
+      return values;
+    },
+    {
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const usePagedCredentials = (queryParams?: Partial<CredentialListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useInfiniteQuery(
+    [
+      CREDENTIAL_LIST_QUERY_KEY,
+      CREDENTIAL_LIST_PAGED_QUERY_KEY,
+      ...getQueryKeyFromCredentialListQueryParams(queryParams),
+    ],
+    ({ pageParam = 0 }) =>
+      core.getCredentials({
+        organisationId,
+        page: pageParam,
+        pageSize: PAGE_SIZE,
+        status: [CredentialStateEnum.ACCEPTED, CredentialStateEnum.SUSPENDED, CredentialStateEnum.REVOKED],
+        ...queryParams,
+      }),
+    {
+      getNextPageParam: (lastPage, allPages) => (allPages.length < lastPage.totalPages ? allPages.length : undefined),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCredentialDetail = (credentialId: string | undefined, active = true) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [CREDENTIAL_DETAIL_QUERY_KEY, credentialId],
+    () => (credentialId ? core.getCredential(credentialId) : undefined),
+    {
+      enabled: active && Boolean(credentialId),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useInvitationHandler = () => {
+  const queryClient = useQueryClient();
+  const { core, organisationId } = useONECore();
+
+  return useMutation(
+    async ({ invitationUrl, transport }: { invitationUrl: string; transport: 'HTTP' | 'MQTT' | 'BLE' }) =>
+      core.handleInvitation(invitationUrl, organisationId, [transport]),
+    {
+      onSuccess: async (result: InvitationResult) => {
+        if ('credentialIds' in result) {
+          await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+          await queryClient.invalidateQueries(CREDENTIAL_SCHEMA_LIST_QUERY_KEY);
+        }
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useCredentialAccept = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  type CredentialAcceptHookParams = { didId: string; interactionId: string; keyId?: string; txCode?: string };
+
+  return useMutation(
+    async ({ interactionId, didId, keyId, txCode }: CredentialAcceptHookParams) =>
+      core.holderAcceptCredential(interactionId, didId, keyId, txCode),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(CREDENTIAL_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useCredentialReject = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async (interactionId: string) =>
+      core.holderRejectCredential(interactionId).catch((e) => {
+        if (e instanceof OneError && e.code === OneErrorCode.OperationNotSupported) {
+          return;
+        }
+        throw e;
+      }),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(CREDENTIAL_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useCredentialRevocationCheck = (bypassCache?: BypassCache[]) => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (credentialIds: string[]) => core.checkRevocation(credentialIds, bypassCache), {
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+      await queryClient.invalidateQueries(CREDENTIAL_DETAIL_QUERY_KEY);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useCredentialDelete = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (credentialId: string) => core.deleteCredential(credentialId), {
+    onSuccess: async (_, credentialId) => {
+      await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+      await queryClient.invalidateQueries([CREDENTIAL_DETAIL_QUERY_KEY, credentialId]);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useInvalidateCredentialDetails = () => {
+  const queryClient = useQueryClient();
+
+  return (credentialId: string | undefined) =>
+    queryClient.invalidateQueries([CREDENTIAL_DETAIL_QUERY_KEY, credentialId]);
+};

package/src/utils/hooks/core/dids.ts

@@ -0,0 +1,28 @@
+import { DidListQuery, DidTypeEnum } from '@procivis/react-native-one-core';
+import { useQuery } from 'react-query';
+
+import { getQueryKeyFromDidListQueryParams } from '../../parsers/query';
+import { useONECore } from './core-context';
+
+const PAGE_SIZE = 20;
+export const DID_LIST_QUERY_KEY = 'did-list';
+
+export const useDids = (queryParams?: Partial<DidListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useQuery(
+    [DID_LIST_QUERY_KEY, ...getQueryKeyFromDidListQueryParams(queryParams)],
+    async ({ pageParam = 0 }) => {
+      const dids = await core.getDids({
+        deactivated: false,
+        organisationId,
+        page: pageParam,
+        pageSize: PAGE_SIZE,
+        type: DidTypeEnum.LOCAL,
+        ...queryParams,
+      });
+
+      return dids;
+    },
+  );
+};

package/src/utils/hooks/core/error-code.ts

@@ -0,0 +1,6 @@
+export enum OneErrorCode {
+  OrganisationAlreadyExists = 'BR_0023',
+  KeyStorageNotSupported = 'BR_0039',
+  OperationNotSupported = 'BR_0062',
+  NoTrustEntityFound = 'BR_0186',
+}

package/src/utils/hooks/core/history.ts

@@ -0,0 +1,85 @@
+import { HistoryEntityTypeEnum, HistoryListItem, HistoryListQuery, ItemList } from '@procivis/react-native-one-core';
+import { useInfiniteQuery } from 'react-query';
+
+import { getQueryKeyFromHistoryListQueryParams } from '../../parsers/query';
+import { useONECore } from './core-context';
+
+export type HistoryListItemWithDid = HistoryListItem & {
+  did?: string;
+};
+
+const PAGE_SIZE = 20;
+export const HISTORY_LIST_QUERY_KEY = 'history-list';
+
+export const useHistory = (queryParams?: Partial<HistoryListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useInfiniteQuery(
+    [HISTORY_LIST_QUERY_KEY, ...getQueryKeyFromHistoryListQueryParams(queryParams)],
+    async ({ pageParam = 0 }) => {
+      const historyPage = await core.getHistory({
+        organisationId,
+        page: pageParam,
+        pageSize: PAGE_SIZE,
+        ...queryParams,
+      });
+
+      const credentialIds = Array.from(
+        new Set(
+          historyPage.values
+            .filter((historyItem) => historyItem.entityType === HistoryEntityTypeEnum.CREDENTIAL)
+            .map((historyItem) => historyItem.entityId!),
+        ),
+      );
+      const proofIds = Array.from(
+        new Set(
+          historyPage.values
+            .filter((historyItem) => historyItem.entityType === HistoryEntityTypeEnum.PROOF)
+            .map((historyItem) => historyItem.entityId!),
+        ),
+      );
+
+      const credentials = await core.getCredentials({
+        ids: credentialIds,
+        organisationId,
+        page: 0,
+        pageSize: credentialIds.length,
+      });
+      const credentialDidsMap: Record<string, string> = Object.assign(
+        {},
+        ...credentials.values.map((credential) => ({
+          [credential.id]: credential.issuerDid,
+        })),
+      );
+
+      const proofs = await Promise.all(proofIds.map((id) => core.getProof(id)));
+      const proofDidsMap: Record<string, string> = Object.assign(
+        {},
+        ...proofs.map((proof) => ({
+          [proof.id]: proof.verifierDid?.did,
+        })),
+      );
+
+      const result: ItemList<HistoryListItemWithDid> = {
+        totalItems: historyPage.totalItems,
+        totalPages: historyPage.totalPages,
+        values: historyPage.values.map((item) => {
+          const did =
+            item.entityType === HistoryEntityTypeEnum.CREDENTIAL
+              ? credentialDidsMap[item.entityId!]
+              : proofDidsMap[item.entityId!];
+          return {
+            ...item,
+            did,
+          };
+        }),
+      };
+
+      return result;
+    },
+    {
+      getNextPageParam: (lastPage, allPages) => (allPages.length < lastPage.totalPages ? allPages.length : undefined),
+      keepPreviousData: true,
+    },
+  );
+};

package/src/utils/hooks/core/index.ts

@@ -0,0 +1,12 @@
+export * from './backup';
+export * from './core-config';
+export * from './core-context';
+export * from './core-init';
+export * from './credential-schemas';
+export * from './credentials';
+export * from './dids';
+export * from './history';
+export * from './proof-schemas';
+export * from './proofs';
+export * from './query';
+export * from './trust-entity';