feat: Present Proof v2 (WIP Accept Proposal)

Signed-off-by: NB Prasad Katkar <[email protected]>

Author: NB-PrasadKatkar

packages/core/src/modules/proofs/PresentationExchangeRecord.ts

@@ -11,11 +11,11 @@ export interface PresentationRecordTags {
 }
 
 export enum PresentationRecordType {
-  INDY,
-  W3C,
+  Indy = 'Indy',
+  W3c = 'W3c',
 }
 export enum W3CFormatType {
-  JSONLD,
+  Jsonld = 'Jsonld',
   // others to follow
 }
 
@@ -44,7 +44,7 @@ export interface PresentationExchangeRecord {
   role: ProofRole
 
   // This value binds the PresentationExchangeRecord to the actual proof records.
-  // Because we can have multiple proof record types (Indy & W3C), a proof
+  // Because we can have multiple proof record types (Indy & W3c), a proof
   // record id alone doesn't tell us where to look for the proof.
   // Therefore we use the PresentationRecordBinding interface to specify the proof // record id, as well as the type.
   presentation: PresentationRecordBinding[]

packages/core/src/modules/proofs/ProofService.ts

@@ -7,7 +7,13 @@ import type { ProofRecord } from './repository'
 import type { ProofRequest, RetrievedCredentials } from './v1/models'
 import type { ProofFormatService } from './v2/formats/ProofFormatService'
 import type { V2ProposePresentationHandler } from './v2/handlers/V2ProposePresentationHandler'
-import type { ProofRequestAsResponse, ProofRequestsOptions, ProposeProofOptions } from './v2/interface'
+import type {
+  CreateRequestOptions,
+  ProofRequestAsResponse,
+  ProofRequestsOptions,
+  ProposeProofOptions,
+  RequestProofOptions,
+} from './v2/interface'
 
 import { ConsoleLogger, LogLevel } from '../../logger'
 
@@ -16,10 +22,20 @@ const logger = new ConsoleLogger(LogLevel.debug)
 export abstract class ProofService {
   abstract getVersion(): ProofProtocolVersion
   abstract createProposal(proposal: ProposeProofOptions): Promise<{ proofRecord: ProofRecord; message: AgentMessage }>
+
+  abstract requestProof(
+    requestProofOptions: RequestProofOptions
+  ): Promise<{ proofRecord: ProofRecord; message: AgentMessage }>
+
+  abstract createRequest(
+    createRequestOptions: CreateRequestOptions
+  ): Promise<{ proofRecord: ProofRecord; message: AgentMessage }>
+
   public getFormatService(presentationRecordType: PresentationRecordType): ProofFormatService {
     logger.debug(presentationRecordType.toString())
     throw Error('Not Implemented')
   }
+
   abstract processProposal(messageContext: HandlerInboundMessage<V2ProposePresentationHandler>): Promise<ProofRecord>
 
   abstract getById(proofRecordId: string): Promise<ProofRecord>

packages/core/src/modules/proofs/ProofsAPI.ts

@@ -4,19 +4,23 @@ import type { ProofRecord } from './repository'
 import type { RetrievedCredentials } from './v1/models'
 import type {
   AcceptProposalOptions,
+  CreateRequestOptions,
   ProofRequestAsResponse,
   ProofRequestsOptions,
   ProposeProofOptions,
+  RequestProofOptions,
 } from './v2/interface'
 
-import { Lifecycle, scoped } from 'tsyringe'
+import { inject, Lifecycle, scoped } from 'tsyringe'
 
 import { AgentConfig } from '../../agent/AgentConfig'
 import { Dispatcher } from '../../agent/Dispatcher'
 import { EventEmitter } from '../../agent/EventEmitter'
 import { MessageSender } from '../../agent/MessageSender'
 import { createOutboundMessage } from '../../agent/helpers'
+import { InjectionSymbols } from '../../constants'
 import { AriesFrameworkError } from '../../error/AriesFrameworkError'
+import { Wallet } from '../../wallet/Wallet'
 import { ConnectionService } from '../connections/services/ConnectionService'
 import { IndyHolderService } from '../indy'
 import { MediationRecipientService } from '../routing'
@@ -29,11 +33,14 @@ import { ProofsModule } from './ProofsModule'
 import { ProofRepository } from './repository'
 import { V1LegacyProofService } from './v1/V1LegacyProofService'
 import { V1ProofService } from './v1/V1ProofService'
+import { ProofRequest } from './v1/models'
 import { ProofRole } from './v2/ProofRole'
 import { V2ProofService } from './v2/V2ProofService'
 
 export interface ProofsAPI {
   proposeProof(proofOptions: ProposeProofOptions): Promise<PresentationExchangeRecord>
+  acceptProposal(acceptProposalOptions: AcceptProposalOptions): Promise<ProofRecord>
+  requestProof(requestProofOptions: RequestProofOptions): Promise<ProofRecord>
   getById(proofRecordId: string): Promise<ProofRecord>
 }
 
@@ -51,6 +58,7 @@ export class ProofsAPI extends ProofsModule implements ProofsAPI {
   private v2Service: V2ProofService
   private serviceMap: { '1.0': V1ProofService; '2.0': V2ProofService }
   private indyHolderService: IndyHolderService
+  private wallet: Wallet
 
   public constructor(
     dispatcher: Dispatcher,
@@ -62,7 +70,8 @@ export class ProofsAPI extends ProofsModule implements ProofsAPI {
     v1ProofService: V1LegacyProofService,
     proofRepository: ProofRepository,
     eventEmitter: EventEmitter,
-    indyHolderService: IndyHolderService
+    indyHolderService: IndyHolderService,
+    @inject(InjectionSymbols.Wallet) wallet: Wallet
   ) {
     super(
       dispatcher,
@@ -82,6 +91,7 @@ export class ProofsAPI extends ProofsModule implements ProofsAPI {
     this.agntConfig = agentConfig
     this.proofResponseCoord = proofResponseCoordinator
     this.indyHolderService = indyHolderService
+    this.wallet = wallet
     this.v1Service = new V1ProofService(this.v1ProofService, this.connService)
     this.v2Service = new V2ProofService(
       this.proofRepository,
@@ -90,6 +100,7 @@ export class ProofsAPI extends ProofsModule implements ProofsAPI {
       this.agntConfig,
       this.dispatcher,
       this.proofResponseCoord,
+      this.wallet,
       this.indyHolderService
     )
 
@@ -120,8 +131,8 @@ export class ProofsAPI extends ProofsModule implements ProofsAPI {
 
     const recordBinding: PresentationRecordBinding = {
       presentationRecordType: proofOptions.proofFormats?.indy
-        ? PresentationRecordType.INDY
-        : PresentationRecordType.W3C,
+        ? PresentationRecordType.Indy
+        : PresentationRecordType.W3c,
       presentationRecordId: proofRecord.id,
     }
 
@@ -139,7 +150,7 @@ export class ProofsAPI extends ProofsModule implements ProofsAPI {
     return presentationExchangeRecord
   }
 
-  public async acceptProof(acceptProposalOptions: AcceptProposalOptions): Promise<ProofRecord> {
+  public async acceptProposal(acceptProposalOptions: AcceptProposalOptions): Promise<ProofRecord> {
     const version: ProofProtocolVersion = acceptProposalOptions.protocolVersion
 
     const service: ProofService = this.getService(version)
@@ -208,6 +219,44 @@ export class ProofsAPI extends ProofsModule implements ProofsAPI {
     return service.getRequestedCredentialsForProofRequest(indyProofRequest, presentationPreview)
   }
 
+  public async requestProof(requestProofOptions: RequestProofOptions): Promise<ProofRecord> {
+    const version: ProofProtocolVersion = requestProofOptions.protocolVersion
+
+    const { proofRequestOptions } = requestProofOptions
+
+    const service: ProofService = this.getService(version)
+
+    const connection = await this.connService.getById(requestProofOptions.connectionId)
+
+    const nonce = proofRequestOptions.nonce ?? (await this.generateProofRequestNonce())
+
+    const proofRequest = new ProofRequest({
+      name: proofRequestOptions.name ?? 'proof-request',
+      version: proofRequestOptions.name ?? '1.0',
+      nonce,
+      requestedAttributes: proofRequestOptions.requestedAttributes,
+      requestedPredicates: proofRequestOptions.requestedPredicates,
+    })
+
+    const createRequestOptions: CreateRequestOptions = {
+      proofRequest,
+      connectionRecord: connection,
+      comment: requestProofOptions.comment,
+      autoAcceptProof: requestProofOptions.autoAcceptProof,
+    }
+
+    const { message, proofRecord } = await service.createRequest(createRequestOptions)
+
+    const outboundMessage = createOutboundMessage(connection, message)
+    await this.msgSender.sendMessage(outboundMessage)
+
+    return proofRecord
+  }
+
+  public async generateProofRequestNonce() {
+    return this.wallet.generateNonce()
+  }
+
   /**
    * Retrieve a proof record by id
    *

packages/core/src/modules/proofs/ProofsModule.ts

@@ -66,7 +66,7 @@ export class ProofsModule {
    *
    */
 
-  public async v1ProposeProof(
+  public async oldProposeProof(
     connectionId: string,
     presentationProposal: PresentationPreview,
     config?: {
@@ -93,7 +93,7 @@ export class ProofsModule {
    * @returns Proof record associated with the presentation request
    *
    */
-  public async acceptProposal(
+  public async oldAcceptProposal(
     proofRecordId: string,
     config?: {
       request?: {
@@ -144,7 +144,7 @@ export class ProofsModule {
    * @returns Proof record associated with the sent request message
    *
    */
-  public async requestProof(
+  public async oldRequestProof(
     connectionId: string,
     proofRequestOptions: CreateProofRequestOptions,
     config?: ProofRequestConfig

packages/core/src/modules/proofs/v1/V1ProofService.ts

@@ -3,8 +3,14 @@ import type { HandlerInboundMessage } from '../../../agent/Handler'
 import type { AutoAcceptProof } from '../ProofAutoAcceptType'
 import type { ProofRecord } from '../repository/ProofRecord'
 import type { V2ProposePresentationHandler } from '../v2/handlers/V2ProposePresentationHandler'
-import type { ProofRequestAsResponse, ProposeProofOptions } from '../v2/interface'
-import type { ProofRequest, ProofRequestOptions, RetrievedCredentials } from './models'
+import type {
+  CreateRequestOptions,
+  PresentationConfig,
+  ProofRequestAsResponse,
+  ProposeProofOptions,
+  RequestProofOptions,
+} from '../v2/interface'
+import type { ProofRequestOptions, RetrievedCredentials } from './models'
 
 import { Lifecycle, scoped } from 'tsyringe'
 
@@ -15,6 +21,7 @@ import { ProofProtocolVersion } from '../ProofProtocolVersion'
 import { ProofService } from '../ProofService'
 
 import { V1LegacyProofService } from './V1LegacyProofService'
+import { ProofRequest } from './models'
 
 const logger = new ConsoleLogger(LogLevel.debug)
 
@@ -25,6 +32,12 @@ const logger = new ConsoleLogger(LogLevel.debug)
  */
 @scoped(Lifecycle.ContainerScoped)
 export class V1ProofService extends ProofService {
+  createRequest(
+    createRequestOptions: CreateRequestOptions
+  ): Promise<{ proofRecord: ProofRecord; message: AgentMessage }> {
+    throw new Error('Method not implemented.')
+  }
+
   public createProofRequestFromProposal(
     presentationProposal: PresentationPreview,
     proofRequestOptions: ProofRequestOptions
@@ -69,8 +82,6 @@ export class V1ProofService extends ProofService {
   ): Promise<{ proofRecord: ProofRecord; message: AgentMessage }> {
     // Assert
     const connection = await this.connectionService.getById(proposal.connectionId)
-    
-    console.log('V1 proposal', proposal.proofFormats.indy)
 
     let presentationProposal: PresentationPreview | undefined
     if (proposal?.proofFormats?.indy?.proofPreview?.attributes) {
@@ -85,7 +96,7 @@ export class V1ProofService extends ProofService {
       })
     }
 
-    const proposalConfig: PresentationProposalConfig = {
+    const proposalConfig: PresentationConfig = {
       comment: proposal?.comment,
       autoAcceptProof: proposal?.autoAcceptProof,
     }
@@ -118,12 +129,42 @@ export class V1ProofService extends ProofService {
     return { proofRecord, message }
   }
 
+  public async requestProof(
+    requestProofOptions: RequestProofOptions
+  ): Promise<{ proofRecord: ProofRecord; message: AgentMessage }> {
+    const { connectionId, proofRequestOptions, comment, autoAcceptProof } = requestProofOptions
+
+    const connection = await this.connectionService.getById(connectionId)
+
+    const nonce = proofRequestOptions.nonce ?? (await this.legacyProofService.generateProofRequestNonce())
+
+    const proofRequest = new ProofRequest({
+      name: proofRequestOptions.name ?? 'proof-request',
+      version: proofRequestOptions.name ?? '1.0',
+      nonce,
+      requestedAttributes: proofRequestOptions.requestedAttributes,
+      requestedPredicates: proofRequestOptions.requestedPredicates,
+    })
+
+    const proposalConfig: PresentationConfig = {
+      comment: comment,
+      autoAcceptProof: autoAcceptProof,
+    }
+
+    const { message, proofRecord } = await this.legacyProofService.createRequest(
+      proofRequest,
+      connection,
+      proposalConfig
+    )
+
+    return { proofRecord, message }
+  }
+
+  public async generateProofRequestNonce() {
+    return this.legacyProofService.generateProofRequestNonce()
+  }
+
   public async getById(proofRecordId: string): Promise<ProofRecord> {
     return this.legacyProofService.getById(proofRecordId)
   }
 }
-
-interface PresentationProposalConfig {
-  comment?: string
-  autoAcceptProof?: AutoAcceptProof
-}