ETCM-167: RLP codec for all payloads.

Author: aakoshh

src/main/scala/io/iohk/ethereum/network/discovery/codecs/RLPCodecs.scala

@@ -1,37 +1,100 @@
 package io.iohk.ethereum.network.discovery.codecs
 
-import io.iohk.scalanet.discovery.ethereum.Node
+import io.iohk.scalanet.discovery.crypto.{PublicKey, Signature}
+import io.iohk.scalanet.discovery.ethereum.{Node, EthereumNodeRecord}
 import io.iohk.scalanet.discovery.ethereum.v4.Payload
-import io.iohk.ethereum.rlp.RLPCodec
+import io.iohk.scalanet.discovery.hash.Hash
+import io.iohk.ethereum.rlp
+import io.iohk.ethereum.rlp.{RLPCodec, RLPList}
+import io.iohk.ethereum.rlp.RLPCodec.Ops
 import io.iohk.ethereum.rlp.RLPImplicits._
 import io.iohk.ethereum.rlp.RLPImplicitConversions._
 import io.iohk.ethereum.rlp.RLPImplicitDerivations._
 import scodec.Codec
+import scodec.bits.{BitVector, ByteVector}
 import java.net.InetAddress
+import scala.collection.SortedMap
 
 /** RLP codecs based on https://github.com/ethereum/devp2p/blob/master/discv4.md */
 object RLPCodecs {
 
   implicit val policy: DerivationPolicy = DerivationPolicy(omitTrailingOptionals = true)
 
   implicit val inetAddressRLPCodec: RLPCodec[InetAddress] =
-    RLPCodec.instance[InetAddress](
-      ip => ip.getAddress,
-      // Implicit conversion to `Array[Byte]`
-      { case rlp => InetAddress.getByAddress(rlp) }
-    )
+    implicitly[RLPCodec[Array[Byte]]].xmap(InetAddress.getByAddress(_), _.getAddress)
+
+  implicit val bitVectorRLPCodec: RLPCodec[BitVector] =
+    implicitly[RLPCodec[Array[Byte]]].xmap(BitVector(_), _.toByteArray)
+
+  implicit val byteVectorRLPCodec: RLPCodec[ByteVector] =
+    implicitly[RLPCodec[Array[Byte]]].xmap(ByteVector(_), _.toArray)
+
+  implicit val hashRLPCodec: RLPCodec[Hash] =
+    implicitly[RLPCodec[BitVector]].xmap(Hash(_), identity)
+
+  implicit val publicKeyRLPCodec: RLPCodec[PublicKey] =
+    implicitly[RLPCodec[BitVector]].xmap(PublicKey(_), identity)
+
+  implicit val signatureRLPCodec: RLPCodec[Signature] =
+    implicitly[RLPCodec[BitVector]].xmap(Signature(_), identity)
 
   implicit val nodeAddressRLPCodec: RLPCodec[Node.Address] =
-    RLPCodec[Node.Address](
-      deriveLabelledGenericRLPListEncoder,
-      deriveLabelledGenericRLPListDecoder
+    deriveLabelledGenericRLPCodec
+
+  implicit val nodeRLPCodec: RLPCodec[Node] =
+    deriveLabelledGenericRLPCodec
+
+  // https://github.com/ethereum/devp2p/blob/master/enr.md#rlp-encoding
+  // `record = [signature, seq, k, v, ...]`
+  implicit val enrRLPCodec: RLPCodec[EthereumNodeRecord] =
+    RLPCodec.instance(
+      { case EthereumNodeRecord(signature, EthereumNodeRecord.Content(seq, attrs)) =>
+        val kvs = attrs
+          .map { case (k, v) =>
+            RLPList(k.toArray, v.toArray)
+          }
+          .foldRight(RLPList())(_ ++ _)
+
+        signature.toByteArray :: seq :: kvs
+      },
+      { case RLPList(signature, seq, kvs @ _*) =>
+        val attrs = kvs
+          .grouped(2)
+          .collect { case Seq(k, v) =>
+            rlp.decode[ByteVector](k) -> rlp.decode[ByteVector](v)
+          }
+          .toSeq
+
+        // TODO: Should have a constructor for key-value pairs.
+        import EthereumNodeRecord.byteOrdering
+
+        EthereumNodeRecord(
+          rlp.decode[Signature](signature),
+          EthereumNodeRecord.Content(
+            seq,
+            SortedMap(attrs: _*)
+          )
+        )
+      }
     )
 
   implicit val pingRLPCodec: RLPCodec[Payload.Ping] =
-    RLPCodec[Payload.Ping](
-      deriveLabelledGenericRLPListEncoder,
-      deriveLabelledGenericRLPListDecoder
-    )
+    deriveLabelledGenericRLPCodec
+
+  implicit val pongRLPCodec: RLPCodec[Payload.Pong] =
+    deriveLabelledGenericRLPCodec
+
+  implicit val findNodeRLPCodec: RLPCodec[Payload.FindNode] =
+    deriveLabelledGenericRLPCodec
+
+  implicit val neighborsRLPCodec: RLPCodec[Payload.Neighbors] =
+    deriveLabelledGenericRLPCodec
+
+  implicit val enrRequestRLPCodec: RLPCodec[Payload.ENRRequest] =
+    deriveLabelledGenericRLPCodec
+
+  implicit val enrResponseRLPCodec: RLPCodec[Payload.ENRResponse] =
+    deriveLabelledGenericRLPCodec
 
   implicit def payloadCodec: Codec[Payload] = ???
 }

src/main/scala/io/iohk/ethereum/rlp/RLPImplicitDerivations.scala

@@ -109,7 +109,7 @@ object RLPImplicitDerivations {
   }
 
   /** Encoder for a case class based on its labelled generic record representation. */
-  implicit def deriveLabelledGenericRLPListEncoder[T, Rec](implicit
+  implicit def deriveLabelledGenericRLPEncoder[T, Rec](implicit
       // Auto-derived by Shapeless.
       generic: LabelledGeneric.Aux[T, Rec],
       // Derived by `deriveOptionHListRLPListEncoder` and `deriveNonOptionHListRLPListEncoder`.
@@ -203,12 +203,20 @@ object RLPImplicitDerivations {
   }
 
   /** Decoder for a case class based on its labelled generic record representation. */
-  implicit def deriveLabelledGenericRLPListDecoder[T, Rec](implicit
+  implicit def deriveLabelledGenericRLPDecoder[T, Rec](implicit
       // Auto-derived by Shapeless.
       generic: LabelledGeneric.Aux[T, Rec],
       // Derived by `deriveOptionHListRLPListDecoder` and `deriveNonOptionHListRLPListDecoder`.
       recDecoder: Lazy[RLPDecoder[Rec]]
   ): RLPDecoder[T] = RLPDecoder { rlp =>
     generic.from(recDecoder.value.decode(rlp))
   }
+
+  /** Derive both encoder and decoder. */
+  implicit def deriveLabelledGenericRLPCodec[T, Rec](implicit
+      generic: LabelledGeneric.Aux[T, Rec],
+      recEncoder: Lazy[RLPEncoder[Rec]],
+      recDecoder: Lazy[RLPDecoder[Rec]]
+  ): RLPCodec[T] =
+    RLPCodec[T](deriveLabelledGenericRLPEncoder, deriveLabelledGenericRLPDecoder)
 }

src/main/scala/io/iohk/ethereum/rlp/RLPImplicits.scala

@@ -3,6 +3,7 @@ package io.iohk.ethereum.rlp
 import akka.util.ByteString
 import io.iohk.ethereum.rlp.RLP._
 import io.iohk.ethereum.utils.BigIntExtensionMethods.BigIntAsUnsigned
+import RLPCodec.Ops
 
 object RLPImplicits {
 
@@ -108,6 +109,9 @@ object RLPImplicits {
       }
     }
 
+  implicit def listEncDec[T: RLPEncoder: RLPDecoder]: RLPCodec[List[T]] =
+    seqEncDec[T]().xmap(_.toList, _.toSeq)
+
   implicit def optionEnc[T](implicit enc: RLPEncoder[T]): RLPEncoder[Option[T]] = {
     case None => RLPList()
     case Some(value) => RLPList(enc.encode(value))

src/main/scala/io/iohk/ethereum/rlp/package.scala

@@ -12,7 +12,10 @@ package object rlp {
 
   case class RLPList(items: RLPEncodeable*) extends RLPEncodeable {
     def ::(item: RLPEncodeable): RLPList =
-      RLPList((item :: items.toList): _*)
+      RLPList((item +: items): _*)
+
+    def ++(other: RLPList): RLPList =
+      RLPList((items ++ other.items): _*)
   }
 
   case class RLPValue(bytes: Array[Byte]) extends RLPEncodeable {
@@ -97,5 +100,15 @@ package object rlp {
         override def encode(obj: T): RLPEncodeable = enc.encode(obj)
         override def decode(rlp: RLPEncodeable): T = dec.decode(rlp)
       }
+
+    implicit class Ops[A](val codec: RLPCodec[A]) extends AnyVal {
+
+      /** Given a codec for type A, make a coded for type B. */
+      def xmap[B](f: A => B, g: B => A): RLPCodec[B] =
+        new RLPEncoder[B] with RLPDecoder[B] {
+          override def encode(obj: B): RLPEncodeable = codec.encode(g(obj))
+          override def decode(rlp: RLPEncodeable): B = f(codec.decode(rlp))
+        }
+    }
   }
 }