@bifold/core 1.0.0

package/src/container-impl.ts

@@ -0,0 +1,235 @@
+import { Agent } from '@credo-ts/core'
+import { getProofRequestTemplates } from '@bifold/verifier'
+import { DefaultOCABundleResolver } from '@bifold/oca/build/legacy'
+import { createContext, useContext } from 'react'
+import { DependencyContainer } from 'tsyringe'
+
+import * as bundle from './assets/oca-bundles.json'
+import Button from './components/buttons/Button'
+import defaultIndyLedgers from './configs/ledgers/indy'
+import { LocalStorageKeys, PINRules } from './constants'
+import { TOKENS, Container, TokenMapping } from './container-api'
+import { DispatchAction, ReducerAction } from './contexts/reducers/store'
+import { defaultState } from './contexts/store'
+import { useNotifications } from './hooks/notifications'
+import { IHistoryManager } from './modules/history'
+import HistoryManager from './modules/history/context/historyManager'
+import OnboardingStack from './navigators/OnboardingStack'
+import { DefaultScreenOptionsDictionary } from './navigators/defaultStackOptions'
+import Developer from './screens/Developer'
+import Onboarding from './screens/Onboarding'
+import Preface from './screens/Preface'
+import Splash from './screens/Splash'
+import UpdateAvailable from './screens/UpdateAvailable'
+import ScreenTerms, { TermsVersion } from './screens/Terms'
+import { loadLoginAttempt } from './services/keychain'
+import { BifoldLogger } from './services/logger'
+import {
+  Migration as MigrationState,
+  Preferences as PreferencesState,
+  State,
+  Onboarding as StoreOnboardingState,
+  Tours as ToursState,
+  PersistentState,
+} from './types/state'
+import OnboardingPages from './screens/OnboardingPages'
+import UseBiometry from './screens/UseBiometry'
+import Scan from './screens/Scan'
+import PINExplainer from './screens/PINExplainer'
+import HomeHeaderView from './components/views/HomeHeaderView'
+import HomeFooterView from './components/views/HomeFooterView'
+import EmptyList from './components/misc/EmptyList'
+import Record from './components/record/Record'
+import NotificationListItem from './components/listItems/NotificationListItem'
+import NoNewUpdates from './components/misc/NoNewUpdates'
+import PINCreateHeader from './components/misc/PINCreateHeader'
+import { PersistentStorage } from './services/storage'
+import { Config, HistoryEventsLoggerConfig } from './types/config'
+import { Locales } from './localization'
+import ContactListItem from './components/listItems/ContactListItem'
+import ContactCredentialListItem from './components/listItems/ContactCredentialListItem'
+import { InlineErrorPosition } from './types/error'
+import { DefaultScreenLayoutOptions } from './navigators/defaultLayoutOptions'
+import ConnectionAlert from './components/misc/ConnectionAlert'
+import { generateOnboardingWorkflowSteps } from './onboarding'
+
+export const defaultConfig: Config = {
+  PINSecurity: {
+    rules: PINRules,
+    displayHelper: false,
+  },
+  settings: [],
+  enableChat: true,
+  enableTours: 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_CREATE_HEADER, PINCreateHeader)
+    this._container.registerInstance(TOKENS.SCREEN_USE_BIOMETRY, UseBiometry)
+    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.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, new BifoldLogger())
+    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_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

@@ -0,0 +1,170 @@
+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 { useAuth } from './auth'
+import { useStore } from './store'
+import { DispatchAction } from './reducers/store'
+import { TOKENS, useServices } from '../container-api'
+import { defaultAutoLockTime } from '../constants'
+
+// 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, dispatch] = useStore()
+  const { agent } = useAgent()
+  const { removeSavedWalletSecret } = 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)
+
+  const lockOutUser = useCallback(async () => {
+    if (!store.authentication.didAuthenticate) {
+      return
+    }
+
+    try {
+      removeSavedWalletSecret()
+      await agent?.shutdown()
+      logger.info('Agent shutdown successfully')
+    } catch (error) {
+      logger.error(`Error during agent shutdown: ${error}`)
+    }
+
+    dispatch({
+      type: DispatchAction.DID_AUTHENTICATE,
+      payload: [false],
+    })
+
+    dispatch({
+      type: DispatchAction.LOCKOUT_UPDATED,
+      payload: [{ displayNotification: true }],
+    })
+  }, [agent, removeSavedWalletSecret, dispatch, logger, store.authentication.didAuthenticate])
+
+  const clearInactivityTimeoutIfExists = useCallback(() => {
+    if (inactivityTimeoutRef.current) {
+      clearTimeout(inactivityTimeoutRef.current)
+    }
+  }, [])
+
+  const resetInactivityTimeout = useCallback(
+    async (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, 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()
+
+        // if going to background after agent initialization, stop message pickup
+        if (agent?.isInitialized) {
+          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
+        ) {
+          await lockOutUser()
+        } else if (agent?.isInitialized) {
+          // otherwise if agent is initialized, 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
+        await 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

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

@@ -0,0 +1,190 @@
+// 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 { AskarWallet } from '@credo-ts/askar'
+import { ConsoleLogger, LogLevel, SigningProviderRegistry } from '@credo-ts/core'
+import { useAgent } from '@credo-ts/react-hooks'
+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'
+
+export interface AuthContext {
+  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>
+  rekeyWallet: (oldPin: string, newPin: string, useBiometry?: boolean) => Promise<boolean>
+}
+
+export const AuthContext = createContext<AuthContext>(null as unknown as AuthContext)
+
+export const AuthProvider: React.FC<React.PropsWithChildren> = ({ children }) => {
+  const [walletSecret, setWalletSecret] = useState<WalletSecret>()
+  const [store, dispatch] = useStore()
+  const { agent } = useAgent()
+  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()
+
+        const fullSecret = await secretForPIN(PIN, secret.salt)
+        setWalletSecret(fullSecret)
+        return true
+      } catch (e) {
+        return false
+      }
+    },
+    [dispatch, store.migration.didMigrateToAskar]
+  )
+
+  const removeSavedWalletSecret = useCallback(() => {
+    setWalletSecret(undefined)
+  }, [])
+
+  const disableBiometrics = useCallback(async () => {
+    await wipeWalletKey(true)
+  }, [])
+
+  const rekeyWallet = useCallback(
+    async (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
+    },
+    [agent]
+  )
+
+  return (
+    <AuthContext.Provider
+      value={{
+        checkWalletPIN,
+        getWalletSecret,
+        removeSavedWalletSecret,
+        disableBiometrics,
+        commitWalletToKeychain,
+        setPIN,
+        isBiometricsActive,
+        rekeyWallet,
+        walletSecret,
+      }}
+    >
+      {children}
+    </AuthContext.Provider>
+  )
+}
+
+export const useAuth = () => useContext(AuthContext)

package/src/contexts/index.ts

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

package/src/contexts/network.tsx

@@ -0,0 +1,81 @@
+import { NetInfoStateType, useNetInfo } from '@react-native-community/netinfo'
+import { createContext, useContext, useState, useCallback, PropsWithChildren } from 'react'
+
+import NetInfoModal from '../components/modals/NetInfoModal'
+
+export interface NetworkContext {
+  silentAssertConnectedNetwork: () => boolean | null
+  assertNetworkConnected: () => boolean
+  displayNetInfoModal: () => void
+  hideNetInfoModal: () => void
+  assertInternetReachable: () => boolean | null
+}
+
+export const NetworkContext = createContext<NetworkContext>(null as unknown as NetworkContext)
+
+// NOTE: @react-native-community/netinfo can be configured to use whichever reachability check desired
+// eg. isInternetReachable can be set to check a specific URL (like your mediator). See the docs here for more info:
+// https://github.com/react-native-netinfo/react-native-netinfo?tab=readme-ov-file#configure
+export const NetworkProvider = ({ children }: PropsWithChildren) => {
+  const { isConnected, type, isInternetReachable } = useNetInfo()
+  const [isNetInfoModalDisplayed, setIsNetInfoModalDisplayed] = useState<boolean>(false)
+
+  const displayNetInfoModal = useCallback(() => {
+    setIsNetInfoModalDisplayed(true)
+  }, [])
+
+  const hideNetInfoModal = useCallback(() => {
+    setIsNetInfoModalDisplayed(false)
+  }, [])
+
+  /**
+   * Returns null until the network state is known, then returns boolean
+   * Useful for cases where we do not want to take action until the network state is known
+   *
+   * @returns {boolean | null} - `true` if the network is connected, `false` if not connected,
+   *                             and `null` if the network status not yet known
+   */
+  const silentAssertConnectedNetwork = useCallback((): boolean | null => {
+    return type === NetInfoStateType.unknown
+      ? null
+      : isConnected || [NetInfoStateType.wifi, NetInfoStateType.cellular].includes(type)
+  }, [isConnected, type])
+
+  /**
+   * Strictly asserts that the network is connected. Will return false even if
+   * the network state is not yet known - in this case it will also display the
+   * NetInfoModal
+   * Useful for cases where we must be sure of connectivity before proceeding
+   *
+   * @returns {boolean} - `true` if the network is checked and connected, otherwise `false`
+   */
+  const assertNetworkConnected = useCallback(() => {
+    const connectionConfirmed = silentAssertConnectedNetwork() === true
+    if (!connectionConfirmed) {
+      displayNetInfoModal()
+    }
+
+    return connectionConfirmed
+  }, [silentAssertConnectedNetwork, displayNetInfoModal])
+
+  const assertInternetReachable = useCallback((): boolean | null => {
+    return isInternetReachable
+  }, [isInternetReachable])
+
+  return (
+    <NetworkContext.Provider
+      value={{
+        silentAssertConnectedNetwork,
+        assertNetworkConnected,
+        displayNetInfoModal,
+        hideNetInfoModal,
+        assertInternetReachable,
+      }}
+    >
+      {children}
+      <NetInfoModal visible={isNetInfoModalDisplayed} onSubmit={() => hideNetInfoModal()} />
+    </NetworkContext.Provider>
+  )
+}
+
+export const useNetwork = () => useContext(NetworkContext)