feat(mercury): Split DidComm into DidAgent and DidOps (#319)

hyperledger · Jan 26, 2023 · e12ca22 · e12ca22
1 parent aee80fb
commit e12ca22
Show file tree

Hide file tree

Showing 17 changed files with 337 additions and 261 deletions.
diff --git a/...ry/mercury-library/agent-cli-didcommx/src/main/scala/io/iohk/atala/AgentClientAlice.scala b/...ry/mercury-library/agent-cli-didcommx/src/main/scala/io/iohk/atala/AgentClientAlice.scala
@@ -1,24 +1,24 @@
-package io.iohk.atala
+// package io.iohk.atala
 
-import zio._
+// import zio._
 
-import io.iohk.atala.mercury._
-import io.iohk.atala.mercury.given
-import io.circe.Printer
-import io.circe.syntax._
-import io.circe.Json._
-import io.circe.parser._
-import io.circe.JsonObject
-import io.circe.Encoder._
-import io.iohk.atala.mercury.model.Message
-import io.circe.generic.auto._, io.circe.syntax._
-import io.circe._, io.circe.parser._
+// import io.iohk.atala.mercury._
+// import io.iohk.atala.mercury.given
+// import io.circe.Printer
+// import io.circe.syntax._
+// import io.circe.Json._
+// import io.circe.parser._
+// import io.circe.JsonObject
+// import io.circe.Encoder._
+// import io.iohk.atala.mercury.model.Message
+// import io.circe.generic.auto._, io.circe.syntax._
+// import io.circe._, io.circe.parser._
 
-@main def AgentClientAlice() = {
+// @main def AgentClientAlice() = {
 
-  val app = AgentPrograms.pickupMessageProgram
-    .provide(AgentService.alice, ZioHttpClient.layer)
+//   val app = AgentPrograms.pickupMessageProgram
+//     .provide(AgentService.alice, ZioHttpClient.layer)
 
-  Unsafe.unsafe { implicit u => Runtime.default.unsafe.run(app).getOrThrowFiberFailure() }
+//   Unsafe.unsafe { implicit u => Runtime.default.unsafe.run(app).getOrThrowFiberFailure() }
 
-}
+// }
diff --git a/mercury/mercury-library/agent-cli-didcommx/src/main/scala/io/iohk/atala/AgentClientBob.scala b/mercury/mercury-library/agent-cli-didcommx/src/main/scala/io/iohk/atala/AgentClientBob.scala
@@ -1,17 +1,17 @@
-package io.iohk.atala
+// package io.iohk.atala
 
-import zio._
-import zio.http.service._
-import io.iohk.atala.mercury._
-import io.iohk.atala.mercury.model.UnpackMessage
-import io.iohk.atala.mercury.protocol.mailbox.Mailbox.ReadMessage
-import org.didcommx.didcomm.message.Attachment.Data.Json
+// import zio._
+// import zio.http.service._
+// import io.iohk.atala.mercury._
+// import io.iohk.atala.mercury.model.UnpackMessage
+// import io.iohk.atala.mercury.protocol.mailbox.Mailbox.ReadMessage
+// import org.didcommx.didcomm.message.Attachment.Data.Json
 
-@main def AgentClientBob() = {
+// @main def AgentClientBob() = {
 
-  val app = AgentPrograms.senderProgram
-    .provide(AgentService.bob, ZioHttpClient.layer)
+//   val app = AgentPrograms.senderProgram
+//     .provide(AgentService.bob, ZioHttpClient.layer)
 
-  Unsafe.unsafe { implicit u => Runtime.default.unsafe.run(app).getOrThrowFiberFailure() }
+//   Unsafe.unsafe { implicit u => Runtime.default.unsafe.run(app).getOrThrowFiberFailure() }
 
-}
+// }
diff --git a/...ry/mercury-library/agent-cli-didcommx/src/main/scala/io/iohk/atala/mercury/AgentCli.scala b/...ry/mercury-library/agent-cli-didcommx/src/main/scala/io/iohk/atala/mercury/AgentCli.scala
@@ -10,16 +10,15 @@ import zio.http.service._
 import java.io.IOException
 import org.didcommx.didcomm.DIDComm
 import io.iohk.atala.QRcode
+import io.iohk.atala.mercury._
 import io.iohk.atala.mercury.model.{given, _}
 import io.iohk.atala.mercury.model.error._
 import io.iohk.atala.mercury.protocol.outofbandlogin._
 import io.iohk.atala.mercury.protocol.issuecredential._
 import io.iohk.atala.mercury.protocol.presentproof._
-import io.iohk.atala.resolvers.PeerDidMediatorSecretResolver
-import io.iohk.atala.resolvers.UniversalDidResolver
 import io.iohk.atala.mercury.protocol.connection.*
 import io.iohk.atala.mercury.protocol.invitation.v2.Invitation
-import io.iohk.atala.resolvers.DIDResolver
+import io.iohk.atala.resolvers._
 import io.circe.Json
 import io.circe.parser.*
 import io.circe.syntax.*
@@ -63,13 +62,6 @@ object AgentCli extends ZIOAppDefault {
 
   // val env = zio.http.Client.default ++ zio.Scope.default
 
-  def agentLayer(peer: PeerDID): ZLayer[Any, Nothing, AgentServiceAny] = ZLayer.succeed(
-    io.iohk.atala.mercury.AgentServiceAny(
-      new DIDComm(UniversalDidResolver, peer.getSecretResolverInMemory),
-      peer.did
-    )
-  )
-
   def askForMediation = {
     for {
       _ <- Console.printLine("Enter the Mediator URL (defualt is 'http://localhost:8000')")
@@ -90,8 +82,9 @@ object AgentCli extends ZIOAppDefault {
 
     // InvitationPrograms.createInvitationV2().map(oob => Response.text(serverUrl + oob))
     for {
-      didCommService <- ZIO.service[DidComm]
-      invitation = OutOfBandLoginInvitation(from = didCommService.myDid)
+      agentService <- ZIO.service[DidAgent]
+      didCommService <- ZIO.service[DidOps]
+      invitation = OutOfBandLoginInvitation(from = agentService.id)
       invitationSigned <- didCommService.packSigned(invitation.makeMsg)
       serverUrl = s"https://didcomm-bootstrap.atalaprism.com?_oob=${invitationSigned.base64}" // FIXME locahost
       _ <- Console.printLine(QRcode.getQr(serverUrl).toString)
@@ -103,8 +96,8 @@ object AgentCli extends ZIOAppDefault {
   def generateConnectionInvitation = {
     import io.iohk.atala.mercury.protocol.invitation._
     for {
-      didCommService <- ZIO.service[DidComm]
-      invitation = OutOfBandConnection.createInvitation(from = didCommService.myDid)
+      agentService <- ZIO.service[DidAgent]
+      invitation = OutOfBandConnection.createInvitation(from = agentService.id)
       serverUrl = s"https://didcomm-bootstrap.atalaprism.com?_oob=${invitation.toBase64}"
       _ <- Console.printLine(serverUrl)
       _ <- Console.printLine(invitation.id + " -> " + invitation)
@@ -120,23 +113,24 @@ object AgentCli extends ZIOAppDefault {
     }
 
     for {
-      didCommService <- ZIO.service[DidComm]
       _ <- Console.printLine("Read OutOfBand Invitation")
       data <- Console.readLine.flatMap {
         case ""  => ZIO.fail(???) // TODO retry
         case url => ZIO.succeed(Utils.parseLink(url).getOrElse(???)) /// TODO make ERROR
       }
+      didCommService <- ZIO.service[DidOps]
       msg <- didCommService.unpack(data)
       outOfBandLoginInvitation = reaOutOfBandLoginInvitation(msg.getMessage)
-      reply = outOfBandLoginInvitation.reply(didCommService.myDid)
+      agentService <- ZIO.service[DidAgent]
+      reply = outOfBandLoginInvitation.reply(agentService.id)
       _ <- Console.printLine(s"Replying to ${outOfBandLoginInvitation.id} with $reply")
 
       res <- MessagingService.send(reply.makeMsg)
       _ <- Console.printLine(res.bodyAsString)
     } yield ()
   }
 
-  def proposeAndSendCredential: ZIO[DidComm & DIDResolver & HttpClient, MercuryError | IOException, Unit] = {
+  def proposeAndSendCredential: ZIO[DidOps & DidAgent & DIDResolver & HttpClient, MercuryError | IOException, Unit] = {
     for {
 
       _ <- Console.printLine("Propose Credential")
@@ -152,10 +146,10 @@ object AgentCli extends ZIOAppDefault {
       attribute2 = Attribute(name = "dob", value = "01/10/1947")
       credentialPreview = CredentialPreview(attributes = Seq(attribute1, attribute2))
 
-      didCommService <- ZIO.service[DidComm]
-      _ <- Console.printLine(s"Send to (ex: ${didCommService.myDid})")
+      agentService <- ZIO.service[DidAgent]
+      _ <- Console.printLine(s"Send to (ex: ${agentService.id})")
       sendTo <- Console.readLine.flatMap {
-        case ""  => ZIO.succeed(didCommService.myDid)
+        case ""  => ZIO.succeed(agentService.id)
         case did => ZIO.succeed(DidId(did))
       }
 
@@ -167,7 +161,7 @@ object AgentCli extends ZIOAppDefault {
           formats = Seq.empty // : Seq[CredentialFormat]
         ),
         attachments = Seq(attachmentDescriptor),
-        from = didCommService.myDid,
+        from = agentService.id,
         to = sendTo,
       )
       _ <- Console.printLine(proposeCredential)
@@ -178,14 +172,14 @@ object AgentCli extends ZIOAppDefault {
     } yield ()
   }
 
-  def presentProof: ZIO[DidComm & DIDResolver & HttpClient, MercuryError | IOException, Unit] = {
+  def presentProof: ZIO[DidOps & DidAgent & DIDResolver & HttpClient, MercuryError | IOException, Unit] = {
     for {
       _ <- Console.printLine("Present Proof")
-      didCommService <- ZIO.service[DidComm]
+      agentService <- ZIO.service[DidAgent]
 
-      _ <- Console.printLine(s"Request proof from did (ex: ${didCommService.myDid})")
+      _ <- Console.printLine(s"Request proof from did (ex: ${agentService.id})")
       requestTo <- Console.readLine.flatMap {
-        case ""  => ZIO.succeed(didCommService.myDid)
+        case ""  => ZIO.succeed(agentService.id)
         case did => ZIO.succeed(DidId(did))
       }
 
@@ -202,20 +196,20 @@ object AgentCli extends ZIOAppDefault {
         body = body,
         attachments = Seq(attachmentDescriptor),
         to = requestTo,
-        from = didCommService.myDid,
+        from = agentService.id,
       )
       msg = requestPresentation.makeMessage
       _ <- Console.printLine("Sending: " + msg)
       _ <- MessagingService.send(msg)
     } yield ()
   }
 
-  def connect: ZIO[DidComm & DIDResolver & HttpClient, MercuryError | IOException, Unit] = {
+  def connect: ZIO[DidOps & DidAgent & DIDResolver & HttpClient, MercuryError | IOException, Unit] = {
 
     import io.iohk.atala.mercury.protocol.invitation.OutOfBand
     import io.circe._, io.circe.parser._
     for {
-      didCommService <- ZIO.service[DidComm]
+      agentService <- ZIO.service[DidAgent]
       _ <- Console.printLine("Read OutOfBand Invitation")
       data <- Console.readLine.flatMap {
         case ""  => ZIO.fail(???) // TODO retry
@@ -226,19 +220,18 @@ object AgentCli extends ZIOAppDefault {
       connectionInvitation = parseResult.as[Invitation].getOrElse(???)
       _ <- Console.printLine(s"Invitation to ${connectionInvitation.id} with $connectionInvitation")
       connectionRequest = ConnectionRequest(
-        from = didCommService.myDid,
+        from = agentService.id,
         to = connectionInvitation.from,
         thid = Some(connectionInvitation.id), // TODO if this is coorect
         body = ConnectionRequest.Body(goal_code = Some("connect"), goal = Some("Establish Connection"))
       )
       msg = connectionRequest.makeMessage
       _ <- Console.printLine("Sending: " + msg)
       _ <- MessagingService.send(msg)
-
     } yield ()
   }
 
-  def webServer: HttpApp[DidComm & DIDResolver & HttpClient, Throwable] = {
+  def webServer: HttpApp[DidOps & DidAgent & DIDResolver & HttpClient, Throwable] = {
     val header = "content-type" -> MediaTypes.contentTypeEncrypted
     Http
       .collectZIO[Request] {
@@ -261,12 +254,12 @@ object AgentCli extends ZIOAppDefault {
 
   }
 
-  def startEndpoint: ZIO[DidComm & DIDResolver & HttpClient, IOException, Unit] = for {
+  def startEndpoint: ZIO[DidOps & DidAgent & DIDResolver & HttpClient, IOException, Unit] = for {
     _ <- Console.printLine("Setup a endpoint")
-    didCommService <- ZIO.service[DidComm]
+    agentService <- ZIO.service[DidAgent]
 
     defualtPort = UniversalDidResolver
-      .resolve(didCommService.myDid.value)
+      .resolve(agentService.id.value)
       .get()
       .getDidCommServices()
       .asScala
@@ -309,7 +302,7 @@ object AgentCli extends ZIOAppDefault {
       case str                              => ZIO.succeed(Some(str))
     }
 
-    agentDID <- for {
+    didPeer <- for {
       peer <- ZIO.succeed(PeerDID.makePeerDid(serviceEndpoint = serviceEndpoint))
       // jwkForKeyAgreement <- ZIO.succeed(PeerDID.makeNewJwkKeyX25519)
       // jwkForKeyAuthentication <- ZIO.succeed(PeerDID.makeNewJwkKeyEd25519)
@@ -319,22 +312,23 @@ object AgentCli extends ZIOAppDefault {
         Console.printLine(s"JWK for KeyAuthentication: ${peer.jwkForKeyAuthentication.toJSONString}")
     } yield (peer)
 
-    didCommLayer = agentLayer(agentDID)
-    layers: ZLayer[Any, Nothing, AgentServiceAny & DIDResolver & HttpClient] =
-      didCommLayer ++ DIDResolver.layer ++ ZioHttpClient.layer
+    agentService = AgentPeerService.makeLayer(didPeer)
+
+    layers: ZLayer[Any, Nothing, DidOps & DidAgent & DIDResolver & HttpClient] =
+      DidCommX.liveLayer ++ agentService ++ DIDResolver.layer ++ ZioHttpClient.layer
 
     _ <- options(
       Seq(
         "none" -> ZIO.unit,
-        "Show DID" -> Console.printLine(agentDID),
-        "Get DID Document" -> Console.printLine("DID Document:") *> Console.printLine(agentDID.getDIDDocument),
+        "Show DID" -> Console.printLine(didPeer),
+        "Get DID Document" -> Console.printLine("DID Document:") *> Console.printLine(didPeer.getDIDDocument),
         "Start WebServer endpoint" -> startEndpoint.provide(layers),
         "Ask for Mediation Coordinate" -> askForMediation.provide(layers),
-        "Generate login invitation" -> generateLoginInvitation.provide(didCommLayer),
+        "Generate login invitation" -> generateLoginInvitation.provide(DidCommX.liveLayer ++ agentService),
         "Login with DID" -> loginInvitation.provide(layers),
         "Propose Credential" -> proposeAndSendCredential.provide(layers),
         "Present Proof" -> presentProof.provide(layers),
-        "Generate Connection invitation" -> generateConnectionInvitation.provide(didCommLayer),
+        "Generate Connection invitation" -> generateConnectionInvitation.provide(DidCommX.liveLayer ++ agentService),
         "Connect" -> connect.provide(layers),
       )
     ).repeatWhile((_) => true)
@@ -343,8 +337,8 @@ object AgentCli extends ZIOAppDefault {
 
   def webServerProgram(
       jsonString: String
-  ): ZIO[DidComm & DIDResolver & HttpClient, MercuryThrowable, String] = { // TODO Throwable
-    import io.iohk.atala.mercury.DidComm.*
+  ): ZIO[DidOps & DidAgent & DIDResolver & HttpClient, MercuryThrowable, String] = { // TODO Throwable
+    import io.iohk.atala.mercury.DidOps.*
     ZIO.logAnnotate("request-id", java.util.UUID.randomUUID.toString()) {
       for {
         _ <- ZIO.logInfo("Received new message")
@@ -367,7 +361,7 @@ object AgentCli extends ZIOAppDefault {
                 _ <- ZIO.logInfo("Got ProposeCredential: " + msg)
                 offer = OfferCredential.makeOfferToProposeCredential(msg) // OfferCredential
 
-                didCommService <- ZIO.service[DidComm]
+                didCommService <- ZIO.service[DidOps]
                 msgToSend = offer.makeMessage
                 _ <- MessagingService.send(msgToSend)
               } yield ("OfferCredential Sent")
@@ -380,7 +374,7 @@ object AgentCli extends ZIOAppDefault {
                 // store on BD TODO //pc = OfferCredential.readFromMessage(msg)
                 requestCredential = RequestCredential.makeRequestCredentialFromOffer(msg) // RequestCredential
 
-                didCommService <- ZIO.service[DidComm]
+                didCommService <- ZIO.service[DidOps]
                 msgToSend = requestCredential.makeMessage
                 _ <- MessagingService.send(msgToSend)
               } yield ("RequestCredential Sent")
@@ -392,7 +386,7 @@ object AgentCli extends ZIOAppDefault {
                 _ <- ZIO.logInfo("Got RequestCredential: " + msg)
                 issueCredential = IssueCredential.makeIssueCredentialFromRequestCredential(msg) // IssueCredential
 
-                didCommService <- ZIO.service[DidComm]
+                didCommService <- ZIO.service[DidOps]
                 msgToSend = issueCredential.makeMessage
                 _ <- MessagingService.send(msgToSend)
               } yield ("IssueCredential Sent")
@@ -411,7 +405,7 @@ object AgentCli extends ZIOAppDefault {
                 requestPresentation = RequestPresentation.readFromMessage(msg)
                 _ <- ZIO.logInfo("Got RequestPresentation: " + requestPresentation)
                 presentation = Presentation.makePresentationFromRequest(msg)
-                didCommService <- ZIO.service[DidComm]
+                didCommService <- ZIO.service[DidOps]
                 msgToSend = presentation.makeMessage
                 _ <- MessagingService.send(msgToSend)
               } yield ("Presentation Sent")

diff --git a/...rcury-library/agent-cli-didcommx/src/main/scala/io/iohk/atala/mercury/AgentHardCode.scala b/...rcury-library/agent-cli-didcommx/src/main/scala/io/iohk/atala/mercury/AgentHardCode.scala
@@ -8,17 +8,17 @@ import io.iohk.atala.mercury.model.{given, _}
 import io.iohk.atala.mercury.protocol.issuecredential._
 import java.io.IOException
 
+import io.iohk.atala.mercury.DidCommX
 object AgentHardCode extends ZIOAppDefault {
 
   def run = for {
-    agentDID <- for {
+    didPeer <- for {
       peer <- ZIO.succeed(PeerDID.makePeerDid()) // (serviceEndpoint = serviceEndpoint))
       _ <- Console.printLine(s"New DID: ${peer.did}") *>
         Console.printLine(s"JWK for KeyAgreement: ${peer.jwkForKeyAgreement.toJSONString}") *>
         Console.printLine(s"JWK for KeyAuthentication: ${peer.jwkForKeyAuthentication.toJSONString}")
     } yield (peer)
-    didCommLayer = AgentCli.agentLayer(agentDID)
-    _ <- test.provide(didCommLayer)
+    _ <- test.provide(DidCommX.liveLayer, AgentPeerService.makeLayer(didPeer))
   } yield ()
 
   val attribute1 = Attribute(name = "name", value = "Joe Blog")
@@ -30,18 +30,19 @@ object AgentHardCode extends ZIOAppDefault {
     formats = Seq.empty
   )
 
-  def test: ZIO[DidComm, IOException, Unit] = {
+  def test: ZIO[DidOps & DidAgent, IOException, Unit] = {
     for {
-      didCommService <- ZIO.service[DidComm]
+      agentService <- ZIO.service[DidAgent]
+      opsService <- ZIO.service[DidOps]
       msg = Message(
         `type` = "TEST",
-        from = Some(didCommService.myDid),
+        from = Some(agentService.id),
         to = Seq.empty,
         body = body.asJson.asObject.get
       )
       // signed <- didCommService.packSigned(msg)
-      ttt <- didCommService.packEncrypted(msg, to = didCommService.myDid)
-      msg2 <- didCommService.unpack(ttt.string)
+      ttt <- opsService.packEncrypted(msg, to = agentService.id)
+      msg2 <- opsService.unpack(ttt.string)
       _ <- Console.printLine(msg)
 
       aaa = msg: org.didcommx.didcomm.message.Message