Add TLV stream to Init message

Author: t-bast

eclair-core/src/main/scala/fr/acinq/eclair/wire/InitTlv.scala

@@ -40,22 +40,14 @@ object InitTlvCodecs {
 
   import InitTlv._
 
-  // TODO: wire test-cases:
-  //  * Init not containing any tlv stream
-  //  * Init containing tlv stream without networks (other odd records)
-  //  * Init containing tlv stream without networks (other even records)
-  //  * Init containing tlv stream with networks only
-  //  * Init containing tlv stream with networks and other odd records)
-  //  * Init containing tlv stream with networks and other even records)
-
   // TODO:
-  //  * Add to the Init message after flat features merged
   //  * Send the chainHash from nodeParams when creating Init
   //  * Add logic to Peer.scala to fail connections to others that don't offer my chainHash
 
   private val networks: Codec[Networks] = variableSizeBytesLong(varintoverflow, list(bytes32)).as[Networks]
 
-  val initTlvCodec = discriminated[InitTlv].by(varint)
+  val initTlvCodec = TlvCodecs.tlvStream(discriminated[InitTlv].by(varint)
     .typecase(UInt64(1), networks)
+  )
 
 }

eclair-core/src/main/scala/fr/acinq/eclair/wire/LightningMessageCodecs.scala

@@ -39,7 +39,7 @@ object LightningMessageCodecs {
     },
     { features => (ByteVector.empty, features) })
 
-  val initCodec: Codec[Init] = combinedFeaturesCodec.as[Init]
+  val initCodec: Codec[Init] = (("features" | combinedFeaturesCodec) :: ("tlvStream" | InitTlvCodecs.initTlvCodec)).as[Init]
 
   val errorCodec: Codec[Error] = (
     ("channelId" | bytes32) ::

eclair-core/src/main/scala/fr/acinq/eclair/wire/LightningMessageTypes.scala

@@ -45,7 +45,9 @@ sealed trait HasChainHash extends LightningMessage { def chainHash: ByteVector32
 sealed trait UpdateMessage extends HtlcMessage // <- not in the spec
 // @formatter:on
 
-case class Init(features: ByteVector) extends SetupMessage
+case class Init(features: ByteVector, tlvs: TlvStream[InitTlv] = TlvStream.empty) extends SetupMessage {
+  val networks = tlvs.get[InitTlv.Networks].map(_.chainHashes).getOrElse(Nil)
+}
 
 case class Error(channelId: ByteVector32, data: ByteVector) extends SetupMessage with HasChannelId {
   def toAscii: String = if (fr.acinq.eclair.isAsciiPrintable(data)) new String(data.toArray, StandardCharsets.US_ASCII) else "n/a"

eclair-core/src/main/scala/fr/acinq/eclair/wire/TlvTypes.scala

@@ -22,41 +22,40 @@ import scodec.bits.ByteVector
 import scala.reflect.ClassTag
 
 /**
-  * Created by t-bast on 20/06/2019.
-  */
+ * Created by t-bast on 20/06/2019.
+ */
 
 trait Tlv
 
 /**
-  * Generic tlv type we fallback to if we don't understand the incoming tlv.
-  *
-  * @param tag   tlv tag.
-  * @param value tlv value (length is implicit, and encoded as a varint).
-  */
+ * Generic tlv type we fallback to if we don't understand the incoming tlv.
+ *
+ * @param tag   tlv tag.
+ * @param value tlv value (length is implicit, and encoded as a varint).
+ */
 case class GenericTlv(tag: UInt64, value: ByteVector) extends Tlv
 
 /**
-  * A tlv stream is a collection of tlv records.
-  * A tlv stream is constrained to a specific tlv namespace that dictates how to parse the tlv records.
-  * That namespace is provided by a trait extending the top-level tlv trait.
-  *
-  * @param records known tlv records.
-  * @param unknown unknown tlv records.
-  * @tparam T the stream namespace is a trait extending the top-level tlv trait.
-  */
+ * A tlv stream is a collection of tlv records.
+ * A tlv stream is constrained to a specific tlv namespace that dictates how to parse the tlv records.
+ * That namespace is provided by a trait extending the top-level tlv trait.
+ *
+ * @param records known tlv records.
+ * @param unknown unknown tlv records.
+ * @tparam T the stream namespace is a trait extending the top-level tlv trait.
+ */
 case class TlvStream[T <: Tlv](records: Traversable[T], unknown: Traversable[GenericTlv] = Nil) {
   /**
-    *
-    * @tparam R input type parameter, must be a subtype of the main TLV type
-    * @return the TLV record of type that matches the input type parameter if any (there can be at most one, since BOLTs specify
-    *         that TLV records are supposed to be unique)
-    */
+   *
+   * @tparam R input type parameter, must be a subtype of the main TLV type
+   * @return the TLV record of type that matches the input type parameter if any (there can be at most one, since BOLTs specify
+   *         that TLV records are supposed to be unique)
+   */
   def get[R <: T : ClassTag]: Option[R] = records.collectFirst { case r: R => r }
 }
 
 object TlvStream {
-  def empty[T <: Tlv] = TlvStream[T](Nil, Nil)
+  def empty[T <: Tlv]: TlvStream[T] = TlvStream[T](Nil, Nil)
 
   def apply[T <: Tlv](records: T*): TlvStream[T] = TlvStream(records, Nil)
-
 }

eclair-core/src/test/scala/fr/acinq/eclair/wire/LightningMessageCodecsSpec.scala

@@ -44,21 +44,36 @@ class LightningMessageCodecsSpec extends FunSuite {
   def publicKey(fill: Byte) = PrivateKey(ByteVector.fill(32)(fill)).publicKey
 
   test("encode/decode init message") {
+    val chainHash1 = ByteVector32(hex"0101010101010101010101010101010101010101010101010101010101010101")
+    val chainHash2 = ByteVector32(hex"0202020202020202020202020202020202020202020202020202020202020202")
     val testCases = Seq(
-      (hex"0000 0000", hex"", hex"0000 0000"), // no features
-      (hex"0000 0002088a", hex"088a", hex"0000 0002088a"), // no global features
-      (hex"00020200 0000", hex"0200", hex"0000 00020200"), // no local features
-      (hex"00020200 0002088a", hex"0a8a", hex"0000 00020a8a"), // local and global - no conflict - same size
-      (hex"00020200 0003020002", hex"020202", hex"0000 0003020202"), // local and global - no conflict - different sizes
-      (hex"00020a02 0002088a", hex"0a8a", hex"0000 00020a8a"), // local and global - conflict - same size
-      (hex"00022200 000302aaa2", hex"02aaa2", hex"0000 000302aaa2") // local and global - conflict - different sizes
+      (hex"0000 0000", hex"", Nil, true, None), // no features
+      (hex"0000 0002088a", hex"088a", Nil, true, None), // no global features
+      (hex"00020200 0000", hex"0200", Nil, true, Some(hex"0000 00020200")), // no local features
+      (hex"00020200 0002088a", hex"0a8a", Nil, true, Some(hex"0000 00020a8a")), // local and global - no conflict - same size
+      (hex"00020200 0003020002", hex"020202", Nil, true, Some(hex"0000 0003020202")), // local and global - no conflict - different sizes
+      (hex"00020a02 0002088a", hex"0a8a", Nil, true, Some(hex"0000 00020a8a")), // local and global - conflict - same size
+      (hex"00022200 000302aaa2", hex"02aaa2", Nil, true, Some(hex"0000 000302aaa2")), // local and global - conflict - different sizes
+      (hex"0000 0002088a 03012a05022aa2", hex"088a", Nil, true, None), // unknown odd records
+      (hex"0000 0002088a 03012a04022aa2", hex"088a", Nil, false, None), // unknown even records
+      (hex"0000 0002088a 0120010101010101010101010101010101010101010101010101010101010101", hex"088a", Nil, false, None), // invalid tlv stream
+      (hex"0000 0002088a 01200101010101010101010101010101010101010101010101010101010101010101", hex"088a", List(chainHash1), true, None), // single network
+      (hex"0000 0002088a 014001010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202", hex"088a", List(chainHash1, chainHash2), true, None), // multiple networks
+      (hex"0000 0002088a 0120010101010101010101010101010101010101010101010101010101010101010103012a", hex"088a", List(chainHash1), true, None), // network and unknown odd records
+      (hex"0000 0002088a 0120010101010101010101010101010101010101010101010101010101010101010102012a", hex"088a", Nil, false, None) // network and unknown even records
     )
 
-    for ((bin, features, encoded) <- testCases) {
-      val init = initCodec.decode(bin.bits).require.value
-      assert(init.features === features)
-      assert(initCodec.encode(init).require.bytes === encoded)
-      assert(initCodec.decode(encoded.bits).require.value === init)
+    for ((bin, features, networks, valid, encodedOverride) <- testCases) {
+      if (valid) {
+        val init = initCodec.decode(bin.bits).require.value
+        assert(init.features === features)
+        assert(init.networks === networks)
+        val encoded = initCodec.encode(init).require
+        assert(encoded.bytes === encodedOverride.getOrElse(bin))
+        assert(initCodec.decode(encoded).require.value === init)
+      } else {
+        assert(initCodec.decode(bin.bits).isFailure)
+      }
     }
   }