longfellow 0.1.0

data/vendor/longfellow-zk/lib/util/ceildiv_test.cc

@@ -0,0 +1,152 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "util/ceildiv.h"
+
+#include <cstddef>
+#include <cstdint>
+
+#include "gtest/gtest.h"
+
+namespace proofs {
+namespace morton {
+namespace {
+
+static uint64_t bit(uint64_t x) { return x & 1u; }
+static uint64_t naive_even(uint64_t x) {
+  uint64_t r = 0;
+  for (size_t i = 0; i < 32; ++i) {
+    r |= bit(x >> (2 * i)) << i;
+  }
+  return r;
+}
+
+static uint64_t naive_uneven(uint64_t x) {
+  uint64_t r = 0;
+  for (size_t i = 0; i < 32; ++i) {
+    r |= bit(x >> i) << (2 * i);
+  }
+  return r;
+}
+
+TEST(Morton, Even) {
+  // small integers
+  for (uint64_t x = 0; x < 8192; ++x) {
+    EXPECT_EQ(naive_even(x), morton::even(x));
+  }
+
+  // powers of two and neighbors
+  for (uint64_t x = 1; x != 0; x *= 2) {
+    EXPECT_EQ(naive_even(x - 1), morton::even(x - 1));
+    EXPECT_EQ(naive_even(x), morton::even(x));
+    EXPECT_EQ(naive_even(x + 1), morton::even(x + 1));
+  }
+
+  // semi-random
+  for (uint64_t x = 0; x < 8192; ++x) {
+    uint64_t y = x * 0xdeadbeefabadcafeull;
+    EXPECT_EQ(naive_even(y - 1), morton::even(y - 1));
+    EXPECT_EQ(naive_even(y), morton::even(y));
+    EXPECT_EQ(naive_even(y + 1), morton::even(y + 1));
+  }
+}
+
+TEST(Morton, Uneven) {
+  // small integers
+  for (uint64_t x = 0; x < 8192; ++x) {
+    EXPECT_EQ(naive_uneven(x), morton::uneven(x));
+  }
+
+  // powers of two and neighbors
+  for (uint64_t x = 1; x != 0; x *= 2) {
+    EXPECT_EQ(naive_uneven(x - 1), morton::uneven(x - 1));
+    EXPECT_EQ(naive_uneven(x), morton::uneven(x));
+    EXPECT_EQ(naive_uneven(x + 1), morton::uneven(x + 1));
+  }
+
+  // semi-random
+  for (uint64_t x = 0; x < 8192; ++x) {
+    uint64_t y = x * 0xdeadbeefabadcafeull;
+    EXPECT_EQ(naive_uneven(y - 1), morton::uneven(y - 1));
+    EXPECT_EQ(naive_uneven(y), morton::uneven(y));
+    EXPECT_EQ(naive_uneven(y + 1), morton::uneven(y + 1));
+  }
+}
+
+static void one_add_test(uint64_t x, uint64_t y) {
+  uint32_t x0 = morton::even(x), x1 = morton::even(x >> 1);
+  uint32_t y0 = morton::even(y), y1 = morton::even(y >> 1);
+  morton::add<uint32_t>(&x0, &x1, y0, y1);
+  uint64_t r = morton::uneven(x0) | (morton::uneven(x1) << 1);
+  EXPECT_EQ(r, x + y);
+}
+
+static void one_sub_test(uint64_t x, uint64_t y) {
+  uint32_t x0 = morton::even(x), x1 = morton::even(x >> 1);
+  uint32_t y0 = morton::even(y), y1 = morton::even(y >> 1);
+  morton::sub<uint32_t>(&x0, &x1, y0, y1);
+  uint64_t r = morton::uneven(x0) | (morton::uneven(x1) << 1);
+  EXPECT_EQ(r, x - y);
+}
+
+static void one_lt_test(uint64_t x, uint64_t y) {
+  uint32_t x0 = morton::even(x), x1 = morton::even(x >> 1);
+  uint32_t y0 = morton::even(y), y1 = morton::even(y >> 1);
+  bool lt = morton::lt<uint32_t>(x0, x1, y0, y1);
+  // Define x < y as the sign bit of the subtraction.
+  // We could cast to int64_t but signed overflow is
+  // undefined behavior.
+  EXPECT_EQ(lt, (((x - y) >> 63) == 1));
+}
+
+static void one_eq_test(uint64_t x, uint64_t y) {
+  uint32_t x0 = morton::even(x), x1 = morton::even(x >> 1);
+  uint32_t y0 = morton::even(y), y1 = morton::even(y >> 1);
+  bool eq = morton::eq<uint32_t>(x0, x1, y0, y1);
+  // Define x < y as the sign bit of the subtraction.
+  // We could cast to int64_t but signed overflow is
+  // undefined behavior.
+  EXPECT_EQ(eq, x == y);
+}
+
+static void one_test(uint64_t x, uint64_t y) {
+  one_add_test(x, y);
+  one_sub_test(x, y);
+  one_lt_test(x, y);
+  one_eq_test(x, y);
+}
+
+TEST(Morton, AddSub) {
+  // small integers
+  for (size_t x = 0; x < 256; ++x) {
+    for (size_t y = 0; y < 256; ++y) {
+      one_test(x, y);
+    }
+  }
+
+  // powers of two plus delta
+  for (size_t x = 1; x; x *= 2) {
+    for (size_t y = 1; y; y *= 2) {
+      for (int dx = -16; dx < 16; ++dx) {
+        for (int dy = -16; dy < 16; ++dy) {
+          one_test(x + dx, y + dx);
+        }
+      }
+    }
+  }
+}
+
+}  // namespace
+}  // namespace morton
+}  // namespace proofs

data/vendor/longfellow-zk/lib/util/crc64.h

@@ -0,0 +1,45 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef PRIVACY_PROOFS_ZK_LIB_UTIL_CRC64_H_
+#define PRIVACY_PROOFS_ZK_LIB_UTIL_CRC64_H_
+
+/*
+This package defines 3 basic methods for computing a simple 64-bit CRC.
+It is used for checksum and comparison of datastructures that are internal
+to this library.
+*/
+
+#include <stdlib.h>
+
+#include <cstdint>
+
+namespace proofs {
+namespace crc64 {
+static inline uint64_t shlu64(uint64_t x, size_t n) {
+  return (n >= 64) ? 0u : (x << n);
+}
+static inline uint64_t shru64(uint64_t x, size_t n) {
+  return (n >= 64) ? 0u : (x >> n);
+}
+static inline uint64_t update(uint64_t crc, uint64_t u, size_t n = 64) {
+  crc ^= u;
+  uint64_t l = shlu64(crc, 127u - n) ^ shlu64(crc, 125u - n) ^
+               shlu64(crc, 124u - n) ^ shlu64(crc, 64u - n);
+  return shru64(crc, n) ^ l ^ (l >> 1) ^ (l >> 3) ^ (l >> 4);
+}
+}  // namespace crc64
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_UTIL_CRC64_H_

data/vendor/longfellow-zk/lib/util/crypto.cc

@@ -0,0 +1,39 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "util/crypto.h"
+
+#include <cstddef>
+#include <cstdint>
+
+#include "util/panic.h"
+#include "openssl/rand.h"
+
+namespace proofs {
+
+void rand_bytes(uint8_t out[/*n*/], size_t n) {
+  int ret = RAND_bytes(out, n);
+  check(ret == 1, "openssl RAND_bytes failed");
+}
+
+void hex_to_str(char out[/* 2*n + 1*/], const uint8_t in[/*n*/], size_t n) {
+  for (size_t i = 0; i < n; ++i) {
+    out[2 * i] = "0123456789abcdef"[in[i] >> 4];
+    out[2 * i + 1] = "0123456789abcdef"[in[i] & 0xf];
+  }
+  out[2 * n] = '\0';
+}
+
+
+}  // namespace proofs

data/vendor/longfellow-zk/lib/util/crypto.h

@@ -0,0 +1,108 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef PRIVACY_PROOFS_ZK_LIB_UTIL_CRYPTO_H_
+#define PRIVACY_PROOFS_ZK_LIB_UTIL_CRYPTO_H_
+
+// Encapsulates all of the cryptographic primitives used by this library.
+// Specifically, for the collision-resistant hash function, this library uses
+// SHA256. For a pseudo-random function, this library uses AES in ECB mode.
+// Finally, this library provides a method to generate random bytes using the
+// openssl library.
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include "util/panic.h"
+#include "openssl/sha.h"
+#include "openssl/evp.h"
+#include "openssl/aes.h"
+
+namespace proofs {
+
+constexpr size_t kSHA256DigestSize = 32;
+constexpr size_t kPRFKeySize = 32;
+constexpr size_t kPRFInputSize = 16;
+constexpr size_t kPRFOutputSize = 16;
+
+class SHA256 {
+ public:
+  SHA256() { SHA256_Init(&sha_); }
+
+  // Disable copy for good measure.
+  SHA256(const SHA256&) = delete;
+  SHA256& operator=(const SHA256&) = delete;
+
+  void Update(const uint8_t bytes[/*n*/], size_t n) { SHA256_Update(&sha_, bytes, n); }
+  void DigestData(uint8_t digest[/* kSHA256DigestSize */]) {
+    SHA256_Final(digest, &sha_);
+  }
+  void CopyState(const SHA256& src) { sha_ = src.sha_; }
+
+  void Update8(uint64_t x) {
+    uint8_t buf[8];
+    for (size_t i = 0; i < 8; ++i) {
+      buf[i] = x & 0xff;
+      x >>= 8;
+    }
+    Update(buf, 8);
+  }
+
+ private:
+  SHA256_CTX sha_;
+};
+
+// A pseudo-random function interface. This implementation uses AES in ECB mode.
+// The caller must ensure that arguments are not reused.
+class PRF {
+ public:
+  explicit PRF(const uint8_t key[/*kPRFKeySize*/]) {
+    ctx_ = EVP_CIPHER_CTX_new();
+    int ret =
+        EVP_EncryptInit_ex(ctx_, EVP_aes_256_ecb(), nullptr, key, nullptr);
+    check(ret == 1, "EVP_EncryptInit_ex failed");
+  }
+
+  ~PRF() { EVP_CIPHER_CTX_free(ctx_); }
+
+  // Disable copy for good measure.
+  PRF(const PRF&) = delete;
+  PRF& operator=(const PRF&) = delete;
+
+  // Evaluate the PRF on the input and write the output to the output buffer.
+  // This method should only be used internally by the Transcript class. The
+  // caller must ensure that the input and output buffers are different.
+  // This function implements a permutation, but we only need to exploit its
+  // pseudo-random function property in this application.
+  void Eval(uint8_t out[/*kPRFOutputSize*/], uint8_t in[/*kPRFInputSize*/]) {
+    int out_len = static_cast<int>(kPRFOutputSize);
+    int ret = EVP_EncryptUpdate(ctx_, out, &out_len, in,
+                                static_cast<int>(kPRFInputSize));
+    check(ret == 1, "EVP_EncryptUpdate failed");
+  }
+
+ private:
+  EVP_CIPHER_CTX* ctx_;
+};
+
+// Generate n random bytes, following the openssl API convention.
+// This method will panic if the openssl library fails.
+void rand_bytes(uint8_t out[/*n*/], size_t n);
+
+void hex_to_str(char out[/* 2*n + 1*/], const uint8_t in[/*n*/], size_t n);
+
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_UTIL_CRYPTO_H_

data/vendor/longfellow-zk/lib/util/log.cc

@@ -0,0 +1,110 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "util/log.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+// The logic of these #ifdefs implements the following:
+//   1. If we are building for Android, use the android logging library.
+//   2. If we are building for google3, use the absl logging library.
+//   3. Otherwise, use the std::chrono and fprintf(stderr) for logging.
+
+#if defined(__ANDROID__)
+#include <android/log.h>
+#endif
+
+#if defined(__ABSL__)
+#include "third_party/absl/log/log.h"
+#else
+// The point of using std::chrono is to avoid the dependency on absl::time.
+#include <chrono>
+#endif
+
+namespace proofs {
+
+// This implementation maintains its own error thresholds in order to
+// support future migration away from absl or android logging libraries.
+static enum LogLevel _LOG_LEVEL = INFO;
+
+#if !defined(__ABSL__)
+static auto _last = std::chrono::steady_clock::now();
+const char* level_str(enum LogLevel l) {
+  switch (l) {
+    case ERROR:
+      return "ERROR";
+    case WARNING:
+      return "WARNING";
+    case INFO:
+      return "INFO";
+    default:
+      return "[Unknown]";
+  }
+}
+#endif
+
+void set_log_level(enum LogLevel l) { _LOG_LEVEL = l; }
+
+void log(enum LogLevel l, const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  char tmp[1024];
+  vsnprintf(tmp, sizeof(tmp), format, args);
+  va_end(args);
+
+#if defined(__ANDROID__)
+  if (l <= _LOG_LEVEL) {
+    switch (l) {
+      case ERROR:
+        __android_log_print(ANDROID_LOG_ERROR, "proofs", "%s", tmp);
+        break;
+      case WARNING:
+        __android_log_print(ANDROID_LOG_WARN, "proofs", "%s", tmp);
+        break;
+      case INFO:
+        __android_log_print(ANDROID_LOG_INFO, "proofs", "%s", tmp);
+        break;
+    }
+  }
+#elif defined(__ABSL__)
+  if (l <= _LOG_LEVEL) {
+    switch (l) {
+      case LogLevel::ERROR:
+        LOG(ERROR) << tmp;
+        break;
+      case LogLevel::WARNING:
+        LOG(WARNING) << tmp;
+        break;
+      case LogLevel::INFO:
+        LOG(INFO) << tmp;
+        break;
+    }
+  }
+#else
+  using microseconds = std::chrono::microseconds;
+  using milliseconds = std::chrono::milliseconds;
+  if (l <= _LOG_LEVEL) {
+    auto nt = std::chrono::steady_clock::now();
+    auto mus = std::chrono::duration_cast<microseconds>(nt - _last).count();
+    auto ms = std::chrono::duration_cast<milliseconds>(nt - _last).count();
+    mus -= ms * 1000;
+    _last = nt;
+    fprintf(stderr, "[%s][+%5llu.%.3llu ms] %s\n", level_str(_LOG_LEVEL),
+            static_cast<long long>(ms), static_cast<long long>(mus), tmp);
+  }
+#endif
+}
+
+}  // namespace proofs

data/vendor/longfellow-zk/lib/util/log.h

@@ -0,0 +1,33 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef PRIVACY_PROOFS_ZK_LIB_UTIL_LOG_H_
+#define PRIVACY_PROOFS_ZK_LIB_UTIL_LOG_H_
+
+// Simple, self-contained logger for this library.
+
+namespace proofs {
+
+enum LogLevel {
+  ERROR = 1,
+  WARNING = 10,
+  INFO = 100,
+};
+
+void set_log_level(enum LogLevel l);
+
+void log(enum LogLevel l, const char* format, ...);
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_UTIL_LOG_H_

data/vendor/longfellow-zk/lib/util/panic.h

@@ -0,0 +1,40 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef PRIVACY_PROOFS_ZK_LIB_UTIL_PANIC_H_
+#define PRIVACY_PROOFS_ZK_LIB_UTIL_PANIC_H_
+
+#if defined(__ABSL__)
+#include "third_party/absl/log/check.h"
+#else
+#include <cstdio>
+#include <cstdlib>
+#endif
+
+namespace proofs {
+
+inline void check(bool truth, const char* why) {
+#if defined(__ABSL__)
+  CHECK(truth) << why;
+#else
+  if (!truth) {
+    fprintf(stderr, "%s", why);
+    abort();
+  }
+#endif
+}
+
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_UTIL_PANIC_H_

data/vendor/longfellow-zk/lib/util/readbuffer.h

@@ -0,0 +1,67 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef PRIVACY_PROOFS_ZK_LIB_UTIL_READBUFFER_H_
+#define PRIVACY_PROOFS_ZK_LIB_UTIL_READBUFFER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include "util/panic.h"
+
+namespace proofs {
+
+class ReadBuffer {
+ public:
+  explicit ReadBuffer(const uint8_t *buf, size_t sz)
+      : buf_(buf), size_(sz), next_(0) {}
+
+  explicit ReadBuffer(const std::vector<uint8_t> &v)
+      : ReadBuffer(v.data(), v.size()) {}
+
+  // no copies
+  ReadBuffer(const ReadBuffer &) = delete;
+
+  // TRUE if at least N bytes remain
+  bool have(size_t n) const { return remaining() >= n; }
+
+  size_t remaining() const {
+    check(next_ <= size_, "next_ <= size_");
+    return size_ - next_;
+  }
+
+  const uint8_t *next(size_t n) {
+    check(have(n), "have(n)");
+    const uint8_t *p = &buf_[next_];
+    next_ += n;
+    return p;
+  }
+
+  void next(size_t n, uint8_t dest[/*n*/]) {
+    const uint8_t *p = next(n);
+    for (size_t i = 0; i < n; ++i) {
+      dest[i] = p[i];
+    }
+  }
+
+ private:
+  const uint8_t *buf_;
+  size_t size_;
+  size_t next_;
+};
+
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_UTIL_READBUFFER_H_

data/vendor/longfellow-zk/lib/util/serialization.h

@@ -0,0 +1,54 @@
+// Copyright 2026 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef PRIVACY_PROOFS_ZK_LIB_UTIL_SERIALIZATION_H_
+#define PRIVACY_PROOFS_ZK_LIB_UTIL_SERIALIZATION_H_
+
+#include <cstdint>
+
+namespace proofs {
+
+static inline void u64_to_le(uint8_t a[/*8*/], uint64_t x) {
+  a[0] = x & 0xffu;
+  a[1] = (x >> 8) & 0xffu;
+  a[2] = (x >> 16) & 0xffu;
+  a[3] = (x >> 24) & 0xffu;
+  a[4] = (x >> 32) & 0xffu;
+  a[5] = (x >> 40) & 0xffu;
+  a[6] = (x >> 48) & 0xffu;
+  a[7] = (x >> 56) & 0xffu;
+}
+
+static inline uint64_t u64_of_le(const uint8_t a[/*8*/]) {
+  return ((uint64_t)a[7] << 56) | ((uint64_t)a[6] << 48) |
+         ((uint64_t)a[5] << 40) | ((uint64_t)a[4] << 32) |
+         ((uint64_t)a[3] << 24) | ((uint64_t)a[2] << 16) |
+         ((uint64_t)a[1] << 8) | (uint64_t)a[0];
+}
+
+static inline void u32_to_le(uint8_t a[/*4*/], uint32_t x) {
+  a[0] = x & 0xffu;
+  a[1] = (x >> 8) & 0xffu;
+  a[2] = (x >> 16) & 0xffu;
+  a[3] = (x >> 24) & 0xffu;
+}
+
+static inline uint32_t u32_of_le(const uint8_t a[/*4*/]) {
+  return ((uint32_t)a[3] << 24) | ((uint32_t)a[2] << 16) |
+         ((uint32_t)a[1] << 8) | (uint32_t)a[0];
+}
+
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_UTIL_SERIALIZATION_H_