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

package/src/utils/hooks/connectivity/connectivity.ts

@@ -0,0 +1,186 @@
+import {
+  addEventListener as onNetworkStateChange,
+  NetInfoStateType,
+  NetInfoSubscription,
+} from '@react-native-community/netinfo';
+import parseUrl from 'parse-url';
+import { useEffect, useMemo, useState } from 'react';
+import { EventSubscription } from 'react-native';
+import BTStateManager from 'react-native-bluetooth-state-manager';
+
+import { getEnabledTransports, useCoreConfig } from '../core/core-config';
+
+export enum InternetState {
+  Available,
+  Unreachable,
+  Disabled,
+}
+
+export type InternetError = Exclude<InternetState, InternetState.Available>;
+
+export enum BluetoothState {
+  Available,
+  Unauthorized,
+  Disabled,
+  Unavailable,
+}
+
+export type BluetoothError = Exclude<BluetoothState, BluetoothState.Available>;
+
+export enum Transport {
+  Bluetooth = 'BLE',
+  HTTP = 'HTTP',
+  MQTT = 'MQTT',
+}
+
+export type TransportError = {
+  ble?: BluetoothError;
+  internet?: InternetError;
+};
+
+export const useAvailableTransports = (
+  possibleTransports: Transport[],
+): {
+  availableTransport: Transport[] | undefined;
+  transportError: TransportError;
+} => {
+  const [internetState, setInternetState] = useState<InternetState>();
+  const [bluetoothState, setBluetoothState] = useState<BluetoothState>();
+
+  const { data: coreConfig } = useCoreConfig();
+
+  const supportedTransports = useMemo(() => {
+    if (!coreConfig) {
+      return;
+    }
+    const enabledTransports = getEnabledTransports(coreConfig);
+
+    return possibleTransports.filter((t) => enabledTransports.includes(t));
+  }, [possibleTransports, coreConfig]);
+
+  useEffect(() => {
+    if (!supportedTransports) {
+      return;
+    }
+
+    let btSubscription: EventSubscription | undefined;
+    if (supportedTransports.includes(Transport.Bluetooth)) {
+      btSubscription = BTStateManager.onStateChange((state) => {
+        switch (state) {
+          case 'PoweredOn':
+            setBluetoothState(BluetoothState.Available);
+            break;
+          case 'PoweredOff':
+            setBluetoothState(BluetoothState.Disabled);
+            break;
+          case 'Unauthorized':
+            setBluetoothState(BluetoothState.Unauthorized);
+            break;
+          default:
+            setBluetoothState(BluetoothState.Unavailable);
+        }
+      }, true);
+    }
+    let netSubscription: NetInfoSubscription | undefined;
+    if (supportedTransports.includes(Transport.HTTP) || supportedTransports.includes(Transport.MQTT)) {
+      netSubscription = onNetworkStateChange((state) => {
+        if (state.type === NetInfoStateType.none) {
+          setInternetState(InternetState.Disabled);
+          return;
+        }
+        if (state.isInternetReachable === null) {
+          return;
+        }
+        if (state.isInternetReachable) {
+          setInternetState(InternetState.Available);
+        } else {
+          setInternetState(InternetState.Unreachable);
+        }
+      });
+    }
+    return () => {
+      btSubscription?.remove();
+      netSubscription?.();
+    };
+  }, [supportedTransports]);
+
+  const transportStatus = useMemo(() => {
+    if (!supportedTransports) {
+      return {
+        availableTransport: undefined,
+        transportError: {},
+      };
+    }
+
+    const waitingForInternetState =
+      (supportedTransports.includes(Transport.HTTP) || supportedTransports.includes(Transport.MQTT)) &&
+      internetState === undefined;
+    const waitingForBluetoothState = supportedTransports.includes(Transport.Bluetooth) && bluetoothState === undefined;
+    if (waitingForInternetState || waitingForBluetoothState) {
+      return {
+        availableTransport: undefined,
+        transportError: {},
+      };
+    }
+    const availableTransport: Transport[] = [];
+    const transportError: TransportError = {};
+    if (internetState === InternetState.Available) {
+      supportedTransports.includes(Transport.MQTT) && availableTransport.push(Transport.MQTT);
+      supportedTransports.includes(Transport.HTTP) && availableTransport.push(Transport.HTTP);
+    } else {
+      transportError.internet = internetState;
+    }
+    if (bluetoothState === BluetoothState.Available) {
+      availableTransport.push(Transport.Bluetooth);
+    } else {
+      transportError.ble = bluetoothState;
+    }
+    return { availableTransport, transportError };
+  }, [bluetoothState, internetState, supportedTransports]);
+
+  return transportStatus;
+};
+
+export const getInvitationUrlTransports = (url: string, customOpenIdUrlScheme?: string): Transport[] => {
+  let parsedUrl: parseUrl.ParsedUrl;
+  try {
+    parsedUrl = parseUrl(url);
+  } catch (e) {
+    return [];
+  }
+
+  if (parsedUrl.parse_failed) {
+    return [];
+  }
+  const protocol = parsedUrl.protocol as string;
+  if (protocol !== 'openid4vp' && protocol !== customOpenIdUrlScheme?.toLowerCase()) {
+    return [Transport.HTTP];
+  }
+
+  const query = parsedUrl.query as Record<string, string>;
+  const hasAllParameters = (...params: string[]): boolean => {
+    return params.every((param) => param in query);
+  };
+
+  const transports: Transport[] = [];
+  // BLE/MQTT
+  if (parsedUrl.host === 'connect') {
+    if (hasAllParameters('name', 'key')) {
+      transports.push(Transport.Bluetooth);
+    }
+    if (hasAllParameters('brokerUrl', 'topicId')) {
+      transports.push(Transport.MQTT);
+    }
+
+    return transports;
+  }
+  // HTTP
+  if (
+    hasAllParameters('response_type', 'state', 'nonce', 'presentation_definition_uri') ||
+    hasAllParameters('client_id', 'request_uri')
+  ) {
+    transports.push(Transport.HTTP);
+  }
+
+  return transports;
+};

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

@@ -0,0 +1,144 @@
+import { DidTypeEnum, OneError } from '@procivis/react-native-one-core';
+import { useCallback } from 'react';
+import { useMutation, useQuery, useQueryClient } from 'react-query';
+
+import { generateUUID } from '../../uuid';
+import { useONECore } from './core-context';
+import { HW_DID_NAME_PREFIX, IdentifiersInitializationConfig, SW_DID_NAME_PREFIX } from './core-init';
+import { OneErrorCode } from './error-code';
+import { HISTORY_LIST_QUERY_KEY } from './history';
+
+const BACKUP_INFO_QUERY_KEY = 'backup-info';
+
+export const useBackupInfo = () => {
+  const { core } = useONECore();
+
+  return useQuery([BACKUP_INFO_QUERY_KEY], () => core.backupInfo(), {
+    keepPreviousData: true,
+  });
+};
+
+export const useCreateBackup = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async ({ password, outputPath }: { outputPath: string; password: string }) =>
+      core.createBackup(password, outputPath),
+    {
+      onSuccess: () => queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY),
+    },
+  );
+};
+
+export const useUnpackBackup = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async ({ password, inputPath }: { inputPath: string; password: string }) => core.unpackBackup(password, inputPath),
+    {
+      onSuccess: () => queryClient.resetQueries(),
+    },
+  );
+};
+
+export const useFinalizeImport = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async () => core.finalizeImport(), {
+    onSuccess: () => queryClient.resetQueries(),
+  });
+};
+
+export const useRollbackImport = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async () => core.rollbackImport(), {
+    onSuccess: () => queryClient.resetQueries(),
+  });
+};
+
+export const useBackupFinalizeImportProcedure = ({ generateHwKey, generateSwKey }: IdentifiersInitializationConfig) => {
+  const { mutateAsync: finalizeImport } = useFinalizeImport();
+  const { core, organisationId } = useONECore();
+
+  return useCallback(async () => {
+    await finalizeImport();
+
+    // update wallet did references
+    const dids = await core.getDids({
+      deactivated: false,
+      organisationId,
+      page: 0,
+      pageSize: 1,
+      type: DidTypeEnum.LOCAL,
+    });
+    let swDidId = dids.values.find((did) => did.name.startsWith(SW_DID_NAME_PREFIX))?.id;
+
+    if (!swDidId && generateSwKey) {
+      const swKeyId = await core.generateKey({
+        keyParams: {},
+        keyType: 'EDDSA',
+        name: `holder-key-sw-${generateUUID()}`,
+        organisationId,
+        storageParams: {},
+        storageType: 'INTERNAL',
+      });
+      swDidId = await core.createDid({
+        didMethod: 'KEY',
+        keys: {
+          assertionMethod: [swKeyId],
+          authentication: [swKeyId],
+          capabilityDelegation: [swKeyId],
+          capabilityInvocation: [swKeyId],
+          keyAgreement: [swKeyId],
+        },
+        name: `${SW_DID_NAME_PREFIX}-${generateUUID()}`,
+        organisationId,
+        params: {},
+      });
+    }
+
+    let hwKeyId: string | null = null;
+    if (generateHwKey) {
+      hwKeyId = await core
+        .generateKey({
+          keyParams: {},
+          keyType: 'ECDSA',
+          name: `holder-key-hw-${generateUUID()}`,
+          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;
+        });
+    }
+
+    let hwDidId: string | null = null;
+    if (hwKeyId) {
+      hwDidId = await core.createDid({
+        didMethod: 'KEY',
+        keys: {
+          assertionMethod: [hwKeyId],
+          authentication: [hwKeyId],
+          capabilityDelegation: [hwKeyId],
+          capabilityInvocation: [hwKeyId],
+          keyAgreement: [hwKeyId],
+        },
+        name: `${HW_DID_NAME_PREFIX}-${generateUUID()}`,
+        organisationId,
+        params: {},
+      });
+    }
+
+    return [hwDidId, swDidId] as [string | null, string | undefined];
+  }, [core, organisationId, finalizeImport, generateHwKey, generateSwKey]);
+};

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

@@ -0,0 +1,43 @@
+import { CacheType } from '@procivis/react-native-one-core';
+import { useMutation, useQueryClient } from 'react-query';
+
+import { useONECore } from './core-context';
+import { CREDENTIAL_DETAIL_QUERY_KEY, CREDENTIAL_LIST_PAGED_QUERY_KEY, CREDENTIAL_LIST_QUERY_KEY } from './credentials';
+import { REMOTE_TRUST_ENTITY_DETAIL_QUERY_KEY, TRUST_ENTITY_DETAIL_QUERY_KEY } from './trust-entity';
+
+const CREDENTIAL_QUERY_KEYS = [CREDENTIAL_LIST_QUERY_KEY, CREDENTIAL_LIST_PAGED_QUERY_KEY, CREDENTIAL_DETAIL_QUERY_KEY];
+const TRUST_ENTITY_QUERY_KEYS = [TRUST_ENTITY_DETAIL_QUERY_KEY, REMOTE_TRUST_ENTITY_DETAIL_QUERY_KEY];
+
+// Map each CacheType to the query keys that should be invalidated when that cache is cleared.
+const cacheTypeToQueryKeys: Record<CacheType, string[]> = {
+  [CacheType.DID_DOCUMENT]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.JSON_LD_CONTEXT]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.STATUS_LIST_CREDENTIAL]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.VCT_METADATA]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.JSON_SCHEMA]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.TRUST_LIST]: [...TRUST_ENTITY_QUERY_KEYS, ...CREDENTIAL_QUERY_KEYS],
+};
+
+export const useCacheClear = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async (cacheTypes: CacheType[]) => {
+      await core.deleteCache(cacheTypes);
+      return cacheTypes;
+    },
+    {
+      onSuccess: async (_, cacheTypes) => {
+        const queryKeysToInvalidate = new Set<string>();
+
+        cacheTypes.forEach((cacheType) => {
+          const keys = cacheTypeToQueryKeys[cacheType] || [];
+          keys.forEach((key) => queryKeysToInvalidate.add(key));
+        });
+
+        await Promise.all([...queryKeysToInvalidate].map((queryKey) => queryClient.invalidateQueries(queryKey)));
+      },
+    },
+  );
+};

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

@@ -0,0 +1,32 @@
+import { Config, ConfigEntities } from '@procivis/react-native-one-core';
+import { useQuery } from 'react-query';
+
+import { useONECore } from './core-context';
+
+const CONFIG_QUERY_KEY = 'config';
+
+export const useCoreConfig = () => {
+  const { core } = useONECore();
+
+  return useQuery([CONFIG_QUERY_KEY], () => core?.getConfig(), {
+    keepPreviousData: true,
+  });
+};
+
+export const getEnabledTransports = (config: Config): string[] => {
+  return Object.values(config?.transport ?? {})
+    .filter((t) => t.enabled !== false)
+    .map((transport) => transport.type);
+};
+
+export const getEnabledExchangeProtocols = (exchangeProtocol: ConfigEntities<any>): string[] => {
+  return Object.values(exchangeProtocol ?? {})
+    .filter((t) => t.enabled !== false)
+    .map((exchange) => exchange.type);
+};
+
+export const getEnabledTrustManagement = (config: Config): string[] => {
+  return Object.values(config?.trustManagement ?? {})
+    .filter((t) => t.enabled !== false)
+    .map((trustManagement) => trustManagement.type);
+};

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

@@ -0,0 +1,114 @@
+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 { getEnabledTrustManagement } from './core-config';
+import { TrustManagementEnum, 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;
+    }
+
+    core
+      .getConfig()
+      .then((coreConfig) => {
+        const trustManagementEnabled = getEnabledTrustManagement(coreConfig).includes(
+          TrustManagementEnum.SimpleTrustList,
+        );
+
+        if (trustManagementEnabled) {
+          createTrustAnchor(core).catch(() => {});
+        }
+      })
+      .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,106 @@
+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: 'ECDSA',
+      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: 'ECDSA',
+    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: {},
+  });
+};
+
+export interface IdentifiersInitializationConfig {
+  generateHwKey: boolean;
+  generateSwKey: boolean;
+}
+
+/**
+ * Create base local identifiers
+ * @param {IdentifiersInitializationConfig} config Select desired keys/dids to be created
+ * @returns [hwDidId, swDidId]
+ */
+export const useInitializeONECoreIdentifiers = ({ generateHwKey, generateSwKey }: IdentifiersInitializationConfig) => {
+  const { core, organisationId } = useONECore();
+
+  return useCallback(async () => {
+    return await core
+      .createOrganisation({ id: organisationId })
+      .catch((e) => {
+        if (e instanceof OneError && e.code === OneErrorCode.OrganisationAlreadyExists) {
+          return;
+        }
+        throw e;
+      })
+      .then(() =>
+        Promise.all([
+          generateHwKey ? generateHwDid(core, organisationId) : null,
+          generateSwKey ? generateSwDid(core, organisationId) : null,
+        ]),
+      )
+      .catch((err) => {
+        reportException(err, 'Failed to create base identifiers');
+        throw err;
+      });
+  }, [core, organisationId, generateHwKey, generateSwKey]);
+};