refactor!: prefix DIDComm module and main classes (openwallet-foundation#2361)

Signed-off-by: Ariel Gentile <gentilester@gmail.com>

Author: genaris

.changeset/fuzzy-nails-think.md

@@ -0,0 +1,14 @@
+---
+"@credo-ts/action-menu": minor
+"@credo-ts/anoncreds": minor
+"@credo-ts/question-answer": minor
+"@credo-ts/cheqd": minor
+"@credo-ts/drpc": minor
+"@credo-ts/didcomm": minor
+
+---
+
+- All `didcomm` package modules, APIs, models and services that are used for dependency injection now are prefixed with `DidComm` in its naming
+- DIDComm-related events have also changed their text string to make it possible to distinguish them from events triggered by other protocols
+- DIDComm credentials module API has been updated to use the term `credentialExchangeRecord` instead of `credentialRecord`, since it is usually confused with W3cCredentialRecords (and potentially other kind of credential records we might have). I took this opportunity to also update `declineOffer` options structure to match DIDComm proofs module API
+- DIDComm-related records were renamed, but their type is still the original one (e.g. `CredentialRecord`, `BasicMessageRecord`). Probably it's worth to take this major release to do the migration, but I'm afraid that it will be a bit risky, so I'm hesitating to do so or leaving it for some other major upgrade (if we think it's actually needed)

.changeset/purple-donkeys-camp.md

@@ -32,11 +32,11 @@ Previously:
       config,
       dependencies: agentDependencies,
       modules: {
-        connections: new ConnectionsModule({
+        connections: new DidCommConnectionsModule({
            autoAcceptConnections: true,
         })
       })
-    this.agent.registerInboundTransport(new HttpInboundTransport({ port }))
+    this.agent.registerInboundTransport(new DidCommHttpInboundTransport({ port }))
     this.agent.registerOutboundTransport(new HttpOutboundTransport())
 
 ```
@@ -57,10 +57,10 @@ Now:
       dependencies: agentDependencies,
       modules: {
         ...getDefaultDidcommModules({ endpoints: ['https://myendpoint'] }),
-        connections: new ConnectionsModule({
+        connections: new DidCommConnectionsModule({
            autoAcceptConnections: true,
         })
       })
-    agent.modules.didcomm.registerInboundTransport(new HttpInboundTransport({ port }))
-    agent.modules.didcomm.registerOutboundTransport(new HttpOutboundTransport())
+    agent.modules.didcomm.registerInboundTransport(new DidCommHttpInboundTransport({ port }))
+    agent.modules.didcomm.registerOutboundTransport(new DidCommHttpOutboundTransport())
 ```

demo/src/Alice.ts

@@ -1,4 +1,8 @@
-import type { ConnectionRecord, CredentialExchangeRecord, ProofExchangeRecord } from '@credo-ts/didcomm'
+import type {
+  DidCommConnectionRecord,
+  DidCommCredentialExchangeRecord,
+  DidCommProofExchangeRecord,
+} from '@credo-ts/didcomm'
 
 import { BaseAgent } from './BaseAgent'
 import { Output, greenText, redText } from './OutputClass'
@@ -35,7 +39,7 @@ export class Alice extends BaseAgent {
     return connectionRecord
   }
 
-  private async waitForConnection(connectionRecord: ConnectionRecord) {
+  private async waitForConnection(connectionRecord: DidCommConnectionRecord) {
     const record = await this.agent.modules.connections.returnWhenIsConnected(connectionRecord.id)
     this.connected = true
     console.log(greenText(Output.ConnectionEstablished))
@@ -47,19 +51,19 @@ export class Alice extends BaseAgent {
     this.connectionRecordFaberId = await this.waitForConnection(connectionRecord)
   }
 
-  public async acceptCredentialOffer(credentialRecord: CredentialExchangeRecord) {
+  public async acceptCredentialOffer(credentialExchangeRecord: DidCommCredentialExchangeRecord) {
     await this.agent.modules.credentials.acceptOffer({
-      credentialRecordId: credentialRecord.id,
+      credentialExchangeRecordId: credentialExchangeRecord.id,
     })
   }
 
-  public async acceptProofRequest(proofRecord: ProofExchangeRecord) {
+  public async acceptProofRequest(proofExchangeRecord: DidCommProofExchangeRecord) {
     const requestedCredentials = await this.agent.modules.proofs.selectCredentialsForRequest({
-      proofRecordId: proofRecord.id,
+      proofExchangeRecordId: proofExchangeRecord.id,
     })
 
     await this.agent.modules.proofs.acceptRequest({
-      proofRecordId: proofRecord.id,
+      proofExchangeRecordId: proofExchangeRecord.id,
       proofFormats: requestedCredentials.proofFormats,
     })
     console.log(greenText('\nProof request accepted!\n'))

demo/src/AliceInquirer.ts

@@ -1,4 +1,4 @@
-import type { CredentialExchangeRecord, ProofExchangeRecord } from '@credo-ts/didcomm'
+import type { DidCommCredentialExchangeRecord, DidCommProofExchangeRecord } from '@credo-ts/didcomm'
 
 import { clear } from 'console'
 import { textSync } from 'figlet'
@@ -69,21 +69,23 @@ export class AliceInquirer extends BaseInquirer {
     await this.processAnswer()
   }
 
-  public async acceptCredentialOffer(credentialRecord: CredentialExchangeRecord) {
+  public async acceptCredentialOffer(credentialExchangeRecord: DidCommCredentialExchangeRecord) {
     const confirm = await prompt([this.inquireConfirmation(Title.CredentialOfferTitle)])
     if (confirm.options === ConfirmOptions.No) {
-      await this.alice.agent.modules.credentials.declineOffer(credentialRecord.id)
+      await this.alice.agent.modules.credentials.declineOffer({
+        credentialExchangeRecordId: credentialExchangeRecord.id,
+      })
     } else if (confirm.options === ConfirmOptions.Yes) {
-      await this.alice.acceptCredentialOffer(credentialRecord)
+      await this.alice.acceptCredentialOffer(credentialExchangeRecord)
     }
   }
 
-  public async acceptProofRequest(proofRecord: ProofExchangeRecord) {
+  public async acceptProofRequest(proofExchangeRecord: DidCommProofExchangeRecord) {
     const confirm = await prompt([this.inquireConfirmation(Title.ProofRequestTitle)])
     if (confirm.options === ConfirmOptions.No) {
-      await this.alice.agent.modules.proofs.declineRequest({ proofRecordId: proofRecord.id })
+      await this.alice.agent.modules.proofs.declineRequest({ proofExchangeRecordId: proofExchangeRecord.id })
     } else if (confirm.options === ConfirmOptions.Yes) {
-      await this.alice.acceptProofRequest(proofRecord)
+      await this.alice.acceptProofRequest(proofExchangeRecord)
     }
   }
 

demo/src/BaseAgent.ts

@@ -2,13 +2,13 @@ import type { DidCommModuleConfigOptions } from '@credo-ts/didcomm'
 import type { IndyVdrPoolConfig } from '@credo-ts/indy-vdr'
 
 import {
-  AnonCredsCredentialFormatService,
+  AnonCredsDidCommCredentialFormatService,
+  AnonCredsDidCommProofFormatService,
   AnonCredsModule,
-  AnonCredsProofFormatService,
-  LegacyIndyCredentialFormatService,
-  LegacyIndyProofFormatService,
-  V1CredentialProtocol,
-  V1ProofProtocol,
+  DidCommCredentialV1Protocol,
+  DidCommProofV1Protocol,
+  LegacyIndyDidCommCredentialFormatService,
+  LegacyIndyDidCommProofFormatService,
 } from '@credo-ts/anoncreds'
 import { AskarModule } from '@credo-ts/askar'
 import {
@@ -20,18 +20,18 @@ import {
 } from '@credo-ts/cheqd'
 import { Agent, DidsModule } from '@credo-ts/core'
 import {
-  AutoAcceptCredential,
-  AutoAcceptProof,
-  ConnectionsModule,
-  CredentialsModule,
-  HttpOutboundTransport,
-  ProofsModule,
-  V2CredentialProtocol,
-  V2ProofProtocol,
+  DidCommAutoAcceptCredential,
+  DidCommAutoAcceptProof,
+  DidCommConnectionsModule,
+  DidCommCredentialV2Protocol,
+  DidCommCredentialsModule,
+  DidCommHttpOutboundTransport,
+  DidCommProofV2Protocol,
+  DidCommProofsModule,
   getDefaultDidcommModules,
 } from '@credo-ts/didcomm'
 import { IndyVdrAnonCredsRegistry, IndyVdrIndyDidResolver, IndyVdrModule } from '@credo-ts/indy-vdr'
-import { HttpInboundTransport, agentDependencies } from '@credo-ts/node'
+import { DidCommHttpInboundTransport, agentDependencies } from '@credo-ts/node'
 import { anoncreds } from '@hyperledger/anoncreds-nodejs'
 import { indyVdr } from '@hyperledger/indy-vdr-nodejs'
 import { askar } from '@openwallet-foundation/askar-nodejs'
@@ -67,8 +67,8 @@ export class BaseAgent {
       dependencies: agentDependencies,
       modules: getAskarAnonCredsIndyModules({ endpoints: [`http://localhost:${this.port}`] }, { id: name, key: name }),
     })
-    this.agent.modules.didcomm.registerInboundTransport(new HttpInboundTransport({ port }))
-    this.agent.modules.didcomm.registerOutboundTransport(new HttpOutboundTransport())
+    this.agent.modules.didcomm.registerInboundTransport(new DidCommHttpInboundTransport({ port }))
+    this.agent.modules.didcomm.registerOutboundTransport(new DidCommHttpOutboundTransport())
   }
 
   public async initializeAgent() {
@@ -82,33 +82,33 @@ function getAskarAnonCredsIndyModules(
   didcommConfig: DidCommModuleConfigOptions,
   askarStoreConfig: AskarModuleConfigStoreOptions
 ) {
-  const legacyIndyCredentialFormatService = new LegacyIndyCredentialFormatService()
-  const legacyIndyProofFormatService = new LegacyIndyProofFormatService()
+  const legacyIndyCredentialFormatService = new LegacyIndyDidCommCredentialFormatService()
+  const legacyIndyProofFormatService = new LegacyIndyDidCommProofFormatService()
 
   return {
     ...getDefaultDidcommModules(didcommConfig),
-    connections: new ConnectionsModule({
+    connections: new DidCommConnectionsModule({
       autoAcceptConnections: true,
     }),
-    credentials: new CredentialsModule({
-      autoAcceptCredentials: AutoAcceptCredential.ContentApproved,
+    credentials: new DidCommCredentialsModule({
+      autoAcceptCredentials: DidCommAutoAcceptCredential.ContentApproved,
       credentialProtocols: [
-        new V1CredentialProtocol({
+        new DidCommCredentialV1Protocol({
           indyCredentialFormat: legacyIndyCredentialFormatService,
         }),
-        new V2CredentialProtocol({
-          credentialFormats: [legacyIndyCredentialFormatService, new AnonCredsCredentialFormatService()],
+        new DidCommCredentialV2Protocol({
+          credentialFormats: [legacyIndyCredentialFormatService, new AnonCredsDidCommCredentialFormatService()],
         }),
       ],
     }),
-    proofs: new ProofsModule({
-      autoAcceptProofs: AutoAcceptProof.ContentApproved,
+    proofs: new DidCommProofsModule({
+      autoAcceptProofs: DidCommAutoAcceptProof.ContentApproved,
       proofProtocols: [
-        new V1ProofProtocol({
+        new DidCommProofV1Protocol({
           indyProofFormat: legacyIndyProofFormatService,
         }),
-        new V2ProofProtocol({
-          proofFormats: [legacyIndyProofFormatService, new AnonCredsProofFormatService()],
+        new DidCommProofV2Protocol({
+          proofFormats: [legacyIndyProofFormatService, new AnonCredsDidCommProofFormatService()],
         }),
       ],
     }),

demo/src/Faber.ts

@@ -1,10 +1,10 @@
 import type { RegisterCredentialDefinitionReturnStateFinished } from '@credo-ts/anoncreds'
-import type { ConnectionRecord, ConnectionStateChangedEvent } from '@credo-ts/didcomm'
+import type { DidCommConnectionRecord, DidCommConnectionStateChangedEvent } from '@credo-ts/didcomm'
 import type { IndyVdrRegisterCredentialDefinitionOptions, IndyVdrRegisterSchemaOptions } from '@credo-ts/indy-vdr'
 import type BottomBar from 'inquirer/lib/ui/bottom-bar'
 
 import { TypedArrayEncoder, utils } from '@credo-ts/core'
-import { ConnectionEventTypes } from '@credo-ts/didcomm'
+import { DidCommConnectionEventTypes } from '@credo-ts/didcomm'
 import { ui } from 'inquirer'
 
 import { transformPrivateKeyToPrivateJwk } from '@credo-ts/askar'
@@ -103,17 +103,20 @@ export class Faber extends BaseAgent {
     console.log('Waiting for Alice to finish connection...')
 
     const getConnectionRecord = (outOfBandId: string) =>
-      new Promise<ConnectionRecord>((resolve, reject) => {
+      new Promise<DidCommConnectionRecord>((resolve, reject) => {
         // Timeout of 20 seconds
         const timeoutId = setTimeout(() => reject(new Error(redText(Output.MissingConnectionRecord))), 20000)
 
         // Start listener
-        this.agent.events.on<ConnectionStateChangedEvent>(ConnectionEventTypes.ConnectionStateChanged, (e) => {
-          if (e.payload.connectionRecord.outOfBandId !== outOfBandId) return
+        this.agent.events.on<DidCommConnectionStateChangedEvent>(
+          DidCommConnectionEventTypes.DidCommConnectionStateChanged,
+          (e) => {
+            if (e.payload.connectionRecord.outOfBandId !== outOfBandId) return
 
-          clearTimeout(timeoutId)
-          resolve(e.payload.connectionRecord)
-        })
+            clearTimeout(timeoutId)
+            resolve(e.payload.connectionRecord)
+          }
+        )
 
         // Also retrieve the connection record by invitation if the event has already fired
         void this.agent.modules.connections.findAllByOutOfBandId(outOfBandId).then(([connectionRecord]) => {

demo/src/Listener.ts

@@ -1,10 +1,10 @@
 import type { Agent } from '@credo-ts/core'
 import type {
-  BasicMessageStateChangedEvent,
-  CredentialExchangeRecord,
-  CredentialStateChangedEvent,
-  ProofExchangeRecord,
-  ProofStateChangedEvent,
+  DidCommBasicMessageStateChangedEvent,
+  DidCommCredentialExchangeRecord,
+  DidCommCredentialStateChangedEvent,
+  DidCommProofExchangeRecord,
+  DidCommProofStateChangedEvent,
 } from '@credo-ts/didcomm'
 import type BottomBar from 'inquirer/lib/ui/bottom-bar'
 import type { Alice } from './Alice'
@@ -13,12 +13,12 @@ import type { Faber } from './Faber'
 import type { FaberInquirer } from './FaberInquirer'
 
 import {
-  BasicMessageEventTypes,
-  BasicMessageRole,
-  CredentialEventTypes,
-  CredentialState,
-  ProofEventTypes,
-  ProofState,
+  DidCommBasicMessageEventTypes,
+  DidCommBasicMessageRole,
+  DidCommCredentialEventTypes,
+  DidCommCredentialState,
+  DidCommProofEventTypes,
+  DidCommProofState,
 } from '@credo-ts/didcomm'
 import { ui } from 'inquirer'
 
@@ -41,17 +41,17 @@ export class Listener {
     this.on = false
   }
 
-  private printCredentialAttributes(credentialRecord: CredentialExchangeRecord) {
-    if (credentialRecord.credentialAttributes) {
-      const attribute = credentialRecord.credentialAttributes
+  private printCredentialAttributes(credentialExchangeRecord: DidCommCredentialExchangeRecord) {
+    if (credentialExchangeRecord.credentialAttributes) {
+      const attribute = credentialExchangeRecord.credentialAttributes
       console.log('\n\nCredential preview:')
       for (const element of attribute) {
         console.log(purpleText(`${element.name} ${Color.Reset}${element.value}`))
       }
     }
   }
 
-  private async newCredentialPrompt(credentialRecord: CredentialExchangeRecord, aliceInquirer: AliceInquirer) {
+  private async newCredentialPrompt(credentialRecord: DidCommCredentialExchangeRecord, aliceInquirer: AliceInquirer) {
     this.printCredentialAttributes(credentialRecord)
     this.turnListenerOn()
     await aliceInquirer.acceptCredentialOffer(credentialRecord)
@@ -61,44 +61,53 @@ export class Listener {
 
   public credentialOfferListener(alice: Alice, aliceInquirer: AliceInquirer) {
     alice.agent.events.on(
-      CredentialEventTypes.CredentialStateChanged,
-      async ({ payload }: CredentialStateChangedEvent) => {
-        if (payload.credentialRecord.state === CredentialState.OfferReceived) {
-          await this.newCredentialPrompt(payload.credentialRecord, aliceInquirer)
+      DidCommCredentialEventTypes.DidCommCredentialStateChanged,
+      async ({ payload }: DidCommCredentialStateChangedEvent) => {
+        if (payload.credentialExchangeRecord.state === DidCommCredentialState.OfferReceived) {
+          await this.newCredentialPrompt(payload.credentialExchangeRecord, aliceInquirer)
         }
       }
     )
   }
 
   public messageListener(agent: Agent, name: string) {
-    agent.events.on(BasicMessageEventTypes.BasicMessageStateChanged, async (event: BasicMessageStateChangedEvent) => {
-      if (event.payload.basicMessageRecord.role === BasicMessageRole.Receiver) {
-        this.ui.updateBottomBar(purpleText(`\n${name} received a message: ${event.payload.message.content}\n`))
+    agent.events.on(
+      DidCommBasicMessageEventTypes.DidCommBasicMessageStateChanged,
+      async (event: DidCommBasicMessageStateChangedEvent) => {
+        if (event.payload.basicMessageRecord.role === DidCommBasicMessageRole.Receiver) {
+          this.ui.updateBottomBar(purpleText(`\n${name} received a message: ${event.payload.message.content}\n`))
+        }
       }
-    })
+    )
   }
 
-  private async newProofRequestPrompt(proofRecord: ProofExchangeRecord, aliceInquirer: AliceInquirer) {
+  private async newProofRequestPrompt(proofExchangeRecord: DidCommProofExchangeRecord, aliceInquirer: AliceInquirer) {
     this.turnListenerOn()
-    await aliceInquirer.acceptProofRequest(proofRecord)
+    await aliceInquirer.acceptProofRequest(proofExchangeRecord)
     this.turnListenerOff()
     await aliceInquirer.processAnswer()
   }
 
   public proofRequestListener(alice: Alice, aliceInquirer: AliceInquirer) {
-    alice.agent.events.on(ProofEventTypes.ProofStateChanged, async ({ payload }: ProofStateChangedEvent) => {
-      if (payload.proofRecord.state === ProofState.RequestReceived) {
-        await this.newProofRequestPrompt(payload.proofRecord, aliceInquirer)
+    alice.agent.events.on(
+      DidCommProofEventTypes.ProofStateChanged,
+      async ({ payload }: DidCommProofStateChangedEvent) => {
+        if (payload.proofRecord.state === DidCommProofState.RequestReceived) {
+          await this.newProofRequestPrompt(payload.proofRecord, aliceInquirer)
+        }
       }
-    })
+    )
   }
 
   public proofAcceptedListener(faber: Faber, faberInquirer: FaberInquirer) {
-    faber.agent.events.on(ProofEventTypes.ProofStateChanged, async ({ payload }: ProofStateChangedEvent) => {
-      if (payload.proofRecord.state === ProofState.Done) {
-        await faberInquirer.processAnswer()
+    faber.agent.events.on(
+      DidCommProofEventTypes.ProofStateChanged,
+      async ({ payload }: DidCommProofStateChangedEvent) => {
+        if (payload.proofRecord.state === DidCommProofState.Done) {
+          await faberInquirer.processAnswer()
+        }
       }
-    })
+    )
   }
 
   public async newAcceptedPrompt(title: string, faberInquirer: FaberInquirer) {