@bifold/verifier 1.0.0

package/src/utils/proof-request.ts

@@ -0,0 +1,177 @@
+import {
+  AnonCredsRequestedAttribute,
+  AnonCredsRequestedPredicate,
+  LegacyIndyProofRequest,
+  V1RequestPresentationMessage,
+} from '@credo-ts/anoncreds'
+import { Agent, AgentMessage, AutoAcceptProof, ProofExchangeRecord } from '@credo-ts/core'
+
+import { BifoldAgent } from '../types/agent'
+import { ProofRequestTemplate, ProofRequestType } from '../types/proof-reqeust-template'
+
+const protocolVersion = 'v2'
+const domain = 'http://aries-mobile-agent.com'
+
+/*
+ * Find Proof Request message in the storage by the given id
+ * */
+export const findProofRequestMessage = async (
+  agent: Agent,
+  id: string
+): Promise<LegacyIndyProofRequest | undefined> => {
+  const message = await agent.proofs.findRequestMessage(id)
+  if (message && message instanceof V1RequestPresentationMessage && message.indyProofRequest) {
+    return message.indyProofRequest
+  } else {
+    return undefined
+  }
+}
+
+/*
+ * Build Proof Request data from for provided template
+ * */
+/*
+ * Build Proof Request data for provided template
+ * */
+export const buildProofRequestDataForTemplate = (
+  template: ProofRequestTemplate,
+  customValues?: Record<string, Record<string, number>>
+) => {
+  if (template.payload.type === ProofRequestType.AnonCreds) {
+    const requestedAttributes: Record<string, AnonCredsRequestedAttribute> = {}
+    const requestedPredicates: Record<string, AnonCredsRequestedPredicate> = {}
+    let index = 0
+
+    template.payload.data.forEach((data) => {
+      if (data.requestedAttributes?.length) {
+        data.requestedAttributes.forEach((requestedAttribute) => {
+          requestedAttributes[`referent_${index}`] = {
+            name: requestedAttribute.name,
+            names: requestedAttribute.names,
+            non_revoked: requestedAttribute.nonRevoked,
+            restrictions: requestedAttribute.restrictions,
+          }
+          index++
+        })
+      }
+      if (data.requestedPredicates?.length) {
+        data.requestedPredicates.forEach((requestedPredicate) => {
+          const customValue =
+            customValues && customValues[data.schema] ? customValues[data.schema][requestedPredicate.name] : undefined
+
+          requestedPredicates[`referent_${index}`] = {
+            name: requestedPredicate.name,
+            p_value:
+              requestedPredicate.parameterizable && customValue ? customValue : requestedPredicate.predicateValue,
+            p_type: requestedPredicate.predicateType,
+            non_revoked: requestedPredicate.nonRevoked,
+            restrictions: requestedPredicate.restrictions,
+          }
+          index++
+        })
+      }
+    })
+    return {
+      anoncreds: {
+        name: template.name,
+        version: template.version,
+        nonce: Date.now().toString(),
+        requested_attributes: requestedAttributes,
+        requested_predicates: requestedPredicates,
+      },
+    }
+  }
+  if (template.payload.type === ProofRequestType.DIF) {
+    return {}
+  }
+}
+
+export interface CreateProofRequestInvitationResult {
+  request: AgentMessage
+  proofRecord: ProofExchangeRecord
+  invitation: AgentMessage
+  invitationUrl: string
+}
+
+/*
+ * Create connectionless proof request invitation for provided template
+ * */
+export const createConnectionlessProofRequestInvitation = async (
+  agent: BifoldAgent,
+  template: ProofRequestTemplate,
+  customPredicateValues?: Record<string, Record<string, number>>
+): Promise<CreateProofRequestInvitationResult | undefined> => {
+  const proofFormats = buildProofRequestDataForTemplate(template, customPredicateValues)
+  if (!proofFormats) {
+    return undefined
+  }
+  const { message: request, proofRecord } = await agent.proofs.createRequest({
+    protocolVersion,
+    autoAcceptProof: AutoAcceptProof.Always,
+    proofFormats,
+  })
+  const { message: invitation, invitationUrl } = await agent.oob.createLegacyConnectionlessInvitation({
+    recordId: proofRecord.id,
+    message: request,
+    domain,
+  })
+  return {
+    request,
+    proofRecord,
+    invitation,
+    invitationUrl,
+  }
+}
+
+export interface SendProofRequestResult {
+  proofRecord: ProofExchangeRecord
+}
+
+/*
+ * Build Proof Request for provided template and send it to provided connection
+ * */
+export const sendProofRequest = async (
+  agent: BifoldAgent,
+  template: ProofRequestTemplate,
+  connectionId: string,
+  customPredicateValues?: Record<string, Record<string, number>>
+): Promise<SendProofRequestResult | undefined> => {
+  const proofFormats = buildProofRequestDataForTemplate(template, customPredicateValues)
+  if (!proofFormats) {
+    return undefined
+  }
+  const proofRecord = await agent.proofs.requestProof({
+    protocolVersion,
+    connectionId,
+    proofFormats,
+  })
+  return {
+    proofRecord,
+  }
+}
+
+/*
+ * Check if the Proof Request template contains at least one predicate
+ * */
+export const hasPredicates = (record: ProofRequestTemplate): boolean => {
+  if (record.payload.type === ProofRequestType.AnonCreds) {
+    return record.payload.data.some((d) => d.requestedPredicates && d.requestedPredicates?.length > 0)
+  }
+  if (record.payload.type === ProofRequestType.DIF) {
+    return false
+  }
+  return false
+}
+
+/*
+ * Check if the Proof Request template contains parameterizable predicates
+ * */
+export const isParameterizable = (record: ProofRequestTemplate): boolean => {
+  if (record.payload.type === ProofRequestType.AnonCreds) {
+    return record.payload.data.some((d) => d.requestedPredicates?.some((predicate) => predicate.parameterizable))
+  }
+  if (record.payload.type === ProofRequestType.DIF) {
+    return false
+  }
+  return false
+}

package/src/utils/proof.ts

@@ -0,0 +1,173 @@
+import { AnonCredsProof, AnonCredsProofRequest } from '@credo-ts/anoncreds'
+import { Agent, ProofExchangeRecord, ProofState } from '@credo-ts/core'
+
+import { BifoldAgent } from '../types/agent'
+import { ProofMetadata } from '../types/metadata'
+import {
+  CredentialSharedProofData,
+  GroupedSharedProofData,
+  GroupedSharedProofDataItem,
+  ParsedAnonCredsProof,
+} from '../types/proof'
+
+/*
+ * Extract identifiers from indy proof
+ * */
+export const getProofIdentifiers = (proof: AnonCredsProof, proofIndex: number) => {
+  const identifiers = proof.identifiers[proofIndex]
+  if (!identifiers) {
+    throw new Error('Invalid indy proof data')
+  }
+  return identifiers
+}
+
+/*
+ * Process anoncreds proof and return
+ *  - shared attributes
+ *  - shared attribute groups
+ *  - resolved predicates
+ *  - missing attributes
+ *  - missing attribute groups
+ *  - unresolved predicates
+ * */
+export const parseAnonCredsProof = (request: AnonCredsProofRequest, proof: AnonCredsProof): ParsedAnonCredsProof => {
+  const result = new ParsedAnonCredsProof()
+
+  for (const [referent, requested_attribute] of Object.entries(request.requested_attributes)) {
+    if (requested_attribute.name) {
+      const shared = proof.requested_proof.revealed_attrs[referent]
+      if (shared) {
+        const identifiers = getProofIdentifiers(proof, shared.sub_proof_index)
+        result.sharedAttributes.push({
+          name: requested_attribute.name,
+          value: shared.raw,
+          identifiers,
+        })
+      } else {
+        result.unresolvedAttributes.push({
+          name: requested_attribute.name,
+        })
+      }
+    }
+
+    if (requested_attribute.names) {
+      const shared = proof.requested_proof.revealed_attr_groups?.[referent]
+      if (shared) {
+        const attributes = Object.entries(shared.values).map(([name, value]) => ({
+          name,
+          value: value.raw,
+        }))
+        const identifiers = getProofIdentifiers(proof, shared.sub_proof_index)
+        result.sharedAttributeGroups.push({
+          attributes,
+          identifiers,
+        })
+      } else {
+        result.unresolvedAttributeGroups.push(requested_attribute.names.map((name) => ({ name })))
+      }
+    }
+  }
+
+  for (const [referent, requestedPredicate] of Object.entries(request.requested_predicates)) {
+    const shared = proof.requested_proof.predicates[referent]
+    if (shared) {
+      const identifiers = getProofIdentifiers(proof, shared.sub_proof_index)
+      result.resolvedPredicates.push({
+        name: requestedPredicate.name,
+        predicateType: requestedPredicate.p_type,
+        predicateValue: requestedPredicate.p_value,
+        identifiers,
+      })
+    } else {
+      result.unresolvedPredicates.push({
+        name: requestedPredicate.name,
+        predicateType: requestedPredicate.p_type,
+        predicateValue: requestedPredicate.p_value,
+      })
+    }
+  }
+
+  return result
+}
+
+/*
+ * Group parsed indy proof data ( returned from `parseIndyProof`) by credential definition id
+ * */
+export const groupSharedProofDataByCredential = (data: ParsedAnonCredsProof): GroupedSharedProofData => {
+  const result: GroupedSharedProofData = new Map<string, GroupedSharedProofDataItem>()
+  for (const item of data.sharedAttributes) {
+    if (!result.has(item.identifiers.cred_def_id)) {
+      result.set(item.identifiers.cred_def_id, {
+        data: new CredentialSharedProofData(),
+        identifiers: item.identifiers,
+      })
+    }
+    result.get(item.identifiers.cred_def_id)?.data.sharedAttributes.push(item)
+  }
+  for (const item of data.sharedAttributeGroups) {
+    if (!result.has(item.identifiers.cred_def_id)) {
+      result.set(item.identifiers.cred_def_id, {
+        data: new CredentialSharedProofData(),
+        identifiers: item.identifiers,
+      })
+    }
+    result.get(item.identifiers.cred_def_id)?.data.sharedAttributeGroups.push(item)
+  }
+  for (const item of data.resolvedPredicates) {
+    if (!result.has(item.identifiers.cred_def_id)) {
+      result.set(item.identifiers.cred_def_id, {
+        data: new CredentialSharedProofData(),
+        identifiers: item.identifiers,
+      })
+    }
+    result.get(item.identifiers.cred_def_id)?.data.resolvedPredicates.push(item)
+  }
+  return result
+}
+
+/*
+ * Retrieve proof details from Credo record
+ * */
+export const getProofData = async (agent: BifoldAgent, recordId: string): Promise<ParsedAnonCredsProof | undefined> => {
+  const data = await agent.proofs.getFormatData(recordId)
+  if (data.request?.anoncreds && data.presentation?.anoncreds) {
+    return parseAnonCredsProof(data.request.anoncreds, data.presentation.anoncreds)
+  } else if (data.request?.indy && data.presentation?.indy) {
+    return parseAnonCredsProof(data.request.indy, data.presentation.indy)
+  }
+
+  return undefined
+}
+
+/*
+ * Check if a presentation received
+ * */
+export const isPresentationReceived = (record: ProofExchangeRecord) => {
+  return record.state === ProofState.PresentationReceived || record.state === ProofState.Done
+}
+
+/*
+ * Check if a presentation failed
+ * */
+export const isPresentationFailed = (record: ProofExchangeRecord) => {
+  return record.state === ProofState.Abandoned
+}
+
+/*
+ * Mark Proof record as viewed
+ * */
+export const markProofAsViewed = async (agent: Agent, record: ProofExchangeRecord) => {
+  record.metadata.set(ProofMetadata.customMetadata, { ...record.metadata.data.customMetadata, details_seen: true })
+  return agent.proofs.update(record)
+}
+
+/*
+ * Add template reference to Proof Exchange record
+ * */
+export const linkProofWithTemplate = async (agent: Agent, record: ProofExchangeRecord, templateId: string) => {
+  record.metadata.set(ProofMetadata.customMetadata, {
+    ...record.metadata.data.customMetadata,
+    proof_request_template_id: templateId,
+  })
+  return agent.proofs.update(record)
+}