feat: add support for new out-of-band protocol

packages/core/src/agent/Agent.ts

@@ -20,6 +20,7 @@ import { CredentialsModule } from '../modules/credentials/CredentialsModule'
 import { DidsModule } from '../modules/dids/DidsModule'
 import { DiscoverFeaturesModule } from '../modules/discover-features'
 import { LedgerModule } from '../modules/ledger/LedgerModule'
+import { OutOfBandModule } from '../modules/oob/OutOfBandModule'
 import { ProofsModule } from '../modules/proofs/ProofsModule'
 import { MediatorModule } from '../modules/routing/MediatorModule'
 import { RecipientModule } from '../modules/routing/RecipientModule'
@@ -56,6 +57,7 @@ export class Agent {
   public readonly discovery: DiscoverFeaturesModule
   public readonly dids: DidsModule
   public readonly wallet: Wallet
+  public readonly oob!: OutOfBandModule
 
   public constructor(initialConfig: InitConfig, dependencies: AgentDependencies) {
     // Create child container so we don't interfere with anything outside of this agent
@@ -105,13 +107,14 @@ export class Agent {
     this.ledger = this.container.resolve(LedgerModule)
     this.discovery = this.container.resolve(DiscoverFeaturesModule)
     this.dids = this.container.resolve(DidsModule)
+    this.oob = this.container.resolve(OutOfBandModule)
 
     // Listen for new messages (either from transports or somewhere else in the framework / extensions)
     this.messageSubscription = this.eventEmitter
       .observable<AgentMessageReceivedEvent>(AgentEventTypes.AgentMessageReceived)
       .pipe(
         takeUntil(this.agentConfig.stop$),
-        concatMap((e) => this.messageReceiver.receiveMessage(e.payload.message))
+        concatMap((e) => this.messageReceiver.receiveMessage(e.payload.message, { connection: e.payload.connection }))
       )
       .subscribe()
   }
@@ -215,7 +218,7 @@ export class Agent {
   }
 
   public async receiveMessage(inboundMessage: unknown, session?: TransportSession) {
-    return await this.messageReceiver.receiveMessage(inboundMessage, session)
+    return await this.messageReceiver.receiveMessage(inboundMessage, { session })
   }
 
   public get injectionContainer() {

packages/core/src/agent/Events.ts

@@ -15,6 +15,7 @@ export interface AgentMessageReceivedEvent extends BaseEvent {
   type: typeof AgentEventTypes.AgentMessageReceived
   payload: {
     message: unknown
+    connection?: ConnectionRecord
   }
 }
 

packages/core/src/agent/MessageReceiver.ts

@@ -60,36 +60,42 @@ export class MessageReceiver {
    *
    * @param inboundMessage the message to receive and handle
    */
-  public async receiveMessage(inboundMessage: unknown, session?: TransportSession) {
+  public async receiveMessage(
+    inboundMessage: unknown,
+    { session, connection }: { session?: TransportSession; connection?: ConnectionRecord }
+  ) {
     this.logger.debug(`Agent ${this.config.label} received message`)
 
     if (this.isPlaintextMessage(inboundMessage)) {
-      await this.receivePlaintextMessage(inboundMessage)
+      await this.receivePlaintextMessage(inboundMessage, connection)
     } else {
       await this.receiveEncryptedMessage(inboundMessage as EncryptedMessage, session)
     }
   }
 
-  private async receivePlaintextMessage(plaintextMessage: PlaintextMessage) {
+  private async receivePlaintextMessage(plaintextMessage: PlaintextMessage, connection?: ConnectionRecord) {
     const message = await this.transformAndValidate(plaintextMessage)
-    const messageContext = new InboundMessageContext(message, {})
+    const messageContext = new InboundMessageContext(message, { connection })
     await this.dispatcher.dispatch(messageContext)
   }
 
   private async receiveEncryptedMessage(encryptedMessage: EncryptedMessage, session?: TransportSession) {
     const { plaintextMessage, senderKey, recipientKey } = await this.decryptMessage(encryptedMessage)
 
     let connection: ConnectionRecord | null = null
+    let unverifiedConnection: ConnectionRecord | null = null
 
     // Only fetch connection if recipientKey and senderKey are present (AuthCrypt)
     if (senderKey && recipientKey) {
-      connection = await this.connectionService.findByVerkey(recipientKey)
+      unverifiedConnection = await this.connectionService.findByVerkey(recipientKey)
 
       // Throw error if the recipient key (ourKey) does not match the key of the connection record
-      if (connection && connection.theirKey !== null && connection.theirKey !== senderKey) {
-        throw new AriesFrameworkError(
-          `Inbound message senderKey '${senderKey}' is different from connection.theirKey '${connection.theirKey}'`
-        )
+      if (
+        unverifiedConnection &&
+        unverifiedConnection.theirKey !== null &&
+        unverifiedConnection.theirKey === senderKey
+      ) {
+        connection = unverifiedConnection
       }
     }
 
@@ -115,7 +121,7 @@ export class MessageReceiver {
       // We allow unready connections to be attached to the session as we want to be able to
       // use return routing to make connections. This is especially useful for creating connections
       // with mediators when you don't have a public endpoint yet.
-      session.connection = connection ?? undefined
+      session.connection = connection ?? unverifiedConnection ?? undefined
       this.transportService.saveSession(session)
     }
 

packages/core/src/index.ts

@@ -31,6 +31,8 @@ export * from './logger'
 export * from './error'
 export * from './wallet/error'
 
+export * from './agent/Events'
+
 const utils = {
   uuid,
 }

packages/core/src/modules/connections/ConnectionsModule.ts

@@ -95,11 +95,11 @@ export class ConnectionsModule {
       alias: config?.alias,
       routing,
     })
-    // if auto accept is enabled (either on the record or the global agent config)
-    // we directly send a connection request
+
     if (connection.autoAcceptConnection ?? this.agentConfig.autoAcceptConnections) {
       connection = await this.acceptInvitation(connection.id)
     }
+
     return connection
   }
 

packages/core/src/modules/connections/services/ConnectionService.ts

@@ -184,7 +184,6 @@ export class ConnectionService {
       connectionRecord.autoAcceptConnection = config?.autoAcceptConnection
     }
 
-    connectionRecord.autoAcceptConnection = config?.autoAcceptConnection
     await this.updateState(connectionRecord, ConnectionState.Requested)
 
     return {