longfellow 0.1.0

data/vendor/longfellow-zk/lib/circuits/cbor_parser_v2/cbor_byte_decoder.h

@@ -0,0 +1,150 @@
+// 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_CIRCUITS_CBOR_PARSER_V2_CBOR_BYTE_DECODER_H_
+#define PRIVACY_PROOFS_ZK_LIB_CIRCUITS_CBOR_PARSER_V2_CBOR_BYTE_DECODER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "circuits/logic/counter.h"
+
+namespace proofs {
+template <class Logic>
+class CborByteDecoder2 {
+ public:
+  using CounterL = Counter<Logic>;
+  using Field = typename Logic::Field;
+  using EltW = typename Logic::EltW;
+  using CEltW = typename CounterL::CEltW;
+  using BitW = typename Logic::BitW;
+  using v8 = typename Logic::v8;
+
+  explicit CborByteDecoder2(const Logic& l) : l_(l), ctr_(l) {}
+
+  //------------------------------------------------------------
+  // Decoder (lexer)
+  //------------------------------------------------------------
+  struct decode {
+    BitW atomp;
+    BitW itemsp;
+    BitW stringp;
+    BitW arrayp;
+    BitW mapp;
+    BitW tagp;
+    BitW specialp;
+    BitW simple_specialp;  // One of false, true, null, or undefined.
+    BitW count0_23;
+    BitW count24_27;
+    BitW count24;
+    BitW count25;
+    BitW count26;
+    BitW count27;
+    BitW length_plus_next_v8;
+    BitW count_is_next_v8;
+    BitW invalid;
+    CEltW length;  // of this item
+    EltW as_scalar;
+    CEltW as_counter;
+    CEltW count_as_counter;
+    v8 as_bits;
+  };
+
+  // Extract whatever we can from one v8 alone, without looking
+  // at witnesses, assuming that
+  // this v8 is the start of a cbor token.
+  struct decode decode_one_v8(const v8& v) const {
+    const Logic& L = l_;  // shorthand
+    struct decode s;
+    L.vassert_is_bit(v);
+
+    // v = type:3 count:5
+    auto count = L.template slice<0, 5>(v);
+    auto type = L.template slice<5, 8>(v);
+
+    s.atomp = L.veqmask(type, /*mask*/ 0b110, /*val*/ 0b000);
+    s.stringp = L.veqmask(type, /*mask*/ 0b110, /*val*/ 0b010);
+    s.itemsp = L.veqmask(type, /*mask*/ 0b110, /*val*/ 0b100);
+
+    s.specialp = L.veq(type, 7);
+    s.tagp = L.veq(type, 6);
+    s.arrayp = L.land(s.itemsp, L.lnot(type[0]));
+    s.mapp = L.land(s.itemsp, type[0]);
+
+    // count0_23 = (0 <= count < 24) = ~(count == 11xxx)
+    s.count0_23 = L.lnot(L.veqmask(count, /*mask*/ 0b11000, /*val*/ 0b11000));
+    s.count24_27 = L.veqmask(count, /*mask*/ 0b11100, /*val*/ 0b11000);
+
+    s.count24 = L.veq(count, 24);
+    s.count25 = L.veq(count, 25);
+    s.count26 = L.veq(count, 26);
+    s.count27 = L.veq(count, 27);
+
+    BitW count20_23 = L.veqmask(count, /*mask*/ 0b11100, /*val*/ 0b10100);
+    s.simple_specialp = L.land(s.specialp, count20_23);
+
+    // stringp && count24
+    s.length_plus_next_v8 =
+        L.veqmask(v, /*mask*/ 0b110'11111, /*val*/ 0b010'11000);
+
+    // itemsp && count24
+    s.count_is_next_v8 =
+        L.veqmask(v, /*mask*/ 0b110'11111, /*val*/ 0b100'11000);
+
+    BitW count0_24 = L.lor_exclusive(s.count24, s.count0_23);
+    BitW atom_or_tag = L.lor_exclusive(s.atomp, s.tagp);
+
+    // count0_24 works for all types (except invalid special)
+    // but atom_or_tag supports count <= 27
+    BitW good_count = L.lor(count0_24, L.land(atom_or_tag, s.count24_27));
+    BitW invalid_special = L.land(s.specialp, L.lnot(s.simple_specialp));
+    s.invalid = L.lor(invalid_special, L.lnot(good_count));
+
+    s.count_as_counter = ctr_.as_counter(count);
+
+    // Hack to compute the length.  Unclear what the right
+    // abstraction should be.
+
+    // Compute l24_27, the length assuming count24_27
+    CEltW l1 = ctr_.as_counter(1 + 1);
+    CEltW l2 = ctr_.as_counter(1 + 2);
+    CEltW l4 = ctr_.as_counter(1 + 4);
+    CEltW l8 = ctr_.as_counter(1 + 8);
+    CEltW l24_25 = ctr_.mux(count[0], l2, l1);
+    CEltW l26_27 = ctr_.mux(count[0], l8, l4);
+    CEltW l24_27 = ctr_.mux(count[1], l26_27, l24_25);
+
+    // choose between count0_23 and count24_27
+    CEltW x1 = ctr_.as_counter(1);
+    s.length = ctr_.mux(s.count0_23, x1, l24_27);
+
+    // adjust for strings
+    BitW str_23 = L.land(s.stringp, s.count0_23);
+    CEltW adjust_if_string = ctr_.ite0(str_23, s.count_as_counter);
+    s.length = ctr_.add(s.length, adjust_if_string);
+
+    s.as_counter = ctr_.as_counter(v);
+    s.as_scalar = L.as_scalar(v);
+    s.as_bits = v;
+
+    return s;
+  }
+
+ private:
+  const Logic& l_;
+  const CounterL ctr_;
+};
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_CIRCUITS_CBOR_PARSER_V2_CBOR_BYTE_DECODER_H_

data/vendor/longfellow-zk/lib/circuits/cbor_parser_v2/cbor_byte_decoder_test.cc

@@ -0,0 +1,147 @@
+// 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 "circuits/cbor_parser_v2/cbor_byte_decoder.h"
+
+#include <stddef.h>
+
+#include "algebra/fp.h"
+#include "circuits/logic/counter.h"
+#include "circuits/logic/evaluation_backend.h"
+#include "circuits/logic/logic.h"
+#include "gf2k/gf2_128.h"
+#include "gtest/gtest.h"
+
+namespace proofs {
+namespace {
+
+template <class Field>
+void test_decode_one_v8(const Field& F) {
+  using EvalBackend = EvaluationBackend<Field>;
+  using Logic = Logic<Field, EvalBackend>;
+  using CounterL = Counter<Logic>;
+
+  const EvalBackend ebk(F);
+  const Logic L(&ebk, F);
+  const CounterL CTR(L);
+
+  using CborBD = CborByteDecoder2<Logic>;
+  const CborBD CBORBD(L);
+  for (size_t type = 0; type < 8; ++type) {
+    for (size_t count = 0; count < 32; ++count) {
+      size_t v_as_size_t = (type << 5) | count;
+      typename Logic::v8 v = L.template vbit<8>(v_as_size_t);
+      auto ds = CBORBD.decode_one_v8(v);
+
+      bool atomp = (type == 0) || (type == 1);
+      bool stringp = (type == 2) || (type == 3);
+      bool arrayp = (type == 4);
+      bool mapp = (type == 5);
+      bool itemsp = arrayp || mapp;
+      bool tagp = (type == 6);
+      bool specialp = (type == 7);
+      bool simple_specialp = specialp && (20 <= count && count < 24);
+      bool count0_23 = (count < 24);
+      bool count24_27 = (24 <= count) && (count < 28);
+      bool count24 = (count == 24);
+      bool count25 = (count == 25);
+      bool count26 = (count == 26);
+      bool count27 = (count == 27);
+
+      bool length_plus_next_v8 = false;
+      bool count_is_next_v8 = false;
+      bool invalid = false;
+      size_t length = ~0;  // bogus
+      size_t count_as_counter = count;
+      if (atomp || tagp) {
+        if (count0_23) {
+          length = 1;
+        } else if (count24) {
+          length = 1 + 1;
+        } else if (count25) {
+          length = 1 + 2;
+        } else if (count26) {
+          length = 1 + 4;
+        } else if (count27) {
+          length = 1 + 8;
+        } else {
+          invalid = true;
+        }
+      } else if (itemsp) {
+        if (count0_23) {
+          length = 1;
+        } else if (count24) {
+          length = 2;
+          count_is_next_v8 = true;
+        } else {
+          invalid = true;
+        }
+      } else if (stringp) {
+        if (count0_23) {
+          length = 1 + count;
+        } else if (count24) {
+          length = 2;
+          length_plus_next_v8 = true;
+        } else {
+          invalid = true;
+        }
+      } else if (simple_specialp) {
+        length = 1;
+      } else {
+        invalid = true;
+      }
+
+      EXPECT_EQ(L.eval(ds.atomp), L.eval(L.bit(atomp)));
+      EXPECT_EQ(L.eval(ds.itemsp), L.eval(L.bit(itemsp)));
+      EXPECT_EQ(L.eval(ds.stringp), L.eval(L.bit(stringp)));
+      EXPECT_EQ(L.eval(ds.arrayp), L.eval(L.bit(arrayp)));
+      EXPECT_EQ(L.eval(ds.mapp), L.eval(L.bit(mapp)));
+      EXPECT_EQ(L.eval(ds.tagp), L.eval(L.bit(tagp)));
+      EXPECT_EQ(L.eval(ds.specialp), L.eval(L.bit(specialp)));
+      EXPECT_EQ(L.eval(ds.simple_specialp), L.eval(L.bit(simple_specialp)));
+
+      EXPECT_EQ(L.eval(ds.count0_23), L.eval(L.bit(count0_23)));
+      EXPECT_EQ(L.eval(ds.count24_27), L.eval(L.bit(count24_27)));
+      EXPECT_EQ(L.eval(ds.count24), L.eval(L.bit(count24)));
+      EXPECT_EQ(L.eval(ds.count25), L.eval(L.bit(count25)));
+      EXPECT_EQ(L.eval(ds.count26), L.eval(L.bit(count26)));
+      EXPECT_EQ(L.eval(ds.count27), L.eval(L.bit(count27)));
+      EXPECT_EQ(L.eval(ds.length_plus_next_v8),
+                L.eval(L.bit(length_plus_next_v8)));
+      EXPECT_EQ(L.eval(ds.count_is_next_v8), L.eval(L.bit(count_is_next_v8)));
+      EXPECT_EQ(L.eval(ds.invalid), L.eval(L.bit(invalid)));
+
+      if (!invalid) {
+        // the length is don't care unless valid
+        EXPECT_EQ(ds.length.e, CTR.as_counter(length).e);
+      }
+
+      EXPECT_EQ(ds.count_as_counter.e, CTR.as_counter(count_as_counter).e);
+      EXPECT_EQ(ds.as_counter.e, CTR.as_counter(v_as_size_t).e);
+      EXPECT_EQ(ds.as_scalar, L.konst(v_as_size_t));
+      for (size_t k = 0; k < 8; ++k) {
+        EXPECT_EQ(L.eval(ds.as_bits[k]), L.eval(L.bit((v_as_size_t >> k) & 1)));
+      }
+    }
+  }
+}
+
+TEST(CborByteDecoder, PrimeField) {
+  test_decode_one_v8(Fp<1>("18446744073709551557"));
+}
+
+TEST(CborByteDecoder, BinaryField) { test_decode_one_v8(GF2_128<>()); }
+
+}  // namespace
+}  // namespace proofs

data/vendor/longfellow-zk/lib/circuits/cbor_parser_v2/cbor_constants.h

@@ -0,0 +1,27 @@
+// 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_CIRCUITS_CBOR_PARSER_V2_CBOR_CONSTANTS_H_
+#define PRIVACY_PROOFS_ZK_LIB_CIRCUITS_CBOR_PARSER_V2_CBOR_CONSTANTS_H_
+
+#include <stddef.h>
+
+namespace proofs {
+struct CborConstants {
+  static constexpr size_t kNCounters = 4;
+  static constexpr size_t kIndexBits = 12;
+};
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_CIRCUITS_CBOR_PARSER_V2_CBOR_CONSTANTS_H_

data/vendor/longfellow-zk/lib/circuits/cbor_parser_v2/cbor_testing.h

@@ -0,0 +1,99 @@
+// 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_CIRCUITS_CBOR_PARSER_V2_CBOR_TESTING_H_
+#define PRIVACY_PROOFS_ZK_LIB_CIRCUITS_CBOR_PARSER_V2_CBOR_TESTING_H_
+
+#include <stddef.h>
+
+#include "circuits/cbor_parser_v2/cbor.h"
+#include "circuits/cbor_parser_v2/cbor_constants.h"
+#include "circuits/cbor_parser_v2/cbor_witness.h"
+#include "circuits/logic/counter.h"
+#include "circuits/logic/evaluation_backend.h"
+#include "circuits/logic/logic.h"
+
+// The purpose of this class is to convert the witnesses from Elt to
+// EltW.
+//
+// Why?
+//
+// We want EltW in the evaluation backend to be a distinct type from
+// Elt.  They are really the same thing, but we want to be able to
+// instantiate circuits in the compiler backend as well, and thus
+// circuits ought not to rely on the fact that EvaluationBackend::EltW
+// is really an Elt in disguise.
+// Consequently, tests in the evaluation backend must accept EltW.
+//
+// The witness generator must produce Elt, otherwise this forces the
+// inclusion of Logic in the app.  We don't like that because Logic
+// is just a set of helpers to generate circuits, and the final app
+// is not supposed to generate circuits (since circuits are part of the
+// prover<->verifier API and so they must be set in stone in advance.)
+//
+// So this class is the price to be paid to maintain this typing
+// hygiene.  Time will tell whether it was worth it.
+
+namespace proofs {
+
+template <class Field>
+class CborTesting {
+  using EvalBackend = EvaluationBackend<Field>;
+  using LogicF = Logic<Field, EvalBackend>;
+  using EltW = typename LogicF::EltW;
+  using BitW = typename LogicF::BitW;
+  using CborL = Cbor<LogicF>;
+  using CborWitnessF = CborWitness<Field>;
+
+ public:
+  explicit CborTesting(const Field& F) : f_(F) {}
+
+  void convert_witnesses(
+      size_t n, typename CborL::v8 in[/*n*/],
+      typename CborL::position_witness pw[/*n*/],
+      const typename CborWitnessF::v8 inS[/*n*/],
+      const typename CborWitnessF::position_witness pwS[/*n*/]) const {
+    const EvalBackend ebk(f_);
+    const LogicF L(&ebk, f_);
+    const Counter<LogicF> CTR(L);
+
+    for (size_t i = 0; i < n; ++i) {
+      for (size_t j = 0; j < 8; ++j) {
+        in[i][j] = BitW(L.konst(inS[i][j]), f_);
+      }
+      pw[i].encoded_header = L.konst(pwS[i].encoded_header);
+      pw[i].encoded_sel = L.konst(pwS[i].encoded_sel);
+      pw[i].slen_next = CTR.as_counter(pwS[i].slen_next);
+      for (size_t j = 0; j < CborWitnessF::kNCounters; ++j) {
+        pw[i].cc_next[j] = CTR.as_counter(pwS[i].cc_next[j]);
+      }
+      pw[i].invprod_decode = L.konst(pwS[i].invprod_decode);
+      pw[i].invprod_parse = L.konst(pwS[i].invprod_parse);
+    }
+  }
+
+  // Return an index that can be fed to a circuit in the
+  // evaluation backend (i.e., a bit vector).
+  typename CborL::vindex index(size_t j) const {
+    const EvalBackend ebk(f_);
+    const LogicF L(&ebk, f_);
+    return L.template vbit<CborConstants::kIndexBits>(j);
+  }
+
+ private:
+  const Field& f_;
+};
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_CIRCUITS_CBOR_PARSER_V2_CBOR_TESTING_H_