@bifold/core 2.4.6 → 2.5.0

package/src/types/state.ts

@@ -1,97 +0,0 @@
-import { BannerMessage } from '../components/views/Banner'
-
-export interface Onboarding {
-  didSeePreface: boolean
-  didCompleteTutorial: boolean
-  didAgreeToTerms: boolean | string
-  didCreatePIN: boolean
-  didConsiderBiometry: boolean
-  didConsiderPushNotifications: boolean
-  didNameWallet: boolean
-  onboardingVersion: number
-  didCompleteOnboarding: boolean
-}
-
-export interface Migration {
-  didMigrateToAskar: boolean
-}
-
-export interface Preferences {
-  useBiometry: boolean
-  usePushNotifications: boolean
-  biometryPreferencesUpdated: boolean
-  developerModeEnabled: boolean
-  useVerifierCapability?: boolean
-  useConnectionInviterCapability?: boolean
-  useDevVerifierTemplates?: boolean
-  enableWalletNaming: boolean
-  walletName: string
-  acceptDevCredentials: boolean
-  useDataRetention: boolean
-  disableDataRetentionOption?: boolean
-  preventAutoLock: boolean
-  enableShareableLink: boolean
-  alternateContactNames: Record<string, string>
-  autoLockTime: number
-  theme?: string
-  selectedMediator: string
-  availableMediators: string[]
-  bannerMessages: BannerMessage[]
-}
-
-export interface Tours {
-  seenToursPrompt: boolean
-  enableTours: boolean
-  seenHomeTour: boolean
-  seenCredentialsTour: boolean
-  seenCredentialOfferTour: boolean
-  seenProofRequestTour: boolean
-  [key: `seen${string}Tour`]: boolean
-}
-
-export interface Lockout {
-  displayNotification: boolean
-}
-
-export interface LoginAttempt {
-  lockoutDate?: number
-  servedPenalty: boolean
-  loginAttempts: number
-}
-
-export interface Authentication {
-  didAuthenticate: boolean
-}
-
-/**
- * Represents information about latest the
- * available version of the application.
- */
-export type VersionInfo = {
-  needsUpdate: boolean
-  lastChecked?: Date
-  version?: string
-  dismissed?: boolean
-}
-
-export interface State {
-  stateLoaded: boolean
-  onboarding: Onboarding
-  authentication: Authentication
-  lockout: Lockout
-  loginAttempt: LoginAttempt
-  preferences: Preferences
-  tours: Tours
-  deepLink?: string
-  migration: Migration
-  versionInfo: VersionInfo
-}
-
-export type PersistentState = {
-  MigrationState: Migration
-  OnboardingState: Onboarding
-  PreferencesState: Preferences
-  historySettingsOption: boolean // TODO: Migrate to proper name (Caps)
-  language: string // TODO: Migrate to proper name (Caps)
-  Lockout: string
-}

package/src/types/tour.ts

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

@@ -1,18 +0,0 @@
-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/PINValidation.ts

@@ -1,98 +0,0 @@
-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 createPINValidations = (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

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

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

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

@@ -1,33 +0,0 @@
-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)
-}