@bifold/core 2.4.6 → 2.5.0

package/src/modules/openid/display.tsx

@@ -1,467 +0,0 @@
-import type {
-  CredentialDisplay,
-  CredentialIssuerDisplay,
-  JffW3cCredentialJson,
-  OpenId4VcCredentialMetadata,
-  W3cCredentialDisplay,
-  W3cCredentialJson,
-} from './types'
-import { JwkJson, Mdoc, MdocRecord, TypedArrayEncoder, W3cCredentialRecord } from '@credo-ts/core'
-
-import { Hasher, SdJwtVcRecord, ClaimFormat, JsonTransformer } from '@credo-ts/core'
-import { decodeSdJwtSync, getClaimsSync } from '@sd-jwt/decode'
-import { CredentialForDisplayId } from './types'
-import { detectImageMimeType, formatDate, getHostNameFromUrl, isDateString, sanitizeString } from './utils/utils'
-import { getOpenId4VcCredentialMetadata } from './metadata'
-
-function findDisplay<Display extends { locale?: string }>(display?: Display[]): Display | undefined {
-  if (!display) return undefined
-
-  let item = display.find((d) => d.locale?.startsWith('en-'))
-  if (!item) item = display.find((d) => !d.locale)
-  if (!item) item = display[0]
-
-  return item
-}
-
-function getOpenId4VcIssuerDisplay(openId4VcMetadata?: OpenId4VcCredentialMetadata | null): CredentialIssuerDisplay {
-  const issuerDisplay: Partial<CredentialIssuerDisplay> = {}
-
-  // Try to extract from openid metadata first
-  if (openId4VcMetadata) {
-    const openidIssuerDisplay = findDisplay(openId4VcMetadata.issuer.display)
-
-    if (openidIssuerDisplay) {
-      issuerDisplay.name = openidIssuerDisplay.name
-
-      if (openidIssuerDisplay.logo) {
-        issuerDisplay.logo = {
-          url: openidIssuerDisplay.logo?.url,
-          altText: openidIssuerDisplay.logo?.alt_text,
-        }
-      }
-    }
-
-    // If the credentialDisplay contains a logo, and the issuerDisplay does not, use the logo from the credentialDisplay
-    const openidCredentialDisplay = findDisplay(openId4VcMetadata.credential.display)
-    if (openidCredentialDisplay && !issuerDisplay.logo && openidCredentialDisplay.logo) {
-      issuerDisplay.logo = {
-        url: openidCredentialDisplay.logo?.url,
-        altText: openidCredentialDisplay.logo?.alt_text,
-      }
-    }
-  }
-
-  // Last fallback: use issuer id from openid4vc
-  if (!issuerDisplay.name && openId4VcMetadata?.issuer.id) {
-    issuerDisplay.name = getHostNameFromUrl(openId4VcMetadata.issuer.id)
-  }
-
-  if (openId4VcMetadata?.issuer.id) {
-    issuerDisplay.domain = getHostNameFromUrl(openId4VcMetadata.issuer.id)
-  }
-
-  return {
-    ...issuerDisplay,
-    name: issuerDisplay.name ?? 'Unknown',
-  }
-}
-
-function getIssuerDisplay(metadata: OpenId4VcCredentialMetadata | null | undefined): Partial<CredentialIssuerDisplay> {
-  const issuerDisplay: Partial<CredentialIssuerDisplay> = {}
-  // Try to extract from openid metadata first
-  const openidIssuerDisplay = findDisplay(metadata?.issuer.display)
-  issuerDisplay.name = openidIssuerDisplay?.name
-  issuerDisplay.logo = openidIssuerDisplay?.logo
-    ? {
-        url: openidIssuerDisplay.logo?.url,
-        altText: openidIssuerDisplay.logo?.alt_text,
-      }
-    : undefined
-
-  // If the credentialDisplay contains a logo, and the issuerDisplay does not, use the logo from the credentialDisplay
-  const openidCredentialDisplay = findDisplay(metadata?.credential.display)
-  if (openidCredentialDisplay && !issuerDisplay.logo && openidCredentialDisplay.logo) {
-    issuerDisplay.logo = {
-      url: openidCredentialDisplay.logo?.url,
-      altText: openidCredentialDisplay.logo?.alt_text,
-    }
-  }
-
-  return issuerDisplay
-}
-
-function processIssuerDisplay(
-  metadata: OpenId4VcCredentialMetadata | null | undefined,
-  issuerDisplay: Partial<CredentialIssuerDisplay>
-): CredentialIssuerDisplay {
-  // Last fallback: use issuer id from openid4vc
-  if (!issuerDisplay.name && metadata?.issuer.id) {
-    issuerDisplay.name = getHostNameFromUrl(metadata.issuer.id)
-  }
-
-  return {
-    ...issuerDisplay,
-    name: issuerDisplay.name ?? 'Unknown',
-  }
-}
-
-function getW3cIssuerDisplay(
-  credential: W3cCredentialJson,
-  openId4VcMetadata?: OpenId4VcCredentialMetadata | null
-): CredentialIssuerDisplay {
-  const issuerDisplay: Partial<CredentialIssuerDisplay> = getIssuerDisplay(openId4VcMetadata)
-
-  // If openid metadata is not available, try to extract display metadata from the credential based on JFF metadata
-  const jffCredential = credential as JffW3cCredentialJson
-  const issuerJson = typeof jffCredential.issuer === 'string' ? undefined : jffCredential.issuer
-
-  // Issuer Display from JFF
-  if (!issuerDisplay.logo || !issuerDisplay.logo.url) {
-    issuerDisplay.logo = issuerJson?.logoUrl
-      ? { url: issuerJson?.logoUrl }
-      : issuerJson?.image
-      ? { url: typeof issuerJson.image === 'string' ? issuerJson.image : issuerJson.image.id }
-      : undefined
-  }
-
-  // Issuer name from JFF
-  if (!issuerDisplay.name) {
-    issuerDisplay.name = issuerJson?.name
-  }
-
-  return processIssuerDisplay(openId4VcMetadata, issuerDisplay)
-}
-
-function getCredentialDisplay(
-  credentialPayload: Record<string, unknown>,
-  openId4VcMetadata?: OpenId4VcCredentialMetadata | null
-): Partial<CredentialDisplay> {
-  const credentialDisplay: Partial<CredentialDisplay> = {}
-
-  if (openId4VcMetadata) {
-    const openidCredentialDisplay = findDisplay(openId4VcMetadata.credential.display)
-    credentialDisplay.name = openidCredentialDisplay?.name
-    credentialDisplay.description = openidCredentialDisplay?.description
-    credentialDisplay.textColor = openidCredentialDisplay?.text_color
-    credentialDisplay.backgroundColor = openidCredentialDisplay?.background_color
-    credentialDisplay.backgroundImage = openidCredentialDisplay?.background_image
-      ? {
-          url: openidCredentialDisplay.background_image.url,
-          altText: openidCredentialDisplay.background_image.alt_text,
-        }
-      : undefined
-    credentialDisplay.logo = openidCredentialDisplay?.logo
-    credentialDisplay.primary_overlay_attribute = openidCredentialDisplay?.primary_overlay_attribute as
-      | string
-      | undefined
-  }
-
-  return credentialDisplay
-}
-
-function getW3cCredentialDisplay(
-  credential: W3cCredentialJson,
-  openId4VcMetadata?: OpenId4VcCredentialMetadata | null
-) {
-  const credentialDisplay: Partial<CredentialDisplay> = getCredentialDisplay(credential, openId4VcMetadata)
-
-  // If openid metadata is not available, try to extract display metadata from the credential based on JFF metadata
-  const jffCredential = credential as JffW3cCredentialJson
-
-  if (!credentialDisplay.name) {
-    credentialDisplay.name = jffCredential.name
-  }
-
-  // If there's no name for the credential, we extract it from the last type
-  // and sanitize it. This is not optimal. But provides at least something.
-  if (!credentialDisplay.name && jffCredential.type.length > 1) {
-    const lastType = jffCredential.type[jffCredential.type.length - 1]
-    credentialDisplay.name = lastType && !lastType.startsWith('http') ? sanitizeString(lastType) : undefined
-  }
-
-  // Use background color from the JFF credential if not provided by the OID4VCI metadata
-  if (!credentialDisplay.backgroundColor && jffCredential.credentialBranding?.backgroundColor) {
-    credentialDisplay.backgroundColor = jffCredential.credentialBranding.backgroundColor
-  }
-
-  return {
-    ...credentialDisplay,
-    // Last fallback, if there's really no name for the credential, we use a generic name
-    name: credentialDisplay.name ?? 'Credential',
-  }
-}
-
-function getSdJwtCredentialDisplay(
-  credentialPayload: Record<string, unknown>,
-  openId4VcMetadata?: OpenId4VcCredentialMetadata | null
-) {
-  const credentialDisplay: Partial<CredentialDisplay> = getCredentialDisplay(credentialPayload, openId4VcMetadata)
-
-  if (!credentialDisplay.name && typeof credentialPayload.vct === 'string') {
-    credentialDisplay.name = sanitizeString(credentialPayload.vct)
-  }
-
-  return {
-    ...credentialDisplay,
-    name: credentialDisplay.name ?? 'Credential',
-  }
-}
-
-function getMdocCredentialDisplay(
-  credentialPayload: Record<string, unknown>,
-  openId4VcMetadata?: OpenId4VcCredentialMetadata | null
-) {
-  const credentialDisplay: Partial<CredentialDisplay> = {}
-
-  if (openId4VcMetadata) {
-    const openidCredentialDisplay = findDisplay(openId4VcMetadata.credential.display)
-
-    if (openidCredentialDisplay) {
-      credentialDisplay.name = openidCredentialDisplay.name
-      credentialDisplay.description = openidCredentialDisplay.description
-      credentialDisplay.textColor = openidCredentialDisplay.text_color
-      credentialDisplay.backgroundColor = openidCredentialDisplay.background_color
-
-      if (openidCredentialDisplay.background_image) {
-        credentialDisplay.backgroundImage = {
-          url: openidCredentialDisplay.background_image.url,
-          altText: openidCredentialDisplay.background_image.alt_text,
-        }
-      }
-
-      // NOTE: logo is used in issuer display (not sure if that's right though)
-    }
-  }
-
-  // TODO: mdoc
-  // If there's no name for the credential, we extract it from the last type
-  // and sanitize it. This is not optimal. But provides at least something.
-  // if (!credentialDisplay.name && typeof credentialPayload.vct === 'string') {
-  //   credentialDisplay.name = sanitizeString(credentialPayload.vct)
-  // }
-
-  return {
-    ...credentialDisplay,
-    // Last fallback, if there's really no name for the credential, we use a generic name
-    // TODO: use on-device AI to determine a name for the credential based on the credential data
-    name: credentialDisplay.name ?? 'Credential',
-  }
-}
-
-export interface DisplayImage {
-  url?: string
-  altText?: string
-}
-
-export interface CredentialMetadata {
-  type: string
-  issuer: string
-  holder?: string
-  validUntil?: string
-  validFrom?: string
-  issuedAt?: string
-}
-
-function safeCalculateJwkThumbprint(jwk: JwkJson): string | undefined {
-  try {
-    const thumbprint = TypedArrayEncoder.toBase64URL(
-      Hasher.hash(
-        JSON.stringify({ k: jwk.k, e: jwk.e, crv: jwk.crv, kty: jwk.kty, n: jwk.n, x: jwk.x, y: jwk.y }),
-        'sha-256'
-      )
-    )
-    return `urn:ietf:params:oauth:jwk-thumbprint:sha-256:${thumbprint}`
-  } catch (e) {
-    return undefined
-  }
-}
-
-export function filterAndMapSdJwtKeys(sdJwtVcPayload: Record<string, unknown>) {
-  type SdJwtVcPayload = {
-    iss: string
-    cnf: Record<string, unknown>
-    vct: string
-    iat?: number
-    nbf?: number
-    exp?: number
-    [key: string]: unknown
-  }
-  // TODO: We should map these claims to nice format and names
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const { _sd_alg, _sd_hash, iss, vct, cnf, iat, exp, nbf, ...visibleProperties } = sdJwtVcPayload as SdJwtVcPayload
-
-  const holder = cnf.kid ?? cnf.jwk ? safeCalculateJwkThumbprint(cnf.jwk as JwkJson) : undefined
-  const credentialMetadata: CredentialMetadata = {
-    type: vct,
-    issuer: iss,
-    holder,
-  }
-
-  if (iat) {
-    credentialMetadata.issuedAt = formatDate(new Date(iat * 1000))
-  }
-  if (exp) {
-    credentialMetadata.validUntil = formatDate(new Date(exp * 1000))
-  }
-  if (nbf) {
-    credentialMetadata.validFrom = formatDate(new Date(nbf * 1000))
-  }
-
-  return {
-    visibleProperties: Object.fromEntries(
-      Object.entries(visibleProperties).map(([key, value]) => [key, recursivelyMapAttribues(value)])
-    ),
-    metadata: credentialMetadata,
-    raw: {
-      issuedAt: iat ? new Date(iat * 1000) : undefined,
-      validUntil: exp ? new Date(exp * 1000) : undefined,
-      validFrom: nbf ? new Date(nbf * 1000) : undefined,
-    },
-  }
-}
-
-export function getCredentialForDisplay(
-  credentialRecord: W3cCredentialRecord | SdJwtVcRecord | MdocRecord
-): W3cCredentialDisplay {
-  if (credentialRecord instanceof SdJwtVcRecord) {
-    // FIXME: we should probably add a decode method on the SdJwtVcRecord
-    // as you now need the agent context to decode the sd-jwt vc, while that's
-    // not really needed
-    const { disclosures, jwt } = decodeSdJwtSync(credentialRecord.compactSdJwtVc, (data, alg) => Hasher.hash(data, alg))
-    const decodedPayload: Record<string, unknown> = getClaimsSync(jwt.payload, disclosures, (data, alg) =>
-      Hasher.hash(data, alg)
-    )
-
-    const openId4VcMetadata = getOpenId4VcCredentialMetadata(credentialRecord)
-    const issuerDisplay = getOpenId4VcIssuerDisplay(openId4VcMetadata)
-    const credentialDisplay = getSdJwtCredentialDisplay(decodedPayload, openId4VcMetadata)
-
-    const mapped = filterAndMapSdJwtKeys(decodedPayload)
-
-    return {
-      id: `sd-jwt-vc-${credentialRecord.id}` satisfies CredentialForDisplayId,
-      createdAt: credentialRecord.createdAt,
-      display: {
-        ...credentialDisplay,
-        issuer: issuerDisplay,
-      },
-      attributes: mapped.visibleProperties,
-      metadata: mapped.metadata,
-      claimFormat: ClaimFormat.SdJwtVc,
-      validUntil: mapped.raw.validUntil,
-      validFrom: mapped.raw.validFrom,
-      credentialSubject: openId4VcMetadata?.credential.credential_subject,
-    }
-  }
-
-  if (credentialRecord instanceof MdocRecord) {
-    const openId4VcMetadata = getOpenId4VcCredentialMetadata(credentialRecord)
-    const issuerDisplay = getOpenId4VcIssuerDisplay(openId4VcMetadata)
-    const credentialDisplay = getMdocCredentialDisplay({}, openId4VcMetadata)
-
-    const mdocInstance = Mdoc.fromBase64Url(credentialRecord.base64Url)
-    const attributes = Object.fromEntries(
-      Object.values(mdocInstance.issuerSignedNamespaces).flatMap((v) =>
-        Object.entries(v).map(([key, value]) => [key, recursivelyMapAttribues(value)])
-      )
-    )
-
-    return {
-      id: `mdoc-${credentialRecord.id}` satisfies CredentialForDisplayId,
-      createdAt: credentialRecord.createdAt,
-      display: {
-        ...credentialDisplay,
-        issuer: issuerDisplay,
-      },
-      attributes,
-      // TODO:
-      metadata: {
-        // holder: 'Unknown',
-        issuer: 'Unknown',
-        type: mdocInstance.docType,
-      } satisfies CredentialMetadata,
-      claimFormat: ClaimFormat.MsoMdoc,
-      validUntil: mdocInstance.validityInfo.validUntil,
-      validFrom: mdocInstance.validityInfo.validFrom,
-      credentialSubject: openId4VcMetadata?.credential.credential_subject,
-    }
-  }
-
-  const credential = JsonTransformer.toJSON(
-    credentialRecord.credential.claimFormat === ClaimFormat.JwtVc
-      ? credentialRecord.credential.credential
-      : credentialRecord.credential
-  ) as W3cCredentialJson
-
-  const openId4VcMetadata = getOpenId4VcCredentialMetadata(credentialRecord)
-  const issuerDisplay = getW3cIssuerDisplay(credential, openId4VcMetadata)
-  const credentialDisplay = getW3cCredentialDisplay(credential, openId4VcMetadata)
-
-  // to be implimented later support credential with multiple subjects
-  const credentialAttributes = Array.isArray(credential.credentialSubject)
-    ? credential.credentialSubject[0] ?? {}
-    : credential.credentialSubject
-
-  return {
-    id: `w3c-credential-${credentialRecord.id}` satisfies CredentialForDisplayId,
-    createdAt: credentialRecord.createdAt,
-    display: {
-      ...credentialDisplay,
-      issuer: issuerDisplay,
-    },
-    credential,
-    attributes: credentialAttributes,
-    metadata: {
-      holder: credentialRecord.credential.credentialSubjectIds[0],
-      issuer: credentialRecord.credential.issuerId,
-      type: credentialRecord.credential.type[credentialRecord.credential.type.length - 1],
-      issuedAt: formatDate(new Date(credentialRecord.credential.issuanceDate)),
-      validUntil: credentialRecord.credential.expirationDate
-        ? formatDate(new Date(credentialRecord.credential.expirationDate))
-        : undefined,
-      validFrom: undefined,
-    } satisfies CredentialMetadata,
-    claimFormat: credentialRecord.credential.claimFormat,
-    validUntil: credentialRecord.credential.expirationDate
-      ? new Date(credentialRecord.credential.expirationDate)
-      : undefined,
-    validFrom: credentialRecord.credential.issuanceDate
-      ? new Date(credentialRecord.credential.issuanceDate)
-      : undefined,
-    credentialSubject: openId4VcMetadata?.credential.credential_subject,
-  }
-}
-
-type MappedAttributesReturnType =
-  | string
-  | number
-  | boolean
-  | { [key: string]: MappedAttributesReturnType }
-  | null
-  | undefined
-  | Array<MappedAttributesReturnType>
-export function recursivelyMapAttribues(value: unknown): MappedAttributesReturnType {
-  if (value instanceof Uint8Array) {
-    const imageMimeType = detectImageMimeType(value)
-    if (imageMimeType) {
-      return `data:${imageMimeType};base64,${TypedArrayEncoder.toBase64(value)}`
-    }
-
-    // TODO: what to do with a buffer that is not an image?
-    return TypedArrayEncoder.toUtf8String(value)
-  }
-  if (value === null || value === undefined || typeof value === 'number' || typeof value === 'boolean') return value
-
-  if (value instanceof Date || (typeof value === 'string' && isDateString(value))) {
-    // TODO: handle DateOnly (should be handled as time is 0 then)
-    return formatDate(value)
-  }
-  if (typeof value === 'string') return value
-  if (value instanceof Map) {
-    return Object.fromEntries(Array.from(value.entries()).map(([key, value]) => [key, recursivelyMapAttribues(value)]))
-  }
-  if (Array.isArray(value)) return value.map(recursivelyMapAttribues)
-
-  return Object.fromEntries(Object.entries(value).map(([key, value]) => [key, recursivelyMapAttribues(value)]))
-}

package/src/modules/openid/displayProof.tsx

@@ -1,86 +0,0 @@
-import { ClaimFormat, type DifPexCredentialsForRequest } from '@credo-ts/core'
-
-import { type CredentialMetadata, type DisplayImage, filterAndMapSdJwtKeys, getCredentialForDisplay } from './display'
-
-export interface FormattedSubmission {
-  name: string
-  purpose?: string
-  areAllSatisfied: boolean
-  entries: FormattedSubmissionEntry[]
-}
-
-export type FormattedSelectedCredentialEntry = {
-  id: string
-  credentialName: string
-  issuerName?: string
-  requestedAttributes?: string[]
-  disclosedPayload?: Record<string, unknown>
-  metadata?: CredentialMetadata
-  backgroundColor?: string
-  backgroundImage?: DisplayImage
-  textColor?: string
-  claimFormat: ClaimFormat | 'AnonCreds'
-}
-
-export interface FormattedSubmissionEntry {
-  /** can be either AnonCreds groupName or PEX inputDescriptorId */
-  inputDescriptorId: string
-  isSatisfied: boolean
-
-  name: string
-  purpose?: string
-  description?: string
-
-  credentials: Array<FormattedSelectedCredentialEntry>
-}
-
-export function formatDifPexCredentialsForRequest(
-  credentialsForRequest: DifPexCredentialsForRequest
-): FormattedSubmission {
-  const entries = credentialsForRequest.requirements.flatMap((requirement) => {
-    return requirement.submissionEntry.map((submission): FormattedSubmissionEntry => {
-      return {
-        inputDescriptorId: submission.inputDescriptorId,
-        name: submission.name ?? 'Unknown',
-        purpose: submission.purpose,
-        description: submission.purpose,
-        isSatisfied: submission.verifiableCredentials.length >= 1,
-
-        credentials: submission.verifiableCredentials.map((verifiableCredential) => {
-          const { display, attributes, metadata, claimFormat } = getCredentialForDisplay(
-            verifiableCredential.credentialRecord
-          )
-
-          let disclosedPayload = attributes
-          if (verifiableCredential.type === ClaimFormat.SdJwtVc) {
-            disclosedPayload = filterAndMapSdJwtKeys(verifiableCredential.disclosedPayload).visibleProperties
-          } else if (verifiableCredential.type === ClaimFormat.MsoMdoc) {
-            disclosedPayload = Object.fromEntries(
-              Object.values(verifiableCredential.disclosedPayload).flatMap((entry) => Object.entries(entry))
-            )
-          }
-
-          return {
-            id: verifiableCredential.credentialRecord.id,
-            credentialName: display.name,
-            issuerName: display.issuer.name,
-            requestedAttributes: [...Object.keys(disclosedPayload)],
-            disclosedPayload,
-            metadata,
-            backgroundColor: display.backgroundColor,
-            textColor: display.textColor,
-            backgroundImage: display.backgroundImage,
-            claimFormat,
-          }
-        }),
-      }
-    })
-  })
-
-  return {
-    areAllSatisfied: entries.every((entry) => entry.isSatisfied),
-    name: credentialsForRequest.name ?? 'Unknown',
-    purpose: credentialsForRequest.purpose,
-    entries,
-  }
-}

package/src/modules/openid/hooks/openid.tsx

@@ -1,111 +0,0 @@
-import { MdocRecord, SdJwtVcRecord, W3cCredentialRecord } from '@credo-ts/core'
-import { useCallback, useEffect, useState } from 'react'
-import { DeviceEventEmitter } from 'react-native'
-import { EventTypes } from '../../../constants'
-import { BifoldError } from '../../../types/error'
-import { useAgent } from '@credo-ts/react-hooks'
-import { useTranslation } from 'react-i18next'
-import { getCredentialsForProofRequest } from '../resolverProof'
-import { OpenId4VPRequestRecord } from '../types'
-import {
-  acquirePreAuthorizedAccessToken,
-  receiveCredentialFromOpenId4VciOffer,
-  resolveOpenId4VciOffer,
-} from '../offerResolve'
-
-type OpenIDContextProps = {
-  openIDUri?: string
-  openIDPresentationUri?: string
-}
-
-export const useOpenID = ({
-  openIDUri,
-  openIDPresentationUri,
-}: OpenIDContextProps): SdJwtVcRecord | W3cCredentialRecord | MdocRecord | OpenId4VPRequestRecord | undefined => {
-  const [openIdRecord, setOpenIdRecord] = useState<
-    SdJwtVcRecord | W3cCredentialRecord | MdocRecord | OpenId4VPRequestRecord
-  >()
-
-  const { agent } = useAgent()
-  const { t } = useTranslation()
-
-  const resolveOpenIDCredential = useCallback(
-    async (uri: string) => {
-      if (!agent) {
-        return
-      }
-      try {
-        const resolvedCredentialOffer = await resolveOpenId4VciOffer({
-          agent: agent,
-          uri: uri,
-        })
-
-        const tokenResponse = await acquirePreAuthorizedAccessToken({ agent, resolvedCredentialOffer })
-
-        return await receiveCredentialFromOpenId4VciOffer({
-          agent,
-          resolvedCredentialOffer,
-          accessToken: tokenResponse,
-        })
-      } catch (err: unknown) {
-        //TODO: Sppecify different error
-        const error = new BifoldError(
-          t('Error.Title1024'),
-          t('Error.Message1024'),
-          (err as Error)?.message ?? err,
-          1043
-        )
-        DeviceEventEmitter.emit(EventTypes.ERROR_ADDED, error)
-      }
-    },
-    [agent, t]
-  )
-
-  const resolveOpenIDPresentationRequest = useCallback(
-    async (uri: string) => {
-      if (!agent) {
-        return
-      }
-      try {
-        const record = await getCredentialsForProofRequest({
-          agent: agent,
-          uri: uri,
-        })
-        return record
-      } 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)
-      }
-    },
-    [agent, t]
-  )
-
-  useEffect(() => {
-    if (!openIDPresentationUri) {
-      return
-    }
-    resolveOpenIDPresentationRequest(openIDPresentationUri).then((value) => {
-      if (value) {
-        setOpenIdRecord(value)
-      }
-    })
-  }, [openIDPresentationUri, resolveOpenIDPresentationRequest])
-
-  useEffect(() => {
-    if (!openIDUri) {
-      return
-    }
-    resolveOpenIDCredential(openIDUri).then((value) => {
-      if (value) {
-        setOpenIdRecord(value)
-      }
-    })
-  }, [openIDUri, resolveOpenIDCredential])
-
-  return openIdRecord
-}