diff --git a/build.sbt b/build.sbt
index 872fd3c571..573c9fde83 100644
--- a/build.sbt
+++ b/build.sbt
@@ -9,7 +9,7 @@ import sbtprotoc.ProtocPlugin.autoImport.PB
 inThisBuild(
   Seq(
     organization := "io.iohk.atala",
-    scalaVersion := "2.13.7",
+    scalaVersion := "2.13.12", // "2.13.7",
     fork := true,
     run / connectInput := true,
     versionScheme := Some("semver-spec"),
@@ -50,7 +50,10 @@ lazy val versions = new {
   val typesafeConfig = "1.4.2"
   val fs2 = "3.2.5"
   val scalaUri = "4.0.0"
-  val prismSdk = "v1.4.1-snapshot-1688975371-7541fd2" // deployed to github packages from sdk branch "node-1.4-extension-sdk"
+  val prismSdk = "v1.4.1-snapshot-1688975371-7541fd2"
+  // From the repo atala-prism-sdk https://github.com/input-output-hk/atala-prism-sdk/tree/node-1.4-extension-sdk
+  // deployed to github packages from sdk branch "node-1.4-extension-sdk"
+  // Also see https://github.com/input-output-hk/atala-prism-sdk/packages/920243
   val vaultSdk = "0.1.0-build-2-96cc137d"
 }
 
@@ -108,9 +111,9 @@ lazy val Dependencies = new {
   // We have to exclude bouncycastle since for some reason bitcoinj depends on bouncycastle jdk15to18
   // (i.e. JDK 1.5 to 1.8), but we are using JDK 11
   val prismCredentials =
-  "io.iohk.atala" % "prism-credentials-jvm" % versions.prismSdk excludeAll ExclusionRule(
-    organization = "org.bouncycastle"
-  )
+    "io.iohk.atala" % "prism-credentials-jvm" % versions.prismSdk excludeAll ExclusionRule(organization =
+      "org.bouncycastle"
+    )
   val prismProtos =
     "io.iohk.atala" % "prism-protos-jvm" % versions.prismSdk % "protobuf-src" intransitive ()
   val vaultProtos =
@@ -162,7 +165,7 @@ lazy val Dependencies = new {
   val sttpDependencies = Seq(sttpCore, sttpCE2)
   val tofuDependencies = Seq(tofu, tofuLogging, tofuDerevoTagless)
   val prismDependencies =
-    Seq(prismCredentials, prismProtos, prismApi, vaultProtos)
+    Seq(prismCredentials, prismProtos, prismApi, vaultProtos, "io.iohk.atala.prism.apollo" % "apollo-jvm" % "1.2.13")
   val scalapbDependencies = Seq(
     "com.thesamet.scalapb" %% "scalapb-runtime" % scalapb.compiler.Version.scalapbVersion % "protobuf",
     "com.thesamet.scalapb" %% "scalapb-runtime-grpc" % scalapb.compiler.Version.scalapbVersion
@@ -190,10 +193,9 @@ lazy val commonSettings = Seq(
         "-Ywarn-dead-code"
       )
     )
-    ),
+  ),
   scalacOptions += "-Ymacro-annotations",
   javacOptions ++= Seq("-source", "1.11", "-target", "1.11"),
-  githubTokenSource := TokenSource.Environment("GITHUB_TOKEN"),
   resolvers += Resolver
     .githubPackages("input-output-hk", "atala-prism-sdk"),
   // Needed for Kotlin coroutines that support new memory management mode
diff --git a/common/src/main/scala/identus/apollo/Apollo.scala b/common/src/main/scala/identus/apollo/Apollo.scala
new file mode 100644
index 0000000000..b8f93c8cf5
--- /dev/null
+++ b/common/src/main/scala/identus/apollo/Apollo.scala
@@ -0,0 +1,215 @@
+package identus.apollo
+
+// import io.iohk.atala.shared.models.HexString
+import org.bouncycastle.jce.ECNamedCurveTable
+import org.bouncycastle.jce.provider.BouncyCastleProvider
+import org.bouncycastle.jce.spec.ECNamedCurveSpec
+// import zio._
+
+import java.security.KeyFactory
+import java.security.spec.{ECPrivateKeySpec, ECPublicKeySpec}
+import scala.util.Try
+import com.google.protobuf.ByteString
+
+trait Apollo {
+  def secp256k1: Secp256k1KeyOps
+  def ed25519: Ed25519KeyOps
+  def x25519: X25519KeyOps
+}
+
+object Apollo {
+  // def layer: ULayer[Apollo] = ZLayer.succeed(default)
+
+  // TODO: migrate to KMP Apollo and support other key types
+  def default: Apollo = new Apollo {
+    override def secp256k1: Secp256k1KeyOps = Prism14Secp256k1Ops
+    override def ed25519: Ed25519KeyOps = ???
+    override def x25519: X25519KeyOps = ???
+  }
+}
+
+trait Encodable {
+  def getEncoded: Array[Byte]
+}
+
+trait Signable {
+  def sign(data: Array[Byte]): Array[Byte]
+}
+
+trait Verifiable {
+  def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit]
+}
+
+/** Note this is a EC Public key */
+trait PublicKey extends Encodable {
+  def curveName: String
+  def toCurvePoint: CurvePoint // FIXME
+  def getX: Array[Byte] = toCurvePoint.x
+  def getY: Array[Byte] = toCurvePoint.y
+
+  def getXAsByteString = ByteString.copyFrom(getX)
+  def getYAsByteString = ByteString.copyFrom(getY)
+
+  // TODO rename this
+  def getEncodedCompressed: Array[Byte] = ???
+  def getEncodedCompressedAsByteString = ByteString.copyFrom(getEncodedCompressed)
+
+  def toJavaPublicKey: java.security.interfaces.ECPublicKey = {
+    val point = toCurvePoint
+    val x = BigInt(point.x).bigInteger
+    val y = BigInt(point.y).bigInteger
+    val keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider())
+    val ecParameterSpec = ECNamedCurveTable.getParameterSpec(curveName)
+    val ecNamedCurveSpec = new ECNamedCurveSpec(
+      ecParameterSpec.getName(),
+      ecParameterSpec.getCurve(),
+      ecParameterSpec.getG(),
+      ecParameterSpec.getN()
+    )
+    val ecPublicKeySpec =
+      new ECPublicKeySpec(new java.security.spec.ECPoint(x, y), ecNamedCurveSpec)
+    keyFactory.generatePublic(ecPublicKeySpec).asInstanceOf[java.security.interfaces.ECPublicKey]
+  }
+}
+
+/** Note this is a EC Public key */
+trait PrivateKey extends Encodable {
+  type Pub <: PublicKey
+  def toPublicKey: Pub
+  override final def toString(): String = "<REDACTED>"
+
+  def curveName: String
+  def getEncodedCompressed: Array[Byte] = ???
+
+  def toJavaPrivateKey: java.security.interfaces.ECPrivateKey = {
+    val bytes = getEncodedCompressed
+    val keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider())
+    val ecParameterSpec = ECNamedCurveTable.getParameterSpec(curveName)
+    val ecNamedCurveSpec = new ECNamedCurveSpec(
+      ecParameterSpec.getName(),
+      ecParameterSpec.getCurve(),
+      ecParameterSpec.getG(),
+      ecParameterSpec.getN()
+    )
+    val ecPrivateKeySpec = new ECPrivateKeySpec(new java.math.BigInteger(1, bytes), ecNamedCurveSpec)
+    keyFactory.generatePrivate(ecPrivateKeySpec).asInstanceOf[java.security.interfaces.ECPrivateKey]
+  }
+}
+
+object PublicKey {
+  def apply(curve: String, x: Array[Byte], y: Array[Byte]): PublicKey = ???
+  def apply(curve: String, data: Array[Byte]): PublicKey = {
+    curve match {
+      case "secp256k1" =>
+        val companion = new io.iohk.atala.prism.apollo.utils.KMMECSecp256k1PublicKey.Companion
+        val secp256k1PublicKey = companion.secp256k1FromBytes(data)
+        val point = secp256k1PublicKey.getCurvePoint()
+        PublicKey(curve, point.getX, point.getY)
+      case "ed25519" => ??? // FIXME TODO
+      case "x25519" => ??? // FIXME TODO
+      case _ => ???
+    }
+  }
+}
+
+object PrivateKey {}
+
+trait MyKeyPair {
+  def publicKey: PublicKey
+  def privateKey: PrivateKey
+}
+
+object MyKeyPair {
+  def fromECKeyPair(pair: io.iohk.atala.prism.crypto.keys.ECKeyPair) = new MyKeyPair {
+    def publicKey: PublicKey = {
+      val p = pair.getPublicKey().getCurvePoint()
+      PublicKey(
+        io.iohk.atala.prism.crypto.ECConfig.INSTANCE.getCURVE_NAME(),
+        p.getX().bytes(),
+        p.getY().bytes()
+      )
+    }
+    def privateKey: PrivateKey = {
+      ??? // FIXME
+    }
+  }
+
+  def generateKeyPair: MyKeyPair = ??? // FIXME  EC.generateKeyPair()
+// import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
+// import io.iohk.atala.prism.crypto.ECConfig.{INSTANCE => ECConfig}
+// import io.iohk.atala.prism.crypto.keys.{ECKeyPair, ECPublicKey}
+}
+
+case class CurvePoint(x: Array[Byte], y: Array[Byte])
+
+//FIXME
+// enum DerivationPath {
+//   case Normal(i: Int) extends DerivationPath
+//   case Hardened(i: Int) extends DerivationPath
+// }
+
+final case class ECPoint(x: BigInt, y: BigInt)
+
+// secp256k1
+final case class Secp256k1KeyPair(publicKey: Secp256k1PublicKey, privateKey: Secp256k1PrivateKey) extends MyKeyPair
+
+object Secp256k1KeyPair {
+  def generateKeyPair: Secp256k1KeyPair = ???
+}
+trait Secp256k1PublicKey extends PublicKey with Verifiable {
+  def getEncodedCompressed: Array[Byte]
+
+  def getEncodedUncompressed: Array[Byte]
+
+  def toCurvePoint: identus.apollo.CurvePoint
+  // def getECPoint: ECPoint
+
+  override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()
+
+  override final def equals(x: Any): Boolean = x match {
+    case otherPK: Secp256k1PublicKey =>
+      HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)
+    case _ => false
+  }
+
+}
+trait Secp256k1PrivateKey extends PrivateKey with Signable {
+  type Pub = Secp256k1PublicKey
+
+  override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()
+
+  override final def equals(x: Any): Boolean = x match {
+    case otherPK: Secp256k1PrivateKey =>
+      HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)
+    case _ => false
+  }
+}
+trait Secp256k1KeyOps {
+  def publicKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PublicKey]
+  def privateKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PrivateKey]
+  // def generateKeyPair: UIO[Secp256k1KeyPair]
+  // def randomBip32Seed: UIO[(Array[Byte], Seq[String])]
+  // def deriveKeyPair(seed: Array[Byte])(path: DerivationPath*): UIO[Secp256k1KeyPair]
+}
+
+// ed25519
+final case class Ed25519KeyPair(publicKey: Ed25519PublicKey, privateKey: Ed25519PrivateKey)
+trait Ed25519PublicKey extends PublicKey
+trait Ed25519PrivateKey extends PrivateKey with Signable {
+  type Pub = Ed25519PublicKey
+}
+trait Ed25519KeyOps {
+  def publicKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PublicKey]
+  def privateKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PrivateKey]
+}
+
+// x25519
+final case class X25519KeyPair(publicKey: X25519PublicKey, privateKey: X25519PrivateKey)
+trait X25519PublicKey extends PublicKey
+trait X25519PrivateKey extends PrivateKey {
+  type Pub = X25519PublicKey
+}
+trait X25519KeyOps {
+  def publicKeyFromEncoded(bytes: Array[Byte]): Try[X25519PublicKey]
+  def privateKeyFromEncoded(bytes: Array[Byte]): Try[X25519PrivateKey]
+}
diff --git a/common/src/main/scala/identus/apollo/BytesOps.scala b/common/src/main/scala/identus/apollo/BytesOps.scala
new file mode 100644
index 0000000000..f658cea6d3
--- /dev/null
+++ b/common/src/main/scala/identus/apollo/BytesOps.scala
@@ -0,0 +1,28 @@
+package identus.apollo
+
+import java.nio.charset.StandardCharsets
+
+object BytesOps {
+  private val HexArray = "0123456789abcdef".getBytes(StandardCharsets.US_ASCII);
+
+  // Converts hex string to bytes representation
+  def hexToBytes(hexEncoded: String): Array[Byte] = {
+    require(hexEncoded.length % 2 == 0, "Hex length needs to be even")
+    hexEncoded.grouped(2).toVector.map(hexToByte).toArray
+  }
+
+  // Converts bytes to hex string representation
+  def bytesToHex(bytes: Iterable[Byte]): String = {
+    val hexChars = new Array[Byte](bytes.size * 2)
+    for ((byte, i) <- bytes.zipWithIndex) {
+      val v = byte & 0xff
+      hexChars(i * 2) = HexArray(v >>> 4)
+      hexChars(i * 2 + 1) = HexArray(v & 0x0f)
+    }
+    new String(hexChars, StandardCharsets.UTF_8)
+  }
+
+  private def hexToByte(h: String): Byte = {
+    Integer.parseInt(h, 16).toByte
+  }
+}
diff --git a/common/src/main/scala/identus/apollo/HexString.scala b/common/src/main/scala/identus/apollo/HexString.scala
new file mode 100644
index 0000000000..ccc81313b8
--- /dev/null
+++ b/common/src/main/scala/identus/apollo/HexString.scala
@@ -0,0 +1,17 @@
+package identus.apollo
+
+import scala.util.Try
+
+// opaque type HexString = String
+
+object HexString {
+  type HexString = String
+  def fromStringUnsafe(s: String): HexString = s
+  def fromString(s: String): Try[HexString] = Try(BytesOps.hexToBytes(s)).map(_ => s)
+  def fromByteArray(bytes: Array[Byte]): HexString = BytesOps.bytesToHex(bytes)
+
+  // extension(s: HexString) {
+  //   def toByteArray: Array[Byte] = BytesOps.hexToBytes(s)
+  //   def toString: String = s
+  // }
+}
diff --git a/common/src/main/scala/identus/apollo/KmpApollo.scala b/common/src/main/scala/identus/apollo/KmpApollo.scala
new file mode 100644
index 0000000000..8805cf2445
--- /dev/null
+++ b/common/src/main/scala/identus/apollo/KmpApollo.scala
@@ -0,0 +1,97 @@
+// package identus.apollo
+
+// import io.iohk.atala.prism.apollo.derivation
+// import io.iohk.atala.prism.apollo.derivation.MnemonicHelper
+// import io.iohk.atala.prism.apollo.secp256k1.Secp256k1Lib
+// import io.iohk.atala.prism.apollo.securerandom.SecureRandom
+// import io.iohk.atala.prism.apollo.utils.KMMECSecp256k1PrivateKey
+// import io.iohk.atala.prism.apollo.utils.KMMECSecp256k1PublicKey
+// // import zio._
+
+// // import scala.jdk.CollectionConverters._
+// import scala.util.{Try, Success, Failure}
+
+// final case class KmpSecp256k1PublicKey(publicKey: KMMECSecp256k1PublicKey) extends Secp256k1PublicKey {
+
+//   override def getECPoint: ECPoint = {
+//     val point = publicKey.getCurvePoint()
+//     val x = BigInt(1, point.getX())
+//     val y = BigInt(1, point.getY())
+//     ECPoint(x, y)
+//   }
+
+//   override def getEncoded: Array[Byte] = publicKey.getCompressed()
+
+//   override def getEncodedCompressed: Array[Byte] = getEncoded
+
+//   override def getEncodedUncompressed: Array[Byte] =
+//     KmpSecp256k1KeyOps.secpLib.uncompressPublicKey(getEncodedCompressed)
+
+//   override def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit] =
+//     Try(publicKey.verify(signature, data))
+//       .flatMap(isValid => if (isValid) Success(()) else Failure(Exception("The signature verification does not match")))
+// }
+
+// final case class KmpSecp256k1PrivateKey(privateKey: KMMECSecp256k1PrivateKey) extends Secp256k1PrivateKey {
+//   override def sign(data: Array[Byte]): Array[Byte] = privateKey.sign(data)
+
+//   override def toPublicKey: Secp256k1PublicKey = KmpSecp256k1PublicKey(privateKey.getPublicKey())
+
+//   override def getEncoded: Array[Byte] = privateKey.getEncoded()
+// }
+
+// object KmpSecp256k1KeyOps extends Secp256k1KeyOps {
+//   private[crypto] val secpLib: Secp256k1Lib = Secp256k1Lib()
+//   private[crypto] val secureRandom: SecureRandom = SecureRandom()
+
+//   override def publicKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PublicKey] =
+//     Try {
+//       val publicKey = KMMECSecp256k1PublicKey.Companion.secp256k1FromBytes(bytes)
+//       val point = publicKey.getCurvePoint()
+//       val isOnCurve = KMMECSecp256k1PublicKey.Companion.isPointOnSecp256k1Curve(point)
+//       if (isOnCurve) KmpSecp256k1PublicKey(publicKey)
+//       else throw new Exception("The public key is not on the secp256k1 curve")
+//     }
+
+//   override def privateKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PrivateKey] =
+//     Try(KMMECSecp256k1PrivateKey.Companion.secp256k1FromByteArray(bytes)).map(KmpSecp256k1PrivateKey(_))
+
+//   override def generateKeyPair: UIO[Secp256k1KeyPair] =
+//     ZIO.attemptBlocking {
+//       val randBytes = secureRandom.nextBytes(32)
+//       val privateKey = KMMECSecp256k1PrivateKey(randBytes)
+//       val publicKey = privateKey.getPublicKey
+//       Secp256k1KeyPair(
+//         KmpSecp256k1PublicKey(publicKey),
+//         KmpSecp256k1PrivateKey(privateKey)
+//       )
+//     }.orDie
+
+//   def randomBip32Seed: UIO[(Array[Byte], Seq[String])] =
+//     ZIO.attemptBlocking {
+//       val words = MnemonicHelper.Companion.createRandomMnemonics()
+//       val seed = MnemonicHelper.Companion.createSeed(words, "")
+//       seed -> words.asScala.toList
+//     }.orDie
+
+//   def deriveKeyPair(seed: Array[Byte])(path: DerivationPath*): UIO[Secp256k1KeyPair] =
+//     ZIO.attemptBlocking {
+//       val pathStr = path
+//         .foldLeft(derivation.DerivationPath.empty()) { case (path, p) =>
+//           p match {
+//             case DerivationPath.Hardened(i) => path.derive(derivation.DerivationAxis.hardened(i))
+//             case DerivationPath.Normal(i) => path.derive(derivation.DerivationAxis.normal(i))
+//           }
+//         }
+//         .toString()
+//       val hdKey = derivation.HDKey(seed, 0, 0).derive(pathStr)
+//       val privateKey = hdKey.getKMMSecp256k1PrivateKey()
+//       val publicKey = privateKey.getPublicKey()
+
+//       Secp256k1KeyPair(
+//         KmpSecp256k1PublicKey(publicKey),
+//         KmpSecp256k1PrivateKey(privateKey)
+//       )
+//     }.orDie
+
+// }
diff --git a/common/src/main/scala/identus/apollo/KmpCompatUtil.scala b/common/src/main/scala/identus/apollo/KmpCompatUtil.scala
new file mode 100644
index 0000000000..4fe4c87fdb
--- /dev/null
+++ b/common/src/main/scala/identus/apollo/KmpCompatUtil.scala
@@ -0,0 +1,14 @@
+// package identus.apollo
+
+// import com.ionspin.kotlin.bignum.integer.BigInteger
+// import com.ionspin.kotlin.bignum.integer.util.ConversionUtilsKt
+
+// object KmpCompatUtil {
+
+//   extension(n: BigInteger) {
+//     def toScalaBigInt: BigInt = BigInt(ConversionUtilsKt.toTwosComplementByteArray(n))
+//   }
+//   extension(n: BigInt) {
+//     def toKotlinBigInt: BigInteger = ConversionUtilsKt.fromTwosComplementByteArray(BigInteger.Companion, n.toByteArray)
+//   }
+// }
diff --git a/common/src/main/scala/identus/apollo/Prism14Apollo.scala b/common/src/main/scala/identus/apollo/Prism14Apollo.scala
new file mode 100644
index 0000000000..458ca152a8
--- /dev/null
+++ b/common/src/main/scala/identus/apollo/Prism14Apollo.scala
@@ -0,0 +1,102 @@
+package identus.apollo
+
+import io.iohk.atala.prism.crypto.EC
+// import io.iohk.atala.prism.crypto.derivation.DerivationAxis
+// import io.iohk.atala.prism.crypto.derivation.KeyDerivation
+// import zio._
+
+// import scala.jdk.CollectionConverters._
+import scala.util.{Try, Success, Failure}
+
+final case class Prism14Secp256k1PublicKey(publicKey: io.iohk.atala.prism.crypto.keys.ECPublicKey)
+    extends Secp256k1PublicKey {
+
+  override def getEncoded: Array[Byte] = getEncodedCompressed
+
+  override def getEncodedUncompressed: Array[Byte] = publicKey.getEncoded()
+
+  override def getEncodedCompressed: Array[Byte] = publicKey.getEncodedCompressed()
+
+  override def curveName: String = io.iohk.atala.prism.crypto.ECConfig.INSTANCE.getCURVE_NAME()
+  override def toCurvePoint: identus.apollo.CurvePoint = CurvePoint(
+    x = publicKey.getCurvePoint().getX().bytes(),
+    y = publicKey.getCurvePoint().getY().bytes()
+  )
+
+  // override def getECPoint: ECPoint = {
+  //   // import KmpCompatUtil._
+  //   // val point = publicKey.getCurvePoint
+  //   // val x = point.getX.getCoordinate.toScalaBigInt
+  //   // val y = point.getY.getCoordinate.toScalaBigInt
+  //   // ECPoint(x, y)
+  //   ???
+  // }
+
+  override def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit] = Try {
+    val sig = EC.INSTANCE.toSignatureFromBytes(signature)
+    EC.INSTANCE.verifyBytes(data, publicKey, sig)
+  }.flatMap(isValid =>
+    if (isValid) Success(()) else Failure(new RuntimeException("The signature verification does not match"))
+  )
+
+}
+
+final case class Prism14Secp256k1PrivateKey(privateKey: io.iohk.atala.prism.crypto.keys.ECPrivateKey)
+    extends Secp256k1PrivateKey {
+
+  override def toPublicKey: Secp256k1PublicKey = Prism14Secp256k1PublicKey(
+    EC.INSTANCE.toPublicKeyFromPrivateKey(privateKey)
+  )
+
+  override def getEncoded: Array[Byte] = privateKey.getEncoded()
+
+  override def sign(data: Array[Byte]): Array[Byte] = EC.INSTANCE.signBytes(data, privateKey).getEncoded
+
+  def curveName: String = ???
+  def toCurvePoint: identus.apollo.CurvePoint = ???
+}
+
+object Prism14Secp256k1Ops extends Secp256k1KeyOps {
+
+  // override def generateKeyPair: UIO[Secp256k1KeyPair] =
+  //   ZIO.attemptBlocking {
+  //     val keyPair = EC.INSTANCE.generateKeyPair()
+  //     Secp256k1KeyPair(
+  //       Prism14Secp256k1PublicKey(keyPair.getPublicKey()),
+  //       Prism14Secp256k1PrivateKey(keyPair.getPrivateKey())
+  //     )
+  //   }.orDie
+
+  override def privateKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PrivateKey] =
+    Try(Prism14Secp256k1PrivateKey(EC.INSTANCE.toPrivateKeyFromBytes(bytes)))
+
+  override def publicKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PublicKey] =
+    Try(EC.INSTANCE.toPublicKeyFromBytes(bytes))
+      .orElse(Try(EC.INSTANCE.toPublicKeyFromCompressed(bytes)))
+      .map(Prism14Secp256k1PublicKey.apply)
+
+  // override def deriveKeyPair(seed: Array[Byte])(path: DerivationPath*): UIO[Secp256k1KeyPair] =
+  //   ZIO.attempt {
+  //     val extendedKey = path
+  //       .foldLeft(KeyDerivation.INSTANCE.derivationRoot(seed)) { case (extendedKey, p) =>
+  //         val axis = p match {
+  //           case DerivationPath.Hardened(i) => DerivationAxis.hardened(i)
+  //           case DerivationPath.Normal(i) => DerivationAxis.normal(i)
+  //         }
+  //         extendedKey.derive(axis)
+  //       }
+  //     val prism14KeyPair = extendedKey.keyPair()
+  //     Secp256k1KeyPair(
+  //       Prism14Secp256k1PublicKey(prism14KeyPair.getPublicKey()),
+  //       Prism14Secp256k1PrivateKey(prism14KeyPair.getPrivateKey())
+  //     )
+  //   }.orDie
+
+  // override def randomBip32Seed: UIO[(Array[Byte], Seq[String])] =
+  //   ZIO.attemptBlocking {
+  //     val mnemonic = KeyDerivation.INSTANCE.randomMnemonicCode()
+  //     val words = mnemonic.getWords().asScala.toList
+  //     KeyDerivation.INSTANCE.binarySeed(mnemonic, "") -> words
+  //   }.orDie
+
+}
diff --git a/common/src/main/scala/io/iohk/atala/prism/auth/utils/DIDUtils.scala b/common/src/main/scala/io/iohk/atala/prism/auth/utils/DIDUtils.scala
index 0e602ed73c..4ab5fe2939 100644
--- a/common/src/main/scala/io/iohk/atala/prism/auth/utils/DIDUtils.scala
+++ b/common/src/main/scala/io/iohk/atala/prism/auth/utils/DIDUtils.scala
@@ -52,6 +52,7 @@ object DIDUtils {
     }
   }
 
+  // FIXME ECConfig.getCURVE_NAME
   private def verifyPublicKey(
       curve: String,
       publicKey: ECPublicKey
diff --git a/common/src/main/scala/io/iohk/atala/prism/logging/GeneralLoggableInstances.scala b/common/src/main/scala/io/iohk/atala/prism/logging/GeneralLoggableInstances.scala
index ae6507bd58..654fa509ab 100644
--- a/common/src/main/scala/io/iohk/atala/prism/logging/GeneralLoggableInstances.scala
+++ b/common/src/main/scala/io/iohk/atala/prism/logging/GeneralLoggableInstances.scala
@@ -12,7 +12,7 @@ import tofu.syntax.monoid.TofuSemigroupOps
   */
 object GeneralLoggableInstances {
 
-  implicit val statusLoggable = new DictLoggable[Status] {
+  implicit val statusLoggable: DictLoggable[Status] = new DictLoggable[Status] {
     override def fields[I, V, R, S](a: Status, i: I)(implicit r: LogRenderer[I, V, R, S]): R = {
       r.addString("grpc_status", a.toString, i)
     }
diff --git a/common/src/test/scala/io/iohk/atala/prism/DIDUtil.scala b/common/src/test/scala/io/iohk/atala/prism/DIDUtil.scala
index a41be1c305..4e2a97733f 100644
--- a/common/src/test/scala/io/iohk/atala/prism/DIDUtil.scala
+++ b/common/src/test/scala/io/iohk/atala/prism/DIDUtil.scala
@@ -4,8 +4,6 @@ import com.google.protobuf.ByteString
 import io.iohk.atala.prism.auth.SignedRpcRequest
 import io.iohk.atala.prism.crypto.{Sha256, Sha256Digest}
 import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
-import io.iohk.atala.prism.crypto.keys.{ECKeyPair, ECPublicKey}
-import io.iohk.atala.prism.crypto.ECConfig.{INSTANCE => ECConfig}
 import io.iohk.atala.prism.identity.{PrismDid => DID}
 import io.iohk.atala.prism.identity.PrismDid.{getDEFAULT_MASTER_KEY_ID => masterKeyId}
 import io.iohk.atala.prism.protos.node_api.{GetDidDocumentRequest, GetDidDocumentResponse}
@@ -14,22 +12,25 @@ import io.iohk.atala.prism.protos.node_models
 import io.iohk.atala.prism.protos.node_models.DIDData
 import org.mockito.IdiomaticMockito._
 import scalapb.GeneratedMessage
+import identus.apollo.PublicKey
 
 import scala.concurrent.Future
+import identus.apollo.MyKeyPair
+import identus.apollo.Secp256k1KeyPair
 
 trait DIDUtil {
   protected def nodeMock: NodeService
 
-  private def publicKeyToProto(key: ECPublicKey): node_models.ECKeyData = {
-    val point = key.getCurvePoint
+  private def publicKeyToProto(key: PublicKey): node_models.ECKeyData = {
+    val point = key.toCurvePoint
     node_models.ECKeyData(
-      curve = ECConfig.getCURVE_NAME,
-      x = ByteString.copyFrom(point.getX.bytes()),
-      y = ByteString.copyFrom(point.getY.bytes())
+      curve = key.curveName,
+      x = ByteString.copyFrom(point.x),
+      y = ByteString.copyFrom(point.y)
     )
   }
 
-  def generateDid(masterPublicKey: ECPublicKey): DID = {
+  def generateDid(masterPublicKey: PublicKey): DID = {
     val publicKey = node_models.PublicKey(
       id = masterKeyId,
       usage = node_models.KeyUsage.MASTER_KEY,
@@ -65,22 +66,22 @@ trait DIDUtil {
 
   def prepareSignedRequest[R <: GeneratedMessage](
       request: R
-  ): (ECPublicKey, SignedRpcRequest[R]) = {
-    val keys = EC.generateKeyPair()
-    val did = generateDid(keys.getPublicKey)
-    (keys.getPublicKey, SignedRpcRequest.generate(keys, did, request))
+  ): (PublicKey, SignedRpcRequest[R]) = {
+    val keys = Secp256k1KeyPair.generateKeyPair
+    val did = generateDid(keys.publicKey)
+    (keys.publicKey, SignedRpcRequest.generate(keys, did, request))
   }
 
   def prepareSignedUnpublishedDidRequest[R <: GeneratedMessage](
       request: R
-  ): (ECPublicKey, SignedRpcRequest[R]) = {
-    val keys = EC.generateKeyPair()
-    val did = DID.buildLongFormFromMasterPublicKey(keys.getPublicKey)
-    (keys.getPublicKey, SignedRpcRequest.generate(keys, did, request))
+  ): (PublicKey, SignedRpcRequest[R]) = {
+    val keys = MyKeyPair.generateKeyPair
+    val did = DID.buildLongFormFromMasterPublicKey(keys.publicKey)
+    (keys.publicKey, SignedRpcRequest.generate(keys, did, request))
   }
 
-  def createDid: (ECKeyPair, DID) = {
-    val keyPair = EC.generateKeyPair()
+  def createDid: (KeyPair, DID) = {
+    val keyPair = MyKeyPair.generateKeyPair
     val publicKey = keyPair.getPublicKey
     val did = generateDid(publicKey)
     (keyPair, did)
diff --git a/common/src/test/scala/io/iohk/atala/prism/auth/SignedRpcRequest.scala b/common/src/test/scala/io/iohk/atala/prism/auth/SignedRpcRequest.scala
index badecd5ca3..78a82ee6ec 100644
--- a/common/src/test/scala/io/iohk/atala/prism/auth/SignedRpcRequest.scala
+++ b/common/src/test/scala/io/iohk/atala/prism/auth/SignedRpcRequest.scala
@@ -2,10 +2,10 @@ package io.iohk.atala.prism.auth
 
 import io.iohk.atala.prism.auth
 import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
-import io.iohk.atala.prism.crypto.keys.ECKeyPair
 import io.iohk.atala.prism.crypto.signature.ECSignature
 import io.iohk.atala.prism.identity.{PrismDid => DID}
 import scalapb.GeneratedMessage
+import identus.apollo.Secp256k1KeyPair
 
 import java.util.UUID
 
@@ -19,11 +19,11 @@ final case class SignedRpcRequest[R <: GeneratedMessage](
 
 object SignedRpcRequest {
   def generate[R <: GeneratedMessage](
-      keyPair: ECKeyPair,
+      keyPair: Secp256k1KeyPair,
       did: DID,
       request: R
   ): SignedRpcRequest[R] = {
-    val privateKey = keyPair.getPrivateKey
+    val privateKey = keyPair.privateKey
     val requestNonce = UUID.randomUUID().toString.getBytes.toVector
     val signature = EC.signBytes(
       auth.model.RequestNonce(requestNonce).mergeWith(request.toByteArray).toArray,
diff --git a/common/src/test/scala/io/iohk/atala/prism/auth/utils/DIDUtilsSpec.scala b/common/src/test/scala/io/iohk/atala/prism/auth/utils/DIDUtilsSpec.scala
index 0a5eb107d8..f238a9c3b6 100644
--- a/common/src/test/scala/io/iohk/atala/prism/auth/utils/DIDUtilsSpec.scala
+++ b/common/src/test/scala/io/iohk/atala/prism/auth/utils/DIDUtilsSpec.scala
@@ -2,8 +2,6 @@ package io.iohk.atala.prism.auth.utils
 
 import com.google.protobuf.ByteString
 import io.iohk.atala.prism.auth.errors.UnknownPublicKeyId
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
-import io.iohk.atala.prism.crypto.keys.{ECKeyPair, ECPublicKey}
 import io.iohk.atala.prism.protos.node_models
 import io.iohk.atala.prism.protos.node_models.{CompressedECKeyData, DIDData, ECKeyData}
 import org.scalatest.matchers.must.Matchers
@@ -12,12 +10,12 @@ import io.iohk.atala.prism.crypto.ECConfig.{INSTANCE => ECConfig}
 import org.scalatest.concurrent.ScalaFutures.convertScalaFuture
 
 import scala.concurrent.ExecutionContext.Implicits.global
+import identus.apollo.PublicKey
+import identus.apollo.MyKeyPair
 
 class DIDUtilsSpec extends AnyWordSpec with Matchers {
-  val masterKeys: ECKeyPair = EC.generateKeyPair()
-  val masterEcKeyData: ECKeyData = protoECKeyDataFromPublicKey(
-    masterKeys.getPublicKey
-  )
+  val masterKeys: MyKeyPair = MyKeyPair.generateKeyPair
+  val masterEcKeyData: ECKeyData = protoECKeyDataFromPublicKey(masterKeys.publicKey)
   val masterEcKeyDataPublicKey = node_models
     .PublicKey(
       "master",
@@ -29,7 +27,7 @@ class DIDUtilsSpec extends AnyWordSpec with Matchers {
       node_models.PublicKey.KeyData.EcKeyData(masterEcKeyData)
     )
   val masterCompressedEcKeyData: CompressedECKeyData =
-    protoCompressedECKeyDataFromPublicKey(masterKeys.getPublicKey)
+    protoCompressedECKeyDataFromPublicKey(masterKeys.publicKey)
   val masterCompressedEcKeyDataPublicKey = node_models
     .PublicKey(
       "master",
@@ -43,21 +41,20 @@ class DIDUtilsSpec extends AnyWordSpec with Matchers {
       )
     )
 
-  def protoECKeyDataFromPublicKey(key: ECPublicKey): ECKeyData = {
-    val point = key.getCurvePoint
-
+  def protoECKeyDataFromPublicKey(key: PublicKey): ECKeyData = {
+    val point = key.toCurvePoint
     node_models.ECKeyData(
-      curve = ECConfig.getCURVE_NAME,
-      x = ByteString.copyFrom(point.getX.bytes()),
-      y = ByteString.copyFrom(point.getY.bytes())
+      curve = key.curveName,
+      x = ByteString.copyFrom(point.x),
+      y = ByteString.copyFrom(point.y)
     )
   }
 
   def protoCompressedECKeyDataFromPublicKey(
-      key: ECPublicKey
+      key: PublicKey
   ): CompressedECKeyData =
     node_models.CompressedECKeyData(
-      curve = ECConfig.getCURVE_NAME,
+      curve = key.curveName,
       data = ByteString.copyFrom(key.getEncodedCompressed)
     )
 
@@ -66,14 +63,14 @@ class DIDUtilsSpec extends AnyWordSpec with Matchers {
       val didData =
         DIDData(publicKeys = Seq(masterCompressedEcKeyDataPublicKey))
       DIDUtils.findPublicKey(didData, "master").value.futureValue mustBe Right(
-        masterKeys.getPublicKey
+        masterKeys.publicKey
       )
     }
 
     "return key given publicKey contains not compressed dKeyData" in {
       val didData = DIDData(publicKeys = Seq(masterEcKeyDataPublicKey))
       DIDUtils.findPublicKey(didData, "master").value.futureValue mustBe Right(
-        masterKeys.getPublicKey
+        masterKeys.publicKey
       )
     }
 
@@ -96,7 +93,7 @@ class DIDUtilsSpec extends AnyWordSpec with Matchers {
         )
       val didData = DIDData(publicKeys = Seq(compressedAsUncompressedKey))
       DIDUtils.findPublicKey(didData, "master").value.futureValue mustBe Right(
-        masterKeys.getPublicKey
+        masterKeys.publicKey
       )
     }
   }
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/grpc/ProtoCodecs.scala b/node/src/main/scala/io/iohk/atala/prism/node/grpc/ProtoCodecs.scala
index 5b0f279af3..524b79941d 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/grpc/ProtoCodecs.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/grpc/ProtoCodecs.scala
@@ -1,11 +1,9 @@
 package io.iohk.atala.prism.node.grpc
 
-import java.security.PublicKey
 import com.google.protobuf.ByteString
 import io.iohk.atala.prism.protos.models.TimestampInfo
 import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
 import io.iohk.atala.prism.crypto.keys.ECPublicKey
-import io.iohk.atala.prism.crypto.ECConfig.{INSTANCE => ECConfig}
 import io.iohk.atala.prism.models.{DidSuffix, Ledger}
 import io.iohk.atala.prism.protos.common_models
 import io.iohk.atala.prism.node.models
@@ -15,6 +13,8 @@ import io.iohk.atala.prism.protos.node_models
 import io.iohk.atala.prism.utils.syntax._
 
 import java.time.Instant
+import java.security.PublicKey
+// import io.iohk.atala.prism.apollo.utils.KMMECPoint // REMVOE
 
 object ProtoCodecs {
   def toTimeStampInfoProto(
@@ -98,13 +98,23 @@ object ProtoCodecs {
     revokedOn.fold(withoutRevKey)(revTime => withoutRevKey.withRevokedOn(revTime))
   }
 
-  def toECKeyData(key: ECPublicKey): node_models.ECKeyData = {
-    val point = key.getCurvePoint
+  // TODO REMOVE
+  // def toECKeyData(key: ECPublicKey): node_models.ECKeyData = {
+  //   // val point = key.getCurvePoint
+  //   node_models
+  //     .ECKeyData()
+  //     .withCurve(ECConfig.getCURVE_NAME)
+  //     .withX(ByteString.copyFrom(point.getX.bytes()))
+  //     .withY(ByteString.copyFrom(point.getY.bytes()))
+  // }
+
+  def toECKeyData(key: identus.apollo.PublicKey): node_models.ECKeyData = {
+    val point = key.toCurvePoint
     node_models
       .ECKeyData()
-      .withCurve(ECConfig.getCURVE_NAME)
-      .withX(ByteString.copyFrom(point.getX.bytes()))
-      .withY(ByteString.copyFrom(point.getY.bytes()))
+      .withCurve(key.curveName)
+      .withX(ByteString.copyFrom(point.x))
+      .withY(ByteString.copyFrom(point.y))
   }
 
   def toProtoKeyUsage(keyUsage: models.KeyUsage): node_models.KeyUsage = {
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/models/ProtocolConstants.scala b/node/src/main/scala/io/iohk/atala/prism/node/models/ProtocolConstants.scala
index fbfc9b4785..fbdcf84ec2 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/models/ProtocolConstants.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/models/ProtocolConstants.scala
@@ -12,7 +12,7 @@ object ProtocolConstants {
   private val defaultServiceEndpointCharLength = 300
   private val defaultServiceTypeCharLength = 100
   private val defaultContextStringCharLength = 100
-  private val defaultIdCharLimit = 50
+  private val defaultIdCharLimit = 50 // Name of the key
 
   val servicesLimit: Int = Try(globalConfig.getInt("didServicesLimit")).toOption.getOrElse(defaultServiceLimit)
   val publicKeysLimit: Int = Try(globalConfig.getInt("didPublicKeysLimit")).toOption.getOrElse(defaultPublicKeysLimit)
@@ -24,6 +24,10 @@ object ProtocolConstants {
   val contextStringCharLimit: Int =
     Try(globalConfig.getInt("contextStringCharLimit")).toOption.getOrElse(defaultContextStringCharLength)
 
+  /** Keys oficial suported by the DID Prism Method
+    * @see
+    *   https://github.com/input-output-hk/atala-prism-docs
+    */
   val supportedEllipticCurves: Seq[String] = List("secp256k1", "Ed25519", "X25519")
 
 }
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/models/package.scala b/node/src/main/scala/io/iohk/atala/prism/node/models/package.scala
index 885ed14d76..8da6472fa7 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/models/package.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/models/package.scala
@@ -5,7 +5,6 @@ import enumeratum.EnumEntry.UpperSnakecase
 import enumeratum._
 import io.iohk.atala.prism.credentials.CredentialBatchId
 import io.iohk.atala.prism.crypto.{MerkleRoot, Sha256Digest}
-import io.iohk.atala.prism.crypto.keys.ECPublicKey
 import io.iohk.atala.prism.protos.models.TimestampInfo
 import io.iohk.atala.prism.models.{AtalaOperationId, DidSuffix, IdType, Ledger, TransactionId}
 import io.iohk.atala.prism.protos.node_models
@@ -13,6 +12,8 @@ import tofu.logging.derivation.loggable
 
 import java.time.Instant
 import scala.util.matching.Regex
+// import io.iohk.atala.prism.apollo.utils.KMMECPoint
+import identus.apollo.PublicKey
 
 package object models {
   sealed trait KeyUsage extends EnumEntry with UpperSnakecase {
@@ -49,7 +50,7 @@ package object models {
       didSuffix: DidSuffix,
       keyId: String,
       keyUsage: KeyUsage,
-      key: ECPublicKey
+      key: PublicKey
   )
 
   case class DIDService(
@@ -152,7 +153,7 @@ package object models {
         didSuffix: DidSuffix,
         keyId: String,
         keyUsage: KeyUsage,
-        key: ECPublicKey,
+        key: PublicKey,
         addedOn: LedgerData,
         revokedOn: Option[LedgerData]
     )
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/operations/CreateDIDOperation.scala b/node/src/main/scala/io/iohk/atala/prism/node/operations/CreateDIDOperation.scala
index b5ad387a67..01ae142ddd 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/operations/CreateDIDOperation.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/operations/CreateDIDOperation.scala
@@ -113,7 +113,7 @@ object CreateDIDOperation extends SimpleOperationCompanion[CreateDIDOperation] {
           val (key, i) = keyi
           acc.flatMap(list =>
             ParsingUtils
-              .parseKey(
+              .parseKey( // We should only validade the Master Key
                 ValueAtPath(key, keysValue.path / i.toString),
                 didSuffix,
                 idCharLenLimit
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/operations/DeactivateDIDOperation.scala b/node/src/main/scala/io/iohk/atala/prism/node/operations/DeactivateDIDOperation.scala
index ddf53fc3d1..ea7f868065 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/operations/DeactivateDIDOperation.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/operations/DeactivateDIDOperation.scala
@@ -40,6 +40,7 @@ case class DeactivateDIDOperation(
         PublicKeysDAO
           .find(didSuffix, keyId)
           .map(_.toRight(StateError.UnknownKey(didSuffix, keyId)))
+
       }.subflatMap { didKey =>
         Either.cond(
           didKey.keyUsage == KeyUsage.MasterKey,
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/operations/ParsingUtils.scala b/node/src/main/scala/io/iohk/atala/prism/node/operations/ParsingUtils.scala
index ca39b38bf9..741f45abba 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/operations/ParsingUtils.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/operations/ParsingUtils.scala
@@ -3,8 +3,6 @@ package io.iohk.atala.prism.node.operations
 import java.time.LocalDate
 import cats.implicits._
 import com.google.protobuf.ByteString
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
-import io.iohk.atala.prism.crypto.keys.ECPublicKey
 import io.iohk.atala.prism.crypto.Sha256Digest
 import io.iohk.atala.prism.models.DidSuffix
 import io.iohk.atala.prism.node.models.{DIDPublicKey, DIDService, KeyUsage, ProtocolConstants}
@@ -14,6 +12,8 @@ import io.iohk.atala.prism.protos.{common_models, node_models}
 import io.iohk.atala.prism.utils.UriUtils
 import io.circe.parser.{parse => parseJson}
 import io.circe.Json
+// import io.iohk.atala.prism.apollo.utils.KMMECPoint
+import identus.apollo.PublicKey
 
 import scala.util.Try
 
@@ -43,10 +43,15 @@ object ParsingUtils {
     } yield parsedDate
   }
 
+  /** This method is used to parse the Master Key only.
+    *
+    * The Master key is of the type secp256k1
+    */
   def parseKeyData(
       keyData: ValueAtPath[node_models.PublicKey]
-  ): Either[ValidationError, ECPublicKey] = {
+  ): Either[ValidationError, PublicKey] = {
     if (keyData(_.keyData.isEcKeyData)) {
+      // this path is here for legacy reason.
       parseECKey(keyData.child(_.getEcKeyData, "ecKeyData"))
     } else if (keyData(_.keyData.isCompressedEcKeyData)) {
       parseCompressedECKey(
@@ -59,7 +64,7 @@ object ParsingUtils {
 
   def parseECKey(
       ecData: ValueAtPath[node_models.ECKeyData]
-  ): Either[ValidationError, ECPublicKey] = {
+  ): Either[ValidationError, PublicKey] = {
 
     val supportedCurves = ProtocolConstants.supportedEllipticCurves
     val curve = ecData(_.curve)
@@ -72,7 +77,8 @@ object ParsingUtils {
       Left(ecData.child(_.curve, "y").missing())
     } else {
       Try(
-        EC.toPublicKeyFromByteCoordinates(
+        PublicKey(
+          ecData(_.curve.toString),
           ecData(_.x.toByteArray),
           ecData(_.y.toByteArray)
         )
@@ -88,8 +94,9 @@ object ParsingUtils {
   }
 
   def parseCompressedECKey(
+      // FIXME need key type
       ecData: ValueAtPath[node_models.CompressedECKeyData]
-  ): Either[ValidationError, ECPublicKey] = {
+  ): Either[ValidationError, PublicKey] = {
 
     val supportedCurves = ProtocolConstants.supportedEllipticCurves
     val curve = ecData(_.curve)
@@ -99,9 +106,7 @@ object ParsingUtils {
     } else if (!supportedCurves.contains(curve)) {
       Left(ecData.child(_.curve, "curve").invalid(s"Unsupported curve - $curve"))
     } else {
-      Try(
-        EC.toPublicKeyFromCompressed(ecData(_.data.toByteArray))
-      ).toEither.left
+      Try { PublicKey(ecData(_.curve), ecData(_.data.toByteArray)) }.toEither.left
         .map(ex =>
           InvalidValue(
             ecData.path,
@@ -419,6 +424,7 @@ object ParsingUtils {
     } yield uniqueValidated
   }
 
+  /** FIXME question is this only used to parse the Master Key? */
   def parseKey(
       key: ValueAtPath[node_models.PublicKey],
       didSuffix: DidSuffix,
@@ -426,8 +432,10 @@ object ParsingUtils {
   ): Either[ValidationError, DIDPublicKey] = {
     for {
       keyUsage <- key.child(_.usage, "usage").parse {
-        case node_models.KeyUsage.MASTER_KEY => Right(KeyUsage.MasterKey)
-        case node_models.KeyUsage.ISSUING_KEY => Right(KeyUsage.IssuingKey)
+        case node_models.KeyUsage.MASTER_KEY =>
+          Right(KeyUsage.MasterKey)
+        case node_models.KeyUsage.ISSUING_KEY =>
+          Right(KeyUsage.IssuingKey)
         case node_models.KeyUsage.KEY_AGREEMENT_KEY =>
           Right(KeyUsage.KeyAgreementKey)
         case node_models.KeyUsage.REVOCATION_KEY =>
@@ -446,7 +454,8 @@ object ParsingUtils {
         (),
         MissingValue(key.path / "keyData")
       )
-      publicKey <- parseKeyData(key)
+      publicKey <- parseKeyData(key) // FIXME all types of keys are validated ...
+      // FIXME !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     } yield DIDPublicKey(didSuffix, keyId, keyUsage, publicKey)
   }
 
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/operations/UpdateDIDOperation.scala b/node/src/main/scala/io/iohk/atala/prism/node/operations/UpdateDIDOperation.scala
index 04bc58dcf4..571860f53d 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/operations/UpdateDIDOperation.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/operations/UpdateDIDOperation.scala
@@ -299,6 +299,7 @@ object UpdateDIDOperation extends OperationCompanion[UpdateDIDOperation] {
           value.key
             .toRight(MissingValue(path))
             .map(ValueAtPath(_, path))
+            // FIXME !!!!!!!!!!!!!!!!!!!!!!!!!!! We Should only validade the Master Key!
             .flatMap(ParsingUtils.parseKey(_, didSuffix, idCharLenLimit))
             .map(AddKeyAction)
 
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/operations/package.scala b/node/src/main/scala/io/iohk/atala/prism/node/operations/package.scala
index 8637f601a9..a3bbf5bbd5 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/operations/package.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/operations/package.scala
@@ -5,7 +5,6 @@ import cats.data.{EitherT, NonEmptyList}
 import doobie.free.connection.ConnectionIO
 import doobie.implicits.toDoobieApplicativeErrorOps
 import doobie.postgres.sqlstate
-import io.iohk.atala.prism.crypto.keys.ECPublicKey
 import io.iohk.atala.prism.crypto.Sha256Digest
 import io.iohk.atala.prism.protos.models.TimestampInfo
 import io.iohk.atala.prism.models.{DidSuffix, Ledger, TransactionId}
@@ -18,6 +17,7 @@ import io.iohk.atala.prism.node.operations.protocolVersion.SupportedOperations
 import io.iohk.atala.prism.node.repositories.daos.{MetricsCountersDAO, ProtocolVersionsDAO}
 import io.iohk.atala.prism.protos.{node_internal, node_models}
 import io.iohk.atala.prism.protos.node_models.SignedAtalaOperation
+import identus.apollo.PublicKey
 
 package object operations {
 
@@ -175,7 +175,7 @@ package object operations {
 
   /** Data required to verify the correctness of the operation */
   case class CorrectnessData(
-      key: ECPublicKey,
+      key: PublicKey,
       previousOperation: Option[Sha256Digest]
   )
 
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/repositories/daos/PublicKeysDAO.scala b/node/src/main/scala/io/iohk/atala/prism/node/repositories/daos/PublicKeysDAO.scala
index 32a39e56cf..bb982f3b67 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/repositories/daos/PublicKeysDAO.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/repositories/daos/PublicKeysDAO.scala
@@ -14,8 +14,13 @@ import java.time.Instant
 
 object PublicKeysDAO {
   def insert(key: DIDPublicKey, ledgerData: LedgerData): ConnectionIO[Unit] = {
-    val curveName = ECConfig.getCURVE_NAME
-    val compressed = key.key.getEncodedCompressed
+    val curveName = ECConfig.getCURVE_NAME // FIXME
+
+    // The Master key must be of the type Secp256k1
+    val companion = new io.iohk.atala.prism.apollo.utils.KMMECSecp256k1PublicKey.Companion
+    val secp256k1PublicKey = companion.secp256k1FromByteCoordinates(key.key.getX, key.key.getY)
+
+    val compressed = secp256k1PublicKey.getCompressed()
 
     val addedOn = ledgerData.timestampInfo
     sql"""
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/repositories/daos/package.scala b/node/src/main/scala/io/iohk/atala/prism/node/repositories/daos/package.scala
index 269360fa0f..1292cc8ffe 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/repositories/daos/package.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/repositories/daos/package.scala
@@ -5,9 +5,7 @@ import doobie._
 import doobie.postgres.implicits._
 import doobie.util.invariant.InvalidEnum
 import io.iohk.atala.prism.credentials.CredentialBatchId
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
 import io.iohk.atala.prism.crypto.ECConfig.{INSTANCE => ECConfig}
-import io.iohk.atala.prism.crypto.keys.ECPublicKey
 import io.iohk.atala.prism.crypto.{MerkleRoot, Sha256Digest}
 import io.iohk.atala.prism.daos.BaseDAO
 import io.iohk.atala.prism.models._
@@ -15,6 +13,7 @@ import io.iohk.atala.prism.node.models._
 import io.iohk.atala.prism.node.models.nodeState.{CredentialBatchState, DIDPublicKeyState, DIDServiceState, LedgerData}
 import io.iohk.atala.prism.protos.models.TimestampInfo
 import io.iohk.atala.prism.utils.syntax._
+import identus.apollo.PublicKey
 
 import java.time.Instant
 
@@ -87,14 +86,12 @@ package object daos extends BaseDAO {
           Option[Int]
       )
     ].contramap { key =>
-      val curveName = ECConfig.getCURVE_NAME
-      val compressed = key.key.getEncodedCompressed
       (
         key.didSuffix,
         key.keyId,
         key.keyUsage,
-        curveName,
-        compressed,
+        key.key.curveName,
+        key.key.getEncodedCompressed,
         key.addedOn.timestampInfo.getAtalaBlockTimestamp.toInstant,
         key.addedOn.timestampInfo.getAtalaBlockSequenceNumber,
         key.addedOn.timestampInfo.getOperationSequenceNumber,
@@ -111,8 +108,8 @@ package object daos extends BaseDAO {
           DidSuffix,
           String,
           KeyUsage,
-          String,
-          Array[Byte],
+          String, // Public key curve name
+          Array[Byte], // Public key encoded
           Instant,
           Int,
           Int,
@@ -142,9 +139,7 @@ package object daos extends BaseDAO {
             rTransactionId,
             rLedger
           ) =>
-        assert(curveId == ECConfig.getCURVE_NAME)
-        val javaPublicKey: ECPublicKey =
-          EC.toPublicKeyFromCompressed(compressed)
+        // assert(curveId == ECConfig.getCURVE_NAME) //FIXME
         val revokeLedgerData =
           for (
             transactionId <- rTransactionId; ledger <- rLedger; t <- rTimestamp;
@@ -155,11 +150,12 @@ package object daos extends BaseDAO {
               ledger = ledger,
               timestampInfo = new TimestampInfo(t.toEpochMilli, absn, osn)
             )
+
         DIDPublicKeyState(
           didSuffix,
           keyId,
           keyUsage,
-          javaPublicKey,
+          PublicKey(curve = curveId, data = compressed),
           LedgerData(
             transactionId = aTransactionId,
             ledger = aLedger,
diff --git a/node/src/main/scala/io/iohk/atala/prism/node/services/BlockProcessingService.scala b/node/src/main/scala/io/iohk/atala/prism/node/services/BlockProcessingService.scala
index d7f6f0aa79..652fd77752 100644
--- a/node/src/main/scala/io/iohk/atala/prism/node/services/BlockProcessingService.scala
+++ b/node/src/main/scala/io/iohk/atala/prism/node/services/BlockProcessingService.scala
@@ -7,7 +7,6 @@ import doobie.free.connection
 import doobie.free.connection.ConnectionIO
 import io.iohk.atala.prism.protos.models.TimestampInfo
 import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
-import io.iohk.atala.prism.crypto.keys.ECPublicKey
 import io.iohk.atala.prism.crypto.signature.ECSignature
 import io.iohk.atala.prism.models.{AtalaOperationId, Ledger, TransactionId}
 import io.iohk.atala.prism.node.metrics.OperationsCounters
@@ -20,6 +19,7 @@ import io.iohk.atala.prism.protos.{node_internal, node_models}
 import org.slf4j.LoggerFactory
 import scala.util.chaining._
 import scala.util.control.NonFatal
+import identus.apollo.PublicKey
 
 // This service syncs Node state with the underlying ledger
 trait BlockProcessingService {
@@ -195,14 +195,14 @@ class BlockProcessingServiceImpl(applyOperationConfig: ApplyOperationConfig) ext
   }
 
   def verifySignature(
-      key: ECPublicKey,
+      key: PublicKey, // FIXME it's only works for Signature
       protoOperation: node_models.SignedAtalaOperation
   ): Either[StateError, Unit] = {
     try {
       Either.cond(
         EC.verifyBytes(
           protoOperation.getOperation.toByteArray,
-          key,
+          { println(key); ??? }, // FIXME //key,
           new ECSignature(protoOperation.signature.toByteArray)
         ),
         (),
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/NodeExplorerServiceSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/NodeExplorerServiceSpec.scala
index fd5e72b50b..d56a818f86 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/NodeExplorerServiceSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/NodeExplorerServiceSpec.scala
@@ -174,7 +174,7 @@ class NodeExplorerServiceSpec
   "NodeExplorerService.getScheduledAtalaOperations" should {
     "return scheduled operations in correct order" in {
       def sign(op: node_models.AtalaOperation): SignedAtalaOperation =
-        BlockProcessingServiceSpec.signOperation(op, "master", CreateDIDOperationSpec.masterKeys.getPrivateKey)
+        BlockProcessingServiceSpec.signOperation(op, "master", CreateDIDOperationSpec.masterKeys.privateKey)
 
       def toAtalaObject(ops: List[node_models.AtalaOperation]): node_internal.AtalaObject = {
         val block = node_internal.AtalaBlock(ops.map(sign))
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/NodeServiceSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/NodeServiceSpec.scala
index f49f21b8fa..0903598f09 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/NodeServiceSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/NodeServiceSpec.scala
@@ -126,7 +126,7 @@ class NodeServiceSpec
         didSuffix,
         "master",
         KeyUsage.MasterKey,
-        CreateDIDOperationSpec.masterKeys.getPublicKey
+        CreateDIDOperationSpec.masterKeys.publicKey
       )
       PublicKeysDAO
         .insert(key, dummyLedgerData)
@@ -164,7 +164,7 @@ class NodeServiceSpec
     }
 
     "return error for a long form DID" in {
-      val masterKey = CreateDIDOperationSpec.masterKeys.getPublicKey
+      val masterKey = CreateDIDOperationSpec.masterKeys.publicKey
       val longFormDID = DID.buildLongFormFromMasterPublicKey(masterKey)
       doReturn(fake[Instant](dummySyncTimestamp))
         .when(objectManagementService)
@@ -184,7 +184,7 @@ class NodeServiceSpec
       val operation = BlockProcessingServiceSpec.signOperation(
         CreateDIDOperationSpec.exampleOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val operationId = AtalaOperationId.of(operation)
       mockOperationId(operationId)
@@ -211,7 +211,7 @@ class NodeServiceSpec
       val operation = BlockProcessingServiceSpec.signOperation(
         CreateDIDOperationSpec.exampleOperationWithCompressedKeys,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val operationId = AtalaOperationId.of(operation)
       mockOperationId(operationId)
@@ -242,7 +242,7 @@ class NodeServiceSpec
           _.updateDid.actions(0).addKey.key.id := ""
         ),
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
 
       val error = intercept[StatusRuntimeException] {
@@ -259,7 +259,7 @@ class NodeServiceSpec
       val operation = BlockProcessingServiceSpec.signOperation(
         UpdateDIDOperationSpec.exampleAddAndRemoveOperation,
         "master",
-        UpdateDIDOperationSpec.masterKeys.getPrivateKey
+        UpdateDIDOperationSpec.masterKeys.privateKey
       )
       val operationId = AtalaOperationId.of(operation)
       mockOperationId(operationId)
@@ -280,7 +280,7 @@ class NodeServiceSpec
       val operation = BlockProcessingServiceSpec.signOperation(
         UpdateDIDOperationSpec.exampleOperationWithCompressedKeys,
         "master",
-        UpdateDIDOperationSpec.masterKeys.getPrivateKey
+        UpdateDIDOperationSpec.masterKeys.privateKey
       )
       val operationId = AtalaOperationId.of(operation)
       mockOperationId(operationId)
@@ -303,7 +303,7 @@ class NodeServiceSpec
           _.updateDid.id := "abc#@!"
         ),
         "master",
-        UpdateDIDOperationSpec.masterKeys.getPrivateKey
+        UpdateDIDOperationSpec.masterKeys.privateKey
       )
 
       val error = intercept[StatusRuntimeException] {
@@ -320,7 +320,7 @@ class NodeServiceSpec
       val operation = BlockProcessingServiceSpec.signOperation(
         IssueCredentialBatchOperationSpec.exampleOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val operationId = AtalaOperationId.of(operation)
       mockOperationId(operationId)
@@ -352,7 +352,7 @@ class NodeServiceSpec
               .copyFrom("abc".getBytes)
           ),
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
 
       val error = intercept[StatusRuntimeException] {
@@ -369,7 +369,7 @@ class NodeServiceSpec
       val operation = BlockProcessingServiceSpec.signOperation(
         RevokeCredentialsOperationSpec.revokeFullBatchOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val operationId = AtalaOperationId.of(operation)
       mockOperationId(operationId)
@@ -392,7 +392,7 @@ class NodeServiceSpec
           _.revokeCredentials.credentialBatchId := ""
         ),
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
 
       val error = intercept[StatusRuntimeException] {
@@ -463,7 +463,7 @@ class NodeServiceSpec
       val validOperation = BlockProcessingServiceSpec.signOperation(
         CreateDIDOperationSpec.exampleOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val operationId = AtalaOperationId.of(validOperation)
       val operationIdProto = operationId.toProtoByteString
@@ -497,7 +497,7 @@ class NodeServiceSpec
       val validOperation = BlockProcessingServiceSpec.signOperation(
         CreateDIDOperationSpec.exampleOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val operationId = AtalaOperationId.of(validOperation)
       val operationIdProto = operationId.toProtoByteString
@@ -821,7 +821,7 @@ class NodeServiceSpec
       val validOperation = BlockProcessingServiceSpec.signOperation(
         CreateDIDOperationSpec.exampleOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
 
       val invalidOperation = BlockProcessingServiceSpec.signOperation(
@@ -831,7 +831,7 @@ class NodeServiceSpec
               .copyFrom("abc".getBytes)
           ),
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
 
       val error = intercept[StatusRuntimeException] {
@@ -849,14 +849,14 @@ class NodeServiceSpec
       val createDIDOperation = BlockProcessingServiceSpec.signOperation(
         CreateDIDOperationSpec.exampleOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val createDIDOperationId = AtalaOperationId.of(createDIDOperation)
 
       val issuanceOperation = BlockProcessingServiceSpec.signOperation(
         IssueCredentialBatchOperationSpec.exampleOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val issuanceOperationId = AtalaOperationId.of(issuanceOperation)
 
@@ -906,14 +906,14 @@ class NodeServiceSpec
       val createDIDOperation = BlockProcessingServiceSpec.signOperation(
         CreateDIDOperationSpec.exampleOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val createDIDOperationId = AtalaOperationId.of(createDIDOperation)
 
       val updateOperation = BlockProcessingServiceSpec.signOperation(
         UpdateDIDOperationSpec.exampleAddAndRemoveOperation,
         "master",
-        UpdateDIDOperationSpec.masterKeys.getPrivateKey
+        UpdateDIDOperationSpec.masterKeys.privateKey
       )
       val updateOperationId = AtalaOperationId.of(updateOperation)
 
@@ -956,7 +956,7 @@ class NodeServiceSpec
       val revokeOperation = BlockProcessingServiceSpec.signOperation(
         RevokeCredentialsOperationSpec.revokeFullBatchOperation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
       val revokeOperationId = AtalaOperationId.of(revokeOperation)
 
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/metrics/OperationsCounterSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/metrics/OperationsCounterSpec.scala
index 25226f52c3..9334722fdb 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/metrics/OperationsCounterSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/metrics/OperationsCounterSpec.scala
@@ -1,6 +1,5 @@
 package io.iohk.atala.prism.node.metrics
 
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
 import org.scalatest.wordspec.AnyWordSpec
 import io.iohk.atala.prism.node.services.BlockProcessingServiceSpec
 import io.iohk.atala.prism.protos.node_models.{AtalaOperation, SignedAtalaOperation}
@@ -15,12 +14,13 @@ import io.iohk.atala.prism.node.operations.{
   ProtocolVersionUpdateOperationSpec,
   DeactivateDIDOperationSpec
 }
+import identus.apollo.MyKeyPair
 
 class OperationsCounterSpec extends AnyWordSpec with Matchers {
   "countReceivedAtalaOperations" should {
     "count all types of operations" in {
       val signingKeyId = "master"
-      val signingKey = EC.generateKeyPair().getPrivateKey
+      val signingKey = MyKeyPair.generateKeyPair.privateKey
       def sign(op: AtalaOperation): SignedAtalaOperation = BlockProcessingServiceSpec.signOperation(
         op,
         signingKeyId,
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/migrations/V19MigrationSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/migrations/V19MigrationSpec.scala
index 14d2180e0f..8ca994a4cf 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/migrations/V19MigrationSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/migrations/V19MigrationSpec.scala
@@ -15,6 +15,7 @@ import io.iohk.atala.prism.crypto.Sha256
 import io.iohk.atala.prism.protos.models.TimestampInfo
 
 import java.time.Instant
+import identus.apollo.MyKeyPair
 
 class V19MigrationSpec extends PostgresMigrationSpec("db.migration.V19") with BaseDAO {
 
@@ -34,22 +35,18 @@ class V19MigrationSpec extends PostgresMigrationSpec("db.migration.V19") with Ba
       didSuffix,
       "master",
       KeyUsage.MasterKey,
-      EC.generateKeyPair().getPublicKey
+      MyKeyPair.generateKeyPair.publicKey
     )
 
   private def insertPublicKey(key: DIDPublicKey, ledgerData: LedgerData) = {
-    val curveName = ECConfig.getCURVE_NAME
-    val point = key.key.getCurvePoint
-
-    val xBytes = point.getX.bytes()
-    val yBytes = point.getY.bytes()
-
+    val curveName = key.key.curveName
+    val point = key.key.toCurvePoint
     val addedOn = ledgerData.timestampInfo
     sql"""
          |INSERT INTO public_keys (did_suffix, key_id, key_usage, curve, x, y,
          |   added_on, added_on_absn, added_on_osn,
          |   added_on_transaction_id, ledger)
-         |VALUES (${key.didSuffix}, ${key.keyId}, ${key.keyUsage}, $curveName, $xBytes, $yBytes,
+         |VALUES (${key.didSuffix}, ${key.keyId}, ${key.keyUsage}, $curveName, ${point.x}, ${point.y},
          |   ${Instant
         .ofEpochMilli(
           addedOn.getAtalaBlockTimestamp
@@ -69,10 +66,11 @@ class V19MigrationSpec extends PostgresMigrationSpec("db.migration.V19") with Ba
     },
     afterApplied = {
       val inDB = selectPublicKeyCompressed(didPublicKey)
+      val curvePoint = didPublicKey.key.toCurvePoint
       val expected = EC
         .toPublicKeyFromByteCoordinates(
-          didPublicKey.key.getCurvePoint.getX.bytes(),
-          didPublicKey.key.getCurvePoint.getY.bytes()
+          curvePoint.x,
+          curvePoint.y
         )
         .getEncodedCompressed
       inDB mustBe expected
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/models/AtalaObjectInfoSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/models/AtalaObjectInfoSpec.scala
index 3a6e0b0dd7..a94db28cbc 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/models/AtalaObjectInfoSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/models/AtalaObjectInfoSpec.scala
@@ -16,7 +16,7 @@ class AtalaObjectInfoSpec extends AtalaWithPostgresSpec {
     BlockProcessingServiceSpec.signOperation(
       dummyAtalaOperation,
       s"master$masterId",
-      CreateDIDOperationSpec.masterKeys.getPrivateKey
+      CreateDIDOperationSpec.masterKeys.privateKey
     )
   }
 
@@ -51,7 +51,7 @@ class AtalaObjectInfoSpec extends AtalaWithPostgresSpec {
         BlockProcessingServiceSpec.signOperation(
           BlockProcessingServiceSpec.createDidOperation,
           s"master$masterId",
-          CreateDIDOperationSpec.masterKeys.getPrivateKey
+          CreateDIDOperationSpec.masterKeys.privateKey
         )
       }
       val atalaObject1 = createAtalaObject(atalaOperations.take(10))
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/operations/CreateDIDOperationSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/operations/CreateDIDOperationSpec.scala
index 30fe98275c..54952ac978 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/operations/CreateDIDOperationSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/operations/CreateDIDOperationSpec.scala
@@ -4,9 +4,6 @@ import cats.effect.unsafe.implicits.global
 import com.google.protobuf.ByteString
 import doobie.implicits._
 import io.iohk.atala.prism.AtalaWithPostgresSpec
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
-import io.iohk.atala.prism.crypto.ECConfig.{INSTANCE => ECConfig}
-import io.iohk.atala.prism.crypto.keys.{ECKeyPair, ECPublicKey}
 import io.iohk.atala.prism.node.DataPreparation.{dummyApplyOperationConfig, dummyLedgerData, dummyTimestampInfo}
 import io.iohk.atala.prism.node.grpc.ProtoCodecs
 import io.iohk.atala.prism.node.models.nodeState.DIDPublicKeyState
@@ -20,58 +17,47 @@ import io.iohk.atala.prism.protos.node_models.{AtalaOperation, CompressedECKeyDa
 import org.scalatest.EitherValues._
 import org.scalatest.Inside._
 import org.scalatest.OptionValues._
+import identus.apollo._
 
 object CreateDIDOperationSpec {
-  def protoECKeyDataFromPublicKey(key: ECPublicKey): ECKeyData = {
-    val point = key.getCurvePoint
-
+  def protoECKeyDataFromPublicKey(key: PublicKey): ECKeyData =
     node_models.ECKeyData(
-      curve = ECConfig.getCURVE_NAME,
-      x = ByteString.copyFrom(point.getX.bytes()),
-      y = ByteString.copyFrom(point.getY.bytes())
+      curve = key.curveName,
+      x = key.getXAsByteString,
+      y = key.getYAsByteString
     )
-  }
 
   def protoCompressedECKeyDataFromPublicKey(
-      key: ECPublicKey
+      key: PublicKey
   ): CompressedECKeyData =
     node_models.CompressedECKeyData(
-      curve = ECConfig.getCURVE_NAME,
-      data = ByteString.copyFrom(key.getEncodedCompressed)
+      curve = key.curveName,
+      data = key.getEncodedCompressedAsByteString
     )
 
   def randomECKeyData: ECKeyData = {
-    val keyPair = EC.generateKeyPair()
-    protoECKeyDataFromPublicKey(keyPair.getPublicKey)
+    val keyPair = MyKeyPair.generateKeyPair
+    protoECKeyDataFromPublicKey(keyPair.publicKey)
   }
 
   def randomCompressedECKeyData: CompressedECKeyData = {
-    val keyPair = EC.generateKeyPair()
-    protoCompressedECKeyDataFromPublicKey(keyPair.getPublicKey)
+    val keyPair = MyKeyPair.generateKeyPair
+    protoCompressedECKeyDataFromPublicKey(keyPair.publicKey)
   }
 
-  val masterKeys: ECKeyPair = EC.generateKeyPair()
-  val masterEcKeyData: ECKeyData = protoECKeyDataFromPublicKey(
-    masterKeys.getPublicKey
-  )
-  val masterCompressedEcKeyData: CompressedECKeyData =
-    protoCompressedECKeyDataFromPublicKey(masterKeys.getPublicKey)
+  // Secp256k1KeyPair
+  val masterKeys: MyKeyPair = MyKeyPair.generateKeyPair
+  val masterEcKeyData: ECKeyData = protoECKeyDataFromPublicKey(masterKeys.publicKey)
+  val masterCompressedEcKeyData: CompressedECKeyData = protoCompressedECKeyDataFromPublicKey(masterKeys.publicKey)
 
-  val issuingKeys: ECKeyPair = EC.generateKeyPair()
-  val issuingEcKeyData: ECKeyData = protoECKeyDataFromPublicKey(
-    issuingKeys.getPublicKey
-  )
-  val issuingCompressedEcKeyData: CompressedECKeyData =
-    protoCompressedECKeyDataFromPublicKey(issuingKeys.getPublicKey)
+  // KeyPair
+  val issuingKeys: MyKeyPair = MyKeyPair.generateKeyPair
+  val issuingEcKeyData: ECKeyData = protoECKeyDataFromPublicKey(issuingKeys.publicKey)
+  val issuingCompressedEcKeyData: CompressedECKeyData = protoCompressedECKeyDataFromPublicKey(issuingKeys.publicKey)
 
-  val revokingKeys: ECKeyPair = EC.generateKeyPair()
-  val revokingEcKeyData: ECKeyData = protoECKeyDataFromPublicKey(
-    revokingKeys.getPublicKey
-  )
-  val revokingCompressedEcKeyData: CompressedECKeyData =
-    protoCompressedECKeyDataFromPublicKey(
-      revokingKeys.getPublicKey
-    )
+  val revokingKeys: MyKeyPair = MyKeyPair.generateKeyPair
+  val revokingEcKeyData: ECKeyData = protoECKeyDataFromPublicKey(revokingKeys.publicKey)
+  val revokingCompressedEcKeyData: CompressedECKeyData = protoCompressedECKeyDataFromPublicKey(revokingKeys.publicKey)
 
   private val serviceId1 = "linked-domain1"
   private val serviceId2 = "linked-domain2"
@@ -970,7 +956,7 @@ class CreateDIDOperationSpec extends AtalaWithPostgresSpec {
         .toOption
         .value
 
-      key mustBe masterKeys.getPublicKey
+      key mustBe masterKeys.publicKey
       previousOperation mustBe None
     }
   }
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/operations/DeactivateDIDOperationSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/operations/DeactivateDIDOperationSpec.scala
index 0e8310fc11..c0a152cb3f 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/operations/DeactivateDIDOperationSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/operations/DeactivateDIDOperationSpec.scala
@@ -88,7 +88,7 @@ class DeactivateDIDOperationSpec extends AtalaWithPostgresSpec with ProtoParsing
         .toOption
         .value
 
-      key mustBe DeactivateDIDOperationSpec.masterKeys.getPublicKey
+      key mustBe DeactivateDIDOperationSpec.masterKeys.publicKey
       previousOperation mustBe Some(DeactivateDIDOperationSpec.createDidOperation.digest)
     }
 
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/operations/IssueCredentialBatchOperationSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/operations/IssueCredentialBatchOperationSpec.scala
index 47eebec6a8..edb73f924c 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/operations/IssueCredentialBatchOperationSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/operations/IssueCredentialBatchOperationSpec.scala
@@ -23,13 +23,13 @@ object IssueCredentialBatchOperationSpec {
       issuerDIDSuffix,
       "master",
       KeyUsage.MasterKey,
-      masterKeys.getPublicKey
+      masterKeys.publicKey
     ),
     DIDPublicKey(
       issuerDIDSuffix,
       "issuing",
       KeyUsage.IssuingKey,
-      issuingKeys.getPublicKey
+      issuingKeys.publicKey
     )
   )
 
@@ -166,7 +166,7 @@ class IssueCredentialBatchOperationSpec extends AtalaWithPostgresSpec {
         .toOption
         .value
 
-      key mustBe issuingKeys.getPublicKey
+      key mustBe issuingKeys.publicKey
       previousOperation mustBe None
     }
     "return state error when there are used different key than issuing key" in {
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/operations/ParsingUtilsSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/operations/ParsingUtilsSpec.scala
index 01d9fbe31e..f05161293c 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/operations/ParsingUtilsSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/operations/ParsingUtilsSpec.scala
@@ -11,6 +11,7 @@ import javax.xml.bind.DatatypeConverter
 import io.iohk.atala.prism.node.operations.path.{Path, ValueAtPath}
 import io.iohk.atala.prism.protos.node_models
 
+/** node/testOnly io.iohk.atala.prism.node.operations.ParsingUtilsSpec */
 class ParsingUtilsSpec extends AnyWordSpec with Matchers {
   "ParsingUtils" should {
     "missing values" in {
@@ -79,9 +80,9 @@ class ParsingUtilsSpec extends AnyWordSpec with Matchers {
 
     }
 
-    "parse key successfully with valid key curves" in {
+    "parse secp256k1 key successfully with valid key curves" in {
 
-      val keyPair = EC.generateKeyPair()
+      val keyPair = EC.generateKeyPair() // key of the type secp256k1
 
       val xByteString: ByteString = ByteString.copyFrom(keyPair.getPublicKey.getCurvePoint.getX.bytes)
       val yByteString: ByteString = ByteString.copyFrom(keyPair.getPublicKey.getCurvePoint.getY.bytes)
@@ -111,6 +112,8 @@ class ParsingUtilsSpec extends AnyWordSpec with Matchers {
         }
       }
     }
+
+    "FIXME TEST other types of keys"
   }
 
 }
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/operations/ProtoParsingTestHelpers.scala b/node/src/test/scala/io/iohk/atala/prism/node/operations/ProtoParsingTestHelpers.scala
index 47c9eb4d29..73fea35d7a 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/operations/ProtoParsingTestHelpers.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/operations/ProtoParsingTestHelpers.scala
@@ -32,7 +32,7 @@ trait ProtoParsingTestHelpers {
 
   protected def signingKeyId = "master"
 
-  protected def signingKey = CreateDIDOperationSpec.masterKeys.getPrivateKey
+  protected def signingKey = CreateDIDOperationSpec.masterKeys.privateKey
 
   protected def missingAtLeastOneValueTest(
       mutation: Lens[
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/operations/ProtocolVersionUpdateOperationSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/operations/ProtocolVersionUpdateOperationSpec.scala
index 3b30ed8989..fccb1696b7 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/operations/ProtocolVersionUpdateOperationSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/operations/ProtocolVersionUpdateOperationSpec.scala
@@ -56,7 +56,7 @@ object ProtocolVersionUpdateOperationSpec {
       proposerDIDSuffix,
       "master",
       KeyUsage.MasterKey,
-      masterKeys.getPublicKey
+      masterKeys.publicKey
     )
   )
 
@@ -214,7 +214,7 @@ class ProtocolVersionUpdateOperationSpec extends AtalaWithPostgresSpec {
           .toOption
           .value
 
-      key mustBe masterKeys.getPublicKey
+      key mustBe masterKeys.publicKey
       previousOperation mustBe None
     }
 
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/operations/RevokeCredentialsOperationSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/operations/RevokeCredentialsOperationSpec.scala
index e37c97fd2e..77aa669d0f 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/operations/RevokeCredentialsOperationSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/operations/RevokeCredentialsOperationSpec.scala
@@ -184,7 +184,7 @@ class RevokeCredentialsOperationSpec extends AtalaWithPostgresSpec {
 
       val CorrectnessData(key, previousOperation) = corrDataE.toOption.value
 
-      key mustBe revokingKeys.getPublicKey
+      key mustBe revokingKeys.publicKey
       previousOperation mustBe Some(credentialIssueBatchOperation.digest)
     }
     "return state error when there are used different key than revocation key" in {
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/poc/EncodedSizes.scala b/node/src/test/scala/io/iohk/atala/prism/node/poc/EncodedSizes.scala
index 0b59c27f3d..85e103da1b 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/poc/EncodedSizes.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/poc/EncodedSizes.scala
@@ -2,12 +2,11 @@ package io.iohk.atala.prism.node.poc
 
 import java.util.Base64
 import com.google.protobuf.ByteString
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
-import io.iohk.atala.prism.crypto.keys.ECPublicKey
-import io.iohk.atala.prism.crypto.ECConfig.{INSTANCE => ECConfig}
 import io.iohk.atala.prism.crypto.Sha256
 import io.iohk.atala.prism.models.DidSuffix
 import io.iohk.atala.prism.protos.node_models
+import identus.apollo.MyKeyPair
+import identus.apollo.PublicKey
 
 object EncodedSizes {
   def main(args: Array[String]): Unit = {
@@ -18,9 +17,9 @@ object EncodedSizes {
 
     val data = for {
       _ <- 1 to n
-      masterPublicKey1 = EC.generateKeyPair().getPublicKey
-      masterPublicKey2 = EC.generateKeyPair().getPublicKey
-      masterPublicKey3 = EC.generateKeyPair().getPublicKey
+      masterPublicKey1 = MyKeyPair.generateKeyPair.publicKey
+      masterPublicKey2 = MyKeyPair.generateKeyPair.publicKey
+      masterPublicKey3 = MyKeyPair.generateKeyPair.publicKey
       did = createDID(
         List(masterPublicKey1, masterPublicKey2, masterPublicKey3)
       )
@@ -40,8 +39,8 @@ object EncodedSizes {
 
   }
 
-  def createDID(masterPublicKeys: List[ECPublicKey]): String = {
-    def keyElement(publicKey: ECPublicKey, index: Int): node_models.PublicKey =
+  def createDID(masterPublicKeys: List[PublicKey]): String = {
+    def keyElement(publicKey: PublicKey, index: Int): node_models.PublicKey =
       node_models.PublicKey(
         id = s"master$index",
         usage = node_models.KeyUsage.MASTER_KEY,
@@ -68,12 +67,12 @@ object EncodedSizes {
     s"did:prism:${didSuffix.getValue}:$encodedOperation"
   }
 
-  private def publicKeyToProto(key: ECPublicKey): node_models.ECKeyData = {
-    val point = key.getCurvePoint
+  private def publicKeyToProto(key: PublicKey): node_models.ECKeyData = {
+    val point = key.toCurvePoint
     node_models.ECKeyData(
-      curve = ECConfig.getCURVE_NAME,
-      x = ByteString.copyFrom(point.getX.bytes()),
-      y = ByteString.copyFrom(point.getY.bytes())
+      curve = key.curveName,
+      x = ByteString.copyFrom(point.x),
+      y = ByteString.copyFrom(point.y)
     )
   }
 }
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/poc/Wallet.scala b/node/src/test/scala/io/iohk/atala/prism/node/poc/Wallet.scala
index d6c21761c8..b0b94d97d8 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/poc/Wallet.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/poc/Wallet.scala
@@ -226,12 +226,12 @@ case class Wallet(node: node_api.NodeServiceGrpc.NodeServiceBlockingStub) {
       )
   }
 
-  private def publicKeyToProto(key: ECPublicKey): node_models.ECKeyData = {
-    val point = key.getCurvePoint
+  private def publicKeyToProto(key: PublicKey): node_models.ECKeyData = {
+    val point = key.toCurvePoint
     node_models.ECKeyData(
-      curve = ECConfig.getCURVE_NAME,
-      x = ByteString.copyFrom(point.getX.bytes()),
-      y = ByteString.copyFrom(point.getY.bytes())
+      curve = key.curveName,
+      x = ByteString.copyFrom(point.x),
+      y = ByteString.copyFrom(point.y)
     )
   }
 }
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/poc/endorsements/EndorsementsService.scala b/node/src/test/scala/io/iohk/atala/prism/node/poc/endorsements/EndorsementsService.scala
index 2e260ba211..e55edadcbb 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/poc/endorsements/EndorsementsService.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/poc/endorsements/EndorsementsService.scala
@@ -236,12 +236,12 @@ object EndorsementsService {
       signingKeyId: String
   )
 
-  def publicKeyToProto(key: ECPublicKey): node_models.ECKeyData = {
-    val point = key.getCurvePoint
+  private def publicKeyToProto(key: PublicKey): node_models.ECKeyData = {
+    val point = key.toCurvePoint
     node_models.ECKeyData(
-      curve = ECConfig.getCURVE_NAME,
-      x = ByteString.copyFrom(point.getX.bytes()),
-      y = ByteString.copyFrom(point.getY.bytes())
+      curve = key.curveName,
+      x = ByteString.copyFrom(point.x),
+      y = ByteString.copyFrom(point.y)
     )
   }
 }
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/poc/estimations/CardanoFeeEstimator.scala b/node/src/test/scala/io/iohk/atala/prism/node/poc/estimations/CardanoFeeEstimator.scala
index d83071ed63..53f385a05e 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/poc/estimations/CardanoFeeEstimator.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/poc/estimations/CardanoFeeEstimator.scala
@@ -212,12 +212,12 @@ class CardanoFeeEstimator(
     )
   }
 
-  private def publicKeyToProto(key: ECPublicKey): node_models.ECKeyData = {
-    val point = key.getCurvePoint
+  private def publicKeyToProto(key: PublicKey): node_models.ECKeyData = {
+    val point = key.toCurvePoint
     node_models.ECKeyData(
-      curve = ECConfig.getCURVE_NAME,
-      x = ByteString.copyFrom(point.getX.bytes()),
-      y = ByteString.copyFrom(point.getY.bytes())
+      curve = key.curveName,
+      x = ByteString.copyFrom(point.x),
+      y = ByteString.copyFrom(point.y)
     )
   }
 }
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/repositories/DIDDataRepositorySpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/repositories/DIDDataRepositorySpec.scala
index d7e6e17518..f1acd7cd6e 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/repositories/DIDDataRepositorySpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/repositories/DIDDataRepositorySpec.scala
@@ -3,7 +3,6 @@ package io.iohk.atala.prism.node.repositories
 import cats.effect.IO
 import cats.effect.unsafe.implicits.global
 import io.iohk.atala.prism.AtalaWithPostgresSpec
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
 import io.iohk.atala.prism.crypto.Sha256Digest
 import io.iohk.atala.prism.models.{Ledger, TransactionId}
 import io.iohk.atala.prism.node.models.nodeState.LedgerData
@@ -15,6 +14,7 @@ import io.iohk.atala.prism.protos.models.TimestampInfo
 import io.iohk.atala.prism.node.DataPreparation
 import tofu.logging.Logging.Make
 import tofu.logging.Logging
+import identus.apollo.MyKeyPair
 
 class DIDDataRepositorySpec extends AtalaWithPostgresSpec {
   val logs: Make[IO] = Logging.Make.plain[IO]
@@ -29,25 +29,25 @@ class DIDDataRepositorySpec extends AtalaWithPostgresSpec {
       didSuffix = didSuffix,
       keyId = "master",
       keyUsage = KeyUsage.MasterKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "issuing",
       keyUsage = KeyUsage.IssuingKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "authentication",
       keyUsage = KeyUsage.AuthenticationKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "keyAgreement",
       keyUsage = KeyUsage.KeyAgreementKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     )
   )
 
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/ContextDAOSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/ContextDAOSpec.scala
index 97093185eb..a45422e511 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/ContextDAOSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/ContextDAOSpec.scala
@@ -5,13 +5,13 @@ import cats.effect.IO
 import cats.effect.unsafe.implicits.global
 import doobie.implicits._
 import io.iohk.atala.prism.AtalaWithPostgresSpec
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
 import io.iohk.atala.prism.models.{Ledger, TransactionId}
 import io.iohk.atala.prism.node.DataPreparation
 import io.iohk.atala.prism.node.models.nodeState.LedgerData
 import io.iohk.atala.prism.node.models.{DIDData, DIDPublicKey, KeyUsage}
 import io.iohk.atala.prism.node.repositories.{didSuffixFromDigest, digestGen}
 import io.iohk.atala.prism.protos.models.TimestampInfo
+import identus.apollo.MyKeyPair
 import org.scalatest.OptionValues._
 
 import java.time.Instant
@@ -26,25 +26,25 @@ class ContextDAOSpec extends AtalaWithPostgresSpec {
       didSuffix = didSuffix,
       keyId = "master",
       keyUsage = KeyUsage.MasterKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "issuing",
       keyUsage = KeyUsage.IssuingKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "authentication",
       keyUsage = KeyUsage.AuthenticationKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "keyAgreement",
       keyUsage = KeyUsage.KeyAgreementKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     )
   )
 
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/PublicKeysDAOSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/PublicKeysDAOSpec.scala
index e29d7260d1..f0bda85f30 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/PublicKeysDAOSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/PublicKeysDAOSpec.scala
@@ -2,7 +2,6 @@ package io.iohk.atala.prism.node.repositories.daos
 
 import java.time.Instant
 import io.iohk.atala.prism.AtalaWithPostgresSpec
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
 import io.iohk.atala.prism.protos.models.TimestampInfo
 import io.iohk.atala.prism.models.{Ledger, TransactionId}
 import io.iohk.atala.prism.node.DataPreparation
@@ -10,6 +9,7 @@ import io.iohk.atala.prism.node.models.{DIDData, DIDPublicKey, KeyUsage}
 import io.iohk.atala.prism.node.models.nodeState.LedgerData
 import io.iohk.atala.prism.node.repositories.{didSuffixFromDigest, digestGen}
 import org.scalatest.OptionValues._
+import identus.apollo.MyKeyPair
 
 class PublicKeysDAOSpec extends AtalaWithPostgresSpec {
 
@@ -21,25 +21,25 @@ class PublicKeysDAOSpec extends AtalaWithPostgresSpec {
       didSuffix = didSuffix,
       keyId = "master",
       keyUsage = KeyUsage.MasterKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "issuing",
       keyUsage = KeyUsage.IssuingKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "authentication",
       keyUsage = KeyUsage.AuthenticationKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "keyAgreement",
       keyUsage = KeyUsage.KeyAgreementKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     )
   )
 
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/ServicesDAOSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/ServicesDAOSpec.scala
index f60fbea772..0cb137c33a 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/ServicesDAOSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/repositories/daos/ServicesDAOSpec.scala
@@ -5,7 +5,6 @@ import cats.effect.IO
 import cats.effect.unsafe.implicits.global
 import doobie.implicits._
 import io.iohk.atala.prism.AtalaWithPostgresSpec
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
 import io.iohk.atala.prism.models.{Ledger, TransactionId}
 import io.iohk.atala.prism.node.DataPreparation
 import io.iohk.atala.prism.node.models.nodeState.{DIDServiceState, LedgerData}
@@ -13,6 +12,7 @@ import io.iohk.atala.prism.node.models.{DIDData, DIDPublicKey, DIDService, KeyUs
 import io.iohk.atala.prism.node.repositories.{didSuffixFromDigest, digestGen}
 import io.iohk.atala.prism.protos.models.TimestampInfo
 import org.scalatest.OptionValues._
+import identus.apollo.MyKeyPair
 
 import java.time.Instant
 
@@ -26,25 +26,25 @@ class ServicesDAOSpec extends AtalaWithPostgresSpec {
       didSuffix = didSuffix,
       keyId = "master",
       keyUsage = KeyUsage.MasterKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "issuing",
       keyUsage = KeyUsage.IssuingKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "authentication",
       keyUsage = KeyUsage.AuthenticationKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     ),
     DIDPublicKey(
       didSuffix = didSuffix,
       keyId = "keyAgreement",
       keyUsage = KeyUsage.KeyAgreementKey,
-      key = EC.generateKeyPair().getPublicKey
+      key = MyKeyPair.generateKeyPair.publicKey
     )
   )
 
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/services/BlockProcessingServiceSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/services/BlockProcessingServiceSpec.scala
index 595bc5746c..52ef6e9a72 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/services/BlockProcessingServiceSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/services/BlockProcessingServiceSpec.scala
@@ -4,9 +4,7 @@ import cats.effect.unsafe.implicits.global
 import com.google.protobuf.ByteString
 import doobie.implicits._
 import io.iohk.atala.prism.AtalaWithPostgresSpec
-import io.iohk.atala.prism.crypto.EC.{INSTANCE => EC}
 import io.iohk.atala.prism.crypto.Sha256
-import io.iohk.atala.prism.crypto.keys.ECPrivateKey
 import io.iohk.atala.prism.protos.models.TimestampInfo
 import io.iohk.atala.prism.models.{AtalaOperationId, DidSuffix, Ledger, TransactionId}
 import io.iohk.atala.prism.node.DataPreparation
@@ -22,8 +20,10 @@ import io.iohk.atala.prism.node.repositories.daos.DIDDataDAO
 import io.iohk.atala.prism.protos.node_models.SignedAtalaOperation
 import io.iohk.atala.prism.protos.{node_internal, node_models}
 import org.scalatest.OptionValues._
+import identus.apollo.PrivateKey
 
 import java.time.Instant
+import identus.apollo.MyKeyPair
 
 object BlockProcessingServiceSpec {
   import io.iohk.atala.prism.node.operations.CreateDIDOperationSpec.masterKeys
@@ -33,21 +33,20 @@ object BlockProcessingServiceSpec {
   def signOperation(
       operation: node_models.AtalaOperation,
       keyId: String,
-      key: ECPrivateKey
+      key: PrivateKey // FIXME ECPrivateKey
   ): node_models.SignedAtalaOperation = {
     node_models.SignedAtalaOperation(
       signedWith = keyId,
       operation = Some(operation),
-      signature = ByteString.copyFrom(EC.signBytes(operation.toByteArray, key).getData)
+      signature = { key; ??? } // FIXME ByteString.copyFrom(EC.signBytes(operation.toByteArray, key).getData)
     )
   }
 
-  val signedCreateDidOperation =
-    signOperation(createDidOperation, "master", masterKeys.getPrivateKey)
+  val signedCreateDidOperation = signOperation(createDidOperation, "master", masterKeys.privateKey)
   val signedCreateDidOperationId = AtalaOperationId.of(signedCreateDidOperation)
 
   val signedUpdateDidOperation: SignedAtalaOperation =
-    signOperation(updateDidOperation, "master", masterKeys.getPrivateKey)
+    signOperation(updateDidOperation, "master", masterKeys.privateKey)
 
   val exampleBlock = node_internal.AtalaBlock(
     operations = Seq(signedCreateDidOperation)
@@ -220,9 +219,9 @@ class BlockProcessingServiceSpec extends AtalaWithPostgresSpec {
       val invalidOperation =
         updateDidOperation.update(_.updateDid.actions(0).addKey.key.id := "")
       val signedInvalidOperation =
-        signOperation(invalidOperation, "master", masterKeys.getPrivateKey)
+        signOperation(invalidOperation, "master", masterKeys.privateKey)
 
-      val signedValidOperation = signOperation(createDidOperation, "master", masterKeys.getPrivateKey)
+      val signedValidOperation = signOperation(createDidOperation, "master", masterKeys.privateKey)
 
       val block = node_internal.AtalaBlock(
         operations = Seq(signedInvalidOperation, signedValidOperation)
@@ -289,16 +288,16 @@ class BlockProcessingServiceSpec extends AtalaWithPostgresSpec {
               keyData = node_models.PublicKey.KeyData
                 .EcKeyData(
                   CreateDIDOperationSpec.protoECKeyDataFromPublicKey(
-                    EC.generateKeyPair().getPublicKey
+                    MyKeyPair.generateKeyPair.publicKey
                   )
                 )
             )
           )
         )
       val incorrectlySignedOperation2 =
-        signOperation(operation2, "master", masterKeys.getPrivateKey)
+        signOperation(operation2, "master", masterKeys.privateKey)
 
-      val operation3Keys = EC.generateKeyPair()
+      val operation3Keys = MyKeyPair.generateKeyPair
       val operation3 = createDidOperation
         .copy()
         .update(
@@ -309,13 +308,13 @@ class BlockProcessingServiceSpec extends AtalaWithPostgresSpec {
               keyData = node_models.PublicKey.KeyData
                 .EcKeyData(
                   CreateDIDOperationSpec
-                    .protoECKeyDataFromPublicKey(operation3Keys.getPublicKey)
+                    .protoECKeyDataFromPublicKey(operation3Keys.publicKey)
                 )
             )
           )
         )
       val signedOperation3 =
-        signOperation(operation3, "rootkey", operation3Keys.getPrivateKey)
+        signOperation(operation3, "rootkey", operation3Keys.privateKey)
 
       val block = node_internal.AtalaBlock(
         operations = Seq(signedOperation1, incorrectlySignedOperation2, signedOperation3)
@@ -401,7 +400,7 @@ class BlockProcessingServiceSpec extends AtalaWithPostgresSpec {
         )
       )
       val updateDidSignedOperation1 =
-        signOperation(updateDidOperation1, "master", masterKeys.getPrivateKey)
+        signOperation(updateDidOperation1, "master", masterKeys.privateKey)
 
       val updateDidOperation2 = node_models.AtalaOperation(
         operation = node_models.AtalaOperation.Operation.UpdateDid(
@@ -415,7 +414,7 @@ class BlockProcessingServiceSpec extends AtalaWithPostgresSpec {
         )
       )
       val updateDidSignedOperation2 =
-        signOperation(updateDidOperation2, "master", masterKeys.getPrivateKey)
+        signOperation(updateDidOperation2, "master", masterKeys.privateKey)
 
       val block = node_internal.AtalaBlock(
         operations = Seq(
@@ -491,16 +490,16 @@ class BlockProcessingServiceSpec extends AtalaWithPostgresSpec {
               keyData = node_models.PublicKey.KeyData
                 .EcKeyData(
                   CreateDIDOperationSpec.protoECKeyDataFromPublicKey(
-                    EC.generateKeyPair().getPublicKey
+                    MyKeyPair.generateKeyPair.publicKey
                   )
                 )
             )
           )
         )
       val incorrectlySignedOperation2 =
-        signOperation(operation2, "master", masterKeys.getPrivateKey)
+        signOperation(operation2, "master", masterKeys.privateKey)
 
-      val operation3Keys = EC.generateKeyPair()
+      val operation3Keys = MyKeyPair.generateKeyPair
       val operation3 = createDidOperation
         .copy()
         .update(
@@ -511,13 +510,13 @@ class BlockProcessingServiceSpec extends AtalaWithPostgresSpec {
               keyData = node_models.PublicKey.KeyData
                 .EcKeyData(
                   CreateDIDOperationSpec
-                    .protoECKeyDataFromPublicKey(operation3Keys.getPublicKey)
+                    .protoECKeyDataFromPublicKey(operation3Keys.publicKey)
                 )
             )
           )
         )
       val signedOperation3 =
-        signOperation(operation3, "rootkey", operation3Keys.getPrivateKey)
+        signOperation(operation3, "rootkey", operation3Keys.privateKey)
 
       val block1 = node_internal
         .AtalaBlock( // first block contains 1 valid and 1 invalid operation
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/services/ObjectManagementServiceSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/services/ObjectManagementServiceSpec.scala
index 53756b265d..86c0ceb58e 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/services/ObjectManagementServiceSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/services/ObjectManagementServiceSpec.scala
@@ -60,7 +60,7 @@ object ObjectManagementServiceSpec {
             usage = node_models.KeyUsage.AUTHENTICATION_KEY,
             keyData = node_models.PublicKey.KeyData.EcKeyData(
               CreateDIDOperationSpec.protoECKeyDataFromPublicKey(
-                keyPair.getPublicKey
+                keyPair.publicKey
               )
             )
           )
@@ -73,7 +73,7 @@ object ObjectManagementServiceSpec {
       BlockProcessingServiceSpec.signOperation(
         operation,
         "master",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
     }
 }
@@ -349,7 +349,7 @@ class ObjectManagementServiceSpec
         )
       )
       val signedCreateDidOperation =
-        signOperation(createOperation, "master", masterKeys.getPrivateKey)
+        signOperation(createOperation, "master", masterKeys.privateKey)
 
       val result =
         publishSingleOperationAndFlush(signedCreateDidOperation).futureValue
@@ -372,7 +372,7 @@ class ObjectManagementServiceSpec
           .toList
       )
       val signedCreateDidOperation =
-        signOperation(createOperation, "master", masterKeys.getPrivateKey)
+        signOperation(createOperation, "master", masterKeys.privateKey)
 
       val result =
         publishSingleOperationAndFlush(signedCreateDidOperation).futureValue
diff --git a/node/src/test/scala/io/iohk/atala/prism/node/services/SubmissionServiceSpec.scala b/node/src/test/scala/io/iohk/atala/prism/node/services/SubmissionServiceSpec.scala
index 616a46ae68..768e7f32ba 100644
--- a/node/src/test/scala/io/iohk/atala/prism/node/services/SubmissionServiceSpec.scala
+++ b/node/src/test/scala/io/iohk/atala/prism/node/services/SubmissionServiceSpec.scala
@@ -515,7 +515,7 @@ class SubmissionServiceSpec
       BlockProcessingServiceSpec.signOperation(
         DataPreparation.exampleOperation,
         s"master$masterId",
-        CreateDIDOperationSpec.masterKeys.getPrivateKey
+        CreateDIDOperationSpec.masterKeys.privateKey
       )
     }