Use keys from inbound message instead of service when sending via ret…

…run route Signed-off-by: Jakub Koci <[email protected]>
openwallet-foundation · Jun 22, 2021 · f759f0e · f759f0e
1 parent 3809402
commit f759f0e
Show file tree

Hide file tree

Showing 4 changed files with 60 additions and 40 deletions.
diff --git a/src/agent/Dispatcher.ts b/src/agent/Dispatcher.ts
@@ -45,13 +45,12 @@ class Dispatcher {
 
       // Check for return routing, with thread id
       if (message.hasReturnRouting(threadId)) {
-        // Find service with highest priority and keys to pack message
-        const [service] = this.transportService.findDidCommServices(outboundMessage.connection)
-        if (!service) {
-          throw new AriesFrameworkError(`Connection with id ${outboundMessage.connection.id} has no service!`)
+        const keys = {
+          recipientKeys: messageContext.senderVerkey ? [messageContext.senderVerkey] : [],
+          routingKeys: [],
+          senderKey: messageContext.connection?.verkey || null,
         }
-        // TODO Should we validate inbound transport session scheme and service endpoint scheme?
-        return await this.messageSender.packMessage(outboundMessage, service)
+        return await this.messageSender.packMessage(outboundMessage, keys)
       }
 
       await this.messageSender.sendMessage(outboundMessage)

diff --git a/src/agent/EnvelopeService.ts b/src/agent/EnvelopeService.ts
@@ -11,7 +11,7 @@ import { Wallet } from '../wallet/Wallet'
 
 import { AgentConfig } from './AgentConfig'
 
-interface Keys {
+export interface EnvelopeKeys {
   recipientKeys: Verkey[]
   routingKeys: Verkey[]
   senderKey: Verkey | null
@@ -27,10 +27,12 @@ class EnvelopeService {
     this.logger = agentConfig.logger
   }
 
-  public async packMessage(keys: Keys, payload: AgentMessage): Promise<JsonWebKey> {
+  public async packMessage(payload: AgentMessage, keys: EnvelopeKeys): Promise<JsonWebKey> {
     const { routingKeys, recipientKeys, senderKey: senderVk } = keys
     const message = payload.toJSON()
 
+    this.logger.debug('Pack outbound message', { message })
+
     let wireMessage = await this.wallet.pack(message, recipientKeys, senderVk)
 
     if (routingKeys && routingKeys.length > 0) {

diff --git a/src/agent/MessageSender.ts b/src/agent/MessageSender.ts
@@ -1,6 +1,6 @@
-import type { DidCommService } from '../modules/connections'
 import type { OutboundTransporter } from '../transport/OutboundTransporter'
 import type { OutboundMessage, OutboundPackage } from '../types'
+import type { EnvelopeKeys } from './EnvelopeService'
 
 import { inject, Lifecycle, scoped } from 'tsyringe'
 
@@ -36,37 +36,43 @@ export class MessageSender {
     return this._outboundTransporter
   }
 
-  public async packMessage(outboundMessage: OutboundMessage, service: DidCommService): Promise<OutboundPackage> {
+  public async packMessage(outboundMessage: OutboundMessage, keys: EnvelopeKeys): Promise<OutboundPackage> {
     const { connection, payload } = outboundMessage
-    const { verkey, theirKey } = connection
-    const endpoint = service.serviceEndpoint
-    const message = payload.toJSON()
-    this.logger.debug('outboundMessage', { verkey, theirKey, message })
-    const keys = {
-      recipientKeys: service.recipientKeys,
-      routingKeys: service.routingKeys || [],
-      senderKey: connection.verkey,
-    }
-    const wireMessage = await this.envelopeService.packMessage(keys, outboundMessage.payload)
-    const responseRequested = outboundMessage.payload.hasReturnRouting()
-    return { connection, payload: wireMessage, endpoint, responseRequested }
+    const wireMessage = await this.envelopeService.packMessage(payload, keys)
+    return { connection, payload: wireMessage }
   }
 
   public async sendMessage(outboundMessage: OutboundMessage): Promise<void> {
     if (!this.outboundTransporter) {
       throw new AriesFrameworkError('Agent has no outbound transporter!')
     }
 
-    const services = this.transportService.findDidCommServices(outboundMessage.connection)
+    const { connection, payload } = outboundMessage
+    const { id, verkey, theirKey } = connection
+    const message = payload.toJSON()
+    this.logger.debug('Send outbound message', {
+      messageId: message.id,
+      connection: { id, verkey, theirKey },
+    })
+
+    const services = this.transportService.findDidCommServices(connection)
     if (services.length === 0) {
-      throw new AriesFrameworkError(`Connection with id ${outboundMessage.connection.id} has no service!`)
+      throw new AriesFrameworkError(`Connection with id ${connection.id} has no service!`)
     }
 
     for await (const service of services) {
-      this.logger.debug(`Sending outbound message to service:`, { service })
+      this.logger.debug(`Sending outbound message to service:`, { messageId: message.id, service })
       try {
-        const outboundPackage = await this.packMessage(outboundMessage, service)
-        outboundPackage.session = this.transportService.findSession(outboundMessage.connection.id)
+        const keys = {
+          recipientKeys: service.recipientKeys,
+          routingKeys: service.routingKeys || [],
+          senderKey: connection.verkey,
+        }
+        const outboundPackage = await this.packMessage(outboundMessage, keys)
+        outboundPackage.session = this.transportService.findSession(connection.id)
+        outboundPackage.endpoint = service.serviceEndpoint
+        outboundPackage.responseRequested = outboundMessage.payload.hasReturnRouting()
+
         await this.outboundTransporter.sendMessage(outboundPackage)
         break
       } catch (error) {

diff --git a/src/agent/__tests__/MessageSender.test.ts b/src/agent/__tests__/MessageSender.test.ts
@@ -139,6 +139,26 @@ describe('MessageSender', () => {
       })
       expect(sendMessageSpy).toHaveBeenCalledTimes(2)
     })
+
+    test('calls send message with responseRequested when message has return route', async () => {
+      messageSender.setOutboundTransporter(outboundTransporter)
+      const sendMessageSpy = jest.spyOn(outboundTransporter, 'sendMessage')
+
+      const message = new AgentMessage()
+      message.setReturnRouting(ReturnRouteTypes.all)
+      const outboundMessage = createOutboundMessage(connection, message)
+
+      await messageSender.sendMessage(outboundMessage)
+
+      expect(sendMessageSpy).toHaveBeenCalledWith({
+        connection,
+        payload: wireMessage,
+        endpoint: firstDidCommService.serviceEndpoint,
+        responseRequested: true,
+        session,
+      })
+      expect(sendMessageSpy).toHaveBeenCalledTimes(1)
+    })
   })
 
   describe('packMessage', () => {
@@ -158,24 +178,17 @@ describe('MessageSender', () => {
       const message = new AgentMessage()
       const outboundMessage = createOutboundMessage(connection, message)
 
-      const result = await messageSender.packMessage(outboundMessage, firstDidCommService)
+      const keys = {
+        recipientKeys: ['service.recipientKeys'],
+        routingKeys: [],
+        senderKey: connection.verkey,
+      }
+      const result = await messageSender.packMessage(outboundMessage, keys)
 
       expect(result).toEqual({
         connection,
         payload: wireMessage,
-        endpoint: firstDidCommService.serviceEndpoint,
-        responseRequested: false,
       })
     })
-
-    test('when message has return route returns outbound message context with responseRequested', async () => {
-      const message = new AgentMessage()
-      message.setReturnRouting(ReturnRouteTypes.all)
-      const outboundMessage = createOutboundMessage(connection, message)
-
-      const result = await messageSender.packMessage(outboundMessage, firstDidCommService)
-
-      expect(result.responseRequested).toEqual(true)
-    })
   })
 })