@bifold/verifier 2.4.6 → 2.5.0

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@bifold/verifier",
-  "version": "2.4.6",
+  "version": "2.5.0",
   "main": "build/commonjs/index.js",
   "types": "build/typescript/index.d.ts",
   "module": "build/module/index.js",
   "source": "src/index.ts",
   "react-native": "src/index.ts",
   "files": [
-    "src",
     "build"
   ],
   "repository": {

package/src/README.md

@@ -1,4 +0,0 @@
-## Verifier Module
-
-This folder contains set of helpers, type definitions, and constants allowing to add verifier capability into Aries Mobile Agent React Native.
-The folder is created to encourage the upcoming split of the project into sub packages.

package/src/__tests__/verifier/__snapshots__/proof-request.test.ts.snap

@@ -1,72 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Helpers Build anoncreds proof request from template containing two requested attributes 1`] = `
-Object {
-  "anoncreds": Object {
-    "name": "Student full name",
-    "nonce": "1677766511505",
-    "requested_attributes": Object {
-      "referent_0": Object {
-        "name": "student_first_name",
-        "names": undefined,
-        "non_revoked": undefined,
-        "restrictions": Array [
-          Object {
-            "cred_def_id": "XUxBrVSALWHLeycAUhrNr9:3:CL:26293:student_card",
-          },
-        ],
-      },
-      "referent_1": Object {
-        "name": "student_last_name",
-        "names": undefined,
-        "non_revoked": undefined,
-        "restrictions": Array [
-          Object {
-            "cred_def_id": "XUxBrVSALWHLeycAUhrNr9:3:CL:26293:student_card",
-          },
-        ],
-      },
-    },
-    "requested_predicates": Object {},
-    "version": "0.0.1",
-  },
-}
-`;
-
-exports[`Helpers Build anoncreds proof request from template containing two requested attributes and predicate 1`] = `
-Object {
-  "anoncreds": Object {
-    "name": "Student full name and expiration date",
-    "nonce": "1677766511505",
-    "requested_attributes": Object {
-      "referent_0": Object {
-        "name": undefined,
-        "names": Array [
-          "student_first_name",
-          "student_last_name",
-        ],
-        "non_revoked": undefined,
-        "restrictions": Array [
-          Object {
-            "cred_def_id": "XUxBrVSALWHLeycAUhrNr9:3:CL:26293:student_card",
-          },
-        ],
-      },
-    },
-    "requested_predicates": Object {
-      "referent_1": Object {
-        "name": "expiry_date",
-        "non_revoked": undefined,
-        "p_type": ">=",
-        "p_value": 20240101,
-        "restrictions": Array [
-          Object {
-            "cred_def_id": "XUxBrVSALWHLeycAUhrNr9:3:CL:26293:student_card",
-          },
-        ],
-      },
-    },
-    "version": "0.0.1",
-  },
-}
-`;

package/src/__tests__/verifier/__snapshots__/proof.test.ts.snap

@@ -1,135 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Helpers Get proof identifiers 1`] = `
-Object {
-  "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest",
-  "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0",
-}
-`;
-
-exports[`Helpers Group shared proof data by credential 1`] = `
-Map {
-  "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest" => Object {
-    "data": CredentialSharedProofData {
-      "resolvedPredicates": Array [
-        Object {
-          "identifiers": Object {
-            "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest",
-            "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0",
-          },
-          "name": "age",
-          "predicateType": ">=",
-          "predicateValue": 1,
-        },
-      ],
-      "sharedAttributeGroups": Array [
-        Object {
-          "attributes": Array [
-            Object {
-              "name": "first_name",
-              "value": "Aries",
-            },
-            Object {
-              "name": "second_name",
-              "value": "Bifold",
-            },
-          ],
-          "identifiers": Object {
-            "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest",
-            "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0",
-          },
-        },
-      ],
-      "sharedAttributes": Array [
-        Object {
-          "identifiers": Object {
-            "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest",
-            "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0",
-          },
-          "name": "date",
-          "value": "1/1/1",
-        },
-      ],
-    },
-    "identifiers": Object {
-      "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest",
-      "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0",
-    },
-  },
-  "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712168:latest" => Object {
-    "data": CredentialSharedProofData {
-      "resolvedPredicates": Array [],
-      "sharedAttributeGroups": Array [],
-      "sharedAttributes": Array [
-        Object {
-          "identifiers": Object {
-            "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712168:latest",
-            "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Passport:1.0.0",
-          },
-          "name": "passport_no",
-          "value": "123123",
-        },
-      ],
-    },
-    "identifiers": Object {
-      "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712168:latest",
-      "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Passport:1.0.0",
-    },
-  },
-}
-`;
-
-exports[`Helpers Parse indy proof 1`] = `
-ParsedAnonCredsProof {
-  "resolvedPredicates": Array [
-    Object {
-      "identifiers": Object {
-        "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest",
-        "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0",
-      },
-      "name": "age",
-      "predicateType": ">=",
-      "predicateValue": 1,
-    },
-  ],
-  "sharedAttributeGroups": Array [
-    Object {
-      "attributes": Array [
-        Object {
-          "name": "first_name",
-          "value": "Aries",
-        },
-        Object {
-          "name": "second_name",
-          "value": "Bifold",
-        },
-      ],
-      "identifiers": Object {
-        "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest",
-        "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0",
-      },
-    },
-  ],
-  "sharedAttributes": Array [
-    Object {
-      "identifiers": Object {
-        "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest",
-        "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0",
-      },
-      "name": "date",
-      "value": "1/1/1",
-    },
-    Object {
-      "identifiers": Object {
-        "cred_def_id": "7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712168:latest",
-        "schema_id": "7KuDTpQh3GJ7Gp6kErpWvM:2:Passport:1.0.0",
-      },
-      "name": "passport_no",
-      "value": "123123",
-    },
-  ],
-  "unresolvedAttributeGroups": Array [],
-  "unresolvedAttributes": Array [],
-  "unresolvedPredicates": Array [],
-}
-`;

package/src/__tests__/verifier/proof-request.test.ts

@@ -1,34 +0,0 @@
-import { getProofRequestTemplates } from '../../request-templates'
-import { buildProofRequestDataForTemplate, hasPredicates } from '../../utils/proof-request'
-
-import SpyInstance = jest.SpyInstance
-
-describe('Helpers', () => {
-  let spy: SpyInstance
-
-  beforeAll(() => {
-    spy = jest.spyOn(Date, 'now').mockImplementation(() => 1677766511505)
-  })
-  const templates = getProofRequestTemplates(false)
-
-  test('Build anoncreds proof request from template containing two requested attributes', async () => {
-    const template = templates[0]
-    const proofRequest = buildProofRequestDataForTemplate(template)
-    expect(proofRequest).toMatchSnapshot()
-  })
-
-  test('Build anoncreds proof request from template containing two requested attributes and predicate', async () => {
-    const template = templates[1]
-    const proofRequest = buildProofRequestDataForTemplate(template)
-    expect(proofRequest).toMatchSnapshot()
-  })
-
-  test('Check if proof has predicates', async () => {
-    expect(hasPredicates(templates[0])).toBeFalsy()
-    expect(hasPredicates(templates[1])).toBeTruthy()
-  })
-
-  afterAll(() => {
-    spy.mockRestore()
-  })
-})

package/src/__tests__/verifier/proof.test.ts

@@ -1,99 +0,0 @@
-import { AnonCredsProof } from '@credo-ts/anoncreds'
-import { getProofIdentifiers, groupSharedProofDataByCredential, parseAnonCredsProof } from '../../utils/proof'
-const proof_request = {
-  name: 'proof-request',
-  version: '1.0',
-  nonce: '1298236324864',
-  requested_attributes: {
-    attribute_1: {
-      names: ['first_name', 'second_name'],
-    },
-    attribute_2: {
-      name: 'date',
-    },
-    attribute_3: {
-      name: 'passport_no',
-    },
-  },
-  requested_predicates: {
-    predicate_1: {
-      name: 'age',
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      p_type: '>=' as any,
-      p_value: 1,
-    },
-  },
-}
-
-const proof: AnonCredsProof = {
-  proof: {
-    proofs: [],
-    aggregated_proof: {
-      c_list: [],
-    },
-  },
-  requested_proof: {
-    revealed_attrs: {
-      attribute_2: {
-        sub_proof_index: 0,
-        raw: '1/1/1',
-        encoded: '',
-      },
-      attribute_3: {
-        sub_proof_index: 1,
-        raw: '123123',
-        encoded: '',
-      },
-    },
-    revealed_attr_groups: {
-      attribute_1: {
-        sub_proof_index: 0,
-        values: {
-          first_name: {
-            raw: 'Aries',
-            encoded: '',
-          },
-          second_name: {
-            raw: 'Bifold',
-            encoded: '',
-          },
-        },
-      },
-    },
-    self_attested_attrs: {},
-    unrevealed_attrs: {},
-    predicates: {
-      predicate_1: {
-        sub_proof_index: 0,
-      },
-    },
-  },
-  identifiers: [
-    {
-      schema_id: '7KuDTpQh3GJ7Gp6kErpWvM:2:Faber College:1.0.0',
-      cred_def_id: '7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712167:latest',
-    },
-    {
-      schema_id: '7KuDTpQh3GJ7Gp6kErpWvM:2:Passport:1.0.0',
-      cred_def_id: '7KuDTpQh3GJ7Gp6kErpWvM:3:CL:712168:latest',
-    },
-  ],
-}
-
-describe('Helpers', () => {
-  test('Parse indy proof', async () => {
-    const proofRequest = parseAnonCredsProof(proof_request, proof)
-    expect(proofRequest).toMatchSnapshot()
-  })
-
-  test('Group shared proof data by credential', async () => {
-    const data = parseAnonCredsProof(proof_request, proof)
-    const groupedData = groupSharedProofDataByCredential(data)
-    expect(groupedData).toMatchSnapshot()
-  })
-
-  test('Get proof identifiers', async () => {
-    const identifiers = getProofIdentifiers(proof, 0)
-    expect(identifiers).toMatchSnapshot()
-  })
-})

package/src/constants.ts

@@ -1,2 +0,0 @@
-export const protocolVersion = 'v2'
-export const domain = 'didcomm://invite'

package/src/hooks/proofs.ts

@@ -1,20 +0,0 @@
-import { ProofExchangeRecord } from '@credo-ts/core'
-import { useProofs } from '@credo-ts/react-hooks'
-import { useMemo } from 'react'
-
-import { ProofCustomMetadata, ProofMetadata } from '../types/metadata'
-
-export const useProofsByTemplateId = (templateId: string): ProofExchangeRecord[] => {
-  const { records: proofs } = useProofs()
-
-  return useMemo(
-    () =>
-      proofs.filter((proof: ProofExchangeRecord) => {
-        const metadata = proof?.metadata.get(ProofMetadata.customMetadata) as ProofCustomMetadata
-        if (metadata?.proof_request_template_id === templateId) {
-          return proof
-        }
-      }),
-    [proofs, templateId]
-  )
-}

package/src/index.ts

@@ -1,45 +0,0 @@
-export { ProofRequestType } from './types/proof-reqeust-template'
-export type {
-  ProofRequestTemplate,
-  DifProofRequestTemplatePayload,
-  DifProofRequestTemplatePayloadData,
-  AnonCredsProofRequestTemplatePayload,
-  AnonCredsProofRequestTemplatePayloadData,
-  AnonCredsRequestedAttribute,
-  AnonCredsRequestedPredicate,
-} from './types/proof-reqeust-template'
-export type {
-  GroupedSharedProofData,
-  GroupedSharedProofDataItem,
-  CredentialSharedProofData,
-  ParsedAnonCredsProof,
-  UnresolvedPredicate,
-  ResolvedPredicate,
-  SharedAttributesGroup,
-  SharedGroupedAttribute,
-  SharedAttribute,
-  MissingAttribute,
-} from './types/proof'
-export type { ProofCustomMetadata } from './types/metadata'
-export { ProofMetadata } from './types/metadata'
-export { useProofsByTemplateId } from './hooks/proofs'
-export {
-  getProofIdentifiers,
-  parseAnonCredsProof,
-  groupSharedProofDataByCredential,
-  getProofData,
-  isPresentationReceived,
-  isPresentationFailed,
-  markProofAsViewed,
-  linkProofWithTemplate,
-} from './utils/proof'
-export type { CreateProofRequestInvitationResult, SendProofRequestResult } from './utils/proof-request'
-export {
-  findProofRequestMessage,
-  buildProofRequestDataForTemplate,
-  createConnectionlessProofRequestInvitation,
-  sendProofRequest,
-  hasPredicates,
-  isParameterizable,
-} from './utils/proof-request'
-export { getProofRequestTemplates } from './request-templates'

package/src/request-templates.ts

@@ -1,62 +0,0 @@
-import { ProofRequestTemplate, ProofRequestType } from './types/proof-reqeust-template'
-
-export const getProofRequestTemplates = (useDevRestrictions: boolean) => {
-  const studentRestrictions = [{ cred_def_id: 'XUxBrVSALWHLeycAUhrNr9:3:CL:26293:student_card' }]
-  const studentDevRestrictions = [{ schema_name: 'student_card' }]
-  const restrictions = useDevRestrictions ? studentDevRestrictions : studentRestrictions
-  const defaultProofRequestTemplates: Array<ProofRequestTemplate> = [
-    {
-      id: 'Aries:5:StudentFullName:0.0.1:indy',
-      name: 'Student full name',
-      description: 'Verify the full name of a student',
-      version: '0.0.1',
-      payload: {
-        type: ProofRequestType.AnonCreds,
-        data: [
-          {
-            schema: 'XUxBrVSALWHLeycAUhrNr9:3:CL:26293:Student Card',
-            requestedAttributes: [
-              {
-                name: 'student_first_name',
-                restrictions,
-              },
-              {
-                name: 'student_last_name',
-                restrictions,
-              },
-            ],
-          },
-        ],
-      },
-    },
-    {
-      id: 'Aries:5:StudentFullNameAndExpirationDate:0.0.1:indy',
-      name: 'Student full name and expiration date',
-      description: 'Verify that full name of a student and that he/she has a not expired student card.',
-      version: '0.0.1',
-      payload: {
-        type: ProofRequestType.AnonCreds,
-        data: [
-          {
-            schema: 'XUxBrVSALWHLeycAUhrNr9:3:CL:26293:Student Card',
-            requestedAttributes: [
-              {
-                names: ['student_first_name', 'student_last_name'],
-                restrictions,
-              },
-            ],
-            requestedPredicates: [
-              {
-                name: 'expiry_date',
-                predicateType: '>=',
-                predicateValue: 20240101,
-                restrictions,
-              },
-            ],
-          },
-        ],
-      },
-    },
-  ]
-  return defaultProofRequestTemplates
-}

package/src/types/agent.ts

@@ -1,53 +0,0 @@
-import {
-  AnonCredsCredentialFormatService,
-  AnonCredsModule,
-  AnonCredsProofFormatService,
-  DataIntegrityCredentialFormatService,
-  LegacyIndyCredentialFormatService,
-  LegacyIndyProofFormatService,
-  V1CredentialProtocol,
-  V1ProofProtocol,
-} from '@credo-ts/anoncreds'
-import {
-  Agent,
-  ConnectionsModule,
-  CredentialsModule,
-  DifPresentationExchangeProofFormatService,
-  MediationRecipientModule,
-  ProofsModule,
-  V2CredentialProtocol,
-  V2ProofProtocol,
-} from '@credo-ts/core'
-
-function getAgentModules() {
-  return null as unknown as {
-    //askar: AskarModule
-    //anoncredsRs: AnonCredsRsModule
-    anoncreds: AnonCredsModule
-    //indyVdr: IndyVdrModule
-    connections: ConnectionsModule
-    credentials: CredentialsModule<
-      (
-        | V1CredentialProtocol
-        | V2CredentialProtocol<
-            (
-              | LegacyIndyCredentialFormatService
-              | AnonCredsCredentialFormatService
-              | DataIntegrityCredentialFormatService
-            )[]
-          >
-      )[]
-    >
-    proofs: ProofsModule<
-      (
-        | V1ProofProtocol
-        | V2ProofProtocol<
-            (LegacyIndyProofFormatService | AnonCredsProofFormatService | DifPresentationExchangeProofFormatService)[]
-          >
-      )[]
-    >
-    mediationRecipient: MediationRecipientModule
-  }
-}
-
-export type BifoldAgent = Agent<ReturnType<typeof getAgentModules>>

package/src/types/metadata.ts

@@ -1,9 +0,0 @@
-export enum ProofMetadata {
-  customMetadata = 'customMetadata',
-}
-
-export interface ProofCustomMetadata {
-  details_seen?: boolean
-  proof_request_template_id?: string
-  delete_conn_after_seen?: boolean
-}

package/src/types/proof-reqeust-template.ts

@@ -1,59 +0,0 @@
-import {
-  AnonCredsNonRevokedInterval,
-  AnonCredsPredicateType,
-  AnonCredsProofRequestRestriction,
-} from '@credo-ts/anoncreds'
-
-export interface AnonCredsRequestedPredicate {
-  label?: string
-  name: string
-  predicateType: AnonCredsPredicateType
-  predicateValue: number
-  restrictions?: AnonCredsProofRequestRestriction[]
-  devRestrictions?: AnonCredsProofRequestRestriction[]
-  nonRevoked?: AnonCredsNonRevokedInterval
-  parameterizable?: boolean
-}
-
-export interface AnonCredsRequestedAttribute {
-  label?: string
-  name?: string
-  names?: Array<string>
-  restrictions?: AnonCredsProofRequestRestriction[]
-  devRestrictions?: AnonCredsProofRequestRestriction[]
-  revealed?: boolean
-  nonRevoked?: AnonCredsNonRevokedInterval
-}
-
-export interface AnonCredsProofRequestTemplatePayloadData {
-  schema: string
-  requestedAttributes?: Array<AnonCredsRequestedAttribute>
-  requestedPredicates?: Array<AnonCredsRequestedPredicate>
-}
-
-export enum ProofRequestType {
-  AnonCreds = 'anoncreds',
-  DIF = 'dif',
-}
-
-export interface AnonCredsProofRequestTemplatePayload {
-  type: ProofRequestType.AnonCreds
-  data: Array<AnonCredsProofRequestTemplatePayloadData>
-}
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface DifProofRequestTemplatePayloadData {}
-
-export interface DifProofRequestTemplatePayload {
-  type: ProofRequestType.DIF
-  data: Array<DifProofRequestTemplatePayloadData>
-}
-
-export interface ProofRequestTemplate {
-  id: string
-  name: string
-  description: string
-  version: string
-  devOnly?: boolean
-  payload: AnonCredsProofRequestTemplatePayload | DifProofRequestTemplatePayload
-}

package/src/types/proof.ts

@@ -1,68 +0,0 @@
-import { AnonCredsProof } from '@credo-ts/anoncreds'
-type AnonCredsProofIdentifier = AnonCredsProof['identifiers'][number]
-
-export interface MissingAttribute {
-  name: string
-}
-
-export interface SharedAttribute {
-  name: string
-  value: string
-  identifiers: AnonCredsProofIdentifier
-}
-
-export interface SharedGroupedAttribute {
-  name: string
-  value: string
-}
-
-export interface SharedAttributesGroup {
-  attributes: Array<SharedGroupedAttribute>
-  identifiers: AnonCredsProofIdentifier
-}
-
-export interface ResolvedPredicate {
-  name: string
-  predicateType: string
-  predicateValue: number
-  identifiers: AnonCredsProofIdentifier
-}
-
-export interface UnresolvedPredicate {
-  name: string
-  predicateType: string
-  predicateValue: number
-}
-
-export class ParsedAnonCredsProof {
-  public sharedAttributes: Array<SharedAttribute>
-  public sharedAttributeGroups: Array<SharedAttributesGroup>
-  public resolvedPredicates: Array<ResolvedPredicate>
-  public unresolvedAttributes: Array<MissingAttribute>
-  public unresolvedAttributeGroups: Array<Array<MissingAttribute>>
-  public unresolvedPredicates: Array<UnresolvedPredicate>
-
-  public constructor() {
-    this.sharedAttributes = []
-    this.sharedAttributeGroups = []
-    this.resolvedPredicates = []
-    this.unresolvedAttributes = []
-    this.unresolvedAttributeGroups = []
-    this.unresolvedPredicates = []
-  }
-}
-
-export class CredentialSharedProofData {
-  public sharedAttributes: Array<SharedAttribute>
-  public sharedAttributeGroups: Array<SharedAttributesGroup>
-  public resolvedPredicates: Array<ResolvedPredicate>
-
-  public constructor() {
-    this.sharedAttributes = []
-    this.sharedAttributeGroups = []
-    this.resolvedPredicates = []
-  }
-}
-
-export type GroupedSharedProofDataItem = { data: CredentialSharedProofData; identifiers: AnonCredsProofIdentifier }
-export type GroupedSharedProofData = Map<string, GroupedSharedProofDataItem>

package/src/utils/proof-request.ts

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

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