feat(castor): implement translation of Node DidData to W3C DidDocument

castor/lib/core/src/main/scala/io/iohk/atala/castor/core/model/ProtoModelHelper.scala

@@ -1,22 +1,32 @@
 package io.iohk.atala.castor.core.model
 
 import java.net.URI
+import java.time.Instant
 import com.google.protobuf.ByteString
 import io.iohk.atala.castor.core.model.did.{
+  CanonicalPrismDID,
+  DIDData,
+  EllipticCurve,
   InternalKeyPurpose,
   InternalPublicKey,
+  LongFormPrismDID,
+  PrismDID,
   PrismDIDOperation,
   PublicKey,
   PublicKeyData,
   ScheduledDIDOperationDetail,
   ScheduledDIDOperationStatus,
   VerificationRelationship
 }
+import io.iohk.atala.prism.crypto.EC
 import io.iohk.atala.prism.protos.common_models.OperationStatus
+import io.iohk.atala.prism.protos.node_models.KeyUsage
+import io.iohk.atala.prism.protos.node_models.PublicKey.KeyData
 import io.iohk.atala.shared.models.HexStrings.*
 import io.iohk.atala.shared.models.Base64UrlStrings.*
 import io.iohk.atala.shared.utils.Traverse.*
-import io.iohk.atala.prism.protos.{KeyUsage, common_models, node_api, node_models}
+import io.iohk.atala.prism.protos.{common_models, node_api, node_models}
+import zio.*
 
 import scala.util.Try
 
@@ -34,6 +44,7 @@ private[castor] trait ProtoModelHelper {
         value = node_models.CreateDIDOperation(
           didData = Some(
             node_models.CreateDIDOperation.DIDCreationData(
+              // TODO: add Service when it is added to Prism DID method spec (ATL-2203)
               publicKeys = createDIDOp.publicKeys.map(_.toProto) ++ createDIDOp.internalKeys.map(_.toProto)
             )
           )
@@ -105,4 +116,109 @@ private[castor] trait ProtoModelHelper {
     }
   }
 
+  extension (didData: node_models.DIDData) {
+    def toDomain: Either[String, DIDData] = {
+      for {
+        canonicalDID <- PrismDID.buildCanonicalFromSuffix(didData.id)
+        allKeys <- didData.publicKeys.traverse(_.toDomain)
+      } yield DIDData(
+        id = canonicalDID,
+        publicKeys = allKeys.collect { case key: PublicKey => key },
+        services = Nil, // TODO: add Service when it is added to Prism DID method spec (ATL-2203)
+        internalKeys = allKeys.collect { case key: InternalPublicKey => key }
+      )
+    }
+
+    /** Return DIDData with keys and services removed by checking revocation time against current time */
+    def filterRevokedKeysAndServices: UIO[node_models.DIDData] = {
+      // TODO: filter Service when it is added to Prism DID method spec (ATL-2203)
+      Clock.instant.map { now =>
+        didData
+          .withPublicKeys(didData.publicKeys.filter { publicKey =>
+            val maybeRevokeTime = publicKey.revokedOn
+              .flatMap(_.timestampInfo)
+              .flatMap(_.blockTimestamp)
+              .map(ts => Instant.ofEpochSecond(ts.seconds).plusNanos(ts.nanos))
+            maybeRevokeTime.forall(revokeTime => revokeTime isBefore now)
+          })
+      }
+    }
+  }
+
+  extension (operation: node_models.CreateDIDOperation) {
+    def toDomain: Either[String, PrismDIDOperation.Create] = {
+      for {
+        allKeys <- operation.didData.map(_.publicKeys.traverse(_.toDomain)).getOrElse(Right(Nil))
+      } yield PrismDIDOperation.Create(
+        publicKeys = allKeys.collect { case key: PublicKey => key },
+        internalKeys = allKeys.collect { case key: InternalPublicKey => key },
+        services = Nil // TODO: add Service when it is added to Prism DID method spec (ATL-2203)
+      )
+    }
+  }
+
+  extension (publicKey: node_models.PublicKey) {
+    def toDomain: Either[String, PublicKey | InternalPublicKey] = {
+      val purpose: Either[String, VerificationRelationship | InternalKeyPurpose] = publicKey.usage match {
+        case node_models.KeyUsage.UNKNOWN_KEY => Left(s"unsupported use of KeyUsage.UNKNOWN_KEY on key ${publicKey.id}")
+        case node_models.KeyUsage.MASTER_KEY  => Right(InternalKeyPurpose.Master)
+        case node_models.KeyUsage.ISSUING_KEY => Right(VerificationRelationship.AssertionMethod)
+        case node_models.KeyUsage.COMMUNICATION_KEY  => Right(VerificationRelationship.KeyAgreement)
+        case node_models.KeyUsage.AUTHENTICATION_KEY => Right(VerificationRelationship.Authentication)
+        case node_models.KeyUsage.REVOCATION_KEY =>
+          ??? // TODO: define the corresponding KeyUsage in Prism DID (ATL-2213)
+        case node_models.KeyUsage.Unrecognized(unrecognizedValue) =>
+          Left(s"unrecognized KeyUsage: $unrecognizedValue on key ${publicKey.id}")
+      }
+
+      for {
+        purpose <- purpose
+        keyData <- publicKey.keyData.toDomain
+      } yield purpose match {
+        case purpose: VerificationRelationship =>
+          PublicKey(
+            id = publicKey.id,
+            purpose = purpose,
+            publicKeyData = keyData
+          )
+        case purpose: InternalKeyPurpose =>
+          publicKey.keyData.ecKeyData
+          InternalPublicKey(
+            id = publicKey.id,
+            purpose = purpose,
+            publicKeyData = keyData
+          )
+      }
+    }
+  }
+
+  extension (publicKeyData: node_models.PublicKey.KeyData) {
+    def toDomain: Either[String, PublicKeyData] = {
+      publicKeyData match {
+        case KeyData.Empty => Left(s"unable to convert KeyData.Emtpy to PublicKeyData")
+        case KeyData.EcKeyData(ecKeyData) =>
+          for {
+            curve <- EllipticCurve
+              .parseString(ecKeyData.curve)
+              .toRight(s"unsupported elliptic curve ${ecKeyData.curve}")
+          } yield PublicKeyData.ECKeyData(
+            crv = curve,
+            x = Base64UrlString.fromByteArray(ecKeyData.x.toByteArray),
+            y = Base64UrlString.fromByteArray(ecKeyData.y.toByteArray)
+          )
+        case KeyData.CompressedEcKeyData(ecKeyData) =>
+          val ecPublicKey = EC.INSTANCE.toPublicKeyFromCompressed(ecKeyData.data.toByteArray)
+          for {
+            curve <- EllipticCurve
+              .parseString(ecKeyData.curve)
+              .toRight(s"unsupported elliptic curve ${ecKeyData.curve}")
+          } yield PublicKeyData.ECKeyData(
+            crv = curve,
+            x = Base64UrlString.fromByteArray(ecPublicKey.getCurvePoint.getX.bytes()),
+            y = Base64UrlString.fromByteArray(ecPublicKey.getCurvePoint.getY.bytes())
+          )
+      }
+    }
+  }
+
 }

castor/lib/core/src/main/scala/io/iohk/atala/castor/core/model/did/DIDData.scala

@@ -1,7 +1,17 @@
 package io.iohk.atala.castor.core.model.did
 
+import io.iohk.atala.castor.core.model.did.w3c.DIDDocumentRepr
+
+import scala.collection.immutable.ArraySeq
+
 final case class DIDData(
+    id: CanonicalPrismDID,
     publicKeys: Seq[PublicKey],
     services: Seq[Service],
     internalKeys: Seq[InternalPublicKey]
 )
+
+final case class DIDMetadata(
+    lastOperationHash: ArraySeq[Byte],
+    deactivated: Boolean
+)

castor/lib/core/src/main/scala/io/iohk/atala/castor/core/model/did/PrismDID.scala

@@ -35,15 +35,21 @@ object PrismDID extends ProtoModelHelper {
       .map(_.getMessage)
       .map(_ => CanonicalPrismDID(HexString.fromByteArray(stateHash)))
 
-  def buildLongFormFromOperation(createOperation: PrismDIDOperation.Create): LongFormPrismDID = {
-    val createDIDOperation = createOperation.toProto
-    val atalaOperation = node_models.AtalaOperation(createDIDOperation)
-    buildLongFormFromAtalaOperation(atalaOperation).toOption.get
-  }
+  def buildCanonicalFromSuffix(suffix: String): Either[String, CanonicalPrismDID] =
+    HexString
+      .fromString(suffix)
+      .toEither
+      .left
+      .map(e => s"unable to parse suffix as hex string: ${e.getMessage}")
+      .flatMap(suffix => buildCanonical(suffix.toByteArray))
+
+  def buildLongFormFromOperation(createOperation: PrismDIDOperation.Create): LongFormPrismDID = LongFormPrismDID(
+    createOperation
+  )
 
   def buildLongFormFromAtalaOperation(atalaOperation: node_models.AtalaOperation): Either[String, LongFormPrismDID] =
     atalaOperation.operation match {
-      case Operation.CreateDid(_) => Right(LongFormPrismDID(atalaOperation))
+      case Operation.CreateDid(op) => op.toDomain.map(LongFormPrismDID.apply)
       case operation =>
         Left(s"Provided initial state of long form Prism DID is ${operation.value}, CreateDid Atala operation expected")
     }
@@ -102,7 +108,8 @@ final case class CanonicalPrismDID private[did] (stateHash: HexString) extends P
   override val suffix: DIDMethodSpecificId = DIDMethodSpecificId.fromString(stateHash.toString).get
 }
 
-final case class LongFormPrismDID private[did] (atalaOperation: node_models.AtalaOperation) extends PrismDID {
+final case class LongFormPrismDID private[did] (createOperation: PrismDIDOperation.Create) extends PrismDID {
+
   override val stateHash: HexString = {
     val encodedState = atalaOperation.toByteArray
     HexString.fromByteArray(Sha256.compute(encodedState).getValue)
@@ -112,4 +119,6 @@ final case class LongFormPrismDID private[did] (atalaOperation: node_models.Atal
     val encodedState = Base64UrlString.fromByteArray(atalaOperation.toByteArray).toStringNoPadding
     DIDMethodSpecificId.fromString(s"${stateHash.toString}:${encodedState}").get
   }
+
+  def atalaOperation: node_models.AtalaOperation = createOperation.toAtalaOperation
 }

castor/lib/core/src/main/scala/io/iohk/atala/castor/core/model/did/w3c/DIDDocumentRepr.scala

@@ -0,0 +1,30 @@
+package io.iohk.atala.castor.core.model.did.w3c
+
+import io.iohk.atala.castor.core.model.did.{DID, DIDUrl}
+
+/** A projection of DIDDocument data model to W3C compliant DID representation */
+final case class DIDDocumentRepr(
+    id: String,
+    controller: String,
+    verificationMethod: Seq[PublicKeyRepr],
+    authentication: Seq[PublicKeyRepr],
+    assertionMethod: Seq[PublicKeyRepr],
+    keyAgreement: Seq[PublicKeyRepr],
+    capabilityInvocation: Seq[PublicKeyRepr],
+    service: Seq[ServiceRepr]
+)
+
+final case class PublicKeyRepr(
+    id: String,
+    `type`: "EcdsaSecp256k1VerificationKey2019",
+    controller: String,
+    publicKeyJwk: PublicKeyJwk
+)
+
+final case class ServiceRepr(
+    id: String,
+    `type`: String,
+    serviceEndpoint: String
+)
+
+final case class PublicKeyJwk(kty: "EC", crv: String, x: String, y: String)

castor/lib/core/src/main/scala/io/iohk/atala/castor/core/model/did/w3c/DIDMetadata.scala

@@ -0,0 +1,17 @@
+package io.iohk.atala.castor.core.model.did.w3c
+
+import java.time.Instant
+
+// errors are based on https://www.w3.org/TR/did-spec-registries/#error
+enum DIDResolutionErrorRepr(val value: String) {
+  case InvalidDID extends DIDResolutionErrorRepr("invalidDid")
+  case InvalidDIDUrl extends DIDResolutionErrorRepr("invalidDidUrl")
+  case NotFound extends DIDResolutionErrorRepr("notFound")
+  case RepresentationNotSupported extends DIDResolutionErrorRepr("representationNotSupported")
+  case InternalError extends DIDResolutionErrorRepr("internalError")
+  case InvalidPublicKeyLength extends DIDResolutionErrorRepr("invalidPublicKeyLength")
+  case InvalidPublicKeyType extends DIDResolutionErrorRepr("invalidPublicKeyType")
+  case UnsupportedPublicKeyType extends DIDResolutionErrorRepr("unsupportedPublicKeyType")
+}
+
+final case class DIDDocumentMetadataRepr(deactivated: Boolean)

castor/lib/core/src/main/scala/io/iohk/atala/castor/core/model/did/w3c/W3CModelHelper.scala

@@ -0,0 +1,62 @@
+package io.iohk.atala.castor.core.model.did.w3c
+
+import io.iohk.atala.castor.core.model.did.{
+  CanonicalPrismDID,
+  DIDData,
+  DIDMetadata,
+  PublicKey,
+  PublicKeyData,
+  Service,
+  VerificationRelationship
+}
+
+object W3CModelHelper extends W3CModelHelper
+
+private[castor] trait W3CModelHelper {
+
+  extension (didMetadata: DIDMetadata) {
+    def toW3C: DIDDocumentMetadataRepr = DIDDocumentMetadataRepr(deactivated = didMetadata.deactivated)
+  }
+
+  extension (didData: DIDData) {
+    def toW3C: DIDDocumentRepr = {
+      val keyWithPurpose = didData.publicKeys.map(k => k.purpose -> k.toW3C(didData.id))
+      DIDDocumentRepr(
+        id = didData.id.toString,
+        controller = didData.id.toString,
+        verificationMethod = Nil,
+        authentication = keyWithPurpose.collect { case (VerificationRelationship.Authentication, k) => k },
+        assertionMethod = keyWithPurpose.collect { case (VerificationRelationship.AssertionMethod, k) => k },
+        keyAgreement = keyWithPurpose.collect { case (VerificationRelationship.KeyAgreement, k) => k },
+        capabilityInvocation = keyWithPurpose.collect { case (VerificationRelationship.CapabilityInvocation, k) => k },
+        service = didData.services.map(_.toW3C)
+      )
+    }
+  }
+
+  extension (service: Service) {
+    def toW3C: ServiceRepr = ServiceRepr(
+      id = service.id,
+      `type` = service.`type`.name,
+      serviceEndpoint = service.serviceEndpoint.toString
+    )
+  }
+
+  extension (publicKey: PublicKey) {
+    def toW3C(controller: CanonicalPrismDID): PublicKeyRepr = PublicKeyRepr(
+      id = publicKey.id,
+      `type` = "EcdsaSecp256k1VerificationKey2019",
+      controller = controller.toString,
+      publicKeyJwk = publicKey.publicKeyData match {
+        case PublicKeyData.ECKeyData(crv, x, y) =>
+          PublicKeyJwk(
+            kty = "EC",
+            crv = crv.name,
+            x = x.toStringNoPadding,
+            y = y.toStringNoPadding
+          )
+      }
+    )
+  }
+
+}