Test-Vector 'Disputes' (#12)

Author: xDimon

.clang-format

@@ -6,7 +6,7 @@
 
 BasedOnStyle: Google
 
-AlignAfterOpenBracket: DontAlign
+AlignAfterOpenBracket: Align
 AlignOperands: AlignAfterOperator
 AllowShortFunctionsOnASingleLine: Empty
 BinPackArguments: false

CMakeLists.txt

@@ -28,6 +28,7 @@ find_package(Boost CONFIG REQUIRED)
 find_package(fmt CONFIG REQUIRED)
 find_package(jam_crust CONFIG REQUIRED)
 find_package(scale CONFIG REQUIRED)
+find_package(schnorrkel_crust CONFIG REQUIRED)
 
 add_library(headers INTERFACE)
 target_include_directories(headers INTERFACE

python/asn1.py

@@ -170,6 +170,8 @@ def asn_sequence_of(t):
     def asn_member(t):
         if t["type"] == "OCTET STRING":
             t = dict(type="SEQUENCE OF", element=dict(type="U8"), size=t["size"])
+        if t["type"] == "BOOLEAN":
+            return "bool"
         if t["type"] == "SEQUENCE OF":
             r = asn_sequence_of(t)
         elif t["type"] in asn_types:
@@ -190,16 +192,22 @@ def asn_member(t):
     enum_trait = []
     for tname, t in asn_types.items():
         ty = types[tname]
+        if tname == "BOOLEAN":
+            ty.decl = c_using(tname, "bool")
+            continue
         if tname == "U8":
             ty.decl = c_using(tname, "uint8_t")
             continue
+        if tname == "U16":
+            ty.decl = c_using(tname, "uint16_t")
+            continue
         if tname == "U32":
             ty.decl = c_using(tname, "uint32_t")
             continue
         if t["type"] == "NULL":
             t = dict(type="SEQUENCE", members=[])
         if t["type"] == "CHOICE":
-            if tname == "MmrPeak":
+            if tname == "MmrPeak" or tname == "AvailabilityAssignmentItem": # TODO(#14): Need to make in universal
                 assert [x["name"] for x in t["members"]] == ["none", "some"]
                 ty.decl = c_using(
                     tname, "std::optional<%s>" % asn_member(t["members"][1])
@@ -348,6 +356,19 @@ def safrole():
     )
     g.write("safrole")
 
+def disputes():
+    g = Gen(
+        "jam::test_vectors_disputes",
+        ["validators-count", "core-count", "epoch-length", "validators-super-majority"],
+        asn_file("disputes/disputes"),
+        "DisputesModule",
+        [
+            (name, parse_const(asn_file("disputes/%s" % name), "Constants"))
+            for name in ["tiny", "full"]
+        ],
+    )
+    g.write("disputes")
+
 
 def history():
     g = Gen(
@@ -362,4 +383,4 @@ def history():
 
 if __name__ == "__main__":
     for arg in sys.argv[1:]:
-        dict(safrole=safrole, history=history)[arg]()
+        dict(safrole=safrole, history=history, disputes=disputes)[arg]()

src/TODO_qtils/bytes_std_hash.hpp

@@ -0,0 +1,18 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <qtils/bytes.hpp>
+#include <qtils/bytestr.hpp>
+
+namespace qtils {
+  struct BytesStdHash {
+    std::size_t operator()(qtils::BytesIn bytes) const {
+      return std::hash<std::string_view>{}(qtils::byte2str(bytes));
+    }
+  };
+}  // namespace qtils

src/TODO_qtils/cxx23/ranges/contains.hpp

@@ -0,0 +1,20 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+#include <algorithm>
+
+namespace qtils::cxx23::ranges {
+  auto contains(auto &&r, const auto &v) {
+    auto end = std::ranges::end(r);
+    return std::find(std::ranges::begin(r), end, v) != end;
+  }
+
+  auto contains_if(auto &&r, const auto &f) {
+    auto end = std::ranges::end(r);
+    return std::find_if(std::ranges::begin(r), end, f) != end;
+  }
+}  // namespace qtils::cxx23::ranges

src/jam/ed25519.hpp

@@ -0,0 +1,37 @@
+/**
+ * Copyright Quadrivium LLC
+ * All Rights Reserved
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <schnorrkel_crust.h>
+#include <qtils/bytes.hpp>
+
+namespace jam::ed25519 {
+  using Secret = qtils::BytesN<ED25519_SECRET_KEY_LENGTH>;
+  using Public = qtils::BytesN<ED25519_PUBLIC_KEY_LENGTH>;
+  using KeyPair = qtils::BytesN<ED25519_KEYPAIR_LENGTH>;
+  using Signature = qtils::BytesN<ED25519_SIGNATURE_LENGTH>;
+  using Message = qtils::BytesIn;
+
+  inline std::optional<Signature> sign(const KeyPair &keypair,
+                                       Message message) {
+    Signature sig;
+    auto res = ed25519_sign(
+        sig.data(), keypair.data(), message.data(), message.size_bytes());
+    if (res != ED25519_RESULT_OK) {
+      return std::nullopt;
+    }
+    return sig;
+  }
+
+  inline bool verify(const Signature &signature,
+                     Message message,
+                     const Public &public_key) {
+    auto res = ed25519_verify(signature.data(),
+                              public_key.data(),
+                              message.data(),
+                              message.size_bytes());
+    return res == ED25519_RESULT_OK;
+  }
+}  // namespace jam::ed25519

test-vectors/CMakeLists.txt

@@ -13,3 +13,4 @@ include(asn1.cmake)
 
 add_subdirectory(history)
 add_subdirectory(safrole)
+add_subdirectory(disputes)

test-vectors/common.hpp

@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <cstring>
 #include <stdexcept>
 
 #include <boost/endian/conversion.hpp>
@@ -37,8 +38,8 @@ namespace jam {
   // [GP 0.4.5 3.7.2]
   // https://github.com/gavofyork/graypaper/blob/v0.4.5/text/notation.tex#L132
   template <size_t X, size_t Y>
-  qtils::BytesN<X + Y> frown(
-      const qtils::BytesN<X> &x, const qtils::BytesN<Y> &y) {
+  qtils::BytesN<X + Y> frown(const qtils::BytesN<X> &x,
+                             const qtils::BytesN<Y> &y) {
     qtils::BytesN<X + Y> xy;
     memcpy(xy.data(), x.data(), X);
     memcpy(xy.data() + X, y.data(), Y);

test-vectors/disputes/.gitignore

@@ -0,0 +1,3 @@
+/types.hpp
+/types.scale.hpp
+/types.diff.hpp

test-vectors/disputes/CMakeLists.txt

@@ -0,0 +1,12 @@
+#
+# Copyright Quadrivium LLC
+# All Rights Reserved
+# SPDX-License-Identifier: Apache-2.0
+#
+
+asn1(disputes disputes tiny full)
+target_link_libraries(test_vectors_disputes_test
+    jam_crust::jam_crust
+    PkgConfig::libb2
+    schnorrkel_crust::schnorrkel_crust
+)