@bifold/core 2.4.6 → 2.5.0

package/src/hooks/notifications.ts

@@ -1,108 +0,0 @@
-import {
-  BasicMessageRecord,
-  CredentialExchangeRecord as CredentialRecord,
-  CredentialState,
-  MdocRecord,
-  ProofExchangeRecord,
-  ProofState,
-  SdJwtVcRecord,
-  W3cCredentialRecord,
-} from '@credo-ts/core'
-import { useBasicMessages, useCredentialByState, useProofByState } from '@credo-ts/react-hooks'
-import { ProofCustomMetadata, ProofMetadata } from '@bifold/verifier'
-import { useEffect, useState } from 'react'
-
-import {
-  BasicMessageMetadata,
-  CredentialMetadata,
-  basicMessageCustomMetadata,
-  credentialCustomMetadata,
-} from '../types/metadata'
-import { useOpenID } from '../modules/openid/hooks/openid'
-import { CustomNotification } from '../types/notification'
-import { OpenId4VPRequestRecord } from '../modules/openid/types'
-
-export type NotificationsInputProps = {
-  openIDUri?: string
-  openIDPresentationUri?: string
-}
-
-export type NotificationReturnType = Array<
-  | BasicMessageRecord
-  | CredentialRecord
-  | ProofExchangeRecord
-  | CustomNotification
-  | SdJwtVcRecord
-  | W3cCredentialRecord
-  | MdocRecord
-  | OpenId4VPRequestRecord
->
-
-export const useNotifications = ({
-  openIDUri,
-  openIDPresentationUri,
-}: NotificationsInputProps): NotificationReturnType => {
-  const [notifications, setNotifications] = useState<NotificationReturnType>([])
-  const { records: basicMessages } = useBasicMessages()
-  const offers = useCredentialByState(CredentialState.OfferReceived)
-  const proofsRequested = useProofByState(ProofState.RequestReceived)
-  const credsReceived = useCredentialByState(CredentialState.CredentialReceived)
-  const credsDone = useCredentialByState(CredentialState.Done)
-  const proofsDone = useProofByState([ProofState.Done, ProofState.PresentationReceived])
-  const openIDCredRecieved = useOpenID({ openIDUri: openIDUri, openIDPresentationUri: openIDPresentationUri })
-
-  useEffect(() => {
-    // get all unseen messages
-    const unseenMessages: BasicMessageRecord[] = basicMessages.filter((msg) => {
-      const meta = msg.metadata.get(BasicMessageMetadata.customMetadata) as basicMessageCustomMetadata
-      return !meta?.seen
-    })
-
-    // add one unseen message per contact to notifications
-    const contactsWithUnseenMessages: string[] = []
-    const messagesToShow: BasicMessageRecord[] = []
-
-    unseenMessages.forEach((msg) => {
-      if (!contactsWithUnseenMessages.includes(msg.connectionId)) {
-        contactsWithUnseenMessages.push(msg.connectionId)
-        messagesToShow.push(msg)
-      }
-    })
-
-    const validProofsDone = proofsDone.filter((proof: ProofExchangeRecord) => {
-      if (proof.isVerified === undefined) {
-        return false
-      }
-
-      const metadata = proof.metadata.get(ProofMetadata.customMetadata) as ProofCustomMetadata
-
-      return !metadata?.details_seen
-    })
-
-    const revoked = credsDone.filter((cred: CredentialRecord) => {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const metadata = cred!.metadata.get(CredentialMetadata.customMetadata) as credentialCustomMetadata
-      if (cred?.revocationNotification && metadata?.revoked_seen == undefined) {
-        return cred
-      }
-    })
-
-    const openIDCreds: Array<SdJwtVcRecord | W3cCredentialRecord | MdocRecord | OpenId4VPRequestRecord> = []
-    if (openIDCredRecieved) {
-      openIDCreds.push(openIDCredRecieved)
-    }
-
-    const notif = [
-      ...messagesToShow,
-      ...offers,
-      ...proofsRequested,
-      ...validProofsDone,
-      ...revoked,
-      ...openIDCreds,
-    ].sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
-
-    setNotifications(notif)
-  }, [basicMessages, credsReceived, proofsDone, proofsRequested, offers, credsDone, openIDCredRecieved])
-
-  return notifications
-}

package/src/hooks/oob.ts

@@ -1,17 +0,0 @@
-import { OutOfBandRecord } from '@credo-ts/core'
-import { useAgent } from '@credo-ts/react-hooks'
-import { useState } from 'react'
-
-export const useOutOfBandByReceivedInvitationId = (receivedInvitationId: string): OutOfBandRecord | undefined => {
-  const { agent } = useAgent()
-
-  const [oob, setOob] = useState<OutOfBandRecord | undefined>(undefined)
-  if (!oob) {
-    agent?.oob.findByReceivedInvitationId(receivedInvitationId).then((res) => {
-      if (res) {
-        setOob(res)
-      }
-    })
-  }
-  return oob
-}

package/src/hooks/proof-request-templates.ts

@@ -1,40 +0,0 @@
-import { ProofRequestTemplate } from '@bifold/verifier'
-import { useEffect, useState } from 'react'
-
-import { TOKENS, useServices } from '../container-api'
-import { useStore } from '../contexts/store'
-import { applyTemplateMarkers, useRemoteProofBundleResolver } from '../utils/proofBundle'
-
-export const useTemplates = (): Array<ProofRequestTemplate> => {
-  const [store] = useStore()
-  const [proofRequestTemplates, setProofRequestTemplates] = useState<ProofRequestTemplate[]>([])
-  const [{ proofTemplateBaseUrl }, logger] = useServices([TOKENS.CONFIG, TOKENS.UTIL_LOGGER])
-  const resolver = useRemoteProofBundleResolver(proofTemplateBaseUrl, logger)
-
-  useEffect(() => {
-    resolver.resolve(store.preferences.acceptDevCredentials).then((templates) => {
-      if (templates) {
-        setProofRequestTemplates(applyTemplateMarkers(templates))
-      }
-    })
-  }, [resolver, store.preferences.acceptDevCredentials])
-
-  return proofRequestTemplates
-}
-
-export const useTemplate = (templateId: string): ProofRequestTemplate | undefined => {
-  const [store] = useStore()
-  const [proofRequestTemplate, setProofRequestTemplate] = useState<ProofRequestTemplate | undefined>(undefined)
-  const [{ proofTemplateBaseUrl }] = useServices([TOKENS.CONFIG])
-  const resolver = useRemoteProofBundleResolver(proofTemplateBaseUrl)
-
-  useEffect(() => {
-    resolver.resolveById(templateId, store.preferences.acceptDevCredentials).then((template) => {
-      if (template) {
-        setProofRequestTemplate(applyTemplateMarkers(template))
-      }
-    })
-  }, [resolver, templateId, store.preferences.acceptDevCredentials])
-
-  return proofRequestTemplate
-}

package/src/hooks/proofs.ts

@@ -1,32 +0,0 @@
-import { ProofExchangeRecord } from '@credo-ts/core'
-import { useAgent, useCredentials, useProofById, useProofs } from '@credo-ts/react-hooks'
-import { useMemo } from 'react'
-import { useTranslation } from 'react-i18next'
-
-import { TOKENS, useServices } from '../container-api'
-import { retrieveCredentialsForProof } from '../utils/helpers'
-
-export const useProofsByConnectionId = (connectionId: string): ProofExchangeRecord[] => {
-  const { records: proofs } = useProofs()
-
-  return useMemo(
-    () => proofs.filter((proof: ProofExchangeRecord) => proof.connectionId === connectionId),
-    [proofs, connectionId]
-  )
-}
-
-export const useAllCredentialsForProof = (proofId: string) => {
-  const { t } = useTranslation()
-  const { agent } = useAgent()
-  const fullCredentials = useCredentials().records
-  const proof = useProofById(proofId)
-  const [groupByReferent] = useServices([TOKENS.GROUP_BY_REFERENT])
-
-  return useMemo(() => {
-    if (!proof || !agent) {
-      return
-    }
-
-    return retrieveCredentialsForProof(agent, proof, fullCredentials, t, groupByReferent)
-  }, [proof, agent, fullCredentials, t, groupByReferent])
-}

package/src/hooks/screen-capture.ts

@@ -1,52 +0,0 @@
-import { useEffect } from 'react'
-import { Platform } from 'react-native'
-import ScreenGuardModule from 'react-native-screenguard'
-
-export const screenGuardOptions = {
-  timeAfterResume: 500, // milliseconds
-  backgroundColor: '#000000', // black
-}
-
-/**
- * Prevents screenshots when component is mounted. When unmounted, allows them again
- *
- * @param {boolean} [active=true] - If `false`, hook does nothing
- * @remarks
- * - If `active` param is `true`, it prevents screenshots when the
- * component is mounted
- * - On unmount, or when `active` is changed to false, it restores
- * the ability to take screenshots
- * - Should be used at the screen level only
- *
- * @example
- * ```tsx
- * import usePreventScreenCapture from './hooks/screen-capture';
- *
- * const MyScreen = () => {
- *   usePreventScreenCapture();
- *   return <View><Text>Secure Content</Text></View>;
- * };
- * ```
- *
- * @returns {void}
- */
-const usePreventScreenCapture = (active: boolean = true) => {
-  useEffect(() => {
-    if (!active) return
-
-    if (Platform.OS === 'android') {
-      // on Android, plain `register` will trigger AppState to
-      // change momentarily, which can have side effects.
-      // `registerWithoutEffect` prevents that
-      ScreenGuardModule.registerWithoutEffect()
-    } else {
-      ScreenGuardModule.register(screenGuardOptions)
-    }
-
-    return () => {
-      ScreenGuardModule.unregister()
-    }
-  }, [active])
-}
-
-export default usePreventScreenCapture

package/src/hooks/useBifoldAgentSetup.ts

@@ -1,169 +0,0 @@
-import { Agent, HttpOutboundTransport, WsOutboundTransport } from '@credo-ts/core'
-import { IndyVdrPoolService } from '@credo-ts/indy-vdr/build/pool'
-import { agentDependencies } from '@credo-ts/react-native'
-import { GetCredentialDefinitionRequest, GetSchemaRequest } from '@hyperledger/indy-vdr-shared'
-import { useCallback, useRef, useState } from 'react'
-import { CachesDirectoryPath } from 'react-native-fs'
-
-import { TOKENS, useServices } from '../container-api'
-import { DispatchAction } from '../contexts/reducers/store'
-import { useStore } from '../contexts/store'
-import { WalletSecret } from '../types/security'
-import { createLinkSecretIfRequired, getAgentModules } from '../utils/agent'
-import { migrateToAskar } from '../utils/migration'
-
-export type AgentSetupReturnType = {
-  agent: Agent | null
-  initializeAgent: (walletSecret: WalletSecret) => Promise<void>
-  shutdownAndClearAgentIfExists: () => Promise<void>
-}
-
-const useBifoldAgentSetup = (): AgentSetupReturnType => {
-  const [agent, setAgent] = useState<Agent | null>(null)
-  const agentInstanceRef = useRef<Agent | null>(null)
-  const [store, dispatch] = useStore()
-  const [cacheSchemas, cacheCredDefs, logger, indyLedgers] = useServices([
-    TOKENS.CACHE_SCHEMAS,
-    TOKENS.CACHE_CRED_DEFS,
-    TOKENS.UTIL_LOGGER,
-    TOKENS.UTIL_LEDGERS,
-  ])
-
-  const restartExistingAgent = useCallback(
-    async (agent: Agent, walletSecret: WalletSecret): Promise<Agent | undefined> => {
-      try {
-        await agent.wallet.open({
-          id: walletSecret.id,
-          key: walletSecret.key,
-        })
-        await agent.initialize()
-      } catch (error) {
-        logger.warn(`Agent restart failed with error ${error}`)
-        // if the existing agents wallet cannot be opened or initialize() fails it was
-        // again not a clean shutdown and the agent should be replaced, not restarted
-        return
-      }
-
-      return agent
-    },
-    [logger]
-  )
-
-  const createNewAgent = useCallback(
-    async (walletSecret: WalletSecret, mediatorUrl: string): Promise<Agent> => {
-      const newAgent = new Agent({
-        config: {
-          label: store.preferences.walletName || 'Aries Bifold',
-          walletConfig: {
-            id: walletSecret.id,
-            key: walletSecret.key,
-          },
-          logger,
-          autoUpdateStorageOnStartup: true,
-        },
-        dependencies: agentDependencies,
-        modules: getAgentModules({
-          indyNetworks: indyLedgers,
-          mediatorInvitationUrl: mediatorUrl,
-          txnCache: {
-            capacity: 1000,
-            expiryOffsetMs: 1000 * 60 * 60 * 24 * 7,
-            path: CachesDirectoryPath + '/txn-cache',
-          },
-        }),
-      })
-      const wsTransport = new WsOutboundTransport()
-      const httpTransport = new HttpOutboundTransport()
-
-      newAgent.registerOutboundTransport(wsTransport)
-      newAgent.registerOutboundTransport(httpTransport)
-
-      return newAgent
-    },
-    [store.preferences.walletName, logger, indyLedgers]
-  )
-
-  const migrateIfRequired = useCallback(
-    async (newAgent: Agent, walletSecret: WalletSecret) => {
-      // If we haven't migrated to Aries Askar yet, we need to do this before we initialize the agent.
-      if (!store.migration.didMigrateToAskar) {
-        await migrateToAskar(walletSecret.id, walletSecret.key, newAgent)
-        // Store that we migrated to askar.
-        dispatch({
-          type: DispatchAction.DID_MIGRATE_TO_ASKAR,
-        })
-      }
-    },
-    [store.migration.didMigrateToAskar, dispatch]
-  )
-
-  const warmUpCache = useCallback(
-    async (newAgent: Agent) => {
-      const poolService = newAgent.dependencyManager.resolve(IndyVdrPoolService)
-      cacheCredDefs.forEach(async ({ did, id }) => {
-        const pool = await poolService.getPoolForDid(newAgent.context, did)
-        const credDefRequest = new GetCredentialDefinitionRequest({ credentialDefinitionId: id })
-        await pool.pool.submitRequest(credDefRequest)
-      })
-
-      cacheSchemas.forEach(async ({ did, id }) => {
-        const pool = await poolService.getPoolForDid(newAgent.context, did)
-        const schemaRequest = new GetSchemaRequest({ schemaId: id })
-        await pool.pool.submitRequest(schemaRequest)
-      })
-    },
-    [cacheCredDefs, cacheSchemas]
-  )
-
-  const initializeAgent = useCallback(
-    async (walletSecret: WalletSecret): Promise<void> => {
-      const mediatorUrl = store.preferences.selectedMediator
-      logger.info('Checking for existing agent...')
-      if (agentInstanceRef.current) {
-        const restartedAgent = await restartExistingAgent(agentInstanceRef.current, walletSecret)
-        if (restartedAgent) {
-          logger.info('Successfully restarted existing agent...')
-          agentInstanceRef.current = restartedAgent
-          setAgent(restartedAgent)
-          return
-        }
-      }
-
-      logger.info('Creating new agent...')
-      const newAgent = await createNewAgent(walletSecret, mediatorUrl)
-
-      logger.info('Migrating if required...')
-      await migrateIfRequired(newAgent, walletSecret)
-
-      logger.info('Initializing agent...')
-      await newAgent.initialize()
-
-      logger.info('Creating link secret if required...')
-      await createLinkSecretIfRequired(newAgent)
-
-      logger.info('Warming up cache...')
-      await warmUpCache(newAgent)
-
-      logger.info('Agent initialized successfully')
-      agentInstanceRef.current = newAgent
-      setAgent(newAgent)
-    },
-    [logger, restartExistingAgent, createNewAgent, migrateIfRequired, warmUpCache, store.preferences.selectedMediator]
-  )
-
-  const shutdownAndClearAgentIfExists = useCallback(async () => {
-    if (agent) {
-      try {
-        await agent.shutdown()
-      } catch (error) {
-        logger.error(`Error shutting down agent with shutdownAndClearAgentIfExists: ${error}`)
-      } finally {
-        setAgent(null)
-      }
-    }
-  }, [agent, logger])
-
-  return { agent, initializeAgent, shutdownAndClearAgentIfExists }
-}
-
-export default useBifoldAgentSetup

package/src/hooks/useOnboardingState.ts

@@ -1,53 +0,0 @@
-import { Agent } from '@credo-ts/core'
-import { useState, useEffect, useMemo } from 'react'
-import { useNavigationState } from '@react-navigation/native'
-import { State } from '../types/state'
-import { OnboardingTask } from '../types/navigators'
-import { Config } from '../types/config'
-
-/**
- * Hook to manage onboarding workflow state
- * Tracks the onboarding tasks, their completion status.
- */
-export const useOnboardingState = (
-  store: State,
-  config: Config,
-  termsVersion: number,
-  agent: Agent | null,
-  generateOnboardingWorkflowSteps: (
-    store: State,
-    config: Config,
-    termsVersion: number,
-    agent: Agent | null
-  ) => OnboardingTask[]
-): {
-  onboardingState: OnboardingTask[]
-  setOnboardingState: React.Dispatch<React.SetStateAction<OnboardingTask[]>>
-  activeScreen: string | undefined
-  currentRoute: any
-  isComplete: boolean
-} => {
-  const [onboardingState, setOnboardingState] = useState<OnboardingTask[]>([])
-  const currentRoute = useNavigationState((state) => state?.routes[state?.index])
-
-  const activeScreen = useMemo(() => {
-    return onboardingState.find((task) => !task.completed)?.name
-  }, [onboardingState])
-
-  useEffect(() => {
-    if (!store.stateLoaded) {
-      return
-    }
-
-    const onboardingTasks = generateOnboardingWorkflowSteps(store, config, termsVersion, agent)
-    setOnboardingState(onboardingTasks)
-  }, [store, config, termsVersion, agent, generateOnboardingWorkflowSteps])
-
-  return {
-    onboardingState,
-    setOnboardingState,
-    activeScreen,
-    currentRoute,
-    isComplete: !activeScreen,
-  }
-}

package/src/hooks/usePINValidation.ts

@@ -1,98 +0,0 @@
-import { useCallback, useEffect, useState } from 'react'
-import { useTranslation } from 'react-i18next'
-
-import { InlineErrorType, InlineMessageProps } from '../components/inputs/InlineErrorText'
-import { TOKENS, useServices } from '../container-api'
-import { createPINValidations, PINValidationsType } from '../utils/PINValidation'
-
-interface ModalState {
-  visible: boolean
-  title: string
-  message: string
-  onModalDismiss?: () => void
-}
-
-const initialModalState: ModalState = {
-  visible: false,
-  title: '',
-  message: '',
-}
-
-export const usePINValidation = (PIN: string, PINTwo: string) => {
-  const { t } = useTranslation()
-  const [{ PINSecurity }, inlineMessages] = useServices([TOKENS.CONFIG, TOKENS.INLINE_ERRORS])
-  const [inlineMessageField1, setInlineMessageField1] = useState<InlineMessageProps>()
-  const [inlineMessageField2, setInlineMessageField2] = useState<InlineMessageProps>()
-  const [modalState, setModalState] = useState<ModalState>(initialModalState)
-
-  const clearModal = useCallback(() => {
-    setModalState(initialModalState)
-  }, [])
-
-  const [PINValidations, setPINValidations] = useState<PINValidationsType[]>(
-    createPINValidations(PIN, PINSecurity.rules)
-  )
-
-  useEffect(() => {
-    setInlineMessageField1(undefined)
-    setInlineMessageField2(undefined)
-    setPINValidations(createPINValidations(PIN, PINSecurity.rules))
-  }, [PIN, PINTwo, PINSecurity.rules])
-
-  const attentionMessage = useCallback(
-    (title: string, message: string, pinOne: boolean) => {
-      if (inlineMessages.enabled) {
-        const config = {
-          message: message,
-          inlineType: InlineErrorType.error,
-          config: inlineMessages,
-        }
-        if (pinOne) {
-          setInlineMessageField1(config)
-        } else {
-          setInlineMessageField2(config)
-        }
-      } else {
-        setModalState({
-          visible: true,
-          title: title,
-          message: message,
-          onModalDismiss: clearModal,
-        })
-      }
-    },
-    [inlineMessages, clearModal]
-  )
-
-  const validatePINEntry = useCallback(
-    (PINOne: string, PINTwo: string): boolean => {
-      for (const validation of PINValidations) {
-        if (validation.isInvalid) {
-          attentionMessage(
-            t('PINCreate.InvalidPIN'),
-            t(`PINCreate.Message.${validation.errorName}`, validation?.errorTextAddition),
-            true
-          )
-          return false
-        }
-      }
-      if (PINOne !== PINTwo) {
-        attentionMessage(t('PINCreate.InvalidPIN'), t('PINCreate.PINsDoNotMatch'), false)
-        return false
-      }
-      return true
-    },
-    [PINValidations, t, attentionMessage]
-  )
-
-  return {
-    PINValidations,
-    validatePINEntry,
-    inlineMessageField1,
-    inlineMessageField2,
-    modalState,
-    setModalState,
-    clearModal,
-    PINSecurity,
-  }
-}