Change content id prefixes to 0x00 and 0x01 as per spec change

Author: kdeme

portal/network/history/content/content_keys.nim

@@ -13,24 +13,14 @@ export ssz_serialization, common_types, results
 
 type
   ContentType* = enum
-    # Note: Need to add this unused value as a case object with an enum without
-    # a 0 valueis not allowed: "low(contentType) must be 0 for discriminant".
-    # For prefix values that are in the enum gap, the deserialization will fail
-    # at runtime as is wanted.
-    # In the future it might be possible that this will fail at compile time for
-    # the SSZ Union type, but currently it is allowed in the implementation, and
-    # the SSZ spec is not explicit about disallowing this.
-    unused = 0x00
-    blockBody = 0x09
-    receipts = 0x0A
+    blockBody = 0x00
+    receipts = 0x01
 
   BlockNumberKey* = object
     blockNumber*: uint64
 
   ContentKey* = object
     case contentType*: ContentType
-    of unused:
-      discard
     of blockBody:
       blockBodyKey*: BlockNumberKey
     of receipts:
@@ -49,22 +39,15 @@ func receiptsContentKey*(blockNumber: uint64): ContentKey =
 template blockNumber*(contentKey: ContentKey): uint64 =
   ## Returns the block number for the given content key
   case contentKey.contentType
-  of unused:
-    raiseAssert "ContentKey may not have unused value as content type"
-  of blockBody:
-    contentKey.blockBodyKey.blockNumber
-  of receipts:
-    contentKey.receiptsKey.blockNumber
+  of blockBody: contentKey.blockBodyKey.blockNumber
+  of receipts: contentKey.receiptsKey.blockNumber
 
 proc readSszBytes*(data: openArray[byte], val: var ContentKey) {.raises: [SszError].} =
   mixin readSszValue
-  if data.len() > 0 and data[0] == ord(unused):
-    raise newException(MalformedSszError, "SSZ selector is unused value")
 
   readSszValue(data, val)
 
 func encode*(contentKey: ContentKey): ContentKeyByteList =
-  doAssert(contentKey.contentType != unused)
   ContentKeyByteList.init(SSZ.encode(contentKey))
 
 func decode*(contentKey: ContentKeyByteList): Opt[ContentKey] =
@@ -101,8 +84,6 @@ func toContentId*(blockNumber: uint64, contentType: ContentType): UInt256 =
 
 func toContentId*(contentKey: ContentKey): ContentId =
   case contentKey.contentType
-  of unused:
-    raiseAssert "ContentKey may not have unused value as content type"
   of blockBody:
     toContentId(contentKey.blockBodyKey.blockNumber, contentKey.contentType)
   of receipts:
@@ -119,8 +100,6 @@ func `$`*(x: ContentKey): string =
   var res = "(type: " & $x.contentType & ", "
 
   case x.contentType
-  of unused:
-    raiseAssert "ContentKey may not have unused value as content type"
   of blockBody:
     res.add($x.blockBodyKey)
   of receipts:

portal/network/history/history_network.nim

@@ -168,8 +168,6 @@ proc validateContent(
   let header = ?(await n.getHeader(contentKey.blockNumber()))
 
   case contentKey.contentType
-  of unused:
-    raiseAssert("ContentKey contentType: unused")
   of blockBody:
     let blockBody = decodeRlp(content, BlockBody).valueOr:
       return err("Error decoding block body: " & error)

portal/network/history/history_validation.nim

@@ -72,8 +72,6 @@ func validateContent*(
 ): Result[void, string] =
   ## Validate the encoded content against the header.
   case key.contentType
-  of unused:
-    raiseAssert("ContentKey contentType: unused")
   of blockBody:
     let content = ?decodeRlp(contentBytes, BlockBody)
     validateBlockBody(content, header)

portal/tests/history_network_tests/test_history_content_keys.nim

@@ -27,20 +27,20 @@ suite "History Content Keys":
 
     # Output
     const contentIds = [
-      "0001000000000000000000000000000000000000000000000000000000000009",
-      "03e8000000000000000000000000000000000000000000000000000000000009",
-      "614e3d0000000000000000000000000000000000000000000000000000000009",
-      "ffffffffffffffff000000000000000000000000000000000000000000000009",
-      "fffeffffffffffff000000000000000000000000000000000000000000000009",
-      "fffffffffffffffe000000000000000000000000000000000000000000000009",
-      "0000000000000008000000000000000000000000000000000000000000000009",
-      "5555aaaaaaaaaaaa000000000000000000000000000000000000000000000009",
-      "aaaa555555555555000000000000000000000000000000000000000000000009",
-      "a0a0050505050505000000000000000000000000000000000000000000000009",
+      "0001000000000000000000000000000000000000000000000000000000000001",
+      "03e8000000000000000000000000000000000000000000000000000000000001",
+      "614e3d0000000000000000000000000000000000000000000000000000000001",
+      "ffffffffffffffff000000000000000000000000000000000000000000000001",
+      "fffeffffffffffff000000000000000000000000000000000000000000000001",
+      "fffffffffffffffe000000000000000000000000000000000000000000000001",
+      "0000000000000008000000000000000000000000000000000000000000000001",
+      "5555aaaaaaaaaaaa000000000000000000000000000000000000000000000001",
+      "aaaa555555555555000000000000000000000000000000000000000000000001",
+      "a0a0050505050505000000000000000000000000000000000000000000000001",
     ]
 
     for i in 0 ..< blockNumbers.len():
-      let contentId = toContentId(blockNumbers[i], ContentType.blockBody)
+      let contentId = toContentId(blockNumbers[i], ContentType.receipts)
 
       check contentIds[i] == contentId.dumpHex()
 
@@ -50,12 +50,12 @@ suite "History Content Keys":
 
     # Output
     const
-      contentKeyHex = "0x094e61bc0000000000"
+      contentKeyHex = "0x004e61bc0000000000"
       contentId =
-        "44012581390156707874310974263613699127815223388818970640389075388176810377225"
+        "44012581390156707874310974263613699127815223388818970640389075388176810377216"
       # or
       contentIdHexBE =
-        "614e3d0000000000000000000000000000000000000000000000000000000009"
+        "614e3d0000000000000000000000000000000000000000000000000000000000"
 
     let contentKey = blockBodyContentKey(blockNumber)
 
@@ -79,12 +79,12 @@ suite "History Content Keys":
 
     # Output
     const
-      contentKeyHex = "0x0a4e61bc0000000000"
+      contentKeyHex = "0x014e61bc0000000000"
       contentId =
-        "44012581390156707874310974263613699127815223388818970640389075388176810377226"
+        "44012581390156707874310974263613699127815223388818970640389075388176810377217"
       # or
       contentIdHexBE =
-        "614e3d000000000000000000000000000000000000000000000000000000000a"
+        "614e3d0000000000000000000000000000000000000000000000000000000001"
 
     let contentKey = receiptsContentKey(blockNumber)
 
@@ -102,20 +102,8 @@ suite "History Content Keys":
       # In stint this does BE hex string
       toContentId(contentKey).toHex() == contentIdHexBE
 
-  test "Invalid prefix - 0 value":
-    let encoded = ContentKeyByteList.init(@[byte 0x00])
-    let decoded = decode(encoded)
-
-    check decoded.isErr()
-
-  test "Invalid prefix - before valid range":
-    let encoded = ContentKeyByteList.init(@[byte 0x08])
-    let decoded = decode(encoded)
-
-    check decoded.isErr()
-
   test "Invalid prefix - after valid range":
-    let encoded = ContentKeyByteList.init(@[byte 0x0B])
+    let encoded = ContentKeyByteList.init(@[byte 0x02])
     let decoded = decode(encoded)
 
     check decoded.isErr()