@bifold/core 1.0.0

package/src/hooks/notifications.ts

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,52 @@
+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/useOnboardingState.ts

@@ -0,0 +1,46 @@
+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,
+  generateOnboardingWorkflowSteps: (store: State, config: Config, termsVersion: number) => 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)
+    setOnboardingState(onboardingTasks)
+  }, [store, config, termsVersion, generateOnboardingWorkflowSteps])
+
+  return {
+    onboardingState,
+    setOnboardingState,
+    activeScreen,
+    currentRoute,
+    isComplete: !activeScreen,
+  }
+}

package/src/index.ts

@@ -0,0 +1,225 @@
+/* eslint-disable import/no-cycle */
+import type { OnboardingStyleSheet } from './screens/Onboarding'
+
+import { Agent } from '@credo-ts/core'
+import AgentProvider from '@credo-ts/react-hooks'
+
+import App from './App'
+import * as components from './components'
+import { Button as IButton, ButtonImpl as Button, ButtonType } from './components/buttons/Button'
+import IconButton, { ButtonLocation } from './components/buttons/IconButton'
+import BulletPoint from './components/inputs/BulletPoint'
+import CheckBoxRow from './components/inputs/CheckBoxRow'
+import ContentGradient from './components/misc/ContentGradient'
+import CredentialCard from './components/misc/CredentialCard'
+import InfoBox, { InfoBoxType } from './components/misc/InfoBox'
+import ErrorModal from './components/modals/ErrorModal'
+import SafeAreaModal from './components/modals/SafeAreaModal'
+import NetInfo from './components/network/NetInfo'
+import Record from './components/record/Record'
+import InfoTextBox from './components/texts/InfoTextBox'
+import Link from './components/texts/Link'
+import Text from './components/texts/Text'
+import { ThemedText } from './components/texts/ThemedText'
+import { ToastType } from './components/toast/BaseToast'
+import toastConfig from './components/toast/ToastConfig'
+import { AttachTourStep } from './components/tour/AttachTourStep'
+import { credentialOfferTourSteps } from './components/tour/CredentialOfferTourSteps'
+import { credentialsTourSteps } from './components/tour/CredentialsTourSteps'
+import { homeTourSteps } from './components/tour/HomeTourSteps'
+import { proofRequestTourSteps } from './components/tour/ProofRequestTourSteps'
+import { TourBox } from './components/tour/TourBox'
+import LimitedTextInput from './components/inputs/LimitedTextInput'
+import HomeFooterView from './components/views/HomeFooterView'
+import KeyboardView from './components/views/KeyboardView'
+import NotificationListItem from './components/listItems/NotificationListItem'
+import * as contexts from './contexts'
+import { AutoLockTime, ActivityProvider, useActivity } from './contexts/activity'
+import { AuthProvider } from './contexts/auth'
+import { NetworkProvider } from './contexts/network'
+import { useTour } from './contexts/tour/tour-context'
+import { TourProvider } from './contexts/tour/tour-provider'
+import AttemptLockout from './screens/AttemptLockout'
+import Developer from './screens/Developer'
+import OnboardingPages from './screens/OnboardingPages'
+import Preface from './screens/Preface'
+import Splash from './screens/Splash'
+import Terms from './screens/Terms'
+import UpdateAvailable from './screens/UpdateAvailable'
+import UseBiometry from './screens/UseBiometry'
+import { loadLoginAttempt } from './services/keychain'
+import { BifoldLogger } from './services/logger'
+import * as types from './types'
+import Scan from './screens/Scan'
+import Onboarding from './screens/Onboarding'
+import { DefaultScreenOptionsDictionary, useDefaultStackOptions } from './navigators/defaultStackOptions'
+import { PINRules, walletTimeout, tours, attemptLockoutConfig } from './constants'
+import { CredentialListFooterProps } from './types/credential-list-footer'
+import { OpenIDCredentialRecordProvider } from './modules/openid/context/OpenIDCredentialRecordProvider'
+import { defaultConfig, defaultHistoryEventsLogger } from './container-impl'
+import useInitializeAgent from './hooks/initialize-agent'
+import usePreventScreenCapture from './hooks/screen-capture'
+import { DefaultScreenLayoutOptions } from './navigators/defaultLayoutOptions'
+
+export * from './navigators'
+export * from './services/storage'
+export * from './types/attestation'
+export * from './types/version-check'
+export { LocalStorageKeys } from './constants'
+export * from './services/storage'
+export { initLanguages, initStoredLanguage, translationResources, Locales } from './localization'
+export { defaultState, mergeReducers, StoreProvider, StoreContext, useStore } from './contexts/store'
+export { default as Store, DispatchAction, reducer } from './contexts/reducers/store'
+export { useDeepLinks } from './hooks/deep-links'
+export { Assets as ImageAssets } from './theme'
+export { ThemeProvider, useTheme } from './contexts/theme'
+export { AnimatedComponentsProvider, useAnimatedComponents } from './contexts/animated-components'
+export { ColorPallet } from './theme'
+export { animatedComponents } from './animated-components'
+export { theme } from './theme'
+export { useAuth } from './contexts/auth'
+export { useNetwork } from './contexts/network'
+export { NavigationTheme } from './theme'
+export { testIdWithKey, testIdForAccessabilityLabel } from './utils/testable'
+export { Screens, Stacks, TabStacks } from './types/navigators'
+export { createStyles } from './screens/OnboardingPages'
+export { statusBarStyleForColor, StatusBarStyles } from './utils/luminance'
+export { BifoldError } from './types/error'
+export { EventTypes } from './constants'
+export { migrateToAskar } from './utils/migration'
+export { createLinkSecretIfRequired, getAgentModules } from './utils/agent'
+export {
+  removeExistingInvitationsById,
+  connectFromScanOrDeepLink,
+  formatTime,
+  useCredentialConnectionLabel,
+  getConnectionName,
+} from './utils/helpers'
+export { isValidAnonCredsCredential, getCredentialIdentifiers } from './utils/credential'
+export { buildFieldsFromAnonCredsCredential } from './utils/oca'
+
+export type { AnimatedComponents } from './animated-components'
+export type {
+  ISVGAssets,
+  ISpacing,
+  IFontAttributes,
+  IInputAttributes,
+  IInlineInputMessage,
+  IInputs,
+  ITextTheme,
+  IBrandColors,
+  ISemanticColors,
+  INotificationColors,
+  IErrorColors,
+  IGrayscaleColors,
+  IColorPallet,
+  IAssets,
+  ITheme,
+} from './theme'
+export type { basicMessageCustomMetadata, credentialCustomMetadata } from './types/metadata'
+export { CredentialMetadata, BasicMessageMetadata } from './types/metadata'
+export type { VersionInfo, PersistentState } from './types/state'
+export type { BifoldAgent } from './utils/agent'
+export type { TourStep, RenderProps } from './contexts/tour/tour-context'
+export type { GenericFn } from './types/fn'
+export type {
+  AuthenticateStackParams,
+  OnboardingStackParams,
+  NotificationStackParams,
+  ContactStackParams,
+} from './types/navigators'
+export type { OnboardingStyleSheet }
+export type { WalletSecret } from './types/security'
+export type { ReducerAction } from './contexts/reducers/store'
+export type {
+  State,
+  Onboarding as OnboardingState,
+  LoginAttempt as LoginAttemptState,
+  Preferences as PreferencesState,
+  Migration as MigrationState,
+  Tours as ToursState,
+} from './types/state'
+
+export type { InlineMessageProps } from './components/inputs/InlineErrorText'
+
+export { InlineErrorPosition } from './types/error'
+
+export type { CredentialListFooterProps }
+export * from './container-api'
+export { MainContainer } from './container-impl'
+
+export type { ScreenLayoutConfig, OnboardingTask } from './types/navigators'
+export type { Config, HistoryEventsLoggerConfig } from './types/config'
+
+export { BaseTourID } from './types/tour'
+
+export {
+  App,
+  Agent,
+  AgentProvider,
+  AuthProvider,
+  NetworkProvider,
+  TourProvider,
+  useTour,
+  AttachTourStep,
+  TourBox,
+  defaultConfig,
+  defaultHistoryEventsLogger,
+  homeTourSteps,
+  credentialsTourSteps,
+  credentialOfferTourSteps,
+  proofRequestTourSteps,
+  ButtonType,
+  ButtonLocation,
+  CheckBoxRow,
+  CredentialCard,
+  ContentGradient,
+  ErrorModal,
+  SafeAreaModal,
+  IconButton,
+  ActivityProvider,
+  useActivity,
+  InfoTextBox,
+  InfoBox,
+  InfoBoxType,
+  Link,
+  AutoLockTime,
+  ToastType,
+  toastConfig,
+  NetInfo,
+  OnboardingPages,
+  OpenIDCredentialRecordProvider,
+  NotificationListItem,
+  useDefaultStackOptions,
+  useInitializeAgent,
+  usePreventScreenCapture,
+  Splash,
+  Developer,
+  Terms,
+  Preface,
+  UpdateAvailable,
+  HomeFooterView as HomeContentView,
+  UseBiometry,
+  AttemptLockout,
+  Record,
+  Scan,
+  Onboarding,
+  types,
+  components,
+  contexts,
+  Text,
+  ThemedText,
+  loadLoginAttempt,
+  Button,
+  BifoldLogger,
+  LimitedTextInput,
+  KeyboardView,
+  BulletPoint,
+  PINRules,
+  walletTimeout,
+  attemptLockoutConfig,
+  tours,
+  DefaultScreenOptionsDictionary,
+  DefaultScreenLayoutOptions,
+}
+export type { IButton }

package/src/layout/ScreenLayout.tsx

@@ -0,0 +1,53 @@
+import React, { PropsWithChildren } from 'react'
+import { StyleSheet, View, ViewStyle } from 'react-native'
+import { Edge, SafeAreaView } from 'react-native-safe-area-context'
+
+import { TOKENS, useServices } from '../container-api'
+import { Screens } from '../types/navigators'
+
+export interface LayoutProps {
+  safeArea?: boolean
+  customEdges?: Edge[]
+  style?: ViewStyle
+  Header?: React.FC | undefined
+}
+
+const defaultStyles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+})
+
+type Props = {
+  screen: Screens
+}
+
+const ScreenLayout: React.FC<PropsWithChildren<Props>> = ({ children, screen }) => {
+  //safeArea, customEdges, style, header
+  const [screenLayoutOptions] = useServices([TOKENS.OBJECT_LAYOUT_CONFIG])
+  const screenProps = screenLayoutOptions[screen]
+  const { safeArea, customEdges, style, Header } = screenProps || {
+    safeArea: false,
+    customEdges: ['top', 'left', 'right', 'bottom'],
+    style: {},
+    Header: undefined,
+  }
+
+  const Container: React.FC<PropsWithChildren> = ({ children }) => {
+    return safeArea ? (
+      <SafeAreaView style={[defaultStyles.container, style]} edges={customEdges || ['top', 'left', 'right', 'bottom']}>
+        {children}
+      </SafeAreaView>
+    ) : (
+      <View style={[defaultStyles.container, style]}>{children}</View>
+    )
+  }
+
+  return (
+    <Container>
+      {Header && <Header />}
+      {children}
+    </Container>
+  )
+}
+export default ScreenLayout