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

package/src/ui-components/text/typography.stories.tsx

@@ -1,26 +1,30 @@
-import type { ComponentMeta, ComponentStory } from '@storybook/react';
+import type { Meta,StoryObj } from '@storybook/react';
+import { fn } from '@storybook/test';
 import React from 'react';
 import type { ColorValue } from 'react-native';
 
 import ColorSchemes from '../../../storybook/colorScheme';
 import { ColorScheme, useAppColorScheme } from '../theme';
-import Typography from './typography';
+import Typography, { TypographyProps } from './typography';
 
 type ColorSchemeKey = keyof Omit<ColorScheme, 'darkMode'>;
 
-const Basic: ComponentStory<typeof Typography> = ({ color, ...args }) => {
+const Render = ({ color, ...args }: TypographyProps) => {
   const colorScheme = useAppColorScheme();
   return <Typography {...args} color={colorScheme[color as ColorSchemeKey] as ColorValue} />;
 };
 
-Basic.args = {
-  children: 'Text',
-  preset: 'regular',
-  caps: false,
-  color: 'text',
-  align: 'left',
-  numberOfLines: 1,
-  ellipsizeMode: 'tail',
+const Basic: StoryObj<typeof Typography> = {
+  args: {
+    children: 'Text',
+    preset: 'regular',
+    caps: false,
+    color: 'text',
+    align: 'left',
+    numberOfLines: 1,
+    ellipsizeMode: 'tail',
+  },
+  render: Render,
 };
 
 export { Basic as Typography };
@@ -28,6 +32,9 @@ export { Basic as Typography };
 export default {
   title: 'base/Typography',
   component: Typography,
+  args: {
+   onAnnouncementFinished: fn()
+  },
   argTypes: {
     preset: {
       options: [
@@ -67,4 +74,4 @@ export default {
       url: 'https://www.figma.com/file/52qDYWUMjXAGre1dcnz5bz/Procivis-One-Wallet?node-id=1045-30326',
     },
   },
-} as ComponentMeta<typeof Typography>;
+} as Meta<typeof Typography>;

package/src/ui-components/theme/color-scheme-context.tsx

@@ -11,6 +11,7 @@ const defaultColorScheme: ColorScheme = {
   codeAccent: '#CFD2E7',
   credentialHeaderBackground: 'rgba(255, 255, 255, 0.87)',
   error: '#D90D0D',
+  errorText: '#A73535',
   grayDark: '#CDD4DA',
   linkText: '#3F7BA6',
   success: '#00D066',

package/src/ui-components/theme/color-scheme.ts

@@ -11,6 +11,7 @@ export interface ColorScheme {
   codeAccent: string;
   credentialHeaderBackground: string;
   error: string;
+  errorText: string;
   grayDark: string;
   linkText: string;
   success: string;

package/src/utils/date.ts

@@ -1,13 +1,13 @@
 // Date & Time formatted as specified in SW-610
 
-import { NativeModules, Platform } from 'react-native';
+import { I18nManager, Platform, Settings } from 'react-native';
 import { format } from 'timeago.js';
 
 const MINUTE = 60 * 1000;
 const DAY = 24 * 60 * MINUTE;
 
 // OS locale
-const systemLocale: string = NativeModules.I18nManager?.localeIdentifier
+const systemLocale: string | undefined = I18nManager.getConstants().localeIdentifier
   ?.replace(/_/g, '-')
   .split('#')[0]
   .replace(/-$/, '');
@@ -138,10 +138,10 @@ export const formatDateOnlyFromUTCTimestamp = (utcTimestamp: number): string =>
 
 const locale = (
   Platform.OS === 'ios'
-    ? NativeModules.SettingsManager.settings.AppleLocale
-    : NativeModules.I18nManager.localeIdentifier
+    ? Settings.get('AppleLocale')
+    : I18nManager.getConstants().localeIdentifier
 )
-  .split('@')[0]
+  ?.split('@')[0]
   .replace('_', '-');
 
 export const formatDateTimeLocalized = (date: Date) => {

package/src/utils/filtering.ts

@@ -0,0 +1,5 @@
+export const nonEmptyFilter = <TValue>(
+  value: TValue | null | undefined,
+): value is TValue => {
+  return value !== null && value !== undefined;
+};

package/src/utils/history.ts

@@ -0,0 +1,71 @@
+import { Claim, ClaimValue, DataTypeEnum, HistoryListItem, ProofInputClaim } from '@procivis/react-native-one-core';
+import moment, { Moment } from 'moment';
+
+import { nonEmptyFilter } from './filtering';
+
+export interface HistoryGroupByDaySection {
+  data: HistoryListItem[];
+  date: Moment;
+  firstYearEntry: boolean;
+}
+
+export const groupEntriesByDay = (entries: HistoryListItem[]) => {
+  const groupedEntries = entries.reduce((result: HistoryGroupByDaySection[], entry: HistoryListItem) => {
+    const entryDate = moment(entry.createdDate);
+
+    const matchingEntry = result.find(({ date }) => date.isSame(entryDate, 'day'));
+    if (matchingEntry) {
+      matchingEntry.data.push(entry);
+    } else {
+      result.push({ data: [entry], date: entryDate, firstYearEntry: false });
+    }
+
+    return result;
+  }, []);
+
+  return groupedEntries
+    .sort(({ date: a }, { date: b }) => b.valueOf() - a.valueOf())
+    .map((item, index, list) => {
+      item.firstYearEntry = !index || !list[index - 1].date.isSame(item.date, 'year');
+      return item;
+    });
+};
+
+export const claimValueFromProofInputClaim = ({ schema, value }: ProofInputClaim): ClaimValue | undefined => {
+  if (!value) {
+    return undefined;
+  }
+
+  if (Array.isArray(value)) {
+    const values = value.map(claimFromProofInputClaim).filter(nonEmptyFilter);
+    return schema.dataType === (DataTypeEnum.Object as string)
+      ? {
+          array: schema.array,
+          dataType: DataTypeEnum.Object,
+          value: values,
+        }
+      : {
+          array: true,
+          dataType: schema.dataType,
+          value: values,
+        };
+  }
+
+  return {
+    array: false,
+    dataType: schema.dataType,
+    value,
+  };
+};
+
+export const claimFromProofInputClaim = (input: ProofInputClaim): Claim | undefined => {
+  const value = claimValueFromProofInputClaim(input);
+  if (!value) {
+    return undefined;
+  }
+  return {
+    ...value,
+    id: input.schema.id,
+    key: input.schema.key,
+  };
+};

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

@@ -1,5 +1,13 @@
 import { getInvitationUrlTransports, Transport } from './connectivity';
 
+jest.mock('@procivis/react-native-one-core', () => ({
+  initializeCore: () => Promise.resolve({} as any),
+}));
+
+jest.mock('@sentry/react-native', () => ({
+  captureException: () => {},
+}));
+
 jest.mock('@react-native-community/netinfo', () => ({
   addEventListener: () => {},
 }));

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

@@ -8,6 +8,8 @@ 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,
@@ -37,7 +39,7 @@ export type TransportError = {
 };
 
 export const useAvailableTransports = (
-  supportedTransports: Transport[],
+  possibleTransports: Transport[],
 ): {
   availableTransport: Transport[] | undefined;
   transportError: TransportError;
@@ -45,7 +47,22 @@ export const useAvailableTransports = (
   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) => {
@@ -88,6 +105,13 @@ export const useAvailableTransports = (
   }, [supportedTransports]);
 
   const transportStatus = useMemo(() => {
+    if (!supportedTransports) {
+      return {
+        availableTransport: undefined,
+        transportError: {},
+      };
+    }
+
     const waitingForInternetState =
       (supportedTransports.includes(Transport.HTTP) || supportedTransports.includes(Transport.MQTT)) &&
       internetState === undefined;
@@ -101,8 +125,8 @@ export const useAvailableTransports = (
     const availableTransport: Transport[] = [];
     const transportError: TransportError = {};
     if (internetState === InternetState.Available) {
-      availableTransport.push(Transport.MQTT);
-      availableTransport.push(Transport.HTTP);
+      supportedTransports.includes(Transport.MQTT) && availableTransport.push(Transport.MQTT);
+      supportedTransports.includes(Transport.HTTP) && availableTransport.push(Transport.HTTP);
     } else {
       transportError.internet = internetState;
     }
@@ -144,7 +168,7 @@ export const getInvitationUrlTransports = (url: string, customOpenIdUrlScheme?:
     if (hasAllParameters('name', 'key')) {
       transports.push(Transport.Bluetooth);
     }
-    if (hasAllParameters('key', 'brokerUrl', 'topicId')) {
+    if (hasAllParameters('brokerUrl', 'topicId')) {
       transports.push(Transport.MQTT);
     }
 

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

@@ -4,7 +4,7 @@ import { useMutation, useQuery, useQueryClient } from 'react-query';
 
 import { generateUUID } from '../../uuid';
 import { useONECore } from './core-context';
-import { HW_DID_NAME_PREFIX, SW_DID_NAME_PREFIX } from './core-init';
+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';
 
@@ -61,7 +61,7 @@ export const useRollbackImport = () => {
   });
 };
 
-export const useBackupFinalizeImportProcedure = () => {
+export const useBackupFinalizeImportProcedure = ({ generateHwKey, generateSwKey }: IdentifiersInitializationConfig) => {
   const { mutateAsync: finalizeImport } = useFinalizeImport();
   const { core, organisationId } = useONECore();
 
@@ -78,7 +78,7 @@ export const useBackupFinalizeImportProcedure = () => {
     });
     let swDidId = dids.values.find((did) => did.name.startsWith(SW_DID_NAME_PREFIX))?.id;
 
-    if (!swDidId) {
+    if (!swDidId && generateSwKey) {
       const swKeyId = await core.generateKey({
         keyParams: {},
         keyType: 'EDDSA',
@@ -102,23 +102,27 @@ export const useBackupFinalizeImportProcedure = () => {
       });
     }
 
+    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;
-    const hwKeyId = await core
-      .generateKey({
-        keyParams: {},
-        keyType: 'ES256',
-        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;
-      });
     if (hwKeyId) {
       hwDidId = await core.createDid({
         didMethod: 'KEY',
@@ -135,6 +139,6 @@ export const useBackupFinalizeImportProcedure = () => {
       });
     }
 
-    return [hwDidId, swDidId] as [string | null, string];
-  }, [core, organisationId, finalizeImport]);
+    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

@@ -1,3 +1,4 @@
+import { Config, ConfigEntities } from '@procivis/react-native-one-core';
 import { useQuery } from 'react-query';
 
 import { useONECore } from './core-context';
@@ -11,3 +12,21 @@ export const useCoreConfig = () => {
     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

@@ -11,7 +11,8 @@ import React, {
 } from 'react';
 
 import { reportException } from '../../reporting';
-import { useCreateTrustAnchor } from './trust-entity';
+import { getEnabledTrustManagement } from './core-config';
+import { TrustManagementEnum, useCreateTrustAnchor } from './trust-entity';
 
 interface ContextValue {
   core: ONECore;
@@ -79,7 +80,19 @@ export const ONECoreContextProvider: FC<PropsWithChildren<ONECoreContextProvider
     if (!core) {
       return;
     }
-    createTrustAnchor(core).catch(() => {});
+
+    core
+      .getConfig()
+      .then((coreConfig) => {
+        const trustManagementEnabled = getEnabledTrustManagement(coreConfig).includes(
+          TrustManagementEnum.SimpleTrustList,
+        );
+
+        if (trustManagementEnabled) {
+          createTrustAnchor(core).catch(() => {});
+        }
+      })
+      .catch(() => {});
   }, [core, createTrustAnchor]);
 
   const contextValue = useMemo(

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

@@ -8,11 +8,11 @@ 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 generateHwIdentifier = async (core: ONECore, organisationId: string) => {
   const hwKeyId = await core
     .generateKey({
       keyParams: {},
-      keyType: 'ES256',
+      keyType: 'ECDSA',
       name: 'holder-key-hw',
       organisationId,
       storageParams: {},
@@ -27,66 +27,84 @@ const generateHwDid = async (core: ONECore, organisationId: string) => {
     });
 
   if (hwKeyId) {
-    return core.createDid({
-      didMethod: 'KEY',
-      keys: {
-        assertionMethod: [hwKeyId],
-        authentication: [hwKeyId],
-        capabilityDelegation: [hwKeyId],
-        capabilityInvocation: [hwKeyId],
-        keyAgreement: [hwKeyId],
+    return core.createIdentifier({
+      did: {
+        method: 'KEY',
+        keys: {
+          assertionMethod: [hwKeyId],
+          authentication: [hwKeyId],
+          capabilityDelegation: [hwKeyId],
+          capabilityInvocation: [hwKeyId],
+          keyAgreement: [hwKeyId],
+        },
+        params: {},
       },
       name: HW_DID_NAME_PREFIX,
       organisationId,
-      params: {},
     });
   }
 
   return null;
 };
 
-const generateSwDid = async (core: ONECore, organisationId: string) => {
+const generateSwIdentifier = async (core: ONECore, organisationId: string) => {
   const swKeyId = await core.generateKey({
     keyParams: {},
-    keyType: 'EDDSA',
+    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],
+  return core.createIdentifier({
+    did: {
+      method: 'KEY',
+      keys: {
+        assertionMethod: [swKeyId],
+        authentication: [swKeyId],
+        capabilityDelegation: [swKeyId],
+        capabilityInvocation: [swKeyId],
+        keyAgreement: [swKeyId],
+      },
+      params: {},
     },
     name: SW_DID_NAME_PREFIX,
     organisationId,
-    params: {},
   });
 };
 
-// create base local identifiers in the wallet
-export const useInitializeONECoreIdentifiers = () => {
+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(organisationId)
+      .createOrganisation({ id: organisationId })
       .catch((e) => {
         if (e instanceof OneError && e.code === OneErrorCode.OrganisationAlreadyExists) {
           return;
         }
         throw e;
       })
-      .then(() => Promise.all([generateHwDid(core, organisationId), generateSwDid(core, organisationId)]))
+      .then(() =>
+        Promise.all([
+          generateHwKey ? generateHwIdentifier(core, organisationId) : null,
+          generateSwKey ? generateSwIdentifier(core, organisationId) : null,
+        ]),
+      )
       .catch((err) => {
         reportException(err, 'Failed to create base identifiers');
         throw err;
       });
-  }, [core, organisationId]);
+  }, [core, organisationId, generateHwKey, generateSwKey]);
 };

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

@@ -90,7 +90,7 @@ export const useCredentialSchemaDelete = () => {
   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.removeQueries([CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY, credentialId]);
       await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
     },
   });

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

@@ -1,22 +1,17 @@
-import {
-  BypassCache,
-  CredentialListQuery,
-  CredentialStateEnum,
-  InvitationResult,
-  OneError,
-} from '@procivis/react-native-one-core';
+import { CredentialListQuery, CredentialStateEnum, InvitationResult, OneError } from '@procivis/react-native-one-core';
 import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from 'react-query';
 
 import { getQueryKeyFromCredentialListQueryParams } from '../../parsers/query';
+import { Transport } from '../connectivity/connectivity';
 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 CREDENTIAL_LIST_QUERY_KEY = 'credential-list';
+export const CREDENTIAL_LIST_PAGED_QUERY_KEY = 'credential-list-paged';
+export const CREDENTIAL_DETAIL_QUERY_KEY = 'credential-detail';
 
 export const useCredentials = (queryParams?: Partial<CredentialListQuery>) => {
   const { core, organisationId } = useONECore();
@@ -82,7 +77,7 @@ export const useInvitationHandler = () => {
   const { core, organisationId } = useONECore();
 
   return useMutation(
-    async ({ invitationUrl, transport }: { invitationUrl: string; transport: 'HTTP' | 'MQTT' | 'BLE' }) =>
+    async ({ invitationUrl, transport }: { invitationUrl: string; transport: Transport }) =>
       core.handleInvitation(invitationUrl, organisationId, [transport]),
     {
       onSuccess: async (result: InvitationResult) => {
@@ -100,11 +95,17 @@ export const useCredentialAccept = () => {
   const queryClient = useQueryClient();
   const { core } = useONECore();
 
-  type CredentialAcceptHookParams = { didId: string; interactionId: string; keyId?: string; txCode?: string };
+  type CredentialAcceptHookParams = {
+    didId?: string;
+    identifierId?: string;
+    interactionId: string;
+    keyId?: string;
+    txCode?: string;
+  };
 
   return useMutation(
-    async ({ interactionId, didId, keyId, txCode }: CredentialAcceptHookParams) =>
-      core.holderAcceptCredential(interactionId, didId, keyId, txCode),
+    async ({ interactionId, didId, identifierId, keyId, txCode }: CredentialAcceptHookParams) =>
+      core.holderAcceptCredential(interactionId, didId, identifierId, keyId, txCode),
     {
       onSuccess: async () => {
         await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
@@ -137,11 +138,11 @@ export const useCredentialReject = () => {
   );
 };
 
-export const useCredentialRevocationCheck = (bypassCache?: BypassCache[]) => {
+export const useCredentialRevocationCheck = (forceRefresh: boolean) => {
   const queryClient = useQueryClient();
   const { core } = useONECore();
 
-  return useMutation(async (credentialIds: string[]) => core.checkRevocation(credentialIds, bypassCache), {
+  return useMutation(async (credentialIds: string[]) => core.checkRevocation(credentialIds, forceRefresh), {
     onSuccess: async () => {
       await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
       await queryClient.invalidateQueries(CREDENTIAL_DETAIL_QUERY_KEY);
@@ -157,7 +158,7 @@ export const useCredentialDelete = () => {
   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.removeQueries([CREDENTIAL_DETAIL_QUERY_KEY, credentialId]);
       await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
     },
   });