feat: negotiation and auto accept credentials

src/__tests__/helpers.ts

@@ -1,17 +1,17 @@
-import type { Agent } from '../agent/Agent'
 import type { BasicMessage, BasicMessageReceivedEvent } from '../modules/basic-messages'
 import type { ConnectionRecordProps } from '../modules/connections'
 import type { CredentialRecord, CredentialOfferTemplate, CredentialStateChangedEvent } from '../modules/credentials'
 import type { SchemaTemplate, CredentialDefinitionTemplate } from '../modules/ledger'
 import type { ProofRecord, ProofState, ProofStateChangedEvent } from '../modules/proofs'
 import type { InboundTransporter, OutboundTransporter } from '../transport'
-import type { InitConfig, OutboundPackage, WireMessage } from '../types'
+import type { AutoAcceptCredential, InitConfig, OutboundPackage, WireMessage } from '../types'
 import type { Schema, CredDef, Did } from 'indy-sdk'
-import type { Subject } from 'rxjs'
 
 import indy from 'indy-sdk'
 import path from 'path'
+import { Subject } from 'rxjs'
 
+import { Agent } from '../agent/Agent'
 import { BasicMessageEventTypes } from '../modules/basic-messages'
 import {
   ConnectionInvitationMessage,
@@ -324,3 +324,59 @@ export async function issueCredential({
 export function mockFunction<T extends (...args: any[]) => any>(fn: T): jest.MockedFunction<T> {
   return fn as jest.MockedFunction<T>
 }
+
+export async function setupCredentialTests(
+  faberName: string,
+  aliceName: string,
+  autoAcceptCredentials?: AutoAcceptCredential
+) {
+  const faberMessages = new Subject()
+  const aliceMessages = new Subject()
+
+  const faberConfig = getBaseConfig(faberName, {
+    genesisPath,
+    autoAcceptCredentials,
+  })
+
+  const aliceConfig = getBaseConfig(aliceName, {
+    genesisPath,
+    autoAcceptCredentials,
+  })
+
+  const faberAgent = new Agent(faberConfig)
+  faberAgent.setInboundTransporter(new SubjectInboundTransporter(faberMessages, aliceMessages))
+  faberAgent.setOutboundTransporter(new SubjectOutboundTransporter(aliceMessages))
+  await faberAgent.init()
+
+  const aliceAgent = new Agent(aliceConfig)
+  aliceAgent.setInboundTransporter(new SubjectInboundTransporter(aliceMessages, faberMessages))
+  aliceAgent.setOutboundTransporter(new SubjectOutboundTransporter(faberMessages))
+  await aliceAgent.init()
+
+  const schemaTemplate = {
+    name: `test-schema-${Date.now()}`,
+    attributes: ['name', 'age', 'lastname'],
+    version: '1.0',
+  }
+  const schema = await registerSchema(faberAgent, schemaTemplate)
+  const schemaId = schema.id
+
+  const definitionTemplate = {
+    schema,
+    tag: 'TAG',
+    signatureType: 'CL' as const,
+    supportRevocation: false,
+  }
+  const credentialDefinition = await registerDefinition(faberAgent, definitionTemplate)
+  const credDefId = credentialDefinition.id
+
+  const publicDid = faberAgent.publicDid?.did
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  await ensurePublicDidIsOnLedger(faberAgent, publicDid!)
+  const { agentAConnection, agentBConnection } = await makeConnection(faberAgent, aliceAgent)
+  const faberConnection = agentAConnection
+  const aliceConnection = agentBConnection
+
+  return { faberAgent, aliceAgent, credDefId, schemaId, faberConnection, aliceConnection }
+}

src/agent/AgentConfig.ts

@@ -3,7 +3,7 @@ import type { InitConfig, InboundConnection } from '../types'
 
 import { DID_COMM_TRANSPORT_QUEUE } from '../constants'
 import { ConsoleLogger, LogLevel } from '../logger'
-import { DidCommMimeType } from '../types'
+import { AutoAcceptCredential, DidCommMimeType } from '../types'
 
 export class AgentConfig {
   private initConfig: InitConfig
@@ -63,6 +63,10 @@ export class AgentConfig {
     return this.initConfig.autoAcceptConnections ?? false
   }
 
+  public get autoAcceptCredentials() {
+    return this.initConfig.autoAcceptCredentials ?? AutoAcceptCredential.Never
+  }
+
   public get didCommMimeType() {
     return this.initConfig.didCommMimeType ?? DidCommMimeType.V0
   }

src/modules/credentials/CredentialUtils.ts

@@ -29,6 +29,21 @@ export class CredentialUtils {
     }, {})
   }
 
+  /**
+   * Check whether the values of two credentials match (using {@link assertValuesMatch})
+   *
+   * @returns a boolean whether the values are equal
+   *
+   */
+  public static checkValuesMatch(firstValues: CredValues, secondValues: CredValues): boolean {
+    try {
+      this.assertValuesMatch(firstValues, secondValues)
+      return true
+    } catch {
+      return false
+    }
+  }
+
   /**
    * Assert two credential values objects match.
    *

src/modules/credentials/CredentialsModule.ts

@@ -1,14 +1,16 @@
-import type { ProposeCredentialMessageOptions } from './messages'
+import type { AutoAcceptCredential } from '../../types'
+import type { CredentialPreview } from './messages'
 import type { CredentialRecord } from './repository/CredentialRecord'
-import type { CredentialOfferTemplate } from './services'
+import type { CredentialOfferTemplate, CredentialProposeOptions } from './services'
 
 import { Lifecycle, scoped } from 'tsyringe'
 
+import { AgentConfig } from '../../agent/AgentConfig'
 import { Dispatcher } from '../../agent/Dispatcher'
 import { MessageSender } from '../../agent/MessageSender'
 import { createOutboundMessage } from '../../agent/helpers'
 import { AriesFrameworkError } from '../../error'
-import { ConnectionService } from '../connections'
+import { ConnectionService } from '../connections/services/ConnectionService'
 
 import {
   ProposeCredentialHandler,
@@ -24,16 +26,19 @@ export class CredentialsModule {
   private connectionService: ConnectionService
   private credentialService: CredentialService
   private messageSender: MessageSender
+  private agentConfig: AgentConfig
 
   public constructor(
     dispatcher: Dispatcher,
     connectionService: ConnectionService,
     credentialService: CredentialService,
-    messageSender: MessageSender
+    messageSender: MessageSender,
+    agentConfig: AgentConfig
   ) {
     this.connectionService = connectionService
     this.credentialService = credentialService
     this.messageSender = messageSender
+    this.agentConfig = agentConfig
     this.registerHandlers(dispatcher)
   }
 
@@ -45,7 +50,7 @@ export class CredentialsModule {
    * @param config Additional configuration to use for the proposal
    * @returns Credential record associated with the sent proposal message
    */
-  public async proposeCredential(connectionId: string, config?: Omit<ProposeCredentialMessageOptions, 'id'>) {
+  public async proposeCredential(connectionId: string, config?: CredentialProposeOptions) {
     const connection = await this.connectionService.getById(connectionId)
 
     const { message, credentialRecord } = await this.credentialService.createProposal(connection, config)
@@ -70,6 +75,7 @@ export class CredentialsModule {
     config?: {
       comment?: string
       credentialDefinitionId?: string
+      autoAcceptCredential?: AutoAcceptCredential
     }
   ) {
     const credentialRecord = await this.credentialService.getById(credentialRecordId)
@@ -96,6 +102,58 @@ export class CredentialsModule {
       preview: credentialProposalMessage.credentialProposal,
       credentialDefinitionId,
       comment: config?.comment,
+      autoAcceptCredential: config?.autoAcceptCredential,
+    })
+
+    const outboundMessage = createOutboundMessage(connection, message)
+    await this.messageSender.sendMessage(outboundMessage)
+
+    return credentialRecord
+  }
+
+  /**
+   * Negotiate a credential proposal as issuer (by sending a credential offer message) to the connection
+   * associated with the credential record.
+   *
+   * @param credentialRecordId The id of the credential record for which to accept the proposal
+   * @param preview The new preview for negotiation
+   * @param config Additional configuration to use for the offer
+   * @returns Credential record associated with the credential offer
+   *
+   */
+  public async negotiateProposal(
+    credentialRecordId: string,
+    preview: CredentialPreview,
+    config?: {
+      comment?: string
+      credentialDefinitionId?: string
+      autoAcceptCredential?: AutoAcceptCredential
+    }
+  ) {
+    const credentialRecord = await this.credentialService.getById(credentialRecordId)
+    const connection = await this.connectionService.getById(credentialRecord.connectionId)
+
+    const credentialProposalMessage = credentialRecord.proposalMessage
+
+    if (!credentialProposalMessage?.credentialProposal) {
+      throw new AriesFrameworkError(
+        `Credential record with id ${credentialRecordId} is missing required credential proposal`
+      )
+    }
+
+    const credentialDefinitionId = config?.credentialDefinitionId ?? credentialProposalMessage.credentialDefinitionId
+
+    if (!credentialDefinitionId) {
+      throw new AriesFrameworkError(
+        'Missing required credential definition id. If credential proposal message contains no credential definition id it must be passed to config.'
+      )
+    }
+
+    const { message } = await this.credentialService.createOfferAsResponse(credentialRecord, {
+      preview,
+      credentialDefinitionId,
+      comment: config?.comment,
+      autoAcceptCredential: config?.autoAcceptCredential,
     })
 
     const outboundMessage = createOutboundMessage(connection, message)
@@ -135,7 +193,10 @@ export class CredentialsModule {
    * @returns Credential record associated with the sent credential request message
    *
    */
-  public async acceptOffer(credentialRecordId: string, config?: { comment?: string }) {
+  public async acceptOffer(
+    credentialRecordId: string,
+    config?: { comment?: string; autoAcceptCredential?: AutoAcceptCredential }
+  ) {
     const credentialRecord = await this.credentialService.getById(credentialRecordId)
     const connection = await this.connectionService.getById(credentialRecord.connectionId)
 
@@ -147,6 +208,35 @@ export class CredentialsModule {
     return credentialRecord
   }
 
+  /**
+   * Negotiate a credential offer as holder (by sending a credential proposal message) to the connection
+   * associated with the credential record.
+   *
+   * @param credentialRecordId The id of the credential record for which to accept the offer
+   * @param preview The new preview for negotiation
+   * @param config Additional configuration to use for the request
+   * @returns Credential record associated with the sent credential request message
+   *
+   */
+  public async negotiateOffer(
+    credentialRecordId: string,
+    preview: CredentialPreview,
+    config?: { comment?: string; autoAcceptCredential?: AutoAcceptCredential }
+  ) {
+    const credentialRecord = await this.credentialService.getById(credentialRecordId)
+    const connection = await this.connectionService.getById(credentialRecord.connectionId)
+
+    const { message } = await this.credentialService.createProposalAsResponse(credentialRecord, {
+      ...config,
+      credentialProposal: preview,
+    })
+
+    const outboundMessage = createOutboundMessage(connection, message)
+    await this.messageSender.sendMessage(outboundMessage)
+
+    return credentialRecord
+  }
+
   /**
    * Accept a credential request as issuer (by sending a credential message) to the connection
    * associated with the credential record.
@@ -156,7 +246,10 @@ export class CredentialsModule {
    * @returns Credential record associated with the sent presentation message
    *
    */
-  public async acceptRequest(credentialRecordId: string, config?: { comment?: string }) {
+  public async acceptRequest(
+    credentialRecordId: string,
+    config?: { comment?: string; autoAcceptCredential?: AutoAcceptCredential }
+  ) {
     const credentialRecord = await this.credentialService.getById(credentialRecordId)
     const connection = await this.connectionService.getById(credentialRecord.connectionId)
 
@@ -231,10 +324,10 @@ export class CredentialsModule {
   }
 
   private registerHandlers(dispatcher: Dispatcher) {
-    dispatcher.registerHandler(new ProposeCredentialHandler(this.credentialService))
-    dispatcher.registerHandler(new OfferCredentialHandler(this.credentialService))
-    dispatcher.registerHandler(new RequestCredentialHandler(this.credentialService))
-    dispatcher.registerHandler(new IssueCredentialHandler(this.credentialService))
+    dispatcher.registerHandler(new ProposeCredentialHandler(this.credentialService, this.agentConfig))
+    dispatcher.registerHandler(new OfferCredentialHandler(this.credentialService, this.agentConfig))
+    dispatcher.registerHandler(new RequestCredentialHandler(this.credentialService, this.agentConfig))
+    dispatcher.registerHandler(new IssueCredentialHandler(this.credentialService, this.agentConfig))
     dispatcher.registerHandler(new CredentialAckHandler(this.credentialService))
   }
 }