@bifold/core 1.0.0

package/src/types/tour.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react'
+
+/**
+ * Makes the target optional. I.e, it can be the target type or `undefined`.
+ */
+export type Optional<T> = T | undefined
+
+/**
+ * An alias of what a React child looks when passed as function.
+ */
+export type ChildFn<T> = (value: T) => ReactNode
+
+export enum BaseTourID {
+  HomeTour = 'homeTourSteps',
+  CredentialsTour = 'credentialsTourSteps',
+  CredentialOfferTour = 'credentialOfferTourSteps',
+  ProofRequestTour = 'proofRequestTourSteps',
+}
+
+export type TourID = `${string}TourSteps`

package/src/types/version-check.ts

@@ -0,0 +1,18 @@
+import { VersionInfo } from './state'
+
+/**
+ * Interface defining the version check service capabilities
+ */
+export interface IVersionCheckService {
+  /**
+   * The date when the version was last checked
+   */
+  readonly lastChecked: Date | undefined
+
+  /**
+   * Checks if an update is available for the application
+   * @param forceCheck If true, checks for update regardless of when last check occurred
+   * @returns Current version information
+   */
+  checkForUpdate(forceCheck?: boolean): Promise<VersionInfo | undefined>
+}

package/src/utils/PINCreationValidation.ts

@@ -0,0 +1,98 @@
+import { PINValidationRules } from '../types/security'
+
+const consecutiveSeriesOfThree = new RegExp(/012|123|234|345|456|567|678|789|987|876|765|654|543|432|321|210/)
+const evenNumberSeries = new RegExp('(13579)')
+const oddNumberSeries = new RegExp('(02468)')
+const isNumber = new RegExp('^[0-9]+$')
+const crossNumberPattern = ['159753', '159357', '951357', '951753', '357159', '357951', '753159', '753951']
+
+export enum PINError {
+  CrossPatternValidation = 'CrossPatternValidation',
+  OddOrEvenSequenceValidation = 'OddOrEvenSequenceValidation',
+  NoRepetitionOfTheSameNumbersValidation = 'NoRepetitionOfTheSameNumbersValidation',
+  MaxAdjacentNumberRepetitionValidation = 'MaxAdjacentNumberRepetitionValidation',
+  NoRepetitionOfTheTwoSameNumbersValidation = 'NoRepetitionOfTheTwoSameNumbersValidation',
+  NoSeriesOfNumbersValidation = 'NoSeriesOfNumbersValidation',
+  PINOnlyContainDigitsValidation = 'PINOnlyContainDigitsValidation',
+  PINTooShortValidation = 'PINTooShortValidation',
+  PINTooLongValidation = 'PINTooLongValidation',
+  PINIsExpectedLength = 'PINExpectedLengthValidation',
+}
+
+export interface PINValidationsType {
+  isInvalid: boolean
+  errorName: PINError
+  errorTextAddition?: Record<string, string>
+}
+
+export const PINCreationValidations = (PIN: string, PINRules: PINValidationRules) => {
+  const PINValidations: PINValidationsType[] = []
+
+  if (PINRules.no_cross_pattern) {
+    PINValidations.push({
+      isInvalid: crossNumberPattern.includes(PIN),
+      errorName: PINError.CrossPatternValidation,
+    } as PINValidationsType)
+  }
+  if (PINRules.no_even_or_odd_series_of_numbers) {
+    PINValidations.push({
+      isInvalid: evenNumberSeries.test(PIN) || oddNumberSeries.test(PIN),
+      errorName: PINError.OddOrEvenSequenceValidation,
+    } as PINValidationsType)
+  }
+
+  if (1 == PINRules.no_repeated_numbers) {
+    const repetitionPattern = new RegExp(/(\d)\1{1,}/)
+    PINValidations.push({
+      isInvalid: repetitionPattern.test(PIN),
+      errorName: PINError.NoRepetitionOfTheSameNumbersValidation,
+    } as PINValidationsType)
+  } else if (1 < PINRules.no_repeated_numbers) {
+    const repetitionPattern = new RegExp(String.raw`(\d)\1{${PINRules.no_repeated_numbers},}`, 'g')
+    PINValidations.push({
+      isInvalid: repetitionPattern.test(PIN),
+      errorName: PINError.MaxAdjacentNumberRepetitionValidation,
+    } as PINValidationsType)
+  }
+
+  if (PINRules.no_repetition_of_the_two_same_numbers) {
+    let noRepetitionOfTheTwoSameNumbers = new RegExp(/([0-9][0-9])\1{1,}/)
+    if (typeof PINRules.no_repetition_of_the_two_same_numbers === 'number') {
+      noRepetitionOfTheTwoSameNumbers = new RegExp(
+        `([0-9][0-9])\\1{${PINRules.no_repetition_of_the_two_same_numbers - 1},}`
+      )
+    }
+    PINValidations.push({
+      isInvalid: noRepetitionOfTheTwoSameNumbers.test(PIN),
+      errorName: PINError.NoRepetitionOfTheTwoSameNumbersValidation,
+    } as PINValidationsType)
+  }
+
+  if (PINRules.no_series_of_numbers) {
+    PINValidations.push({
+      isInvalid: consecutiveSeriesOfThree.test(PIN),
+      errorName: PINError.NoSeriesOfNumbersValidation,
+    } as PINValidationsType)
+  }
+  if (PINRules.only_numbers) {
+    PINValidations.push({
+      isInvalid: !isNumber.test(PIN),
+      errorName: PINError.PINOnlyContainDigitsValidation,
+    } as PINValidationsType)
+  }
+  PINValidations.push({
+    isInvalid: PIN.length < PINRules.min_length || PIN.length > PINRules.max_length,
+    errorName:
+      PINRules.min_length === PINRules.max_length
+        ? PINError.PINIsExpectedLength
+        : PIN.length <= PINRules.max_length
+        ? PINError.PINTooShortValidation
+        : PINError.PINTooLongValidation,
+    errorTextAddition:
+      PINRules.min_length === PINRules.max_length
+        ? { num: `${PINRules.min_length}` }
+        : { num: PIN.length <= PINRules.max_length ? `${PINRules.min_length - 1}` : `${PINRules.max_length + 1}` },
+  } as PINValidationsType)
+
+  return PINValidations
+}

package/src/utils/agent.ts

@@ -0,0 +1,129 @@
+import {
+  AnonCredsCredentialFormatService,
+  AnonCredsModule,
+  AnonCredsProofFormatService,
+  DataIntegrityCredentialFormatService,
+  LegacyIndyCredentialFormatService,
+  LegacyIndyProofFormatService,
+  V1CredentialProtocol,
+  V1ProofProtocol,
+} from '@credo-ts/anoncreds'
+import { AskarModule } from '@credo-ts/askar'
+import {
+  Agent,
+  AutoAcceptCredential,
+  AutoAcceptProof,
+  ConnectionsModule,
+  CredentialsModule,
+  DifPresentationExchangeProofFormatService,
+  MediationRecipientModule,
+  MediatorPickupStrategy,
+  ProofsModule,
+  V2CredentialProtocol,
+  V2ProofProtocol,
+} from '@credo-ts/core'
+import { IndyVdrAnonCredsRegistry, IndyVdrModule, IndyVdrPoolConfig } from '@credo-ts/indy-vdr'
+import { OpenId4VcHolderModule } from '@credo-ts/openid4vc'
+import { PushNotificationsApnsModule, PushNotificationsFcmModule } from '@credo-ts/push-notifications'
+import { useAgent } from '@credo-ts/react-hooks'
+import { anoncreds } from '@hyperledger/anoncreds-react-native'
+import { ariesAskar } from '@hyperledger/aries-askar-react-native'
+import { indyVdr } from '@hyperledger/indy-vdr-react-native'
+
+interface GetAgentModulesOptions {
+  indyNetworks: IndyVdrPoolConfig[]
+  mediatorInvitationUrl?: string
+  txnCache?: { capacity: number; expiryOffsetMs: number; path?: string }
+}
+
+export type BifoldAgent = Agent<ReturnType<typeof getAgentModules>>
+
+/**
+ * Constructs the modules to be used in the agent setup
+ * @param indyNetworks
+ * @param mediatorInvitationUrl determine which mediator to use
+ * @param txnCache optional local cache config for indyvdr
+ * @returns modules to be used in agent setup
+ */
+export function getAgentModules({ indyNetworks, mediatorInvitationUrl, txnCache }: GetAgentModulesOptions) {
+  const indyCredentialFormat = new LegacyIndyCredentialFormatService()
+  const indyProofFormat = new LegacyIndyProofFormatService()
+
+  if (txnCache) {
+    indyVdr.setLedgerTxnCache({
+      capacity: txnCache.capacity,
+      expiry_offset_ms: txnCache.expiryOffsetMs,
+      path: txnCache.path,
+    })
+  }
+
+  return {
+    askar: new AskarModule({
+      ariesAskar,
+    }),
+    anoncreds: new AnonCredsModule({
+      anoncreds,
+      registries: [new IndyVdrAnonCredsRegistry()],
+    }),
+    indyVdr: new IndyVdrModule({
+      indyVdr,
+      networks: indyNetworks as [IndyVdrPoolConfig],
+    }),
+    connections: new ConnectionsModule({
+      autoAcceptConnections: true,
+    }),
+    credentials: new CredentialsModule({
+      autoAcceptCredentials: AutoAcceptCredential.ContentApproved,
+      credentialProtocols: [
+        new V1CredentialProtocol({ indyCredentialFormat }),
+        new V2CredentialProtocol({
+          credentialFormats: [
+            indyCredentialFormat,
+            new AnonCredsCredentialFormatService(),
+            new DataIntegrityCredentialFormatService(),
+          ],
+        }),
+      ],
+    }),
+    proofs: new ProofsModule({
+      autoAcceptProofs: AutoAcceptProof.ContentApproved,
+      proofProtocols: [
+        new V1ProofProtocol({ indyProofFormat }),
+        new V2ProofProtocol({
+          proofFormats: [
+            indyProofFormat,
+            new AnonCredsProofFormatService(),
+            new DifPresentationExchangeProofFormatService(),
+          ],
+        }),
+      ],
+    }),
+    mediationRecipient: new MediationRecipientModule({
+      mediatorInvitationUrl: mediatorInvitationUrl,
+      mediatorPickupStrategy: MediatorPickupStrategy.Implicit,
+    }),
+    pushNotificationsFcm: new PushNotificationsFcmModule(),
+    pushNotificationsApns: new PushNotificationsApnsModule(),
+    openId4VcHolder: new OpenId4VcHolderModule(),
+  }
+}
+
+interface MyAgentContextInterface {
+  loading: boolean
+  agent?: BifoldAgent
+  setAgent: (agent?: BifoldAgent) => void
+}
+
+export const useAppAgent = useAgent as () => MyAgentContextInterface
+
+export const createLinkSecretIfRequired = async (agent: Agent) => {
+  // If we don't have any link secrets yet, we will create a
+  // default link secret that will be used for all anoncreds
+  // credential requests.
+  const linkSecretIds = await agent.modules.anoncreds.getLinkSecretIds()
+  if (linkSecretIds.length === 0) {
+    await agent.modules.anoncreds.createLinkSecret({
+      setAsDefault: true,
+    })
+  }
+}

package/src/utils/anonCredsProofRequestMapper.ts

@@ -0,0 +1,205 @@
+import {
+  AnonCredsCredentialTags,
+  AnonCredsCredentialsForProofRequest,
+  AnonCredsProofRequest,
+  AnonCredsProofRequestRestriction,
+  AnonCredsRequestedAttribute,
+  AnonCredsRequestedPredicate,
+  getAnonCredsTagsFromRecord,
+} from '@credo-ts/anoncreds'
+import {
+  ClaimFormat,
+  DifPexCredentialsForRequest,
+  DifPresentationExchangeDefinition,
+  DifPresentationExchangeDefinitionV2,
+  W3cCredentialRecord,
+} from '@credo-ts/core'
+
+import { ProofCredentialAttributes, ProofCredentialPredicates } from '../types/proof-items'
+
+export type RecordWithMetadata = {
+  record: W3cCredentialRecord
+  anonCredsTags: AnonCredsCredentialTags
+}
+export type DescriptorMetadata = { [key: string]: RecordWithMetadata[] }
+
+export interface DifPexAnonCredsProofRequest extends AnonCredsProofRequest {
+  requested_attributes: Record<string, AnonCredsRequestedAttribute & { descriptorId?: string }>
+  requested_predicates: Record<string, AnonCredsRequestedPredicate & { descriptorId?: string }>
+}
+
+type FieldV2 = NonNullable<
+  DifPresentationExchangeDefinitionV2['input_descriptors'][number]['constraints']['fields']
+>[number]
+
+const getPredicateTypeAndValues = (predicateFilter: NonNullable<FieldV2['filter']>) => {
+  const predicates: {
+    predicateType: AnonCredsRequestedPredicate['p_type']
+    predicateValue: AnonCredsRequestedPredicate['p_value']
+  }[] = []
+
+  const supportedJsonSchemaNumericRangeProperties: Record<string, AnonCredsRequestedPredicate['p_type']> = {
+    exclusiveMinimum: '>',
+    exclusiveMaximum: '<',
+    minimum: '>=',
+    maximum: '<=',
+  }
+
+  for (const [key, value] of Object.entries(predicateFilter)) {
+    if (key === 'type') continue
+
+    const predicateType = supportedJsonSchemaNumericRangeProperties[key]
+    if (!predicateType) throw new Error(`Unsupported predicate filter property '${key}'`)
+    predicates.push({ predicateType, predicateValue: value })
+  }
+
+  return predicates
+}
+
+const getClaimNameForField = (field: FieldV2) => {
+  if (!field.path) throw new Error('Field path is required')
+  const baseClaimPath = '$.credentialSubject.'
+  const claimPaths = field.path.filter((path) => path.startsWith(baseClaimPath))
+  if (claimPaths.length === 0) return undefined
+
+  const claimNames = claimPaths.map((path) => path.slice(baseClaimPath.length))
+  const propertyName = claimNames[0]
+
+  return propertyName
+}
+
+export type ProcessedAttributes = { [key: string]: ProofCredentialAttributes }
+export type ProcessedPredicates = { [key: string]: ProofCredentialPredicates }
+
+export const createAnonCredsProofRequest = (
+  presentationDefinition: DifPresentationExchangeDefinition,
+  descriptorMetadata: DescriptorMetadata
+) => {
+  const anonCredsProofRequest: DifPexAnonCredsProofRequest = {
+    version: '1.0',
+    name: presentationDefinition.name ?? 'Proof request',
+    nonce: 'nonce',
+    requested_attributes: {},
+    requested_predicates: {},
+  }
+
+  const nonRevokedTime = Math.floor(Date.now() / 1000)
+  const nonRevokedInterval = { from: nonRevokedTime, to: nonRevokedTime }
+
+  for (const descriptor of presentationDefinition.input_descriptors) {
+    const referent = descriptor.id
+    let predicateReferentIndex = 0
+
+    const fields = descriptor.constraints?.fields
+    if (!fields) throw new Error('Unclear mapping of constraint with no fields.')
+
+    // Setting `requiresRevocationStatus` 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.
+    const requiresRevocationStatus = false
+
+    const credentialMeta = descriptorMetadata[descriptor.id]
+    const restrictions: AnonCredsProofRequestRestriction[] = credentialMeta.map((credentialMeta) => {
+      return {
+        cred_def_id: credentialMeta.anonCredsTags.anonCredsCredentialDefinitionId,
+        schema_id: credentialMeta.anonCredsTags.anonCredsSchemaId,
+      }
+    })
+
+    for (const field of fields) {
+      const propertyName = getClaimNameForField(field)
+      if (!propertyName) continue
+
+      if (field.predicate) {
+        if (!field.filter) throw new Error('Missing required predicate filter property.')
+        const predicateTypeAndValues = getPredicateTypeAndValues(field.filter)
+        for (const { predicateType, predicateValue } of predicateTypeAndValues) {
+          const predicateReferent = `${referent}_${predicateReferentIndex++}`
+          anonCredsProofRequest.requested_predicates[predicateReferent] = {
+            name: propertyName,
+            p_type: predicateType,
+            p_value: predicateValue,
+            restrictions,
+            non_revoked: requiresRevocationStatus ? nonRevokedInterval : undefined,
+            descriptorId: descriptor.id,
+          }
+        }
+      } else {
+        if (!anonCredsProofRequest.requested_attributes[referent]) {
+          anonCredsProofRequest.requested_attributes[referent] = {
+            names: [propertyName],
+            restrictions,
+            non_revoked: requiresRevocationStatus ? nonRevokedInterval : undefined,
+            descriptorId: descriptor.id,
+          }
+        } else {
+          const names = anonCredsProofRequest.requested_attributes[referent].names ?? []
+          anonCredsProofRequest.requested_attributes[referent].names = [...names, propertyName]
+        }
+      }
+    }
+  }
+
+  return anonCredsProofRequest
+}
+
+export const getDescriptorMetadata = (credentialsForRequest: DifPexCredentialsForRequest) => {
+  const descriptorMetadata: DescriptorMetadata = {}
+
+  for (const requestedAttribute of Object.values(credentialsForRequest.requirements)) {
+    for (const entry of requestedAttribute.submissionEntry) {
+      const inputDescriptorId = entry.inputDescriptorId
+
+      const recordsWithMetadata = entry.verifiableCredentials.map((submissionEntryCredential) => {
+        if (submissionEntryCredential.type !== ClaimFormat.LdpVc) {
+          throw new Error(`Unsupported credential type. ${submissionEntryCredential.type}`)
+        }
+        const record = submissionEntryCredential.credentialRecord
+        const anonCredsTags = getAnonCredsTagsFromRecord(record as W3cCredentialRecord)
+        if (!anonCredsTags) throw new Error('Missing AnonCreds tags from credential record')
+        return { record, anonCredsTags }
+      })
+
+      if (!descriptorMetadata[inputDescriptorId]) descriptorMetadata[inputDescriptorId] = []
+
+      for (const recordWithMetadata of recordsWithMetadata) {
+        if (!descriptorMetadata[inputDescriptorId].find((item) => item.record.id === recordWithMetadata.record.id)) {
+          descriptorMetadata[inputDescriptorId].push(recordWithMetadata)
+        }
+      }
+    }
+  }
+
+  return descriptorMetadata
+}
+
+/**
+ * The matches returned by our artificial anonCredsProofRequest could contain matches,
+ * which are not valid thus we need to filter them out
+ */
+export const filterInvalidProofRequestMatches = (
+  anonCredsCredentialsForRequest: AnonCredsCredentialsForProofRequest,
+  descriptorMetadata: DescriptorMetadata
+) => {
+  anonCredsCredentialsForRequest.attributes = Object.fromEntries(
+    Object.entries(anonCredsCredentialsForRequest.attributes).map(([referent, matches]) => {
+      const descriptorMeta = descriptorMetadata[referent]
+      const validCredentialsForReferent = descriptorMeta.map((meta) => meta.record.id)
+      const validMatches = matches.filter((match) => validCredentialsForReferent.includes(match.credentialId))
+      return [referent, validMatches]
+    })
+  )
+
+  anonCredsCredentialsForRequest.predicates = Object.fromEntries(
+    Object.entries(anonCredsCredentialsForRequest.predicates).map(([_referent, matches]) => {
+      const referent = _referent.split('_').slice(0, -1).join('_')
+      const descriptorMeta = descriptorMetadata[referent]
+      const validCredentialsForReferent = descriptorMeta.map((meta) => meta.record.id)
+      const validMatches = matches.filter((match) => validCredentialsForReferent.includes(match.credentialId))
+      return [_referent, validMatches]
+    })
+  )
+
+  return anonCredsCredentialsForRequest
+}

package/src/utils/contacts.ts

@@ -0,0 +1,59 @@
+import { BasicMessageRecord, ConnectionRecord, CredentialExchangeRecord, ProofExchangeRecord } from '@credo-ts/core'
+
+import { BifoldAgent } from './agent'
+
+interface ConnectionWithMessages {
+  conn: ConnectionRecord
+  msgs: (BasicMessageRecord | CredentialExchangeRecord | ProofExchangeRecord)[]
+}
+
+interface ConnectionWithLatestMessage {
+  conn: ConnectionRecord
+  latestMsg: BasicMessageRecord | CredentialExchangeRecord | ProofExchangeRecord
+}
+
+/**
+ * Function to fetch contacts (connections) in order of latest chat message without using hooks
+ * @param agent - Credo agent
+ * @returns ConnectionRecord[] sorted by most recent message
+ */
+export const fetchContactsByLatestMessage = async (
+  agent: BifoldAgent,
+  connections: ConnectionRecord[]
+): Promise<ConnectionRecord[]> => {
+  const connectionsWithMessages = await Promise.all<ConnectionWithMessages>(
+    connections.map(
+      async (conn: ConnectionRecord): Promise<ConnectionWithMessages> => ({
+        conn,
+        msgs: [
+          ...(await agent.basicMessages.findAllByQuery({ connectionId: conn.id })),
+          ...(await agent.proofs.findAllByQuery({ connectionId: conn.id })),
+          ...(await agent.credentials.findAllByQuery({ connectionId: conn.id })),
+        ],
+      })
+    )
+  )
+
+  const connectionsWithLatestMessage: ConnectionWithLatestMessage[] = connectionsWithMessages.map((pair) => {
+    return {
+      conn: pair.conn,
+      latestMsg: pair.msgs.reduce(
+        (acc, cur) => {
+          const accDate = acc.updatedAt || acc.createdAt
+          const curDate = cur.updatedAt || cur.createdAt
+          return accDate > curDate ? acc : cur
+        },
+        // Initial value if no messages exist for this connection is a placeholder with the date the connection was created
+        { createdAt: pair.conn.createdAt } as BasicMessageRecord | CredentialExchangeRecord | ProofExchangeRecord
+      ),
+    }
+  })
+
+  return connectionsWithLatestMessage
+    .sort(
+      (a, b) =>
+        new Date(b.latestMsg.updatedAt || b.latestMsg.createdAt).valueOf() -
+        new Date(a.latestMsg.updatedAt || a.latestMsg.createdAt).valueOf()
+    )
+    .map((pair) => pair.conn)
+}

package/src/utils/cred-def.ts

@@ -0,0 +1,33 @@
+import { AnonCredsCredentialMetadataKey, parseIndyCredentialDefinitionId, parseIndySchemaId } from '@credo-ts/anoncreds'
+import { CredentialExchangeRecord as CredentialRecord } from '@credo-ts/core'
+
+import { credentialSchema } from './schema'
+
+export function parseCredDefFromId(credDefId?: string, schemaId?: string): string {
+  let name = 'Credential'
+  if (credDefId) {
+    const parseIndyCredDefId = parseIndyCredentialDefinitionId(credDefId)
+    name = parseIndyCredDefId.tag
+  }
+  if (name.toLocaleLowerCase() === 'default' || name.toLowerCase() === 'credential') {
+    if (schemaId) {
+      const parseIndySchema = parseIndySchemaId(schemaId)
+      name = parseIndySchema.schemaName
+    } else {
+      name = 'Credential'
+    }
+  }
+  return name
+}
+
+function credentialDefinition(credential: CredentialRecord): string | undefined {
+  return credential.metadata.get(AnonCredsCredentialMetadataKey)?.credentialDefinitionId
+}
+
+export function parsedCredDefNameFromCredential(credential: CredentialRecord): string {
+  return parseCredDefFromId(credentialDefinition(credential), credentialSchema(credential))
+}
+
+export function parsedCredDefName(credentialDefinitionId: string, schemaId: string): string {
+  return parseCredDefFromId(credentialDefinitionId, schemaId)
+}

package/src/utils/credential.ts

@@ -0,0 +1,37 @@
+import { AnonCredsCredentialMetadataKey } from '@credo-ts/anoncreds'
+import { CredentialExchangeRecord, CredentialState } from '@credo-ts/core'
+import { ImageSourcePropType } from 'react-native'
+
+import { luminanceForHexColor } from './luminance'
+
+export const isValidAnonCredsCredential = (credential: CredentialExchangeRecord) => {
+  return (
+    credential &&
+    (credential.state === CredentialState.OfferReceived ||
+      (Boolean(credential.metadata.get(AnonCredsCredentialMetadataKey)) &&
+        credential.credentials.find((c) => c.credentialRecordType === 'anoncreds' || c.credentialRecordType === 'w3c')))
+  )
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const credentialTextColor = (ColorPallet: any, hex?: string) => {
+  const midpoint = 255 / 2
+  if ((luminanceForHexColor(hex ?? '') ?? 0) >= midpoint) {
+    return ColorPallet.grayscale.darkGrey
+  }
+  return ColorPallet.grayscale.white
+}
+
+export const toImageSource = (source: unknown): ImageSourcePropType => {
+  if (typeof source === 'string') {
+    return { uri: source as string }
+  }
+  return source as ImageSourcePropType
+}
+
+export const getCredentialIdentifiers = (credential: CredentialExchangeRecord) => {
+  return {
+    credentialDefinitionId: credential.metadata.get(AnonCredsCredentialMetadataKey)?.credentialDefinitionId,
+    schemaId: credential.metadata.get(AnonCredsCredentialMetadataKey)?.schemaId,
+  }
+}

package/src/utils/crypto.ts

@@ -0,0 +1,12 @@
+import argon2 from 'react-native-argon2'
+
+export const hashPIN = async (PIN: string, salt: string): Promise<string> => {
+  try {
+    const result = await argon2(PIN, salt, {})
+    const { rawHash } = result
+
+    return rawHash
+  } catch (error) {
+    throw new Error(`Error generating hash for PIN ${String((error as Error)?.message ?? error)}`)
+  }
+}