@bifold/core 2.4.5 → 2.5.0

package/src/utils/helpers.ts

@@ -1,1292 +0,0 @@
-import {
-  AnonCredsCredentialInfo,
-  AnonCredsCredentialsForProofRequest,
-  AnonCredsPredicateType,
-  AnonCredsProofRequest,
-  AnonCredsProofRequestRestriction,
-  AnonCredsRequestedAttribute,
-  AnonCredsRequestedAttributeMatch,
-  AnonCredsRequestedPredicate,
-  AnonCredsRequestedPredicateMatch,
-  getCredentialsForAnonCredsProofRequest,
-} from '@credo-ts/anoncreds'
-import {
-  Agent,
-  BasicMessageRecord,
-  ConnectionRecord,
-  CredentialExchangeRecord,
-  CredentialState,
-  HandshakeProtocol,
-  ProofExchangeRecord,
-  ProofState,
-  parseDid,
-  OutOfBandRecord,
-  CredentialPreviewAttribute,
-  OutOfBandRole,
-} from '@credo-ts/core'
-import { BasicMessageRole } from '@credo-ts/core/build/modules/basic-messages/BasicMessageRole'
-import { useConnectionById } from '@credo-ts/react-hooks'
-import { BrandingOverlay, CaptureBaseAttributeType } from '@bifold/oca'
-import { Attribute, CredentialOverlay, Predicate } from '@bifold/oca/build/legacy'
-import { Buffer } from 'buffer'
-import moment from 'moment'
-import { parseUrl } from 'query-string'
-import { ReactNode } from 'react'
-import { TFunction } from 'react-i18next'
-import { DeviceEventEmitter } from 'react-native'
-
-import { EventTypes, domain } from '../constants'
-import { i18n } from '../localization/index'
-import { BifoldLogger } from '../services/logger'
-import { Role } from '../types/chat'
-import { BifoldError } from '../types/error'
-import { Screens, Stacks } from '../types/navigators'
-import {
-  CredentialDataForProof,
-  ProofCredentialAttributes,
-  ProofCredentialItems,
-  ProofCredentialPredicates,
-} from '../types/proof-items'
-import { ChildFn } from '../types/tour'
-
-import { BifoldAgent } from './agent'
-import {
-  createAnonCredsProofRequest,
-  filterInvalidProofRequestMatches,
-  getDescriptorMetadata,
-} from './anonCredsProofRequestMapper'
-import { parseCredDefFromId } from './cred-def'
-import { isOpenIdCredentialOffer, isOpenIdPresentationRequest } from './parsers'
-import { isMediatorInvitation } from './mediatorhelpers'
-
-export { parsedCredDefNameFromCredential } from './cred-def'
-
-export { parsedCredDefName } from './cred-def'
-export { parsedSchema } from './schema'
-
-/**
- * Generates a numerical hash based on a given string
- * @see https://stackoverflow.com/questions/3426404/create-a-hexadecimal-colour-based-on-a-string-with-javascript
- * @param { string } s given string
- * @returns { number } numerical hash value
- */
-export const hashCode = (s: string): number => {
-  return s.split('').reduce((hash, char) => char.charCodeAt(0) + ((hash << 5) - hash), 0)
-}
-
-/**
- * Generates a pseudorandom number between 0 and 1 based on a seed
- * @see https://gist.github.com/tommyettinger/46a874533244883189143505d203312c
- * @see https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript
- * @param { number } seed any number
- * @returns { number } pseudorandom number between 0 and 1
- */
-const mulberry32 = (seed: number) => {
-  let t = (seed += 0x6d2b79f5)
-  t = Math.imul(t ^ (t >>> 15), t | 1)
-  t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
-  return ((t ^ (t >>> 14)) >>> 0) / 4294967296
-}
-
-/**
- * Converts a numerical hash into a hexidecimal color string
- * @see https://helderesteves.com/generating-random-colors-js/#Generating_random_dark_colors
- * @param { number } hash numerical hash value (generated by hashCode function above)
- * @returns { string } hexidecimal string eg. #32d3cc
- */
-export const hashToRGBA = (hash: number) => {
-  let color = '#'
-  const colorRangeUpperBound = 256
-
-  // once for r, g, b
-  for (let i = 0; i < 3; i++) {
-    // append a pseudorandom two-char hexidecimal value from the lower half of the color spectrum (to limit to darker colors)
-    color += ('0' + Math.floor((mulberry32(hash + i) * colorRangeUpperBound) / 2).toString(16)).slice(-2)
-  }
-
-  return color
-}
-/**
- *
- * @param time
- * @param params see below
- * shortMonth: whether to use Jun in place of June, Mar in place of March for example (overridden by `format`)
- * format: an optional custom moment format string to create the formatted date from
- * includeHour: whether to add the hour and minute and am/pm. eg 9:32 pm (overridden by `chatFormat` and `trim`)
- * chatFormat: whether to style the date to appear like a chat message timestamp eg. '7 minutes ago' or 'Just now'
- * trim: if true, if it's the same day the date will be trimmed to just the hour, if it's the same year then the year will be trimmed from the date
- * eg. if the current year is 2023, February 12, 2023 will be trimmed to February 12
- * @returns formatted time string
- */
-export function formatTime(
-  time: Date,
-  params?: { shortMonth?: boolean; format?: string; includeHour?: boolean; chatFormat?: boolean; trim?: boolean }
-): string {
-  const getMonthKey = 'MMMM'
-  const momentTime = moment(time)
-  const monthKey = momentTime.format(getMonthKey)
-  const customMonthFormatRe = /M+/
-  const shortMonth = params?.shortMonth
-  const format = params?.format
-  const includeHour = params?.includeHour
-  const chatFormat = params?.chatFormat
-  const trim = params?.trim
-  const shortDateFormatMaskLength = 3
-  const millisecondsAgo = moment().diff(momentTime)
-  const lessThanAMinuteAgo = millisecondsAgo / 1000 / 60 < 1
-  const lessThanAnHourAgo = millisecondsAgo / 1000 / 60 / 60 < 1
-  const now = new Date()
-  const sameYear = time.getFullYear() === now.getFullYear()
-  const sameDay = time.getDate() === now.getDate() && time.getMonth() === now.getMonth() && sameYear
-  const isPortuguese = i18n.resolvedLanguage === 'pt-BR'
-  const isNonEnglish = i18n.resolvedLanguage === 'fr' || isPortuguese
-  const hoursFormat = isNonEnglish ? 'HH:mm' : 'h:mm a'
-  // for the shortened approach eg. in chat bubbles
-  if (chatFormat) {
-    if (lessThanAMinuteAgo) {
-      return i18n.t('Date.JustNow')
-    }
-    if (lessThanAnHourAgo) {
-      const minutesAgo = Math.floor(millisecondsAgo / 1000 / 60)
-      return minutesAgo === 1 ? `${i18n.t('Date.MinuteAgo')}` : `${i18n.t('Date.MinutesAgo', { count: minutesAgo })}`
-    }
-    if (sameDay) {
-      return momentTime.format(hoursFormat)
-    }
-  }
-
-  let formatString = i18n.t('Date.ShortFormat')
-  let formattedTime = ''
-  // if sameDay and abbreviated
-  if (sameDay && trim) {
-    return momentTime.format(hoursFormat)
-  }
-
-  if (format) {
-    formatString = format
-    formattedTime = momentTime.format(format)
-  } else {
-    if (!shortMonth) {
-      formatString = i18n.t('Date.LongFormat')
-    }
-
-    // if translation fails
-    if (formatString === 'Date.ShortFormat' || formatString === 'Date.LongFormat' || formatString === undefined) {
-      formatString = 'MMM D'
-    }
-
-    // if trim is true, don't include the year for same year times
-    formattedTime =
-      trim && sameYear
-        ? momentTime.format(formatString)
-        : // if non-english, don't include comma between year and month
-        isNonEnglish
-        ? `${momentTime.format(formatString)} ${momentTime.format('YYYY')}`
-        : `${momentTime.format(formatString)}, ${momentTime.format('YYYY')}`
-    if (includeHour) {
-      formattedTime = `${formattedTime}, ${momentTime.format(hoursFormat)}`
-    }
-  }
-
-  const customMonthFormat = formatString?.match(customMonthFormatRe)?.[0]
-
-  if (customMonthFormat) {
-    let monthReplacement = ''
-    const monthReplacementKey = momentTime.format(customMonthFormat)
-    if (customMonthFormat.length === shortDateFormatMaskLength) {
-      // then we know we're dealing with a short date format: 'MMM'
-      monthReplacement = i18n.t(`Date.MonthShort.${monthKey}`)
-    } else if (customMonthFormat.length > shortDateFormatMaskLength) {
-      // then we know we're working with a long date format: 'MMMM'
-      monthReplacement = i18n.t(`Date.MonthLong.${monthKey}`)
-    }
-    // if translation doesn't work
-    if (monthReplacement === `Date.MonthLong.${monthKey}` || monthReplacement === `Date.MonthShort.${monthKey}`) {
-      monthReplacement = monthReplacementKey
-    }
-
-    if (monthReplacement) {
-      formattedTime = formattedTime.replace(monthReplacementKey, monthReplacement)
-    }
-  }
-  return formattedTime
-}
-
-// need to use rolling b64 encode/decode to prevent hermes from 2048 byte truncation
-export function b64encode(inp: string) {
-  return (
-    inp
-      .match(/.{1,3}/g)
-      ?.map((chunk) => {
-        return Buffer.from(chunk).toString('base64')
-      })
-      .join('') ?? ''
-  )
-}
-
-export function b64decode(b64: string) {
-  return (
-    b64
-      .match(/.{1,4}/g)
-      ?.map((chunk) => {
-        if (chunk.length < 4) {
-          chunk += '='.repeat(4 - chunk.length)
-        }
-        return Buffer.from(chunk, 'base64').toString()
-      })
-      .join('') ?? ''
-  )
-}
-
-export function formatIfDate(format: string | undefined, value: string | number | null) {
-  const potentialDate = value ? value.toString() : null
-  if (format === 'YYYYMMDD' && potentialDate && potentialDate.length === format.length) {
-    const year = potentialDate.substring(0, 4)
-    const month = potentialDate.substring(4, 6)
-    const day = potentialDate.substring(6, 8)
-    // NOTE: JavaScript counts months from 0 to 11: January = 0, December = 11.
-    const date = new Date(Number(year), Number(month) - 1, Number(day))
-    if (!isNaN(date.getDate())) {
-      return formatTime(date, { shortMonth: true })
-    }
-  }
-  return value
-}
-
-export function getConnectionName(
-  connection: ConnectionRecord | undefined,
-  alternateContactNames: Record<string, string>
-): string {
-  return (
-    (connection?.id && alternateContactNames[connection?.id]) ||
-    connection?.theirLabel ||
-    connection?.alias ||
-    connection?.id ||
-    ''
-  )
-}
-
-export function useCredentialConnectionLabel(credential?: CredentialExchangeRecord) {
-  const connection = useConnectionById(credential?.connectionId ?? '')
-
-  if (!credential) {
-    return ''
-  }
-
-  if (credential.connectionId) {
-    return connection?.alias || connection?.theirLabel || credential.connectionId
-  }
-
-  return 'Unknown Contact'
-}
-
-export function useConnectionImageUrl(connectionId: string) {
-  const connection = useConnectionById(connectionId)
-  if (!connection) {
-    return undefined
-  }
-  return connection.imageUrl ?? undefined
-}
-
-export function firstValidCredential(
-  fields: AnonCredsRequestedAttributeMatch[] | AnonCredsRequestedPredicateMatch[],
-  revoked = true
-): AnonCredsRequestedAttributeMatch | AnonCredsRequestedPredicateMatch | null {
-  if (!fields.length) {
-    return null
-  }
-
-  let first = null
-  const firstNonRevoked = fields.filter((field) => !field.revoked)[0]
-  if (firstNonRevoked) {
-    first = firstNonRevoked
-  } else if (fields.length && revoked) {
-    first = fields[0]
-  }
-
-  if (!first?.credentialInfo) {
-    return null
-  }
-
-  return first
-}
-
-/**
- * A sorting function for the Array `sort()` function
- * @param a First retrieved credential
- * @param b Second retrieved credential
- */
-export const credentialSortFn = (a: any, b: any) => {
-  if (a.revoked && !b.revoked) {
-    return 1
-  } else if (!a.revoked && b.revoked) {
-    return -1
-  } else {
-    return b.timestamp - a.timestamp
-  }
-}
-
-const credNameFromRestriction = (queries?: AnonCredsProofRequestRestriction[]): string => {
-  let schema_name = ''
-  let cred_def_id = ''
-  let schema_id = ''
-  queries?.forEach((query) => {
-    schema_name = (query?.schema_name as string) ?? schema_name
-    cred_def_id = (query?.cred_def_id as string) ?? cred_def_id
-    schema_id = (query?.schema_id as string) ?? schema_id
-  })
-  if (schema_name && (schema_name.toLowerCase() !== 'default' || schema_name.toLowerCase() !== 'credential')) {
-    return schema_name
-  } else {
-    return parseCredDefFromId(cred_def_id, schema_id)
-  }
-}
-
-export const credDefIdFromRestrictions = (queries?: AnonCredsProofRequestRestriction[]): string => {
-  return queries?.filter((rstr) => rstr.cred_def_id)[0]?.cred_def_id ?? ''
-}
-
-export const schemaIdFromRestrictions = (queries?: AnonCredsProofRequestRestriction[]): string => {
-  const rstrWithSchemaId = queries?.filter(
-    (rstr) => rstr.schema_id || (rstr.issuer_did && rstr.schema_name && rstr.schema_version)
-  )[0]
-
-  // the '2' here is the enum of the transaction type which, for schemas, is always 2
-  const schemaId = rstrWithSchemaId
-    ? rstrWithSchemaId.schema_id ||
-      `${rstrWithSchemaId.issuer_did}:2:${rstrWithSchemaId.schema_name}:${rstrWithSchemaId.schema_version}`
-    : ''
-  return schemaId
-}
-
-export const isDataUrl = (value: string | number | null) => {
-  return typeof value === 'string' && value.startsWith('data:image/')
-}
-export type Fields = Record<string, AnonCredsRequestedAttributeMatch[] | AnonCredsRequestedPredicateMatch[]>
-
-/**
- * Retrieve current credentials info filtered by `credentialDefinitionId` if given.
- * @param credDefId Credential Definition Id
- * @returns Array of `AnonCredsCredentialInfo`
- */
-export const getCredentialInfo = (credId: string, fields: Fields): AnonCredsCredentialInfo[] => {
-  const credentialInfo: AnonCredsCredentialInfo[] = []
-
-  Object.keys(fields).forEach((proofKey) => {
-    credentialInfo.push(...fields[proofKey].map((attr) => attr.credentialInfo))
-  })
-
-  return !credId ? credentialInfo : credentialInfo.filter((cred) => cred.credentialId === credId)
-}
-
-/**
- * Evaluate if given attribute value satisfies the predicate.
- * @param attribute Credential attribute value
- * @param pValue Predicate value
- * @param pType Predicate type ({@link AnonCredsPredicateType})
- * @returns `true`if predicate is satisfied, otherwise `false`
- */
-const evaluateOperation = (attribute: number, pValue: number, pType: AnonCredsPredicateType): boolean => {
-  if (pType === '>=') {
-    return attribute >= pValue
-  }
-
-  if (pType === '>') {
-    return attribute > pValue
-  }
-
-  if (pType === '<=') {
-    return attribute <= pValue
-  }
-  if (pType === '<') {
-    return attribute < pValue
-  }
-
-  return false
-}
-
-/**
- * Given proof credential items, evaluate and return its predicates, setting `satisfied` property.
- * @param proofCredentialsItems
- * @returns Array of evaluated predicates
- */
-export const evaluatePredicates =
-  (fields: Fields, credId?: string) =>
-  (proofCredentialItems: ProofCredentialItems): Predicate[] => {
-    const predicates = proofCredentialItems.predicates
-    if (!predicates || predicates.length == 0) {
-      return []
-    }
-
-    if ((credId && credId != proofCredentialItems.credId) || !proofCredentialItems.credId) {
-      return []
-    }
-
-    const credentialAttributes = getCredentialInfo(proofCredentialItems.credId, fields).map((ci) => ci.attributes)
-
-    return predicates.map((predicate: Predicate) => {
-      const { pType: pType, pValue: pValue, name: field } = predicate
-      let satisfied = false
-
-      if (field) {
-        const attribute = (credentialAttributes.find((attr) => attr[field] != undefined) ?? {})[field]
-
-        if (attribute && pValue) {
-          satisfied = evaluateOperation(Number(attribute), Number(pValue), pType as AnonCredsPredicateType)
-        }
-      }
-
-      return { ...predicate, satisfied }
-    })
-  }
-
-// scans through requested attributes and records
-// Builds and returns label: value attributes
-// Flagging any attribute not found in wallet credentials
-const addMissingDisplayAttributes = (
-  attrReq: AnonCredsRequestedAttribute,
-  records: CredentialExchangeRecord[]
-): ProofCredentialAttributes => {
-  const { name, names, restrictions } = attrReq
-  const credName = credNameFromRestriction(restrictions)
-  const credDefId = credDefIdFromRestrictions(restrictions)
-  const schemaId = schemaIdFromRestrictions(restrictions)
-
-  //there is no credId in this context so use credName as a placeholder
-  const processedAttributes: ProofCredentialAttributes = {
-    credExchangeRecord: undefined,
-    altCredentials: [credName],
-    credId: credName,
-    schemaId,
-    credDefId,
-    credName: credName,
-    attributes: [] as Attribute[],
-  }
-
-  // Filter records for requested schema id of credential definition id
-  const filteredCredentialRecords = records.filter(
-    (record: CredentialExchangeRecord) =>
-      getCredentialSchemaIdForRecord(record) === schemaId || getCredentialDefinitionIdForRecord(record) === credDefId
-  )
-
-  // for reach requested attribute
-  // scan through filtered credential attributes
-  // display any that are found
-  // flag any not found attributes with an error
-  for (const attributeName of [...(names ?? (name && [name]) ?? [])]) {
-    // filter through credential record attributes for a given name
-    const [attribute] = filteredCredentialRecords.map((item: CredentialExchangeRecord) => {
-      return item.credentialAttributes?.filter(
-        (attribute: CredentialPreviewAttribute) => attribute.name === attributeName
-      )
-    })
-    if (attribute && attribute.length > 0) {
-      // attribute found, display as expected
-      processedAttributes.attributes?.push(
-        new Attribute({
-          revoked: false,
-          credentialId: credName,
-          name: attributeName,
-          value: attribute[0].value,
-          hasError: false,
-        })
-      )
-    } else {
-      // no attribute found, flag this with an error
-      processedAttributes.attributes?.push(
-        new Attribute({
-          revoked: false,
-          credentialId: credName,
-          name: attributeName,
-          value: '',
-          hasError: true,
-        })
-      )
-    }
-  }
-  return processedAttributes
-}
-export const processProofAttributes = (
-  t: TFunction<'translation', undefined>,
-  request?: AnonCredsProofRequest,
-  credentials?: AnonCredsCredentialsForProofRequest, // credentials that 100% validate the proof request
-  credentialRecords?: CredentialExchangeRecord[], // all the credentials in the wallet
-  groupByReferent?: boolean
-): { [key: string]: ProofCredentialAttributes } => {
-  const processedAttributes = {} as { [key: string]: ProofCredentialAttributes }
-  const requestedProofAttributes = request?.requested_attributes
-  const retrievedCredentialAttributes = credentials?.attributes
-  const requestNonRevoked = request?.non_revoked // non_revoked interval can sometimes be top level
-
-  // no proof or credential attributes, nothing to process, leave early
-  if (!requestedProofAttributes || !retrievedCredentialAttributes) {
-    return {}
-  }
-
-  for (const key of Object.keys(retrievedCredentialAttributes)) {
-    const altCredentials = [...(retrievedCredentialAttributes[key] ?? [])]
-      .sort(credentialSortFn)
-      .map((cred) => cred.credentialId)
-
-    const credentialList = [...(retrievedCredentialAttributes[key] ?? [])].sort(credentialSortFn)
-    const { name, names, non_revoked, restrictions } = requestedProofAttributes[key]
-
-    // system assumes one of these values is present in a proof request
-    const proofCredDefId = credDefIdFromRestrictions(restrictions)
-    const proofSchemaId = schemaIdFromRestrictions(restrictions)
-
-    // No credentials satisfy proof request, process attribute errors
-    if (credentialList.length <= 0) {
-      const missingAttributes = addMissingDisplayAttributes(requestedProofAttributes[key], credentialRecords ?? [])
-      const missingCredGroupKey = groupByReferent ? key : missingAttributes.credName
-      if (!processedAttributes[missingCredGroupKey]) {
-        processedAttributes[missingCredGroupKey] = missingAttributes
-      } else {
-        processedAttributes[missingCredGroupKey].attributes?.push(...(missingAttributes.attributes ?? []))
-      }
-    }
-    //iterate over all credentials that satisfy the proof
-    for (const credential of credentialList) {
-      let credName = key
-      if (credential?.credentialInfo?.credentialDefinitionId || credential?.credentialInfo?.schemaId) {
-        credName = parseCredDefFromId(
-          credential?.credentialInfo?.credentialDefinitionId,
-          credential?.credentialInfo?.schemaId
-        )
-      }
-      let revoked = false
-      let credExchangeRecord = undefined
-      if (credential) {
-        credExchangeRecord = credentialRecords?.find(
-          (record) =>
-            record.credentials.map((cred) => cred.credentialRecordId).includes(credential.credentialId) ||
-            record.id === credential.credentialId
-        )
-        revoked = credExchangeRecord?.revocationNotification !== undefined
-      } else {
-        continue
-      }
-      for (const attributeName of [...(names ?? (name && [name]) ?? [])]) {
-        if (!processedAttributes[credential.credentialId]) {
-          // init processedAttributes object
-          processedAttributes[credential.credentialId] = {
-            credExchangeRecord,
-            altCredentials,
-            credId: credential?.credentialId,
-            schemaId: credential?.credentialInfo?.schemaId ?? proofSchemaId,
-            credDefId: credential?.credentialInfo?.credentialDefinitionId ?? proofCredDefId,
-            credName,
-            attributes: [],
-          }
-        }
-
-        const attributeValue = credential ? credential.credentialInfo.attributes[attributeName] : null
-        processedAttributes[credential.credentialId].attributes?.push(
-          new Attribute({
-            ...requestedProofAttributes[key],
-            revoked,
-            credentialId: credential.credentialId,
-            name: attributeName,
-            value: attributeValue,
-            nonRevoked: requestNonRevoked ?? non_revoked,
-          })
-        )
-      }
-    }
-  }
-
-  return processedAttributes
-}
-
-export const mergeAttributesAndPredicates = (
-  attributes: { [key: string]: ProofCredentialAttributes },
-  predicates: { [key: string]: ProofCredentialPredicates }
-) => {
-  const merged: { [key: string]: ProofCredentialAttributes & ProofCredentialPredicates } = { ...attributes }
-  for (const [key, predicate] of Object.entries(predicates)) {
-    const existingEntry = merged[key]
-    if (existingEntry) {
-      const mergedAltCreds = existingEntry.altCredentials?.filter((credId: string) =>
-        predicate.altCredentials?.includes(credId)
-      )
-      merged[key] = { ...existingEntry, ...predicate }
-      merged[key].altCredentials = mergedAltCreds
-    } else {
-      merged[key] = predicate
-    }
-  }
-  return merged
-}
-
-const addMissingDisplayPredicates = (predReq: AnonCredsRequestedPredicate) => {
-  const { name, p_type: pType, p_value: pValue, restrictions } = predReq
-
-  const credName = credNameFromRestriction(restrictions)
-  const credDefId = credDefIdFromRestrictions(restrictions)
-  const schemaId = schemaIdFromRestrictions(restrictions)
-
-  //there is no credId in this context so use credName as a placeholder
-  const processedPredicates: ProofCredentialPredicates = {
-    credExchangeRecord: undefined,
-    altCredentials: [credName],
-    credId: credName,
-    schemaId,
-    credDefId,
-    credName: credName,
-    predicates: [] as Predicate[],
-  }
-
-  processedPredicates.predicates?.push(
-    new Predicate({
-      revoked: false,
-      credentialId: credName,
-      name: name,
-      pValue,
-      pType,
-    })
-  )
-  return processedPredicates
-}
-export const processProofPredicates = (
-  request?: AnonCredsProofRequest,
-  credentials?: AnonCredsCredentialsForProofRequest,
-  credentialRecords?: CredentialExchangeRecord[],
-  groupByReferent?: boolean
-): { [key: string]: ProofCredentialPredicates } => {
-  const processedPredicates = {} as { [key: string]: ProofCredentialPredicates }
-  const requestedProofPredicates = request?.requested_predicates
-  const retrievedCredentialPredicates = credentials?.predicates
-  const requestNonRevoked = request?.non_revoked // // non_revoked interval can sometimes be top level
-
-  if (!requestedProofPredicates || !retrievedCredentialPredicates) {
-    return {}
-  }
-
-  for (const key of Object.keys(retrievedCredentialPredicates)) {
-    const altCredentials = [...(retrievedCredentialPredicates[key] ?? [])]
-      .sort(credentialSortFn)
-      .map((cred) => cred.credentialId)
-
-    const credentialList = [...(retrievedCredentialPredicates[key] ?? [])].sort(credentialSortFn)
-    const { name, p_type: pType, p_value: pValue, non_revoked, restrictions } = requestedProofPredicates[key]
-    const proofCredDefId = credDefIdFromRestrictions(restrictions)
-    const proofSchemaId = schemaIdFromRestrictions(restrictions)
-
-    if (credentialList.length <= 0) {
-      const missingPredicates = addMissingDisplayPredicates(requestedProofPredicates[key])
-      const missingCredGroupKey = groupByReferent ? key : missingPredicates.credName
-      if (!processedPredicates[missingCredGroupKey]) {
-        processedPredicates[missingCredGroupKey] = missingPredicates
-      } else {
-        processedPredicates[missingCredGroupKey].predicates?.push(...(missingPredicates.predicates ?? []))
-      }
-    }
-
-    for (const credential of credentialList) {
-      let revoked = false
-      let credExchangeRecord = undefined
-      if (credential) {
-        credExchangeRecord = credentialRecords?.find(
-          (record) =>
-            record.credentials.map((cred) => cred.credentialRecordId).includes(credential.credentialId) ||
-            record.id === credential.credentialId
-        )
-        revoked = credExchangeRecord?.revocationNotification !== undefined
-      } else {
-        continue
-      }
-      const { credentialDefinitionId, schemaId } = { ...credential, ...credential?.credentialInfo }
-
-      const credNameRestriction = credNameFromRestriction(requestedProofPredicates[key]?.restrictions)
-
-      let credName = credNameRestriction ?? key
-      if (credential?.credentialInfo?.credentialDefinitionId || credential?.credentialInfo?.schemaId) {
-        credName = parseCredDefFromId(
-          credential?.credentialInfo?.credentialDefinitionId,
-          credential?.credentialInfo?.schemaId
-        )
-      }
-      if (!processedPredicates[credential.credentialId]) {
-        processedPredicates[credential.credentialId] = {
-          altCredentials,
-          credExchangeRecord,
-          credId: credential.credentialId,
-          schemaId: schemaId ?? proofSchemaId,
-          credDefId: credentialDefinitionId ?? proofCredDefId,
-          credName: credName,
-          predicates: [],
-        }
-      }
-
-      processedPredicates[credential.credentialId].predicates?.push(
-        new Predicate({
-          ...requestedProofPredicates[key],
-          credentialId: credential?.credentialId,
-          name,
-          revoked,
-          pValue,
-          pType,
-          nonRevoked: requestNonRevoked ?? non_revoked,
-        })
-      )
-    }
-  }
-  return processedPredicates
-}
-
-export const retrieveCredentialsForProof = async (
-  agent: BifoldAgent,
-  proof: ProofExchangeRecord,
-  fullCredentials: CredentialExchangeRecord[],
-  t: TFunction<'translation', undefined>,
-  groupByReferent?: boolean
-): Promise<CredentialDataForProof | undefined> => {
-  // This is the only valid state to retrieve credentials for a proof
-  // `getCredentialsForRequest` will fail otherwise.
-  // if a proof is declined, it will move out of a RequestReceived state
-  // and this will fail because it is running against a declined proof
-  if (proof.state !== ProofState.RequestReceived) {
-    return
-  }
-
-  try {
-    const format = await agent.proofs.getFormatData(proof.id)
-    const hasPresentationExchange = format.request?.presentationExchange !== undefined
-    const hasAnonCreds = format.request?.anoncreds !== undefined
-    const hasIndy = format.request?.indy !== undefined
-
-    // Will fail if credential not in state 'request-received'
-    const credentialsAsPromise = agent.proofs.getCredentialsForRequest({
-      proofRecordId: proof.id,
-      proofFormats: {
-        // FIXME: Credo will try to use the format, even if the value is undefined (but the key is present)
-        // We should ignore the key, if the value is undefined. For now this is a workaround.
-        ...(hasIndy
-          ? {
-              indy: {
-                // Setting `filterByNonRevocationRequirements` to `false` returns all
-                // credentials even if they are revokable (and revoked). We need this to
-                // be able to show why a proof cannot be satisfied. Otherwise we can only
-                // show failure.
-                filterByNonRevocationRequirements: true,
-              },
-            }
-          : {}),
-        ...(hasAnonCreds
-          ? {
-              anoncreds: {
-                // Setting `filterByNonRevocationRequirements` to `false` returns all
-                // credentials even if they are revokable (and revoked). We need this to
-                // be able to show why a proof cannot be satisfied. Otherwise we can only
-                // show failure.
-                filterByNonRevocationRequirements: true,
-              },
-            }
-          : {}),
-        ...(hasPresentationExchange ? { presentationExchange: {} } : {}),
-      },
-    })
-
-    // Will fail if credential not in state 'request-received'
-    const credentialsWithRevokedAsPromise = agent.proofs.getCredentialsForRequest({
-      proofRecordId: proof.id,
-      proofFormats: {
-        // FIXME: Credo will try to use the format, even if the value is undefined (but the key is present)
-        // We should ignore the key, if the value is undefined. For now this is a workaround.
-        ...(hasIndy
-          ? {
-              indy: {
-                // Setting `filterByNonRevocationRequirements` to `false` returns all
-                // credentials even if they are revokable (and revoked). We need this to
-                // be able to show why a proof cannot be satisfied. Otherwise we can only
-                // show failure.
-                filterByNonRevocationRequirements: false,
-              },
-            }
-          : {}),
-        ...(hasAnonCreds
-          ? {
-              anoncreds: {
-                // Setting `filterByNonRevocationRequirements` to `false` returns all
-                // credentials even if they are revokable (and revoked). We need this to
-                // be able to show why a proof cannot be satisfied. Otherwise we can only
-                // show failure.
-                filterByNonRevocationRequirements: false,
-              },
-            }
-          : {}),
-        ...(hasPresentationExchange ? { presentationExchange: {} } : {}),
-      },
-    })
-
-    const [credentials, credentialsWithRevoked] = await Promise.all([
-      credentialsAsPromise,
-      credentialsWithRevokedAsPromise,
-    ])
-
-    // In the case where there are only revoked credentials to satisfy a proof,
-    // include them for errors on the proof screen, otherwise leave them out
-    const addRevokedCredsIfNeeded = (proofFormat: 'indy' | 'anoncreds', proofItem: 'attributes' | 'predicates') => {
-      if (credentials.proofFormats[proofFormat] && credentialsWithRevoked.proofFormats[proofFormat]) {
-        Object.keys(credentials.proofFormats[proofFormat]?.[proofItem] ?? {}).forEach((key) => {
-          if (
-            credentials.proofFormats[proofFormat] &&
-            !credentials.proofFormats[proofFormat]?.[proofItem][key]?.length
-          ) {
-            credentials.proofFormats[proofFormat]?.[proofItem][key].push(
-              ...(credentialsWithRevoked.proofFormats[proofFormat]?.[proofItem][key] ?? ([] as any[]))
-            )
-          }
-        })
-      }
-    }
-
-    for (const proofFormat of ['indy', 'anoncreds']) {
-      for (const proofItem of ['attributes', 'predicates']) {
-        addRevokedCredsIfNeeded(proofFormat as 'indy' | 'anoncreds', proofItem as 'attributes' | 'predicates')
-      }
-    }
-
-    if (!credentials) {
-      throw new Error(t('ProofRequest.RequestedCredentialsCouldNotBeFound'))
-    }
-
-    if (!format) {
-      throw new Error(t('ProofRequest.RequestedCredentialsCouldNotBeFound'))
-    }
-
-    if (!(format && credentials && fullCredentials)) {
-      return
-    }
-
-    if (hasPresentationExchange) {
-      // FIXME: non revocation requirements
-      const presentationExchange = format.request?.presentationExchange
-      const difPexCredentialsForRequest = credentials.proofFormats.presentationExchange
-
-      if (!difPexCredentialsForRequest || !presentationExchange) throw new Error('Invalid presentation request')
-
-      const presentationDefinition = presentationExchange.presentation_definition
-      const descriptorMetadata = getDescriptorMetadata(difPexCredentialsForRequest)
-      const anonCredsProofRequest = createAnonCredsProofRequest(presentationDefinition, descriptorMetadata)
-      const anonCredsCredentialsForRequest = await getCredentialsForAnonCredsProofRequest(
-        agent.context,
-        anonCredsProofRequest,
-        { filterByNonRevocationRequirements: false }
-      )
-
-      const filtered = filterInvalidProofRequestMatches(anonCredsCredentialsForRequest, descriptorMetadata)
-      const processedAttributes = processProofAttributes(
-        t,
-        anonCredsProofRequest,
-        filtered,
-        fullCredentials,
-        groupByReferent
-      )
-      const processedPredicates = processProofPredicates(
-        anonCredsProofRequest,
-        filtered,
-        fullCredentials,
-        groupByReferent
-      )
-      const groupedProof = Object.values(mergeAttributesAndPredicates(processedAttributes, processedPredicates))
-
-      return {
-        groupedProof,
-        retrievedCredentials: filtered,
-        fullCredentials,
-        descriptorMetadata,
-      }
-    }
-
-    const proofRequest = format.request?.anoncreds ?? format.request?.indy
-    const proofFormat = credentials.proofFormats.anoncreds ?? credentials.proofFormats.indy
-
-    const attributes = processProofAttributes(t, proofRequest, proofFormat, fullCredentials, groupByReferent)
-    const predicates = processProofPredicates(proofRequest, proofFormat, fullCredentials, groupByReferent)
-    const groupedProof = Object.values(mergeAttributesAndPredicates(attributes, predicates))
-
-    return { groupedProof, retrievedCredentials: proofFormat, fullCredentials }
-  } catch (err: unknown) {
-    const error = new BifoldError(t('Error.Title1043'), t('Error.Message1043'), (err as Error)?.message ?? err, 1043)
-    DeviceEventEmitter.emit(EventTypes.ERROR_ADDED, error)
-  }
-}
-
-export const pTypeToText = (
-  item: Predicate,
-  t: TFunction<'translation', undefined>,
-  attributeTypes?: Record<string, string>
-) => {
-  const itemCopy = { ...item }
-  const pTypeMap: { [key: string]: string | undefined } = {
-    '>=': t('ProofRequest.PredicateGe'),
-    '>': t('ProofRequest.PredicateGr'),
-    '<=': t('ProofRequest.PredicateLe'),
-    '<': t('ProofRequest.PredicateLs'),
-  }
-  const pTypeDateMap: { [key: string]: string | undefined } = {
-    '>=': t('ProofRequest.PredicateGeDate'),
-    '>': t('ProofRequest.PredicateGeDate'),
-    '<=': t('ProofRequest.PredicateLeDate'),
-    '<': t('ProofRequest.PredicateLeDate'),
-  }
-  const pTypeDateOffset: { [key: string]: number | undefined } = {
-    '>=': -1,
-    '<=': 1,
-  }
-  if (attributeTypes && attributeTypes[item.name ?? ''] == CaptureBaseAttributeType.DateTime) {
-    itemCopy.pType = pTypeDateMap[item.pType] ?? item.pType
-    itemCopy.pValue = parseInt(`${itemCopy.pValue}`) + (pTypeDateOffset[item.pType] ?? 0)
-  } else {
-    itemCopy.pType = pTypeMap[item.pType] ?? item.pType
-  }
-  return itemCopy
-}
-
-/**
- * @deprecated The function should not be used
- */
-export const sortCredentialsForAutoSelect = (
-  credentials: AnonCredsCredentialsForProofRequest
-): AnonCredsCredentialsForProofRequest => {
-  const requestedAttributes = Object.values(credentials?.attributes).pop()
-  const requestedPredicates = Object.values(credentials?.predicates).pop()
-  const sortFn = (a: any, b: any) => {
-    if (a.revoked && !b.revoked) {
-      return 1
-    } else if (!a.revoked && b.revoked) {
-      return -1
-    } else {
-      return b.timestamp - a.timestamp
-    }
-  }
-
-  requestedAttributes && requestedAttributes.sort(sortFn)
-  requestedPredicates && requestedPredicates.sort(sortFn)
-
-  return credentials
-}
-
-/**
- * This cleanup function prevents any errors associated with
- * receiving the same invitation twice if a previous
- * invitation was not completed. Does nothing if no previously
- * received invitations exist
- * @param agent an Agent instance
- * @param invitationId specifically a *received* invitation id
- */
-export const removeExistingInvitationsById = async (agent: Agent | undefined, invitationId: string): Promise<void> => {
-  // This is implemented just as findByReceivedInvitationId is
-  // in Credo only this is able to return multiple if they exist
-  const oobRecords =
-    (await agent?.oob.findAllByQuery({
-      invitationId,
-      role: OutOfBandRole.Receiver,
-    })) || []
-
-  for (const r of oobRecords) {
-    await agent?.oob.deleteById(r.id)
-    agent?.config.logger.info('Successfully removed an existing oob invitation')
-  }
-}
-
-/**
- * Get a oob record and connection record from a URI using built-in Credo methods
- * @param uri a URI that is either a redirect URL or contains a base64 encoded connection invite in query params
- * @param agent an Agent instance
- * @param implicitInvitations a boolean to determine if implicit invitation behavior should be used
- * @param reuseConnection a boolean to determine if connection reuse should be allowed
- * @returns an object containing an OOB record and, if not connectionless, a connection record
- */
-export const connectFromInvitation = async (
-  uri: string,
-  agent: Agent | undefined,
-  implicitInvitations: boolean = false,
-  reuseConnection: boolean = false
-): Promise<OutOfBandRecord> => {
-  const invitation = await agent?.oob.parseInvitation(uri)
-
-  if (!invitation) {
-    throw new Error('Could not parse invitation from URL')
-  }
-
-  if (implicitInvitations) {
-    try {
-      if (invitation.getDidServices().length > 0) {
-        const did = parseDid(invitation.getDidServices()[0])
-        const record = await agent?.oob.receiveImplicitInvitation({
-          did: did.did,
-          label: invitation.label,
-          handshakeProtocols: invitation.handshakeProtocols as HandshakeProtocol[] | undefined,
-        })
-
-        return record?.outOfBandRecord as OutOfBandRecord
-      }
-    } catch (e) {
-      // don't throw an error, will try to connect again below
-    }
-  }
-
-  const record = await agent?.oob.receiveInvitation(invitation, { reuseConnection })
-  return record?.outOfBandRecord as OutOfBandRecord
-}
-
-const processBetaUrlIfRequired = (uri: string): string => {
-  let aUrl = uri
-
-  // _oob is a beta query param, not supported by Credo.
-  aUrl = uri.replace('_oob', 'oob')
-
-  // _url is a beta query param, not supported by Credo.
-  if (uri.includes('_url')) {
-    const queryParams = parseUrl(uri)?.query
-    const b64UrlRedirect = queryParams['_url']
-    aUrl = b64decode(b64UrlRedirect as string)
-  }
-
-  return aUrl
-}
-
-/**
- * Receive a message from a scan or deeplink and navigate accordingly
- * @param uri a URI either containing a base64 encoded connection invite in the query parameters or a redirect URL itself
- * @param agent an Agent instance
- * @param logger injected logger from DI container
- * @param navigation a navigation object from either the Scan screen, Home screen, or PasteUrl screen
- * @param isDeepLink a boolean to communicate where the uri is coming from
- * @param implicitInvitations a boolean to determine if implicit invitation behavior should be used
- * @param reuseConnection a boolean to determine if connection reuse should be allowed
- * @throws Error with message containing the primary and beta error messages if both fail
- */
-export const connectFromScanOrDeepLink = async (
-  uri: string,
-  agent: Agent | undefined,
-  logger: BifoldLogger,
-  navigation: any,
-  isDeepLink: boolean,
-  implicitInvitations: boolean = false,
-  reuseConnection: boolean = false
-) => {
-  if (!agent) {
-    return
-  }
-
-  // TODO:(jl) Do we care if the connection is a deep link?
-  logger.info(`Attempting to connect from ${isDeepLink ? 'deeplink' : 'qr scan'}`)
-  try {
-    if (isOpenIdCredentialOffer(uri)) {
-      navigation.navigate(Stacks.ConnectionStack as any, {
-        screen: Screens.Connection,
-        params: { oobRecordId: '', openIDUri: uri },
-      })
-
-      return
-    }
-
-    if (isOpenIdPresentationRequest(uri)) {
-      navigation.navigate(Stacks.ConnectionStack as any, {
-        screen: Screens.Connection,
-        params: { oobRecordId: '', openIDPresentationUri: uri },
-      })
-
-      return
-    }
-    if (await isMediatorInvitation(agent, uri)) {
-      navigation.navigate(Stacks.SettingStack as any, {
-        screen: Screens.ConfigureMediator,
-        params: { scannedMediatorUri: uri },
-      })
-
-      return
-    }
-
-    const aUrl = processBetaUrlIfRequired(uri)
-    const receivedInvitation = await connectFromInvitation(aUrl, agent, implicitInvitations, reuseConnection)
-
-    if (receivedInvitation?.id) {
-      navigation.navigate(Stacks.ConnectionStack as any, {
-        screen: Screens.Connection,
-        params: { oobRecordId: receivedInvitation.id },
-      })
-    }
-  } catch (error: unknown) {
-    logger.error('Problem during connect strategy, error:', error as Error)
-
-    throw error
-  }
-}
-
-/**
- * Create a new connection invitation
- *
- * @param agent an Agent instance
- * @param goalCode add goalCode to connection invitation
- * @returns a connection record
- */
-export const createConnectionInvitation = async (agent: Agent | undefined, goalCode?: string) => {
-  const record = await agent?.oob.createInvitation({ goalCode })
-  if (!record) {
-    throw new Error('Could not create new invitation')
-  }
-  const invitationUrl = record.outOfBandInvitation.toUrl({ domain })
-
-  return {
-    record,
-    invitation: record.outOfBandInvitation,
-    invitationUrl,
-  }
-}
-
-/**
- * Create a new connection invitation with a goal code specifying that it will be deleted after issuing or verifying once depending on type
- *
- * @param agent an Agent instance
- * @param type add goalCode to connection invitation
- * @returns a connection record
- */
-export const createTempConnectionInvitation = async (agent: Agent | undefined, type: 'issue' | 'verify') => {
-  return createConnectionInvitation(agent, `aries.vc.${type}.once`)
-}
-
-/**
- * Typeguard to check if any React children is represented as a function
- * instead of a Node. I,e., when it's a {@link ChildFn}.
- *
- * @param children any React children
- * @returns true if the children is a function, false otherwise
- */
-export function isChildFunction<T>(children: ReactNode | ChildFn<T>): children is ChildFn<T> {
-  return typeof children === 'function'
-}
-
-// Fetches the credential definition id for a given credential exchange record, returns null if ID is not found
-export const getCredentialDefinitionIdForRecord = (record: CredentialExchangeRecord): string | null => {
-  // assumes record is anonCred
-  return record.metadata.get('_anoncreds/credential')?.credentialDefinitionId ?? null
-}
-
-// Fetches the schema id for a given credential exchange record, returns null if ID is not found
-export const getCredentialSchemaIdForRecord = (record: CredentialExchangeRecord): string | null => {
-  // assumes record is anonCred
-  return record.metadata.get('_anoncreds/credential')?.schemaId ?? null
-}
-
-export function getCredentialEventRole(record: CredentialExchangeRecord) {
-  switch (record.state) {
-    // assuming only Holder states are supported here
-    case CredentialState.ProposalSent:
-      return Role.me
-    case CredentialState.OfferReceived:
-      return Role.them
-    case CredentialState.RequestSent:
-      return Role.me
-    case CredentialState.Declined:
-      return Role.me
-    case CredentialState.CredentialReceived:
-      return Role.me
-    case CredentialState.Done:
-      return Role.me
-    default:
-      return Role.me
-  }
-}
-
-export function getCredentialEventLabel(record: CredentialExchangeRecord) {
-  switch (record.state) {
-    // assuming only Holder states are supported here
-    case CredentialState.ProposalSent:
-      return 'Chat.CredentialProposalSent'
-    case CredentialState.OfferReceived:
-      return 'Chat.CredentialOfferReceived'
-    case CredentialState.RequestSent:
-      return 'Chat.CredentialRequestSent'
-    case CredentialState.Declined:
-      return 'Chat.CredentialDeclined'
-    case CredentialState.CredentialReceived:
-    case CredentialState.Done:
-      return 'Chat.CredentialReceived'
-    default:
-      return ''
-  }
-}
-
-export function getProofEventRole(record: ProofExchangeRecord) {
-  switch (record.state) {
-    case ProofState.RequestSent:
-      return Role.me
-    case ProofState.ProposalReceived:
-      return Role.me
-    case ProofState.PresentationReceived:
-      return Role.them
-    case ProofState.RequestReceived:
-      return Role.them
-    case ProofState.ProposalSent:
-    case ProofState.PresentationSent:
-      return Role.me
-    case ProofState.Declined:
-      return Role.me
-    case ProofState.Abandoned:
-      return Role.them
-    case ProofState.Done:
-      return record.isVerified !== undefined ? Role.them : Role.me
-    default:
-      return Role.me
-  }
-}
-
-export function getProofEventLabel(record: ProofExchangeRecord) {
-  switch (record.state) {
-    case ProofState.RequestSent:
-    case ProofState.ProposalReceived:
-      return 'Chat.ProofRequestSent'
-    case ProofState.PresentationReceived:
-      return 'Chat.ProofPresentationReceived'
-    case ProofState.RequestReceived:
-      return 'Chat.ProofRequestReceived'
-    case ProofState.ProposalSent:
-    case ProofState.PresentationSent:
-      return 'Chat.ProofRequestSatisfied'
-    case ProofState.Declined:
-      return 'Chat.ProofRequestRejected'
-    case ProofState.Abandoned:
-      return 'Chat.ProofRequestRejectReceived'
-    case ProofState.Done:
-      return record.isVerified !== undefined ? 'Chat.ProofPresentationReceived' : 'Chat.ProofRequestSatisfied'
-    default:
-      return ''
-  }
-}
-
-export function getMessageEventRole(record: BasicMessageRecord) {
-  return record.role === BasicMessageRole.Sender ? Role.me : Role.them
-}
-
-export function generateRandomWalletName() {
-  let name = 'My Wallet - '
-  for (let i = 0; i < 4; i++) {
-    name = name.concat(Math.floor(Math.random() * 10).toString())
-  }
-
-  return name
-}
-
-/**
- * Returns the secondary background color for a credential card.
- *
- * @param {CredentialOverlay<BrandingOverlay>} overlay - The credential card containing branding information.
- * @param {boolean} [proof] - Optional flag indicating if the context of the credential card is a proof.
- * @returns {string | undefined} - The secondary background color of the branding or undefined if not applicable.
- */
-export function getSecondaryBackgroundColor(
-  overlay: CredentialOverlay<BrandingOverlay>,
-  proof?: boolean
-): string | undefined {
-  if (proof) {
-    return overlay.brandingOverlay?.primaryBackgroundColor
-  } else {
-    return overlay.brandingOverlay?.backgroundImageSlice
-      ? 'rgba(0, 0, 0, 0)'
-      : overlay.brandingOverlay?.secondaryBackgroundColor
-  }
-}