feat: Reply to Trust Pings (#496)

Implement the Trust Ping protocol
Reply to Trust Pings in the Prism agent

build.sbt

@@ -478,6 +478,14 @@ lazy val protocolPresentProof = project
   .settings(libraryDependencies += D.munitZio)
   .dependsOn(models)
 
+lazy val protocolTrustPing = project
+  .in(file("mercury/mercury-library/protocol-trust-ping"))
+  .settings(name := "mercury-protocol-trust-ping")
+  .settings(libraryDependencies += D.zio)
+  .settings(libraryDependencies ++= Seq(D.circeCore, D.circeGeneric, D.circeParser))
+  .settings(libraryDependencies += D.munitZio)
+  .dependsOn(models)
+
 // ################
 // ### Resolver ###
 // ################
@@ -518,6 +526,7 @@ lazy val agent = project // maybe merge into models
     protocolPresentProof,
     protocolConnection,
     protocolReportProblem,
+    protocolTrustPing,
   )
 
 /** agents implementation with didcommx */

mercury/mercury-library/protocol-trust-ping/src/main/scala/io/iohk/atala/mercury/protocol/trustping/TrustPing.scala

@@ -0,0 +1,72 @@
+package io.iohk.atala.mercury.protocol.trustping
+
+import io.circe._
+import io.circe.syntax._
+import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
+import io.iohk.atala.mercury.model._
+
+/** https://identity.foundation/didcomm-messaging/spec/#trust-ping-protocol-20 */
+final case class TrustPing(
+    `type`: PIURI = TrustPing.`type`,
+    id: String = java.util.UUID.randomUUID().toString,
+    from: DidId,
+    to: DidId,
+    body: TrustPing.Body,
+) {
+  assert(`type` == TrustPing.`type`)
+
+  def makeMessage: Message = Message(
+    id = this.id,
+    `type` = this.`type`,
+    from = Some(this.from),
+    to = Seq(this.to),
+    body = this.body.asJson.asObject.get,
+  )
+
+  def makeReply = TrustPingResponse(
+    thid = this.id,
+    from = to,
+    to = from,
+  )
+}
+
+object TrustPing {
+  def `type`: PIURI = "https://didcomm.org/trust-ping/2.0/ping"
+  case class Body(
+      response_requested: Option[Boolean] = Some(true),
+  )
+  object Body {
+    given Encoder[Body] = deriveEncoder[Body]
+    given Decoder[Body] = deriveDecoder[Body]
+  }
+  given Encoder[TrustPing] = deriveEncoder[TrustPing]
+  given Decoder[TrustPing] = deriveDecoder[TrustPing]
+
+  /** Parse a generecy DIDComm Message into a TrustPing */
+  def fromMessage(message: Message): Either[String, TrustPing] =
+    for {
+      piuri <-
+        if (message.`type` == TrustPing.`type`) Right(message.`type`)
+        else Left(s"Message MUST be of the type '${TrustPing.`type`}' instead of '${message.`type`}'")
+      body <- message.body.asJson
+        .as[TrustPing.Body]
+        .left
+        .map(ex => "Fail to parse the body of the TrustPing because: " + ex.message)
+      ret <- message.to match
+        case Seq(onlyOneRecipient) =>
+          message.from match
+            case Some(from) =>
+              Right(
+                TrustPing(
+                  id = message.id,
+                  `type` = piuri,
+                  body = body,
+                  from = from,
+                  to = onlyOneRecipient
+                )
+              )
+            case None => Left("TrustPing needs to define the recipient")
+        case _ => Left("The recipient is ambiguous. Need to have only 1 recipient")
+    } yield ret
+
+}

mercury/mercury-library/protocol-trust-ping/src/main/scala/io/iohk/atala/mercury/protocol/trustping/TrustPingResponse.scala

@@ -0,0 +1,51 @@
+package io.iohk.atala.mercury.protocol.trustping
+
+import io.circe._
+import io.circe.syntax._
+import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
+import io.iohk.atala.mercury.model._
+
+final case class TrustPingResponse(
+    `type`: PIURI = TrustPingResponse.`type`,
+    id: String = java.util.UUID.randomUUID().toString,
+    thid: String,
+    from: DidId,
+    to: DidId,
+) {
+  assert(`type` == TrustPingResponse.`type`)
+
+  def makeMessage: Message = Message(
+    id = this.id,
+    thid = Some(this.thid),
+    `type` = this.`type`,
+    from = Some(this.from),
+    to = Seq(this.to),
+  )
+}
+
+object TrustPingResponse {
+  def `type`: PIURI = "https://didcomm.org/trust-ping/2.0/ping-response"
+
+  /** Parse a generecy DIDComm Message into a TrustPingResponse */
+  def fromMessage(message: Message): Either[String, TrustPingResponse] =
+    for {
+      piuri <-
+        if (message.`type` == TrustPingResponse.`type`) Right(message.`type`)
+        else Left(s"Message MUST be of the type '${TrustPingResponse.`type`}' instead of '${message.`type`}'")
+      ret <- message.to match
+        case Seq(onlyOneRecipient) =>
+          message.from match
+            case Some(from) =>
+              Right(
+                TrustPingResponse(
+                  id = message.id,
+                  thid = message.thid.getOrElse(???), // TODO
+                  `type` = piuri,
+                  from = from,
+                  to = onlyOneRecipient,
+                )
+              )
+            case None => Left("TrustPingResponse needs to define the recipient")
+        case _ => Left("The recipient is ambiguous. Need to have only 1 recipient")
+    } yield ret
+}

prism-agent/service/server/src/main/scala/io/iohk/atala/agent/server/Modules.scala

@@ -66,6 +66,7 @@ import zio.stream.ZStream
 
 import java.io.IOException
 import java.util.concurrent.Executors
+import io.iohk.atala.mercury.protocol.trustping.TrustPing
 
 object Modules {
 
@@ -98,7 +99,8 @@ object Modules {
   def didCommServiceEndpoint(port: Int) = {
     val header = "content-type" -> MediaTypes.contentTypeEncrypted
     val app: HttpApp[
-      DidOps & DidAgent & CredentialService & PresentationService & ConnectionService & ManagedDIDService,
+      DidOps & DidAgent & CredentialService & PresentationService & ConnectionService & ManagedDIDService & HttpClient &
+        DidAgent & DIDResolver,
       Throwable
     ] =
       Http.collectZIO[Request] {
@@ -194,10 +196,9 @@ object Modules {
     } yield msg.message
   }
 
-  def webServerProgram(
-      jsonString: String
-  ): ZIO[
-    DidOps & CredentialService & PresentationService & ConnectionService & ManagedDIDService,
+  def webServerProgram(jsonString: String): ZIO[
+    DidOps & CredentialService & PresentationService & ConnectionService & ManagedDIDService & HttpClient & DidAgent &
+      DIDResolver,
     MercuryThrowable | DIDSecretStorageError,
     Unit
   ] = {
@@ -211,6 +212,34 @@ object Modules {
         connectionService <- ZIO.service[ConnectionService]
         _ <- {
           msg.piuri match {
+            // ##################
+            // ### Trust-Ping ###
+            // ##################
+            case s if s == TrustPing.`type` =>
+              for {
+                _ <- ZIO.logInfo("*" * 100)
+                trustPingMsg = TrustPing.fromMessage(msg)
+                _ <- ZIO.logInfo(s"TrustPing from ${msg.from}: " + msg + " -> " + trustPingMsg)
+                trustPingResponseMsg = trustPingMsg match {
+                  case Left(value) => None
+                  case Right(trustPing) =>
+                    trustPing.body.response_requested match
+                      case None        => Some(trustPing.makeReply.makeMessage)
+                      case Some(true)  => Some(trustPing.makeReply.makeMessage)
+                      case Some(false) => None
+                }
+                _ <- trustPingResponseMsg match
+                  case None => ZIO.logWarning(s"Did not reply to the ${TrustPing.`type`}")
+                  case Some(message) =>
+                    MessagingService
+                      .send(message)
+                      .flatMap(response =>
+                        response.status match
+                          case c if c >= 200 & c < 300 => ZIO.unit
+                          case c                       => ZIO.logWarning(response.toString())
+                      )
+              } yield ()
+
             // ########################
             // ### issue-credential ###
             // ########################