ETCM-167: Use +: instead of :: on RLPList.

Author: aakoshh

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

@@ -45,7 +45,7 @@ object RLPCodecs {
   implicit val nodeRLPCodec: RLPCodec[Node] =
     RLPCodec.instance[Node](
       { case Node(id, address) =>
-        RLPEncoder.encode(address).asInstanceOf[RLPList] ++ RLPList(id)
+        RLPEncoder.encode(address).asInstanceOf[RLPList] :+ id
       },
       {
         case list @ RLPList(items @ _*) if items.length >= 4 =>
@@ -62,10 +62,10 @@ object RLPCodecs {
       { case EthereumNodeRecord.Content(seq, attrs) =>
         val kvs = attrs
           .foldRight(RLPList()) { case ((k, v), kvs) =>
-            k.toArray :: v.toArray :: kvs
+            k.toArray +: v.toArray +: kvs
           }
 
-        seq :: kvs
+        seq +: kvs
       },
       { case RLPList(seq, kvs @ _*) =>
         val attrs = kvs
@@ -89,7 +89,8 @@ object RLPCodecs {
   implicit val enrRLPCodec: RLPCodec[EthereumNodeRecord] =
     RLPCodec.instance(
       { case EthereumNodeRecord(signature, content) =>
-        signature.toByteArray :: RLPEncoder.encode(content).asInstanceOf[RLPList]
+        val contentList = RLPEncoder.encode(content).asInstanceOf[RLPList]
+        signature.toByteArray +: contentList
       },
       { case RLPList(signature, content @ _*) =>
         EthereumNodeRecord(

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

@@ -40,25 +40,27 @@ object RLPImplicitDerivations {
 
   /** Specialized decoder for case classes that only accepts RLPList for input. */
   trait RLPListDecoder[T] extends RLPDecoder[T] {
+    protected def ct: ClassTag[T]
     def decodeList(items: List[RLPEncodeable]): (T, List[FieldInfo])
 
     override def decode(rlp: RLPEncodeable): T =
       rlp match {
         case list: RLPList =>
           decodeList(list.items.toList)._1
         case _ =>
-          throw RLPException(s"Expected to decode an RLPList", rlp)
+          throw RLPException(s"Cannot decode ${ct.runtimeClass.getSimpleName}: expected an RLPList.", rlp)
       }
   }
   object RLPListDecoder {
-    def apply[T](f: List[RLPEncodeable] => (T, List[FieldInfo])): RLPListDecoder[T] =
+    def apply[T: ClassTag](f: List[RLPEncodeable] => (T, List[FieldInfo])): RLPListDecoder[T] =
       new RLPListDecoder[T] {
+        override val ct = implicitly[ClassTag[T]]
         override def decodeList(items: List[RLPEncodeable]) = f(items)
       }
   }
 
   private def decodeError[T](subject: String, error: String, maybeEncodeable: Option[RLPEncodeable] = None): T =
-    throw RLPException(s"error decoding $subject: $error", maybeEncodeable)
+    throw RLPException(s"Cannot decode $subject: $error", maybeEncodeable)
 
   private def tryDecode[T](subject: => String, encodeable: RLPEncodeable)(f: RLPEncodeable => T): T = {
     try {
@@ -99,15 +101,15 @@ object RLPImplicitDerivations {
           // This is still a trailing optional field, so we can insert it as a value or omit it.
           hEncoder.value.encode(head) match {
             case RLPList(hRLP) =>
-              hRLP :: tRLP
+              hRLP +: tRLP
             case RLPList() if tRLP.items.isEmpty =>
               tRLP
             case hRLP =>
-              hRLP :: tRLP
+              hRLP +: tRLP
           }
         } else {
           // We're no longer in a trailing position, so insert it as a list of 0 or 1 items.
-          hEncoder.value.encode(head) :: tRLP
+          hEncoder.value.encode(head) +: tRLP
         }
 
       htRLP -> (hInfo :: tInfos)
@@ -125,7 +127,7 @@ object RLPImplicitDerivations {
     RLPListEncoder { case head :: tail =>
       val hRLP = hEncoder.value.encode(head)
       val (tRLP, tInfos) = tEncoder.value.encodeList(tail)
-      (hRLP :: tRLP, hInfo :: tInfos)
+      (hRLP +: tRLP, hInfo :: tInfos)
     }
   }
 

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

@@ -15,9 +15,12 @@ package object rlp {
   sealed trait RLPEncodeable
 
   case class RLPList(items: RLPEncodeable*) extends RLPEncodeable {
-    def ::(item: RLPEncodeable): RLPList =
+    def +:(item: RLPEncodeable): RLPList =
       RLPList((item +: items): _*)
 
+    def :+(item: RLPEncodeable): RLPList =
+      RLPList((items :+ item): _*)
+
     def ++(other: RLPList): RLPList =
       RLPList((items ++ other.items): _*)
   }
@@ -96,7 +99,7 @@ package object rlp {
 
         override def decode(rlp: RLPEncodeable): T =
           if (dec.isDefinedAt(rlp)) dec(rlp)
-          else throw RLPException(s"Cannot decode type ${ct.runtimeClass.getSimpleName} from RLP.", rlp)
+          else throw RLPException(s"Cannot decode type ${ct.runtimeClass.getSimpleName} from unexpected RLP.", rlp)
       }
 
     def apply[T](enc: RLPEncoder[T], dec: RLPDecoder[T]): RLPCodec[T] =