@bifold/core 2.4.5 → 2.5.0

package/src/container-impl.ts

@@ -1,243 +0,0 @@
-import { DefaultOCABundleResolver } from '@bifold/oca/build/legacy'
-import { getProofRequestTemplates } from '@bifold/verifier'
-import { Agent } from '@credo-ts/core'
-import { createContext, useContext } from 'react'
-import { DependencyContainer } from 'tsyringe'
-
-import * as bundle from './assets/oca-bundles.json'
-import Button from './components/buttons/Button'
-import ContactCredentialListItem from './components/listItems/ContactCredentialListItem'
-import ContactListItem from './components/listItems/ContactListItem'
-import NotificationListItem from './components/listItems/NotificationListItem'
-import ConnectionAlert from './components/misc/ConnectionAlert'
-import EmptyList from './components/misc/EmptyList'
-import NoNewUpdates from './components/misc/NoNewUpdates'
-import PINHeader from './components/misc/PINHeader'
-import Record from './components/record/Record'
-import HomeFooterView from './components/views/HomeFooterView'
-import { Banner } from './components/views/Banner'
-import HomeHeaderView from './components/views/HomeHeaderView'
-import defaultIndyLedgers from './configs/ledgers/indy'
-import { LocalStorageKeys, PINRules } from './constants'
-import { Container, TokenMapping, TOKENS } from './container-api'
-import { DispatchAction, ReducerAction } from './contexts/reducers/store'
-import { defaultState } from './contexts/store'
-import { useNotifications } from './hooks/notifications'
-import useBifoldAgentSetup from './hooks/useBifoldAgentSetup'
-import { Locales } from './localization'
-import { IHistoryManager } from './modules/history'
-import HistoryManager from './modules/history/context/historyManager'
-import OnboardingStack from './navigators/OnboardingStack'
-import { DefaultScreenLayoutOptions } from './navigators/defaultLayoutOptions'
-import { DefaultScreenOptionsDictionary } from './navigators/defaultStackOptions'
-import { generateOnboardingWorkflowSteps } from './onboarding'
-import Biometry from './screens/Biometry'
-import Developer from './screens/Developer'
-import Onboarding from './screens/Onboarding'
-import OnboardingPages from './screens/OnboardingPages'
-import PINExplainer from './screens/PINExplainer'
-import Preface from './screens/Preface'
-import Scan from './screens/Scan'
-import Splash from './screens/Splash'
-import ScreenTerms, { TermsVersion } from './screens/Terms'
-import ToggleBiometry from './screens/ToggleBiometry'
-import UpdateAvailable from './screens/UpdateAvailable'
-import { loadLoginAttempt } from './services/keychain'
-import { BifoldLogger } from './services/logger'
-import { bifoldLoggerInstance } from './services/bifoldLogger'
-import { PersistentStorage } from './services/storage'
-import { Config, HistoryEventsLoggerConfig } from './types/config'
-import { InlineErrorPosition } from './types/error'
-import {
-  Migration as MigrationState,
-  PersistentState,
-  Preferences as PreferencesState,
-  State,
-  Onboarding as StoreOnboardingState,
-  Tours as ToursState,
-} from './types/state'
-
-export const defaultConfig: Config = {
-  PINSecurity: {
-    rules: PINRules,
-    displayHelper: false,
-  },
-  settings: [],
-  enableChat: true,
-  enableTours: false,
-  preventScreenCapture: false,
-  supportedLanguages: [Locales.en, Locales.fr, Locales.ptBr],
-  showPreface: false,
-  disableOnboardingSkip: false,
-  disableContactsInSettings: false,
-  internetReachabilityUrls: ['https://clients3.google.com/generate_204'],
-  whereToUseWalletUrl: 'https://example.com',
-  showScanHelp: true,
-  showScanButton: true,
-  showDetailsInfo: true,
-  contactDetailsOptions: {
-    showConnectedTime: true,
-    enableEditContactName: true,
-    enableCredentialList: false,
-  },
-  appUpdateConfig: {
-    appleAppStoreUrl: 'https://example.com',
-    googlePlayStoreUrl: 'https://example.com',
-  },
-}
-
-export const defaultHistoryEventsLogger: HistoryEventsLoggerConfig = {
-  logAttestationAccepted: true,
-  logAttestationRefused: true,
-  logAttestationRemoved: true,
-  logInformationSent: true,
-  logInformationNotSent: true,
-  logConnection: true,
-  logConnectionRemoved: true,
-  logAttestationRevoked: true,
-  logPinChanged: true,
-  logToggleBiometry: true,
-}
-
-export class MainContainer implements Container {
-  public static readonly TOKENS = TOKENS
-  private _container: DependencyContainer
-  private log?: BifoldLogger
-  private storage: PersistentStorage<PersistentState>
-
-  public constructor(container: DependencyContainer, log?: BifoldLogger) {
-    this._container = container
-    this.log = log
-    this.storage = new PersistentStorage(log)
-  }
-
-  public get container(): DependencyContainer {
-    return this._container
-  }
-
-  public init(): Container {
-    this.log?.info(`Initializing Bifold container`)
-
-    this._container.registerInstance(TOKENS.SCREEN_PREFACE, Preface)
-    this._container.registerInstance(TOKENS.SCREEN_DEVELOPER, Developer)
-    this._container.registerInstance(TOKENS.SCREEN_TERMS, { screen: ScreenTerms, version: TermsVersion })
-    this._container.registerInstance(TOKENS.SCREEN_SPLASH, Splash)
-    this._container.registerInstance(TOKENS.SCREEN_UPDATE_AVAILABLE, UpdateAvailable)
-    this._container.registerInstance(TOKENS.SCREEN_ONBOARDING_PAGES, OnboardingPages)
-    this._container.registerInstance(TOKENS.COMPONENT_PIN_HEADER, PINHeader)
-    this._container.registerInstance(TOKENS.SCREEN_BIOMETRY, Biometry)
-    this._container.registerInstance(TOKENS.SCREEN_TOGGLE_BIOMETRY, ToggleBiometry)
-    this._container.registerInstance(TOKENS.SCREEN_SCAN, Scan)
-    this._container.registerInstance(TOKENS.SCREEN_ONBOARDING_ITEM, Onboarding)
-    this._container.registerInstance(TOKENS.SCREEN_ONBOARDING, Onboarding)
-    this._container.registerInstance(TOKENS.SCREEN_PIN_EXPLAINER, PINExplainer)
-    this._container.registerInstance(TOKENS.HOOK_USE_AGENT_SETUP, useBifoldAgentSetup)
-    this._container.registerInstance(TOKENS.STACK_ONBOARDING, OnboardingStack)
-    this._container.registerInstance(TOKENS.COMP_BUTTON, Button)
-    this._container.registerInstance(TOKENS.GROUP_BY_REFERENT, false)
-    this._container.registerInstance(TOKENS.HISTORY_ENABLED, false)
-    this._container.registerInstance(TOKENS.HISTORY_EVENTS_LOGGER, defaultHistoryEventsLogger)
-    this._container.registerInstance(TOKENS.CRED_HELP_ACTION_OVERRIDES, [])
-    this._container.registerInstance(TOKENS.OBJECT_SCREEN_CONFIG, DefaultScreenOptionsDictionary)
-    this._container.registerInstance(TOKENS.OBJECT_LAYOUT_CONFIG, DefaultScreenLayoutOptions)
-    this._container.registerInstance(TOKENS.UTIL_LOGGER, bifoldLoggerInstance)
-    this._container.registerInstance(TOKENS.UTIL_OCA_RESOLVER, new DefaultOCABundleResolver(bundle))
-    this._container.registerInstance(TOKENS.UTIL_LEDGERS, defaultIndyLedgers)
-    this._container.registerInstance(TOKENS.UTIL_PROOF_TEMPLATE, getProofRequestTemplates)
-    this._container.registerInstance(TOKENS.UTIL_ATTESTATION_MONITOR, { useValue: undefined })
-    this._container.registerInstance(TOKENS.UTIL_APP_VERSION_MONITOR, { useValue: undefined })
-    this._container.registerInstance(TOKENS.NOTIFICATIONS, {
-      useNotifications,
-    })
-    this._container.registerInstance(TOKENS.NOTIFICATIONS_LIST_ITEM, NotificationListItem)
-    this._container.registerInstance(TOKENS.CONFIG, defaultConfig)
-    this._container.registerInstance(TOKENS.COMPONENT_CRED_LIST_HEADER_RIGHT, () => null)
-    this._container.registerInstance(TOKENS.COMPONENT_CRED_LIST_OPTIONS, () => null)
-    this._container.registerInstance(TOKENS.COMPONENT_CRED_LIST_FOOTER, () => null)
-    this._container.registerInstance(TOKENS.COMPONENT_HOME_HEADER, HomeHeaderView)
-    this._container.registerInstance(TOKENS.COMPONENT_NOTIFICATION_BANNER, Banner)
-    this._container.registerInstance(TOKENS.COMPONENT_HOME_NOTIFICATIONS_EMPTY_LIST, NoNewUpdates)
-    this._container.registerInstance(TOKENS.COMPONENT_HOME_FOOTER, HomeFooterView)
-    this._container.registerInstance(TOKENS.COMPONENT_CRED_EMPTY_LIST, EmptyList)
-    this._container.registerInstance(TOKENS.COMPONENT_RECORD, Record)
-    this._container.registerInstance(TOKENS.COMPONENT_CONTACT_LIST_ITEM, ContactListItem)
-    this._container.registerInstance(TOKENS.COMPONENT_CONTACT_DETAILS_CRED_LIST_ITEM, ContactCredentialListItem)
-    this._container.registerInstance(TOKENS.COMPONENT_CONNECTION_ALERT, ConnectionAlert)
-    this._container.registerInstance(TOKENS.CACHE_CRED_DEFS, [])
-    this._container.registerInstance(TOKENS.CACHE_SCHEMAS, [])
-    this._container.registerInstance(TOKENS.INLINE_ERRORS, {
-      enabled: true,
-      hasErrorIcon: true,
-      position: InlineErrorPosition.Above,
-    })
-    this._container.registerInstance(TOKENS.FN_ONBOARDING_DONE, (dispatch: React.Dispatch<ReducerAction<unknown>>) => {
-      return () => {
-        dispatch({
-          type: DispatchAction.DID_COMPLETE_TUTORIAL,
-        })
-      }
-    })
-    this._container.registerInstance(TOKENS.FN_LOAD_HISTORY, (agent: Agent<any>): IHistoryManager => {
-      return new HistoryManager(agent)
-    })
-    this._container.registerInstance(TOKENS.CUSTOM_NAV_STACK_1, false)
-    this._container.registerInstance(TOKENS.LOAD_STATE, async (dispatch: React.Dispatch<ReducerAction<unknown>>) => {
-      const loadState = async <Type>(key: LocalStorageKeys, updateVal: (newVal: Type) => void) => {
-        const data = await this.storage.getValueForKey(key)
-        if (data) {
-          // @ts-expect-error Fix complicated type error
-          updateVal(data)
-        }
-      }
-
-      let loginAttempt = defaultState.loginAttempt
-      let preferences = defaultState.preferences
-      let migration = defaultState.migration
-      let tours = defaultState.tours
-      let onboarding = defaultState.onboarding
-
-      await Promise.all([
-        loadLoginAttempt().then((data) => {
-          if (data) {
-            loginAttempt = data
-          }
-        }),
-        loadState<PreferencesState>(LocalStorageKeys.Preferences, (val) => (preferences = val)),
-        loadState<MigrationState>(LocalStorageKeys.Migration, (val) => (migration = val)),
-        loadState<ToursState>(LocalStorageKeys.Tours, (val) => (tours = val)),
-        loadState<StoreOnboardingState>(LocalStorageKeys.Onboarding, (val) => (onboarding = val)),
-      ])
-
-      const state = {
-        loginAttempt: { ...defaultState.loginAttempt, ...loginAttempt },
-        preferences: { ...defaultState.preferences, ...preferences },
-        migration: { ...defaultState.migration, ...migration },
-        tours: { ...defaultState.tours, ...tours },
-        onboarding: { ...defaultState.onboarding, ...onboarding },
-      } as State
-
-      dispatch({ type: DispatchAction.STATE_DISPATCH, payload: [state] })
-    })
-
-    this._container.registerInstance(TOKENS.ONBOARDING, generateOnboardingWorkflowSteps)
-
-    return this
-  }
-
-  public resolve<K extends keyof TokenMapping>(token: K): TokenMapping[K] {
-    return this._container.resolve(token)
-  }
-
-  public resolveAll<K extends keyof TokenMapping, T extends K[]>(
-    tokens: [...T]
-  ): { [I in keyof T]: TokenMapping[T[I]] } {
-    return tokens.map((key) => this.resolve(key)!) as { [I in keyof T]: TokenMapping[T[I]] }
-  }
-}
-
-export const SystemContext = createContext<Container | undefined>(undefined)
-
-export const SystemProvider = SystemContext.Provider
-
-// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-export const useSystem = () => useContext(SystemContext)!

package/src/contexts/activity.tsx

@@ -1,145 +0,0 @@
-import { useAgent } from '@credo-ts/react-hooks'
-import React, {
-  createContext,
-  PropsWithChildren,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from 'react'
-import { AppState, AppStateStatus, PanResponder, View } from 'react-native'
-import { defaultAutoLockTime } from '../constants'
-import { TOKENS, useServices } from '../container-api'
-import { LockoutReason, useAuth } from './auth'
-import { useStore } from './store'
-
-// number of minutes before the timeout action is triggered
-// a value of 0 will never trigger the lock out action and
-// an undefined value will default to 5 minutes
-export const AutoLockTime = {
-  OneMinute: 1,
-  ThreeMinutes: 3,
-  FiveMinutes: 5,
-  Never: 0,
-} as const
-
-export interface ActivityContext {
-  appStateStatus: AppStateStatus
-}
-
-export const ActivityContext = createContext<ActivityContext>(null as unknown as ActivityContext)
-
-export const ActivityProvider: React.FC<PropsWithChildren> = ({ children }) => {
-  const [logger] = useServices([TOKENS.UTIL_LOGGER])
-  const [store] = useStore()
-  const { agent } = useAgent()
-  const { lockOutUser } = useAuth()
-  const lastActiveTimeRef = useRef<number | undefined>(undefined)
-  const timeoutInMilliseconds = useRef<number>((store.preferences.autoLockTime ?? defaultAutoLockTime) * 60000)
-  const inactivityTimeoutRef = useRef<NodeJS.Timeout | null>(null)
-  const prevAppStateStatusRef = useRef(AppState.currentState)
-  const [appStateStatus, setAppStateStatus] = useState<AppStateStatus>(AppState.currentState)
-
-  if (!agent) {
-    throw new Error('ActivityProvider must be used within agent context provider')
-  }
-
-  const clearInactivityTimeoutIfExists = useCallback(() => {
-    if (inactivityTimeoutRef.current) {
-      clearTimeout(inactivityTimeoutRef.current)
-    }
-  }, [])
-
-  const resetInactivityTimeout = useCallback(
-    (milliseconds: number) => {
-      clearInactivityTimeoutIfExists()
-      lastActiveTimeRef.current = Date.now()
-
-      // do not set timeout if timeout duration is set to 0
-      if (milliseconds > 0) {
-        // create new timeout
-        inactivityTimeoutRef.current = setTimeout(() => lockOutUser(LockoutReason.Timeout), milliseconds)
-      }
-    },
-    [clearInactivityTimeoutIfExists, lockOutUser]
-  )
-
-  useEffect(() => {
-    // listener for backgrounding / foregrounding
-    const eventSubscription = AppState.addEventListener('change', async (nextAppState) => {
-      // if going into the background
-      if (['active', 'inactive'].includes(prevAppStateStatusRef.current) && nextAppState === 'background') {
-        // remove timeout when backgrounded as timeout refs can be lost when app is backgrounded
-        clearInactivityTimeoutIfExists()
-        try {
-          await agent.mediationRecipient.stopMessagePickup()
-          logger.info('Stopped agent message pickup')
-        } catch (err) {
-          logger.error(`Error stopping agent message pickup, ${err}`)
-        }
-      }
-
-      // if coming to the foreground
-      if (prevAppStateStatusRef.current === 'background' && ['active', 'inactive'].includes(nextAppState)) {
-        // if app was in background for longer than allowed time, lock out user
-        if (
-          lastActiveTimeRef.current &&
-          Date.now() - lastActiveTimeRef.current >= timeoutInMilliseconds.current &&
-          timeoutInMilliseconds.current > 0
-        ) {
-          lockOutUser(LockoutReason.Timeout)
-        } else {
-          // otherwise restart message pickup
-          try {
-            await agent.mediationRecipient.initiateMessagePickup()
-            logger.info('Restarted agent message pickup')
-          } catch (err) {
-            logger.error(`Error restarting agent message pickup, ${err}`)
-          }
-        }
-
-        // app coming into the foreground is 'user activity', reset timeout
-        resetInactivityTimeout(timeoutInMilliseconds.current)
-      }
-
-      prevAppStateStatusRef.current = nextAppState
-      setAppStateStatus(nextAppState)
-    })
-
-    // initial timeout setup
-    resetInactivityTimeout(timeoutInMilliseconds.current)
-
-    return () => {
-      clearInactivityTimeoutIfExists()
-      eventSubscription.remove()
-    }
-  }, [clearInactivityTimeoutIfExists, lockOutUser, resetInactivityTimeout, agent, logger])
-
-  useEffect(() => {
-    // user has updated settings for auto lock time
-    timeoutInMilliseconds.current = store.preferences.autoLockTime * 60000
-  }, [store.preferences.autoLockTime])
-
-  const panResponder = useMemo(() => {
-    return PanResponder.create({
-      onStartShouldSetPanResponderCapture: () => {
-        // some user interaction detected, reset timeout
-        resetInactivityTimeout(timeoutInMilliseconds.current)
-
-        // returns false so the PanResponder doesn't consume the touch event
-        return false
-      },
-    })
-  }, [resetInactivityTimeout])
-
-  return (
-    <ActivityContext.Provider value={{ appStateStatus }}>
-      <View style={{ flex: 1 }} {...panResponder.panHandlers}>
-        {children}
-      </View>
-    </ActivityContext.Provider>
-  )
-}
-export const useActivity = () => useContext(ActivityContext)

package/src/contexts/animated-components.ts

@@ -1,9 +0,0 @@
-import { createContext, useContext } from 'react'
-
-import { AnimatedComponents, animatedComponents } from '../animated-components'
-
-export const AnimatedComponentsContext = createContext<AnimatedComponents>(animatedComponents)
-
-export const AnimatedComponentsProvider = AnimatedComponentsContext.Provider
-
-export const useAnimatedComponents = () => useContext(AnimatedComponentsContext)

package/src/contexts/auth.tsx

@@ -1,240 +0,0 @@
-// Dont remove the following import line or the pin check will fail when opening askar waller
-import '@hyperledger/aries-askar-react-native'
-
-import 'reflect-metadata'
-import { DeviceEventEmitter } from 'react-native'
-import { AskarWallet } from '@credo-ts/askar'
-import { Agent, ConsoleLogger, LogLevel, SigningProviderRegistry } from '@credo-ts/core'
-import { agentDependencies } from '@credo-ts/react-native'
-import React, { createContext, useCallback, useContext, useState } from 'react'
-import { useTranslation } from 'react-i18next'
-
-import { DispatchAction } from './reducers/store'
-import { useStore } from './store'
-import {
-  isBiometricsActive,
-  loadWalletSalt,
-  loadWalletSecret,
-  secretForPIN,
-  storeWalletSecret,
-  wipeWalletKey,
-} from '../services/keychain'
-import { WalletSecret } from '../types/security'
-import { hashPIN } from '../utils/crypto'
-import { migrateToAskar } from '../utils/migration'
-import { BifoldError } from '../types/error'
-import { EventTypes } from '../constants'
-
-export interface AuthContext {
-  lockOutUser: (reason: LockoutReason) => void
-  checkWalletPIN: (PIN: string) => Promise<boolean>
-  getWalletSecret: () => Promise<WalletSecret | undefined>
-  walletSecret?: WalletSecret
-  removeSavedWalletSecret: () => void
-  disableBiometrics: () => Promise<void>
-  setPIN: (PIN: string) => Promise<void>
-  commitWalletToKeychain: (useBiometry: boolean) => Promise<boolean>
-  isBiometricsActive: () => Promise<boolean>
-  verifyPIN: (PIN: string) => Promise<boolean>
-  rekeyWallet: (agent: Agent, oldPin: string, newPin: string, useBiometry?: boolean) => Promise<boolean>
-}
-
-export const AuthContext = createContext<AuthContext>(null as unknown as AuthContext)
-export enum LockoutReason {
-  Timeout = 'Timeout',
-  Logout = 'Logout',
-}
-
-export const AuthProvider: React.FC<React.PropsWithChildren> = ({ children }) => {
-  const [walletSecret, setWalletSecret] = useState<WalletSecret>()
-  const [store, dispatch] = useStore()
-  const { t } = useTranslation()
-
-  const setPIN = useCallback(async (PIN: string): Promise<void> => {
-    const secret = await secretForPIN(PIN)
-    await storeWalletSecret(secret)
-  }, [])
-
-  const getWalletSecret = useCallback(async (): Promise<WalletSecret | undefined> => {
-    if (walletSecret) {
-      return walletSecret
-    }
-
-    const secret = await loadWalletSecret(t('Biometry.UnlockPromptTitle'), t('Biometry.UnlockPromptDescription'))
-
-    setWalletSecret(secret)
-
-    return secret
-  }, [t, walletSecret])
-
-  const commitWalletToKeychain = useCallback(
-    async (useBiometry: boolean): Promise<boolean> => {
-      const secret = await getWalletSecret()
-      if (!secret) {
-        return false
-      }
-
-      // set did authenticate to true if we can get wallet credentials
-      dispatch({
-        type: DispatchAction.DID_AUTHENTICATE,
-      })
-      if (useBiometry) {
-        await storeWalletSecret(secret, useBiometry)
-      } else {
-        // erase wallet key if biometrics is disabled
-        await wipeWalletKey(useBiometry)
-      }
-
-      return true
-    },
-    [dispatch, getWalletSecret]
-  )
-
-  const checkWalletPIN = useCallback(
-    async (PIN: string): Promise<boolean> => {
-      try {
-        const secret = await loadWalletSalt()
-
-        if (!secret?.salt) {
-          return false
-        }
-
-        const hash = await hashPIN(PIN, secret.salt)
-
-        if (!store.migration.didMigrateToAskar) {
-          await migrateToAskar(secret.id, hash)
-          dispatch({
-            type: DispatchAction.DID_MIGRATE_TO_ASKAR,
-          })
-        }
-
-        // NOTE: We create an instance of AskarWallet, which is the underlying wallet that powers the app
-        // we then open that instance with the provided id and key to verify their integrity
-        const askarWallet = new AskarWallet(
-          new ConsoleLogger(LogLevel.off),
-          new agentDependencies.FileSystem(),
-          new SigningProviderRegistry([])
-        )
-        await askarWallet.open({
-          id: secret.id,
-          key: hash,
-        })
-
-        await askarWallet.close()
-
-        setWalletSecret({ id: secret.id, key: hash, salt: secret.salt })
-        return true
-      } catch (e) {
-        return false
-      }
-    },
-    [dispatch, store.migration.didMigrateToAskar]
-  )
-
-  const removeSavedWalletSecret = useCallback(() => {
-    setWalletSecret(undefined)
-  }, [])
-
-  const lockOutUser = useCallback(
-    (reason: LockoutReason) => {
-      removeSavedWalletSecret()
-      dispatch({
-        type: DispatchAction.DID_AUTHENTICATE,
-        payload: [false],
-      })
-      dispatch({
-        type: DispatchAction.LOCKOUT_UPDATED,
-        payload: [{ displayNotification: reason === LockoutReason.Timeout }],
-      })
-    },
-    [removeSavedWalletSecret, dispatch]
-  )
-
-  const disableBiometrics = useCallback(async () => {
-    await wipeWalletKey(true)
-  }, [])
-
-  const rekeyWallet = useCallback(
-    async (agent: Agent, oldPin: string, newPin: string, useBiometry?: boolean): Promise<boolean> => {
-      try {
-        if (!agent) {
-          // no agent set, cannot rekey the wallet
-          return false
-        }
-        // argon2.hash can sometimes generate an error
-        const secret = await loadWalletSalt()
-        if (!secret) {
-          return false
-        }
-
-        const oldHash = await hashPIN(oldPin, secret.salt)
-        const newSecret = await secretForPIN(newPin)
-        const newHash = await hashPIN(newPin, newSecret.salt)
-        if (!newSecret.key) {
-          return false
-        }
-
-        await agent.wallet.close()
-        // wallet.rotateKey calls open under the hood
-        await agent.wallet.rotateKey({ id: secret.id, key: oldHash, rekey: newHash })
-
-        await storeWalletSecret(newSecret, useBiometry)
-        setWalletSecret(newSecret)
-      } catch {
-        return false
-      }
-      return true
-    },
-    []
-  )
-
-  const verifyPIN = useCallback(
-    async (PIN: string) => {
-      try {
-        const credentials = await getWalletSecret()
-        if (!credentials) {
-          throw new Error('Get wallet credentials error')
-        }
-
-        const key = await hashPIN(PIN, credentials.salt)
-        if (credentials.key !== key) {
-          return false
-        }
-
-        return true
-      } catch (err: unknown) {
-        const error = new BifoldError(
-          t('Error.Title1042'),
-          t('Error.Message1042'),
-          (err as Error)?.message ?? err,
-          1042
-        )
-        DeviceEventEmitter.emit(EventTypes.ERROR_ADDED, error)
-        return false
-      }
-    },
-    [getWalletSecret, t]
-  )
-
-  return (
-    <AuthContext.Provider
-      value={{
-        lockOutUser,
-        checkWalletPIN,
-        getWalletSecret,
-        removeSavedWalletSecret,
-        disableBiometrics,
-        commitWalletToKeychain,
-        setPIN,
-        isBiometricsActive,
-        rekeyWallet,
-        walletSecret,
-        verifyPIN,
-      }}
-    >
-      {children}
-    </AuthContext.Provider>
-  )
-}
-
-export const useAuth = () => useContext(AuthContext)

package/src/contexts/index.ts

@@ -1,3 +0,0 @@
-import * as reducers from './reducers'
-import * as store from './store'
-export { reducers, store }

package/src/contexts/navigation.tsx

@@ -1,19 +0,0 @@
-import { NavigationContainer, NavigationContainerRef } from '@react-navigation/native'
-import React from 'react'
-import { useTheme } from './theme'
-
-export interface NavContainerProps extends React.PropsWithChildren {
-  navigationRef: React.RefObject<NavigationContainerRef<any>> | null
-}
-
-const NavContainer = ({ navigationRef, children }: NavContainerProps) => {
-  const { NavigationTheme } = useTheme()
-
-  return (
-    <NavigationContainer ref={navigationRef} theme={NavigationTheme}>
-      {children}
-    </NavigationContainer>
-  )
-}
-
-export default NavContainer