@bifold/core 2.4.5 → 2.5.0

package/src/utils/ledger.ts

@@ -1,212 +0,0 @@
-import { IndyVdrPoolConfig } from '@credo-ts/indy-vdr'
-import axios from 'axios'
-
-const INDY_NETWORK_URL =
-  'https://raw.githubusercontent.com/hyperledger/indy-node-monitor/main/fetch-validator-status/networks.json'
-
-const ERROR_TAG = 'LEDGER ERROR'
-
-export enum IndyLedger {
-  SOVRIN_BUILDER_NET = 'sbn',
-  SOVRIN_STAGING_NET = 'ssn',
-  SOVERIN_MAIN_NET = 'smn',
-  LOCAL_VON_NETWORK = 'vn',
-  LINUX_LOCAL_VON_NETWORK = 'lln',
-  BCOVRIN_DEV = 'bcd',
-  BCOVRIN_TEST = 'bct',
-  BCOVRIN = 'bcp',
-  GREENLIGHT_DEV_LEDGER = 'gld',
-  INDICO_MAINNET = 'imn',
-  INDICO_DEMONET = 'idn',
-  INDICO_TESTNET = 'itn',
-  CANDY_DEV_NETWORK = 'cdn',
-  CANDY_TEST_NETWORK = 'ctn',
-  CANDY_PRODUCTION_NETWORK = 'cpn',
-}
-
-export interface IndyLedgerConfig {
-  ledgerId: IndyLedger
-  isProduction: boolean
-  doNotConnectOnStartup?: true
-}
-
-export interface IndyLedgerJSON extends IndyVdrPoolConfig {
-  // A human-readable identifier for the ledger, useful for identifing the ledger in the JSON file.
-  // Note: This value will not be used downstream as the IndyVdrPoolConfig interface will exclude it.
-  id: string
-}
-
-export type IndyLedgersRecord = Record<
-  IndyLedger,
-  {
-    name: string
-    indyNamespace: string
-    genesisUrl: string
-  }
->
-
-// This interface allows us to abstract the file system operations,
-// preventing android from complaining about the use of the Node.js module 'fs'.
-export interface IndyLedgerFileSystem {
-  /**
-   * Writes data to a file at the specified file path.
-   *
-   * @param {string} filePath - The path to the file where data should be written.
-   * @param {*} {string} data - The data to write to the file.
-   * @returns {*} {void}
-   */
-  writeFile: (filePath: string, data: string) => void
-  /**
-   * Reads and returns the content of a file at the specified file path.
-   *
-   * @param {string} filePath - The path to the file to read.
-   * @returns {*} {string} - The content of the file as a string.
-   */
-  readFile: (filePath: string) => string
-  /**
-   * Checks if a file exists at the specified file path.
-   *
-   * @param {string} filePath - The path to the file to check.
-   * @returns {*} {boolean} - True if the file exists, false otherwise.
-   */
-  fileExists: (filePath: string) => boolean
-  /**
-   * Resolves and returns the absolute path for a given file path.
-   *
-   * @example ./ledgers.json -> /Users/username/project/ledgers.json
-   *
-   * @param {string} filePath - The file path to resolve.
-   * @returns {*} {string} - The resolved absolute file path.
-   */
-  pathResolve: (filePath: string) => string
-}
-
-/**
- * Fetches the content from a given URL and returns it as a Promise.
- *
- * @throws {Error} - Throws an error if the fetch operation fails.
- * @template T - The type of content expected from the URL.
- * @param {string} url - The URL to fetch content from.
- * @returns {*} {Promise<T>} - A promise that resolves to the content fetched from the URL
- */
-export async function _fetchUrlContent<T>(url: string): Promise<T> {
-  try {
-    const response = await axios.get<T>(url)
-    return response.data
-  } catch (error: any) {
-    throw new Error(`${ERROR_TAG}: Failed to fetch content from URL ${url}: ${error.message}`)
-  }
-}
-
-/**
- * Fetches and returns a list of Indy ledgers based on the provided configurations.
- *
- * @throws {Error} - Throws an error if a ledgerConfig is not found in the IndyLedgersRecord.
- * @param {IndyLedgerConfig[]} indyLedgerConfigs - The list of supported Indy ledger configurations.
- * @returns {*} {Promise<IndyLedgerJSON[]>} - A promise that resolves to an array of ledgers.
- */
-export async function getIndyLedgers(indyLedgerConfigs: IndyLedgerConfig[]): Promise<IndyLedgerJSON[]> {
-  if (!indyLedgerConfigs.length) {
-    return []
-  }
-
-  const allIndyLedgers = await _fetchUrlContent<IndyLedgersRecord>(INDY_NETWORK_URL)
-
-  const ledgers: IndyLedgerJSON[] = []
-  // Iterate through the supported network configs and map them to the Indy ledgers
-  for (const ledgerConfig of indyLedgerConfigs) {
-    const indyLedger = allIndyLedgers[ledgerConfig.ledgerId]
-
-    if (!indyLedger) {
-      throw new Error(`${ERROR_TAG}: Ledger config for ${ledgerConfig.ledgerId} not found`)
-    }
-
-    const ledgerId = indyLedger.name
-      .split(' ')
-      .filter((word) => !/\W+/im.test(word))
-      .join('')
-
-    ledgers.push({
-      id: ledgerId,
-      indyNamespace: indyLedger.indyNamespace,
-      isProduction: ledgerConfig.isProduction,
-      connectOnStartup: !ledgerConfig.doNotConnectOnStartup,
-      // This url will need to be fetched to get the genesis transactions
-      genesisTransactions: indyLedger.genesisUrl,
-    })
-  }
-
-  // Step 1: Collect all genesis transaction promises
-  const genesisPromises = ledgers.map((ledger) => _fetchUrlContent<string>(ledger.genesisTransactions))
-
-  // Step 2: Await all promises to resolve in parallel
-  const genesisTransactions = await Promise.all(genesisPromises)
-
-  // Step 3: Assign the fetched genesis transactions back to the ledgers
-  genesisTransactions.forEach((transactions, index) => {
-    ledgers[index].genesisTransactions = transactions.trim()
-  })
-
-  return ledgers
-}
-
-/**
- * Writes the provided Indy ledgers to a JSON file at the specified file path.
- *
- * @throws {Error} - Throws an error if writing to the file fails or if the file path is invalid.
- * @param {IndyLedgerFileSystem} fileSystem - The file system interface to use for writing the file.
- * @param {string} filePath - The path to the JSON file where the ledgers should be written.
- * @param {IndyLedgerJSON[]} ledgers - The array of Indy ledgers to write to the file.
- * @returns {*} {void}
- */
-export function writeIndyLedgersToFile(
-  fileSystem: IndyLedgerFileSystem,
-  filePath: string,
-  ledgers: IndyLedgerJSON[]
-): void {
-  try {
-    if (!filePath.endsWith('.json')) {
-      throw new Error('File path must point to a JSON file')
-    }
-
-    // Skip writing to file if the new ledgers are the same
-    if (
-      fileSystem.fileExists(filePath) &&
-      JSON.stringify(readIndyLedgersFromFile(fileSystem, filePath)) === JSON.stringify(ledgers)
-    ) {
-      return
-    }
-
-    const jsonContent = JSON.stringify(ledgers, null, 2)
-
-    // Convert to absolute path ie: ./ledgers.json -> /Users/username/project/ledgers.json
-    const absoluteFilePath = fileSystem.pathResolve(filePath)
-    fileSystem.writeFile(absoluteFilePath, jsonContent)
-  } catch (error: any) {
-    throw new Error(`${ERROR_TAG}: Failed to write ledgers to file ${filePath}: ${error.message}`)
-  }
-}
-
-/**
- * Reads and parses Indy ledgers from a JSON file at the specified file path.
- *
- * @throws {Error} - Throws an error if reading from the file fails, if the file path is invalid, or if parsing fails.
- * @param {IndyLedgerFileSystem} fileSystem - The file system interface to use for reading the file.
- * @param {string} filePath - The path to the JSON file to read the ledgers from.
- * @returns {*} {IndyLedgerJSON[]} - An array of Indy ledgers read from the file.
- */
-export function readIndyLedgersFromFile(fileSystem: IndyLedgerFileSystem, filePath: string): IndyLedgerJSON[] {
-  try {
-    if (!filePath.endsWith('.json')) {
-      throw new Error('File path must point to a JSON file')
-    }
-
-    // Convert to absolute path ie: ./ledgers.json -> /Users/username/project/ledgers.json
-    const absoluteFilePath = fileSystem.pathResolve(filePath)
-    const jsonContent = fileSystem.readFile(absoluteFilePath)
-
-    return JSON.parse(jsonContent)
-  } catch (error: any) {
-    throw new Error(`${ERROR_TAG}: Failed to read ledgers from file ${filePath}: ${error.message}`)
-  }
-}

package/src/utils/luminance.ts

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

@@ -1,71 +0,0 @@
-import { Agent, MediationRecord } from '@credo-ts/core'
-
-export const isMediatorInvitation = async (agent: Agent, url: string): Promise<boolean> => {
-  try {
-    const invitation = await agent.oob.parseInvitation(url)
-    if (!invitation) {
-      return false
-    }
-
-    if (invitation.goalCode === 'aries.vc.mediate') {
-      agent.config.logger.info(`Invitation is a mediator invitation with goal code: ${invitation.goalCode}`)
-      return true
-    }
-
-    return false
-  } catch (error) {
-    agent.config.logger.error(`Invitation is not a mediator invitation.`, error as Error)
-    return false
-  }
-}
-
-const provisionMediationRecordFromMediatorUrl = async (
-  agent: Agent,
-  url: string
-): Promise<MediationRecord | undefined> => {
-  try {
-    const invitation = await agent.oob.parseInvitation(url)
-    if (!invitation) {
-      agent.config.logger.error(`No invitation found in URL: ${url}`)
-      return undefined
-    }
-
-    const outOfBandRecord = await agent.oob.findByReceivedInvitationId(invitation.id)
-    let [connection] = outOfBandRecord ? await agent.connections.findAllByOutOfBandId(outOfBandRecord.id) : []
-
-    if (!connection) {
-      agent.config.logger.warn(`No connection found for out-of-band record: ${outOfBandRecord?.id}`)
-      const invite = await agent.oob.parseInvitation(url)
-      const { connectionRecord: newConnection } = await agent.oob.receiveInvitation(invite)
-
-      if (!newConnection) {
-        agent.config.logger.error(`Failed to create connection from invitation: ${JSON.stringify(invite, null, 2)}`)
-        return
-      }
-      connection = newConnection
-    }
-
-    const result = connection.isReady ? connection : await agent.connections.returnWhenIsConnected(connection.id)
-    return agent.mediationRecipient.provision(result)
-  } catch (error) {
-    agent.config.logger.error(`Failed to get connection ID from mediator URL: ${error}`)
-    return
-  }
-}
-
-export const setMediationToDefault = async (agent: Agent, mediatorUrl: string) => {
-  const mediationRecord = await provisionMediationRecordFromMediatorUrl(agent, mediatorUrl)
-  if (!mediationRecord) {
-    agent.config.logger.error(`No connection record found for mediator URL: ${mediatorUrl}`)
-    return
-  }
-
-  const currentDefault = await agent.mediationRecipient.findDefaultMediator()
-  if (currentDefault?.connectionId === mediationRecord.id) {
-    agent.config.logger.info(`Default mediator already set for connection ID: ${mediationRecord.id}`)
-    return
-  }
-
-  await agent.mediationRecipient.setDefaultMediator(mediationRecord)
-  agent.config.logger.info(`setting default mediator with record: ${JSON.stringify(mediationRecord)}`)
-}

package/src/utils/migration.ts

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

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

@@ -1,173 +0,0 @@
-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 type FieldExt = {
-  field: Attribute
-  attribute_name: string
-}
-
-type AttributeFieldValue = string | number | null
-
-export const getAttributeField = (display: W3cCredentialDisplay, searchKey: string): FieldExt | undefined => {
-  let attributeName: string = 'Unknown'
-  let attributeValue: AttributeFieldValue = 'Unknown'
-
-  for (const [key, value] of Object.entries(display.attributes)) {
-    let formattedValue: AttributeFieldValue
-
-    if (searchKey === key) {
-      if (typeof value === 'object' && value !== null) {
-        formattedValue = JSON.stringify(value) // Convert object to string
-      } else {
-        formattedValue = value as AttributeFieldValue
-      }
-
-      attributeName = key
-      attributeValue = formattedValue
-    }
-  }
-
-  //Now check credentialSubject for attributeName mapping
-  const credentialSubject = display.credentialSubject
-
-  if (credentialSubject) {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    for (const [key, value] of Object.entries(credentialSubject)) {
-      if (key !== searchKey || !value) continue
-      const { display } = value
-      const { name } = display[0]
-      attributeName = name
-    }
-  }
-
-  return {
-    field: new Attribute({
-      name: attributeName,
-      value: attributeValue,
-      mimeType: typeof attributeValue === 'number' ? 'text/number' : 'text/plain',
-    }),
-    attribute_name: searchKey,
-  }
-}
-
-export const buildFieldsFromW3cCredsCredential = (
-  display: W3cCredentialDisplay,
-  filterByAttributes?: string[]
-): Array<Field> => {
-  return (
-    Object.entries(display.attributes)
-      .filter(([key]) => key !== 'id')
-      .map(([key]) => getAttributeField(display, key))
-      .filter((field) => field !== undefined)
-      .filter((field: FieldExt) => (filterByAttributes ? filterByAttributes.includes(field.attribute_name) : true))
-      .map((fld) => fld.field) || []
-  )
-}
-
-export const buildFieldsFromAnonCredsCredential = (credential: CredentialExchangeRecord): Array<Field> => {
-  return credential?.credentialAttributes?.map((attr) => new Attribute(attr)) || []
-}
-
-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

@@ -1,111 +0,0 @@
-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.',
-  }
-}