Add trustping protocol

src/lib/agent/Agent.ts

@@ -7,6 +7,7 @@ import { ConnectionService } from '../protocols/connections/ConnectionService';
 import { MessageType as ConnectionsMessageType } from '../protocols/connections/messages';
 import { MessageType as BasicMessageMessageType } from '../protocols/basicmessage/messages';
 import { MessageType as RoutingMessageType } from '../protocols/routing/messages';
+import { MessageType as TrustPingMessageType } from '../protocols/trustping/messages';
 import { ProviderRoutingService } from '../protocols/routing/ProviderRoutingService';
 import { BasicMessageService } from '../protocols/basicmessage/BasicMessageService';
 import { ConsumerRoutingService } from '../protocols/routing/ConsumerRoutingService';
@@ -24,6 +25,8 @@ import { BasicMessageHandler } from '../handlers/BasicMessageHandler';
 import { RouteUpdateHandler } from '../handlers/RouteUpdateHandler';
 import { ForwardHandler } from '../handlers/ForwardHandler';
 import { Handler } from '../handlers/Handler';
+import { TrustPingHandler } from '../handlers/TrustPingHandler';
+import { TrustPingService } from '../protocols/trustping/TrustPingService';
 
 export class Agent {
   inboundTransporter: InboundTransporter;
@@ -33,6 +36,7 @@ export class Agent {
   basicMessageService: BasicMessageService;
   providerRoutingService: ProviderRoutingService;
   consumerRoutingService: ConsumerRoutingService;
+  trustPingService: TrustPingService;
   handlers: { [key: string]: Handler } = {};
 
   constructor(config: InitConfig, inboundTransporter: InboundTransporter, outboundTransporter: OutboundTransporter) {
@@ -53,6 +57,7 @@ export class Agent {
     this.basicMessageService = new BasicMessageService();
     this.providerRoutingService = new ProviderRoutingService();
     this.consumerRoutingService = new ConsumerRoutingService(this.context);
+    this.trustPingService = new TrustPingService();
 
     this.registerHandlers();
 
@@ -142,6 +147,7 @@ export class Agent {
   }
 
   private registerHandlers() {
+    const trustPingHandler = new TrustPingHandler(this.trustPingService, this.connectionService);
     const handlers = {
       [ConnectionsMessageType.ConnectionInvitation]: new InvitationHandler(
         this.connectionService,
@@ -156,6 +162,8 @@ export class Agent {
         this.providerRoutingService
       ),
       [RoutingMessageType.ForwardMessage]: new ForwardHandler(this.providerRoutingService),
+      [TrustPingMessageType.TrustPingMessage]: trustPingHandler,
+      [TrustPingMessageType.TrustPingResponseMessage]: trustPingHandler,
     };
 
     this.handlers = handlers;

src/lib/handlers/TrustPingHandler.ts

@@ -0,0 +1,31 @@
+import { Handler } from './Handler';
+import { InboundMessage } from '../types';
+import { TrustPingService } from '../protocols/trustping/TrustPingService';
+import { ConnectionService } from '../protocols/connections/ConnectionService';
+import { MessageType } from '../protocols/trustping/messages';
+
+export class TrustPingHandler implements Handler {
+  trustPingService: TrustPingService;
+  connectionService: ConnectionService;
+
+  constructor(trustPingService: TrustPingService, connectionService: ConnectionService) {
+    this.trustPingService = trustPingService;
+    this.connectionService = connectionService;
+  }
+
+  async handle(inboundMessage: InboundMessage) {
+    switch (inboundMessage.message['@type']) {
+      case MessageType.TrustPingMessage:
+        const { recipient_verkey } = inboundMessage;
+        const connection = this.connectionService.findByVerkey(recipient_verkey);
+        if (!connection) {
+          throw new Error(`Connection for receipient_verkey ${recipient_verkey} not found`);
+        }
+        return this.trustPingService.process_ping(inboundMessage, connection);
+      case MessageType.TrustPingResponseMessage:
+        return this.trustPingService.process_ping_response(inboundMessage);
+      default:
+        throw new Error('Invalid message type for handler');
+    }
+  }
+}

src/lib/protocols/connections/ConnectionService.ts

@@ -9,6 +9,7 @@ import { Context } from '../../agent/Context';
 import { createOutboundMessage } from '../helpers';
 import { Connection } from './domain/Connection';
 import { ConnectionState } from './domain/ConnectionState';
+import { createTrustPingMessage } from '../trustping/messages';
 
 class ConnectionService {
   context: Context;
@@ -82,7 +83,7 @@ class ConnectionService {
 
     validateSenderKey(connection, sender_verkey);
 
-    const response = createAckMessage(message['@id']);
+    const response = createTrustPingMessage();
     connection.updateState(ConnectionState.COMPLETE);
     return createOutboundMessage(connection, response);
   }

src/lib/protocols/trustping/TrustPingService.ts

@@ -0,0 +1,22 @@
+import { InboundMessage } from '../../types';
+import { createOutboundMessage } from '../helpers';
+import { createTrustPingResponseMessage, MessageType } from './messages';
+import { Connection } from '../..';
+import { ConnectionState } from '../connections/domain/ConnectionState';
+
+export class TrustPingService {
+  process_ping(inboundMessage: InboundMessage, connection: Connection) {
+    if (connection.getState() != ConnectionState.COMPLETE) {
+      connection.updateState(ConnectionState.COMPLETE);
+    }
+    if (inboundMessage.message['response_requested']) {
+      const reply = createTrustPingResponseMessage(inboundMessage.message['@id']);
+      return createOutboundMessage(connection, reply);
+    }
+    return null;
+  }
+
+  process_ping_response(inboundMessage: InboundMessage) {
+    return null;
+  }
+}

src/lib/protocols/trustping/messages.ts

@@ -0,0 +1,26 @@
+import uuid from 'uuid/v4';
+
+export enum MessageType {
+  TrustPingMessage = 'did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/trust_ping/1.0/ping',
+  TrustPingResponseMessage = 'did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/trust_ping/1.0/ping_response',
+}
+
+export function createTrustPingMessage(response_requested: boolean = true, comment: string = '') {
+  return {
+    '@id': uuid(),
+    '@type': MessageType.TrustPingMessage,
+    ...(comment && { comment }),
+    response_requested,
+  };
+}
+
+export function createTrustPingResponseMessage(thid: string, comment: string = '') {
+  return {
+    '@id': uuid(),
+    '@type': MessageType.TrustPingResponseMessage,
+    '~thread': {
+      thid,
+    },
+    ...(comment && { comment }),
+  };
+}