feat: Added support for sending messages through simple HTTP-based transports

__tests__/localAgent.test.ts

@@ -56,6 +56,7 @@ import didComm from './shared/didcomm'
 import messageHandler from './shared/messageHandler'
 import didDiscovery from './shared/didDiscovery'
 import { FakeDidProvider, FakeDidResolver } from './utils/fake-did'
+import { DIDCommHttpTransport } from '../packages/did-comm/src/transports/transports'
 
 const databaseFile = 'local-database.sqlite'
 const infuraProjectId = '5ffc47f65c4042ce847ef66a3fa70d4c'
@@ -152,12 +153,13 @@ const setup = async (options?: IAgentOptions): Promise<boolean> => {
           new SdrMessageHandler(),
         ],
       }),
-      new DIDComm(),
+      new DIDComm([new DIDCommHttpTransport()]),
       new CredentialIssuer(),
       new SelectiveDisclosure(),
       new DIDDiscovery({
         providers: [new AliasDiscoveryProvider(), new ProfileDiscoveryProvider()],
       }),
+      ...options?.plugins || [],
     ],
   })
   return true

__tests__/localMemoryStoreAgent.test.ts

@@ -49,7 +49,6 @@ import { FakeDidProvider, FakeDidResolver } from './utils/fake-did'
 
 const databaseFile = 'local-database2.sqlite'
 const infuraProjectId = '5ffc47f65c4042ce847ef66a3fa70d4c'
-const secretKey = '29739248cad1bd1a0fc4d9b75cd4d2990de535baf5caadfdf8d8f86664aa830c'
 
 let agent: TAgent<
   IDIDManager &
@@ -143,6 +142,7 @@ const setup = async (options?: IAgentOptions): Promise<boolean> => {
       new DIDComm(),
       new CredentialIssuer(),
       new SelectiveDisclosure(),
+      ...options?.plugins || [],
     ],
   })
   return true

__tests__/restAgent.test.ts

@@ -40,14 +40,15 @@ import {
 import { AgentRestClient } from '../packages/remote-client/src'
 import express from 'express'
 import { Server } from 'http'
-import { AgentRouter, RequestWithAgentRouter } from '../packages/remote-server/src'
+import { AgentRouter, RequestWithAgentRouter, MessagingRouter } from '../packages/remote-server/src'
 import { Resolver } from 'did-resolver'
 import { getResolver as ethrDidResolver } from 'ethr-did-resolver'
 import { getResolver as webDidResolver } from 'web-did-resolver'
 import { IDIDDiscovery, DIDDiscovery } from '../packages/did-discovery'
-import { getUniversalResolver } from '../packages/did-resolver/src/universal-resolver'
 import { FakeDidProvider, FakeDidResolver } from './utils/fake-did'
-
+// import { getUniversalResolver } from '../packages/did-resolver/src/universal-resolver'
+import { DIDCommHttpTransport } from '../packages/did-comm/src/transports/transports'
+import { getDidKeyResolver } from '../packages/did-provider-key/build'
 import fs from 'fs'
 
 jest.setTimeout(30000)
@@ -61,6 +62,7 @@ import documentationExamples from './shared/documentationExamples'
 import keyManager from './shared/keyManager'
 import didManager from './shared/didManager'
 import didComm from './shared/didcomm'
+import didCommRemote from './shared/didcommRemote'
 import messageHandler from './shared/messageHandler'
 import didDiscovery from './shared/didDiscovery'
 
@@ -146,7 +148,8 @@ const setup = async (options?: IAgentOptions): Promise<boolean> => {
         resolver: new Resolver({
           ...ethrDidResolver({ infuraProjectId }),
           ...webDidResolver(),
-          key: getUniversalResolver(), // resolve using remote resolver,
+          // key: getUniversalResolver(), // resolve using remote resolver... when uniresolver becomes more stable,
+          ...getDidKeyResolver(),
           ...new FakeDidResolver(() => serverAgent as TAgent<IDIDManager>).getDidFakeResolver(),
         }),
       }),
@@ -160,12 +163,13 @@ const setup = async (options?: IAgentOptions): Promise<boolean> => {
           new SdrMessageHandler(),
         ],
       }),
-      new DIDComm(),
+      new DIDComm([new DIDCommHttpTransport()]),
       new CredentialIssuer(),
       new SelectiveDisclosure(),
       new DIDDiscovery({
         providers: [new AliasDiscoveryProvider(), new ProfileDiscoveryProvider()],
       }),
+      ...options?.plugins || [],
     ],
   })
 
@@ -180,6 +184,13 @@ const setup = async (options?: IAgentOptions): Promise<boolean> => {
   return new Promise((resolve) => {
     const app = express()
     app.use(basePath, requestWithAgent, agentRouter)
+    app.use(
+      '/messaging',
+      requestWithAgent,
+      MessagingRouter({
+        metaData: { type: 'DIDComm', value: 'integration test' },
+      }),
+    )
     restServer = app.listen(port, () => {
       resolve(true)
     })
@@ -205,5 +216,6 @@ describe('REST integration tests', () => {
   didManager(testContext)
   messageHandler(testContext)
   didComm(testContext)
+  didCommRemote(testContext)
   didDiscovery(testContext)
 })

__tests__/shared/didcommRemote.ts

@@ -0,0 +1,126 @@
+import {
+  TAgent,
+  IDIDManager,
+  IKeyManager,
+  IIdentifier,
+  IResolver,
+  IEventListener,
+  IAgentOptions,
+} from '../../packages/core/src'
+import { IDIDComm } from '../../packages/did-comm/src'
+
+type ConfiguredAgent = TAgent<IDIDManager & IKeyManager & IResolver & IDIDComm>
+
+const DIDCommEventSniffer: IEventListener = {
+  eventTypes: ['DIDCommV2Message-sent', 'DIDCommV2Message-received'],
+  onEvent: jest.fn(),
+}
+
+export default (testContext: {
+  getAgent: () => ConfiguredAgent
+  setup: (options?: IAgentOptions) => Promise<boolean>
+  tearDown: () => Promise<boolean>
+}) => {
+  describe('DID comm remote', () => {
+    let agent: ConfiguredAgent
+    let sender: IIdentifier
+    let receiver: IIdentifier
+
+    beforeAll(async () => {
+      await testContext.setup({ plugins: [DIDCommEventSniffer] })
+      agent = testContext.getAgent()
+
+      sender = await agent.didManagerImport({
+        did: 'did:fake:z6MkgbqNU4uF9NKSz5BqJQ4XKVHuQZYcUZP8pXGsJC8nTHwo',
+        keys: [
+          {
+            type: 'Ed25519',
+            kid: 'didcomm-senderKey-1',
+            publicKeyHex: '1fe9b397c196ab33549041b29cf93be29b9f2bdd27322f05844112fad97ff92a',
+            privateKeyHex:
+              'b57103882f7c66512dc96777cbafbeb2d48eca1e7a867f5a17a84e9a6740f7dc1fe9b397c196ab33549041b29cf93be29b9f2bdd27322f05844112fad97ff92a',
+            kms: 'local',
+          },
+        ],
+        services: [
+          {
+            id: 'msg1',
+            type: 'DIDCommMessaging',
+            serviceEndpoint: 'http://localhost:3002/messaging',
+          },
+        ],
+        provider: 'did:fake',
+        alias: 'sender',
+      })
+
+      receiver = await agent.didManagerImport({
+        did: 'did:fake:z6MkrPhffVLBZpxH7xvKNyD4sRVZeZsNTWJkLdHdgWbfgNu3',
+        keys: [
+          {
+            type: 'Ed25519',
+            kid: 'didcomm-receiverKey-1',
+            publicKeyHex: 'b162e405b6485eff8a57932429b192ec4de13c06813e9028a7cdadf0e2703636',
+            privateKeyHex:
+              '19ed9b6949cfd0f9a57e30f0927839a985fa699491886ebcdda6a954d869732ab162e405b6485eff8a57932429b192ec4de13c06813e9028a7cdadf0e2703636',
+            kms: 'local',
+          },
+        ],
+        services: [
+          {
+            id: 'msg2',
+            type: 'DIDCommMessaging',
+            serviceEndpoint: 'http://localhost:3002/messaging',
+          },
+        ],
+        provider: 'did:fake',
+        alias: 'receiver',
+      })
+      return true
+    })
+    afterAll(testContext.tearDown)
+
+    it('should send a message', async () => {
+      expect.assertions(3)
+
+      const message = {
+        type: 'test',
+        to: receiver.did,
+        from: sender.did,
+        id: 'test',
+        body: { hello: 'world' },
+      }
+      const packedMessage = await agent.packDIDCommMessage({
+        packing: 'authcrypt',
+        message,
+      })
+      const result = await agent.sendDIDCommMessage({
+        messageId: '123',
+        packedMessage,
+        recipientDidUrl: receiver.did,
+      })
+
+      expect(result).toBeTruthy()
+      expect(DIDCommEventSniffer.onEvent).toHaveBeenCalledWith(
+        { data: '123', type: 'DIDCommV2Message-sent' },
+        expect.anything(),
+      )
+      // in our case, it is the same agent that is receiving the messages
+      expect(DIDCommEventSniffer.onEvent).toHaveBeenCalledWith(
+        {
+          data: {
+            message: {
+              body: { hello: 'world' },
+              from: 'did:fake:z6MkgbqNU4uF9NKSz5BqJQ4XKVHuQZYcUZP8pXGsJC8nTHwo',
+              id: 'test',
+              to: 'did:fake:z6MkrPhffVLBZpxH7xvKNyD4sRVZeZsNTWJkLdHdgWbfgNu3',
+              type: 'test',
+            },
+            metaData: { packing: 'authcrypt' },
+          },
+          type: 'DIDCommV2Message-received',
+        },
+        expect.anything(),
+      )
+    })
+  })
+}

packages/did-comm/plugin.schema.json

@@ -103,39 +103,22 @@
             "packedMessage": {
               "$ref": "#/components/schemas/IPackedDIDCommMessage"
             },
-            "returnTransport": {
-              "$ref": "#/components/schemas/IDIDCommTransport"
+            "messageId": {
+              "type": "string"
             },
-            "recipientDID": {
+            "returnTransportId": {
               "type": "string"
-            }
-          },
-          "required": [
-            "packedMessage",
-            "recipientDID"
-          ]
-        },
-        "IDIDCommTransport": {
-          "type": "object",
-          "properties": {
-            "id": {
+            },
+            "recipientDidUrl": {
               "type": "string"
             }
           },
           "required": [
-            "id"
-          ]
-        },
-        "ISendDIDCommMessageResult": {
-          "type": "object",
-          "properties": {
-            "sent": {
-              "type": "boolean"
-            },
-            "error": {
-              "type": "string"
-            }
-          }
+            "packedMessage",
+            "messageId",
+            "recipientDidUrl"
+          ],
+          "description": "The input to the  {@link  DIDComm.sendDIDCommMessage }  method. The provided `messageId` will be used in the emitted event to allow event/message correlation."
         },
         "ISendMessageDIDCommAlpha1Args": {
           "type": "object",
@@ -488,12 +471,12 @@
           }
         },
         "sendDIDCommMessage": {
-          "description": "TODO: add docs here",
+          "description": "Sends the given message to the recipient. If a return transport is provided it will be checked whether the parent thread allows reusing the route. You cannot reuse the transport if the message was forwarded from a DIDComm mediator.",
           "arguments": {
             "$ref": "#/components/schemas/ISendDIDCommMessageArgs"
           },
           "returnType": {
-            "$ref": "#/components/schemas/ISendDIDCommMessageResult"
+            "type": "string"
           }
         },
         "sendMessageDIDCommAlpha1": {