@bifold/core 1.0.0

package/src/utils/luminance.ts

@@ -0,0 +1,40 @@
+export enum StatusBarStyles {
+  Light = 'light-content',
+  Dark = 'dark-content',
+}
+
+export enum Shade {
+  Light = 'light',
+  Dark = 'dark',
+}
+
+export const luminanceForHexColor = (hex: string): number | undefined => {
+  if (!/^#([A-Fa-f0-9]{6})$/.test(hex)) {
+    return
+  }
+
+  const hexAsNumber = Number(`0x${hex.slice(1)}`)
+  const [r, g, b] = [(hexAsNumber >> 16) & 255, (hexAsNumber >> 8) & 255, hexAsNumber & 255]
+  // Scalars below defined [here](https://en.wikipedia.org/wiki/Relative_luminance)
+  const y = 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+  return Math.round(y)
+}
+
+export const shadeIsLightOrDark = (hex: string): Shade => {
+  const rgbMidPoint = 255 / 2
+  const y = luminanceForHexColor(hex) ?? 0
+
+  return y <= rgbMidPoint ? Shade.Dark : Shade.Light
+}
+
+export const statusBarStyleForColor = (hex: string): StatusBarStyles | undefined => {
+  const rgbMidPoint = 255 / 2
+  const y = luminanceForHexColor(hex)
+
+  if (typeof y === 'undefined') {
+    return
+  }
+
+  return y <= rgbMidPoint ? StatusBarStyles.Light : StatusBarStyles.Dark
+}

package/src/utils/migration.ts

@@ -0,0 +1,40 @@
+import { AskarModule } from '@credo-ts/askar'
+import { Agent, ConsoleLogger, LogLevel } from '@credo-ts/core'
+import { IndySdkToAskarMigrationUpdater } from '@credo-ts/indy-sdk-to-askar-migration'
+import { agentDependencies } from '@credo-ts/react-native'
+import { ariesAskar } from '@hyperledger/aries-askar-react-native'
+import { Platform } from 'react-native'
+import * as RNFS from 'react-native-fs'
+
+export const migrateToAskar = async (walletId: string, key: string, agent?: Agent) => {
+  // The backup file is kept in case anything goes wrong. this will allow us to release patches and still update the
+  // original indy-sdk database in a future version we could manually add a check to remove the old file from storage.
+  const basePath = Platform.OS === 'ios' ? RNFS.DocumentDirectoryPath : RNFS.ExternalDirectoryPath
+  const dbPath = `${basePath}/.indy_client/wallet/${walletId}/sqlite.db`
+  const aAgent =
+    agent ??
+    new Agent({
+      config: {
+        label: 'Aries Bifold',
+        walletConfig: {
+          id: walletId,
+          key,
+        },
+        logger: new ConsoleLogger(LogLevel.trace),
+        autoUpdateStorageOnStartup: false,
+      },
+      modules: {
+        askar: new AskarModule({
+          ariesAskar,
+        }),
+      },
+      dependencies: agentDependencies,
+    })
+
+  const updater = await IndySdkToAskarMigrationUpdater.initialize({
+    dbPath,
+    agent: aAgent,
+  })
+
+  await updater.update()
+}

package/src/utils/network.tsx

@@ -0,0 +1,55 @@
+import TcpSocket from 'react-native-tcp-socket'
+
+import pools from '../configs/ledgers/indy'
+import { GenesisTransaction } from '../types/genesis'
+
+export const canConnectToHost = async (host: { host: string; port: number }): Promise<boolean> =>
+  new Promise((resolve) => {
+    const socketTimeoutInMs = 3000
+    const client = TcpSocket.createConnection(host, () => {
+      resolve(true)
+      client.destroy()
+    })
+
+    // Other events that can be safely be ignored. See the
+    // library for more details:
+    // https://www.npmjs.com/package/react-native-tcp-socket
+
+    client.on('error', () => {
+      client.destroy()
+      resolve(false)
+    })
+
+    client.on('timeout', () => {
+      client.destroy()
+      client.removeAllListeners()
+
+      resolve(false)
+    })
+
+    client.setTimeout(socketTimeoutInMs)
+  })
+
+export const fetchLedgerNodes = (indyNamespace = 'sovrin'): Array<{ host: string; port: number }> => {
+  const [pool] = pools.filter((p) => p.indyNamespace === indyNamespace)
+  if (!pool) {
+    return []
+  }
+
+  const genesisTransactionsAsString = pool.genesisTransactions
+  let genesisTransactions: Array<GenesisTransaction> = []
+
+  if (genesisTransactionsAsString) {
+    try {
+      genesisTransactions = genesisTransactionsAsString.split('\n').map((g) => JSON.parse(g))
+    } catch (error: unknown) {
+      return []
+    }
+  }
+
+  const nodes = genesisTransactions.map((g) => {
+    return { host: g.txn.data.data.client_ip, port: parseInt(g.txn.data.data.client_port) }
+  })
+
+  return nodes
+}

package/src/utils/oca.ts

@@ -0,0 +1,132 @@
+import { CredentialExchangeRecord } from '@credo-ts/core'
+import { AnonCredsProofRequestTemplatePayloadData, CredentialSharedProofData } from '@bifold/verifier'
+import {
+  Attribute,
+  CredentialOverlay,
+  Field,
+  OCABundleResolveAllParams,
+  OCABundleResolverType,
+  Predicate,
+} from '@bifold/oca/build/legacy'
+import { W3cCredentialDisplay } from '../modules/openid/types'
+import { BrandingOverlay } from '@bifold/oca'
+
+export const buildFieldsFromAnonCredsCredential = (credential: CredentialExchangeRecord): Array<Field> => {
+  return credential?.credentialAttributes?.map((attr) => new Attribute(attr)) || []
+}
+
+export const buildFieldsFromW3cCredsCredential = (value: W3cCredentialDisplay): Array<Field> => {
+  return (
+    Object.entries(value.attributes)
+      .filter(([key]) => key !== 'id')
+      .map(([key, value]) => {
+        let formattedValue: string | number | null
+
+        if (typeof value === 'object' && value !== null) {
+          formattedValue = JSON.stringify(value) // Convert object to string
+        } else {
+          formattedValue = value as string | number | null
+        }
+
+        return new Attribute({
+          name: key,
+          value: formattedValue,
+          mimeType: typeof value === 'number' ? 'text/number' : 'text/plain',
+        })
+      }) || []
+  )
+}
+
+export const buildFieldsFromAnonCredsProofRequestTemplate = (
+  data: AnonCredsProofRequestTemplatePayloadData
+): Array<Field> => {
+  const fields = []
+  if (data.requestedAttributes) {
+    for (const item of data.requestedAttributes) {
+      if (item.name) {
+        fields.push(new Attribute({ name: item.name, value: null, ...item }))
+      }
+      if (item.names) {
+        for (const name of item.names) {
+          fields.push(new Attribute({ name, value: null, ...item }))
+        }
+      }
+    }
+  }
+  if (data.requestedPredicates) {
+    for (const item of data.requestedPredicates) {
+      fields.push(
+        new Predicate({
+          pType: item.predicateType,
+          pValue: item.predicateValue,
+          ...item,
+        })
+      )
+    }
+  }
+  return fields
+}
+
+export const buildFieldsFromSharedAnonCredsProof = (data: CredentialSharedProofData): Array<Field> => {
+  const fields = []
+  for (const attribute of data.sharedAttributes) {
+    fields.push(
+      new Attribute({
+        name: attribute.name,
+        value: attribute.value,
+      })
+    )
+  }
+  for (const attributesGroup of data.sharedAttributeGroups) {
+    for (const attribute of attributesGroup.attributes) {
+      fields.push(
+        new Attribute({
+          name: attribute.name,
+          value: attribute.value,
+        })
+      )
+    }
+  }
+  for (const predicate of data.resolvedPredicates) {
+    fields.push(
+      new Predicate({
+        name: predicate.name,
+        pType: predicate.predicateType,
+        pValue: predicate.predicateValue,
+        satisfied: true,
+      })
+    )
+  }
+  return fields
+}
+
+export const buildOverlayFromW3cCredential = async ({
+  credentialDisplay,
+  language,
+  resolver,
+}: {
+  credentialDisplay: W3cCredentialDisplay
+  language: string
+  resolver: OCABundleResolverType
+}): Promise<CredentialOverlay<BrandingOverlay>> => {
+  const params: OCABundleResolveAllParams = {
+    identifiers: {
+      schemaId: '',
+      credentialDefinitionId: credentialDisplay.id,
+    },
+    meta: {
+      alias: credentialDisplay.display.issuer.name,
+      credConnectionId: undefined,
+      credName: credentialDisplay.display.name,
+    },
+    attributes: buildFieldsFromW3cCredsCredential(credentialDisplay),
+    language,
+  }
+
+  const bundle = await resolver.resolveAllBundles(params)
+
+  return {
+    ...(bundle as CredentialOverlay<BrandingOverlay>),
+    presentationFields: buildFieldsFromW3cCredsCredential(credentialDisplay),
+  }
+}

package/src/utils/parsers.tsx

@@ -0,0 +1,111 @@
+export type ParseInvitationResult =
+  | {
+      success: true
+      result: ParsedInvitation
+    }
+  | {
+      success: false
+      error: string
+    }
+
+export type ParsedInvitation = {
+  type: 'didcomm' | 'openid-credential-offer' | 'openid-authorization-request'
+  format: 'url' | 'parsed'
+  data: string | Record<string, unknown>
+}
+
+export enum InvitationQrTypes {
+  OPENID_INITIATE_ISSUANCE = 'openid-initiate-issuance://',
+  OPENID_CREDENTIAL_OFFER = 'openid-credential-offer://',
+  // TODO: I think we should not support openid://, as we mainly support openid4vp
+  // But older requests do use openid:// I think (such as the DIIP dbc login)
+  // but I think we're going to move to just openid4p in the future
+  OPENID = 'openid://',
+  OPENID4VP = 'openid4vp://',
+  OPENID_VC = 'openid-vc://',
+  DIDCOMM = 'didcomm://',
+  HTTPS = 'https://',
+}
+
+export const isOpenIdCredentialOffer = (url: string) => {
+  if (
+    url.startsWith(InvitationQrTypes.OPENID_INITIATE_ISSUANCE) ||
+    url.startsWith(InvitationQrTypes.OPENID_CREDENTIAL_OFFER)
+  ) {
+    return true
+  }
+
+  if (url.includes('credential_offer_uri=') || url.includes('credential_offer=')) {
+    return true
+  }
+
+  return false
+}
+
+export const isOpenIdPresentationRequest = (url: string) => {
+  if (
+    url.startsWith(InvitationQrTypes.OPENID) ||
+    url.startsWith(InvitationQrTypes.OPENID_VC) ||
+    url.startsWith(InvitationQrTypes.OPENID4VP)
+  ) {
+    return true
+  }
+
+  if (url.includes('request_uri=') || url.includes('request=')) {
+    return true
+  }
+
+  return false
+}
+
+export const isDidCommInvitation = (url: string) => {
+  if (url.startsWith(InvitationQrTypes.DIDCOMM)) {
+    return true
+  }
+
+  if (url.includes('c_i=') || url.includes('oob=') || url.includes('oobUrl=') || url.includes('d_m=')) {
+    return true
+  }
+
+  return false
+}
+
+export async function parseInvitationUrl(invitationUrl: string): Promise<ParseInvitationResult> {
+  if (isOpenIdCredentialOffer(invitationUrl)) {
+    return {
+      success: true,
+      result: {
+        format: 'url',
+        type: 'openid-credential-offer',
+        data: invitationUrl,
+      },
+    }
+  }
+
+  if (isOpenIdPresentationRequest(invitationUrl)) {
+    return {
+      success: true,
+      result: {
+        format: 'url',
+        type: 'openid-authorization-request',
+        data: invitationUrl,
+      },
+    }
+  }
+
+  if (isDidCommInvitation(invitationUrl)) {
+    return {
+      success: true,
+      result: {
+        format: 'url',
+        type: 'didcomm',
+        data: invitationUrl,
+      },
+    }
+  }
+
+  return {
+    success: false,
+    error: 'Invitation not recognized.',
+  }
+}

package/src/utils/proofBundle.ts

@@ -0,0 +1,220 @@
+import { AnonCredsProofRequestTemplatePayload, ProofRequestTemplate, getProofRequestTemplates } from '@bifold/verifier'
+import { useState, useEffect } from 'react'
+
+import { TOKENS, useServices } from '../container-api'
+import { templateBundleStorageDirectory, templateCacheDataFileName, templateBundleIndexFileName } from '../constants'
+import { BifoldLogger } from '../services/logger'
+import { FileCache } from './fileCache'
+
+type ProofRequestTemplateFn = (useDevTemplates: boolean) => Array<ProofRequestTemplate>
+
+const calculatePreviousYear = (yearOffset: number) => {
+  const pastDate = new Date()
+  pastDate.setFullYear(pastDate.getFullYear() + yearOffset)
+  return parseInt(pastDate.toISOString().split('T')[0].replace(/-/g, ''))
+}
+
+export const applyTemplateMarkers = (templates: any): any => {
+  if (!templates) {
+    return templates
+  }
+
+  const markerActions: { [key: string]: (param: string) => string } = {
+    now: () => Math.floor(new Date().getTime() / 1000).toString(),
+    currentDate: (offset: string) => calculatePreviousYear(parseInt(offset)).toString(),
+  }
+
+  let templateString = JSON.stringify(templates)
+  // regex to find all markers in the template so we can replace
+  // them with computed values
+  const markers = [...templateString.matchAll(/"@\{(\w+)(?:\((\S*)\))?\}"/gm)]
+
+  markers.forEach((marker) => {
+    const markerValue = markerActions[marker[1] as string](marker[2])
+    templateString = templateString.replace(marker[0], markerValue)
+  })
+
+  return JSON.parse(templateString)
+}
+
+export const applyDevRestrictions = (templates: ProofRequestTemplate[]): ProofRequestTemplate[] => {
+  return templates.map((temp) => {
+    return {
+      ...temp,
+      payload: {
+        ...temp.payload,
+        data: (temp.payload as AnonCredsProofRequestTemplatePayload).data.map((data) => {
+          return {
+            ...data,
+            requestedAttributes: data.requestedAttributes?.map((attr) => {
+              return {
+                ...attr,
+                restrictions: [...(attr.restrictions ?? []), ...(attr.devRestrictions ?? [])],
+                devRestrictions: [],
+              }
+            }),
+            requestedPredicates: data.requestedPredicates?.map((pred) => {
+              return {
+                ...pred,
+                restrictions: [...(pred.restrictions ?? []), ...(pred.devRestrictions ?? [])],
+                devRestrictions: [],
+              }
+            }),
+          }
+        }),
+      },
+    }
+  })
+}
+
+export interface IProofBundleResolver {
+  resolve: (acceptDevRestrictions: boolean) => Promise<ProofRequestTemplate[] | undefined>
+  resolveById: (templateId: string, acceptDevRestrictions: boolean) => Promise<ProofRequestTemplate | undefined>
+}
+
+export const useRemoteProofBundleResolver = (
+  indexFileBaseUrl: string | undefined,
+  log?: BifoldLogger
+): IProofBundleResolver => {
+  const [proofRequestTemplates] = useServices([TOKENS.UTIL_PROOF_TEMPLATE])
+  const [resolver, setResolver] = useState<IProofBundleResolver>(new DefaultProofBundleResolver(proofRequestTemplates))
+
+  useEffect(() => {
+    if (indexFileBaseUrl) {
+      setResolver(new RemoteProofBundleResolver(indexFileBaseUrl, log))
+    } else {
+      setResolver(new DefaultProofBundleResolver(proofRequestTemplates))
+    }
+  }, [log, indexFileBaseUrl, proofRequestTemplates])
+
+  return resolver
+}
+
+export class RemoteProofBundleResolver extends FileCache implements IProofBundleResolver {
+  private templateData: ProofRequestTemplate[] | undefined
+  private cacheDataFileName = templateCacheDataFileName
+
+  public constructor(indexFileBaseUrl: string, log?: BifoldLogger) {
+    super(indexFileBaseUrl, templateBundleStorageDirectory, templateCacheDataFileName, log)
+  }
+
+  public async resolve(acceptDevRestrictions: boolean): Promise<ProofRequestTemplate[] | undefined> {
+    let templateData
+
+    if (!this.templateData) {
+      await this.checkForUpdates()
+    }
+
+    if (!this.templateData) {
+      return []
+    }
+
+    templateData = this.templateData
+
+    if (acceptDevRestrictions) {
+      templateData = applyDevRestrictions(this.templateData)
+    }
+
+    return Promise.resolve(templateData)
+  }
+
+  public async resolveById(
+    templateId: string,
+    acceptDevRestrictions: boolean
+  ): Promise<ProofRequestTemplate | undefined> {
+    let templateData
+
+    if (!this.templateData) {
+      return (await this.resolve(acceptDevRestrictions))?.find((template) => template.id === templateId)
+    }
+
+    templateData = this.templateData
+
+    if (acceptDevRestrictions) {
+      templateData = applyDevRestrictions(templateData)
+    }
+
+    return templateData.find((template) => template.id === templateId)
+  }
+
+  public async checkForUpdates(): Promise<void> {
+    await this.createWorkingDirectoryIfNotExists()
+
+    if (!this.fileEtag) {
+      this.log?.info('Loading cache data')
+
+      const cacheData = await this.loadCacheData()
+      if (cacheData) {
+        this.fileEtag = cacheData.fileEtag
+      }
+    }
+
+    this.log?.info('Loading index now')
+    await this.loadBundleIndex(templateBundleIndexFileName)
+  }
+
+  private loadBundleIndex = async (filePath: string) => {
+    let remoteFetchSucceeded = false
+    try {
+      const response = await this.axiosInstance.get(filePath)
+      const { status } = response
+      const { etag } = response.headers
+
+      if (status !== 200) {
+        this.log?.error(`Failed to fetch remote resource at ${filePath}`)
+
+        throw new Error('Failed to fetch remote resource')
+      }
+
+      if (etag && this.compareWeakEtags(this.fileEtag, etag)) {
+        this.log?.info(`Index file ${filePath} has not changed, etag ${etag}`)
+        // etag is the same, no need to refresh
+        this.templateData = response.data
+
+        return
+      }
+
+      this.fileEtag = etag
+      this.templateData = response.data
+      remoteFetchSucceeded = true
+
+      await this.saveFileToLocalStorage(filePath, JSON.stringify(this.templateData))
+    } catch (error) {
+      this.log?.error(`Failed to fetch remote file index ${filePath}`)
+    }
+
+    if (remoteFetchSucceeded) {
+      return
+    }
+
+    const data = await this.loadFileFromLocalStorage(filePath)
+    if (!data) {
+      this.log?.error(`Failed to load index file ${filePath} from cache`)
+      return
+    }
+
+    this.log?.info(`Using index file ${filePath} from cache`)
+    this.templateData = JSON.parse(data)
+  }
+}
+
+export class DefaultProofBundleResolver implements IProofBundleResolver {
+  private proofRequestTemplates
+
+  public constructor(proofRequestTemplates: ProofRequestTemplateFn | undefined) {
+    this.proofRequestTemplates = proofRequestTemplates ?? getProofRequestTemplates
+  }
+
+  public async resolve(acceptDevRestrictions: boolean): Promise<ProofRequestTemplate[]> {
+    return Promise.resolve(this.proofRequestTemplates(acceptDevRestrictions))
+  }
+
+  public async resolveById(
+    templateId: string,
+    acceptDevRestrictions: boolean
+  ): Promise<ProofRequestTemplate | undefined> {
+    return Promise.resolve(
+      this.proofRequestTemplates(acceptDevRestrictions).find((template) => template.id === templateId)
+    )
+  }
+}

package/src/utils/schema.ts

@@ -0,0 +1,28 @@
+import { AnonCredsCredentialMetadataKey } from '@credo-ts/anoncreds'
+import { CredentialExchangeRecord as CredentialRecord } from '@credo-ts/core'
+
+export function parseSchemaFromId(schemaId?: string): { name: string; version: string } {
+  let name = 'Credential'
+  let version = ''
+  if (schemaId) {
+    const schemaIdRegex = /(.*?):([0-9]):([a-zA-Z .\-_0-9]+):([a-z0-9._-]+)$/
+    const schemaIdParts = schemaId.match(schemaIdRegex)
+    if (schemaIdParts?.length === 5) {
+      name = `${schemaIdParts?.[3].replace(/_|-/g, ' ')}`
+        .split(' ')
+        .map((schemaIdPart) => schemaIdPart.charAt(0).toUpperCase() + schemaIdPart.substring(1))
+        .join(' ')
+      version = schemaIdParts?.[4]
+    }
+  }
+
+  return { name, version }
+}
+
+export function credentialSchema(credential: CredentialRecord): string | undefined {
+  return credential.metadata?.get(AnonCredsCredentialMetadataKey)?.schemaId
+}
+
+export function parsedSchema(credential: CredentialRecord): { name: string; version: string } {
+  return parseSchemaFromId(credentialSchema(credential))
+}

package/src/utils/testable.ts

@@ -0,0 +1,17 @@
+import { testIdPrefix } from '../constants'
+
+export const testIdWithKey = (key: string): string => {
+  return `${testIdPrefix}${key}`
+}
+
+export const testIdForAccessabilityLabel = (label: string) => {
+  if (!label) {
+    return ''
+  }
+
+  return label
+    .split(' ')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ')
+    .replace(/\s/g, '')
+}