longfellow 0.1.0

data/vendor/longfellow-zk/lib/circuits/tests/anoncred/ptrcred.h

@@ -0,0 +1,171 @@
+// 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_TESTS_ANONCRED_PTRCRED_H_
+#define PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_ANONCRED_PTRCRED_H_
+#include <cstddef>
+#include <vector>
+
+#include "circuits/ecdsa/verify_circuit.h"
+#include "circuits/logic/bit_plucker.h"
+#include "circuits/logic/memcmp.h"
+#include "circuits/logic/routing.h"
+#include "circuits/sha/flatsha256_circuit.h"
+#include "circuits/tests/anoncred/small_io.h"
+
+namespace proofs {
+
+// This class creates a circuit to verify the signatures in a "ptrcred".
+// A ptr credential is a document formatted as:
+//      n // 8 bits specifying the number of attributes
+//      ind <table of n pointer, each of 10 bits>
+//          each pointer references from the beginning of the document
+//      A byte string containing keys and values.
+//          A key consists of 3 bytes.
+//          A value can be arbitrarily long.
+template <class LogicCircuit, class Field, class EC, size_t kNumAttr>
+class PtrCred {
+  using EltW = typename LogicCircuit::EltW;
+  using Elt = typename LogicCircuit::Elt;
+  using Nat = typename Field::N;
+  using Ecdsa = VerifyCircuit<LogicCircuit, Field, EC>;
+  using EcdsaWitness = typename Ecdsa::Witness;
+
+  using v8 = typename LogicCircuit::v8;
+  using v32 = typename LogicCircuit::v32;
+  static constexpr size_t kIndexBits = 5;
+  static constexpr size_t kMaxSHABlocks = 3;
+  static constexpr size_t kMaxMsoLen = kMaxSHABlocks * 64 - 9;
+
+  using vind = typename LogicCircuit::template bitvec<kIndexBits>;
+  using Flatsha = FlatSHA256Circuit<LogicCircuit, BitPlucker<LogicCircuit, 3>>;
+  using RoutingL = Routing<LogicCircuit>;
+  using ShaBlockWitness = typename Flatsha::BlockWitness;
+
+  const LogicCircuit& lc_;
+  const EC& ec_;
+  const Nat& order_;
+
+ public:
+  class Witness {
+   public:
+    EltW e_;
+    EltW dpkx_, dpky_;
+
+    EcdsaWitness sig_;
+    EcdsaWitness dpk_sig_;
+
+    v8 in_[64 * kMaxSHABlocks]; /* input bytes, 64 * MAX */
+    v8 nb_; /* index of sha block that contains the real hash  */
+    ShaBlockWitness sig_sha_[kMaxSHABlocks];
+
+    void input(const LogicCircuit& lc) {
+      e_ = lc.eltw_input();
+      dpkx_ = lc.eltw_input();
+      dpky_ = lc.eltw_input();
+
+      sig_.input(lc);
+      dpk_sig_.input(lc);
+
+      nb_ = lc.template vinput<8>();
+
+      // sha input init =========================
+      for (size_t i = 0; i < 64 * kMaxSHABlocks; ++i) {
+        in_[i] = lc.template vinput<8>();
+      }
+      for (size_t j = 0; j < kMaxSHABlocks; j++) {
+        sig_sha_[j].input(lc);
+      }
+    }
+  };
+
+  struct OpenedAttribute {
+    v8 ind;    /* index of attribute */
+    v8 len;    /* length of attribute, 1--32 */
+    v8 v1[32]; /* attribute value */
+    void input(const LogicCircuit& lc) {
+      ind = lc.template vinput<8>();
+      len = lc.template vinput<8>();
+      for (size_t j = 0; j < 32; ++j) {
+        v1[j] = lc.template vinput<8>();
+      }
+    }
+  };
+
+  EltW repack(const v8 in[], size_t ind) const {
+    EltW h = lc_.konst(0);
+    EltW base = lc_.konst(0x2);
+    for (size_t i = 0; i < 32; ++i) {
+      for (size_t j = 0; j < 8; ++j) {
+        auto t = lc_.mul(h, base);
+        auto tin = lc_.eval(in[ind + i][7 - j]);
+        h = lc_.add(tin, t);
+      }
+    }
+    return h;
+  }
+
+  explicit PtrCred(const LogicCircuit& lc, const EC& ec, const Nat& order)
+      : lc_(lc), ec_(ec), order_(order), sha_(lc), r_(lc) {}
+
+  void assert_credential(EltW pkX, EltW pkY, EltW hash_tr,
+                         OpenedAttribute oa[/* NUM_ATTR */],
+                         const v8 now[/*kDateLen*/], const Witness& vw) const {
+    Ecdsa ecc(lc_, ec_, order_);
+
+    ecc.verify_signature3(pkX, pkY, vw.e_, vw.sig_);
+    ecc.verify_signature3(vw.dpkx_, vw.dpky_, hash_tr, vw.dpk_sig_);
+    sha_.assert_message(kMaxSHABlocks, vw.nb_, vw.in_, vw.sig_sha_);
+
+    const Memcmp<LogicCircuit> CMP(lc_);
+    // validFrom <= now
+    lc_.assert1(CMP.leq(kDateLen, &vw.in_[84], &now[0]));
+
+    // now <= validUntil
+    lc_.assert1(CMP.leq(kDateLen, &now[0], &vw.in_[92]));
+
+    // DPK_{x,y}
+    EltW dpkx = repack(vw.in_, 100);
+    EltW dpky = repack(vw.in_, 132);
+    lc_.assert_eq(dpkx, vw.dpkx_);
+    lc_.assert_eq(dpky, vw.dpky_);
+
+    // Attributes parsing
+    const v8 zz = lc_.template vbit<8>(0xff);  // cannot appear in strings
+    std::vector<v8> cmp_buf(32);
+    for (size_t ai = 0; ai < kNumAttr; ++ai) {
+      r_.shift(oa[ai].ind, 32, &cmp_buf[0], kMaxMsoLen, vw.in_, zz, 3);
+      assert_attribute(32, oa[ai].len, &cmp_buf[0], &oa[ai].v1[0]);
+    }
+  }
+
+ private:
+  // Checks that an attribute id or attribute value is as expected.
+  // The len parameter holds the byte length of the expected id or value.
+  void assert_attribute(size_t max, const v8& vlen, const v8 got[/*max*/],
+                        const v8 want[/*max*/]) const {
+    for (size_t j = 0; j < max; ++j) {
+      auto ll = lc_.vlt(j, vlen);
+      auto cmp = lc_.veq(got[j], want[j]);
+      lc_.assert_implies(ll, cmp);
+    }
+  }
+
+  Flatsha sha_;
+  RoutingL r_;
+};
+
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_ANONCRED_PTRCRED_H_

data/vendor/longfellow-zk/lib/circuits/tests/anoncred/small.h

@@ -0,0 +1,218 @@
+// 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_TESTS_ANONCRED_SMALL_H_
+#define PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_ANONCRED_SMALL_H_
+
+#include <cstddef>
+#include <vector>
+
+#include "circuits/ecdsa/verify_circuit.h"
+#include "circuits/logic/bit_plucker.h"
+#include "circuits/logic/memcmp.h"
+#include "circuits/logic/routing.h"
+#include "circuits/sha/flatsha256_circuit.h"
+#include "circuits/tests/anoncred/small_io.h"
+
+namespace proofs {
+
+// This class creates a circuit to verify the signatures in a "small" MDOC.
+// A small credential is a 183-byte document formatted as:
+//      first_name    32 0
+//      family_name   32 32
+//      date_of_birth YYYYMMDD 64
+//      gender        B 72
+//      age_over_X.   BBBBBBB 73    [16, 18, 21, 25, 62, 65, 67]
+//      issuerid   BBBB 80
+//      validfrom  YYYYMMDD 84
+//      validuntil YYYYMMDD 92
+//      DPKX  32x 100
+//      DPKY  32x 132
+//      <arbitrary bytes of information>
+template <class LogicCircuit, class Field, class EC, size_t kNumAttr>
+class Small {
+  using EltW = typename LogicCircuit::EltW;
+  using Elt = typename LogicCircuit::Elt;
+  using Nat = typename Field::N;
+  using Ecdsa = VerifyCircuit<LogicCircuit, Field, EC>;
+  using EcdsaWitness = typename Ecdsa::Witness;
+
+  using v8 = typename LogicCircuit::v8;
+  using v32 = typename LogicCircuit::v32;
+  static constexpr size_t kIndexBits = 5;
+  static constexpr size_t kMaxSHABlocks = 7;
+  static constexpr size_t kMaxMsoLen = kMaxSHABlocks * 64 - 9;
+
+  using vind = typename LogicCircuit::template bitvec<kIndexBits>;
+  using Flatsha = FlatSHA256Circuit<LogicCircuit, BitPlucker<LogicCircuit, 3>>;
+  using RoutingL = Routing<LogicCircuit>;
+  using ShaBlockWitness = typename Flatsha::BlockWitness;
+  using sha_packed_v32 = typename Flatsha::packed_v32;
+
+  const LogicCircuit& lc_;
+  const EC& ec_;
+  const Nat& order_;
+
+ public:
+  class Witness {
+   public:
+    EltW e_;
+    EltW dpkx_, dpky_;
+
+    EcdsaWitness sig_;
+    EcdsaWitness dpk_sig_;
+
+    v8 in_[64 * kMaxSHABlocks]; /* input bytes, 64 * MAX */
+    v8 nb_; /* index of sha block that contains the real hash  */
+    ShaBlockWitness sig_sha_[kMaxSHABlocks];
+
+    void input(const LogicCircuit& lc) {
+      e_ = lc.eltw_input();
+      dpkx_ = lc.eltw_input();
+      dpky_ = lc.eltw_input();
+
+      sig_.input(lc);
+      dpk_sig_.input(lc);
+
+      nb_ = lc.template vinput<8>();
+
+      // sha input init =========================
+      for (size_t i = 0; i < 64 * kMaxSHABlocks; ++i) {
+        in_[i] = lc.template vinput<8>();
+      }
+      for (size_t j = 0; j < kMaxSHABlocks; j++) {
+        sig_sha_[j].input(lc);
+      }
+    }
+  };
+
+  struct OpenedAttribute {
+    v8 ind;    /* index of attribute */
+    v8 len;    /* length of attribute, 1--32 */
+    v8 v1[32]; /* attribute value */
+    void input(const LogicCircuit& lc) {
+      ind = lc.template vinput<8>();
+      len = lc.template vinput<8>();
+      for (size_t j = 0; j < 32; ++j) {
+        v1[j] = lc.template vinput<8>();
+      }
+    }
+  };
+
+  explicit Small(const LogicCircuit& lc, const EC& ec, const Nat& order)
+      : lc_(lc), ec_(ec), order_(order), sha_(lc), r_(lc) {}
+
+  void assert_credential(EltW pkX, EltW pkY, EltW hash_tr,
+                         OpenedAttribute oa[/* NUM_ATTR */],
+                         const v8 now[/*kDateLen*/], const Witness& vw) const {
+    Ecdsa ecc(lc_, ec_, order_);
+
+    ecc.verify_signature3(pkX, pkY, vw.e_, vw.sig_);
+    ecc.verify_signature3(vw.dpkx_, vw.dpky_, hash_tr, vw.dpk_sig_);
+
+    sha_.assert_message(kMaxSHABlocks, vw.nb_, vw.in_, vw.sig_sha_);
+    assert_hash(vw.e_, vw);
+
+    const Memcmp<LogicCircuit> CMP(lc_);
+    // // validFrom <= now
+    lc_.assert1(CMP.leq(kDateLen, &vw.in_[84], &now[0]));
+
+    // // now <= validUntil
+    lc_.assert1(CMP.leq(kDateLen, &now[0], &vw.in_[92]));
+
+    // // DPK_{x,y}
+    EltW dpkx = repack(vw.in_, 100);
+    EltW dpky = repack(vw.in_, 132);
+    lc_.assert_eq(dpkx, vw.dpkx_);
+    lc_.assert_eq(dpky, vw.dpky_);
+
+    // Attributes parsing
+    const v8 zz = lc_.template vbit<8>(0xff);  // cannot appear in strings
+    std::vector<v8> cmp_buf(32);
+    for (size_t ai = 0; ai < kNumAttr; ++ai) {
+      r_.shift(oa[ai].ind, 32, &cmp_buf[0], kMaxMsoLen, vw.in_, zz, 3);
+      assert_attribute(32, oa[ai].len, &cmp_buf[0], &oa[ai].v1[0]);
+    }
+  }
+
+ private:
+  // Checks that an attribute id or attribute value is as expected.
+  // The len parameter holds the byte length of the expected id or value.
+  void assert_attribute(size_t max, const v8& vlen, const v8 got[/*max*/],
+                        const v8 want[/*max*/]) const {
+    for (size_t j = 0; j < max; ++j) {
+      auto ll = lc_.vlt(j, vlen);
+      auto cmp = lc_.veq(got[j], want[j]);
+      lc_.assert_implies(ll, cmp);
+    }
+  }
+
+  // Assert that the hash of the mdoc is equal to e.
+  // The hash is encoded in the SHA witness, and thus the correct block
+  // must be muxed for the comparison. Thus method first muxes the "packed"
+  // encoding of the SHA witness, then unpacks it and compares it to e to
+  // save a lot of work in the bit plucker.
+  void assert_hash(const EltW& e, const Witness& vw) const {
+    sha_packed_v32 x[8];
+    for (size_t b = 0; b < kMaxSHABlocks; ++b) {
+      auto bt = lc_.veq(vw.nb_, b + 1); /* b is zero-indexed */
+      auto ebt = lc_.eval(bt);
+      for (size_t i = 0; i < 8; ++i) {
+        for (size_t k = 0; k < sha_.bp_.kNv32Elts; ++k) {
+          if (b == 0) {
+            x[i][k] = lc_.mul(ebt, vw.sig_sha_[b].h1[i][k]);
+          } else {
+            auto maybe_sha = lc_.mul(ebt, vw.sig_sha_[b].h1[i][k]);
+            x[i][k] = lc_.add(x[i][k], maybe_sha);
+          }
+        }
+      }
+    }
+
+    EltW h = repack32(x);
+    lc_.assert_eq(h, e);
+  }
+
+  EltW repack(const v8 in[], size_t ind) const {
+    EltW h = lc_.konst(0);
+    EltW base = lc_.konst(0x2);
+    for (size_t i = 0; i < 32; ++i) {
+      for (size_t j = 0; j < 8; ++j) {
+        auto t = lc_.mul(h, base);
+        auto tin = lc_.eval(in[ind + i][7 - j]);
+        h = lc_.add(tin, t);
+      }
+    }
+    return h;
+  }
+
+  EltW repack32(const sha_packed_v32 H[]) const {
+    EltW h = lc_.konst(0);
+    Elt twok = lc_.one();
+    for (size_t j = 8; j-- > 0;) {
+      auto hj = sha_.bp_.unpack_v32(H[j]);
+      for (size_t k = 0; k < 32; ++k) {
+        h = lc_.axpy(h, twok, lc_.eval(hj[k]));
+        lc_.f_.add(twok, twok);
+      }
+    }
+    return h;
+  }
+
+  Flatsha sha_;
+  RoutingL r_;
+};
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_ANONCRED_SMALL_H_

data/vendor/longfellow-zk/lib/circuits/tests/anoncred/small_examples.h

@@ -0,0 +1,118 @@
+// 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_TESTS_ANONCRED_SMALL_EXAMPLES_H_
+#define PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_ANONCRED_SMALL_EXAMPLES_H_
+
+#include <cstddef>
+#include <cstdint>
+
+#include "algebra/static_string.h"
+
+namespace proofs {
+
+struct SmallTest {
+  StaticString pkx, pky; /* public key of the issuer */
+  StaticString sigr, sigs, sigtr, sigts;
+  uint8_t transcript[1024];
+  size_t transcript_size;
+  uint8_t *now;
+  size_t mdoc_size;
+  uint8_t mdoc[5000];
+};
+
+static const struct SmallTest mdoc_small_tests[] = {
+    // Example that requires 3 SHA blocks for the credential.
+    {StaticString(
+         "0x298aa30b14298b8bdb5b2b1cc0150e84a86a1469fa813f8df0f0bd09d8489661"),
+     StaticString(
+         "0x2f821d00395d0c63b222a8613c7af5f5cb2b655dda6c3926af7ea3acd6a05fba"),
+     StaticString(
+         "0xc96b7605f15536877592c24d4d65066a377c34e3e6a624ea52ce9d899207"),
+     StaticString(
+         "0xaca1128a3460368caefc5c24a27a7f9e8cc8d590b93485db2c408d1ac96d80ae"),
+     StaticString(
+         "0x08ca78156b6c60c711e501641d4b5000f1ff7715386f1186ce4aec1d6eb2ba92"),
+     StaticString(
+         "0xfdcb8d4da84f1dc03a7bd22909a6bcc103281310f9fe1fb97c13e5d2eb6934df"),
+     {0x60, 0x80, 0xf3, 0x09, 0x55, 0x56, 0xe5, 0x21, 0x4c, 0x5f, 0xff,
+      0x7c, 0x6d, 0x3d, 0xcb, 0x90, 0x3e, 0x2d, 0xcc, 0x45, 0x42, 0x9c,
+      0x4d, 0x81, 0xf9, 0x80, 0x8d, 0x5e, 0x7a, 0xd2, 0x14, 0x50},
+     32,
+     (uint8_t *)"20241005",
+     183,
+     {0x45, 0x72, 0x69, 0x6b, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4d, 0x75, 0x73, 0x74,
+      0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x31, 0x39, 0x38, 0x30, 0x30, 0x31, 0x30, 0x31,
+      0x00, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00,
+      0x32, 0x30, 0x32, 0x34, 0x31, 0x30, 0x30, 0x31, 0x32, 0x30, 0x32, 0x35,
+      0x31, 0x30, 0x30, 0x31, 0x3c, 0xeb, 0x4a, 0xec, 0x0d, 0x76, 0xbb, 0x50,
+      0x35, 0x09, 0xc6, 0x46, 0xad, 0xc6, 0x30, 0x3f, 0xb9, 0xea, 0xa5, 0x84,
+      0xb4, 0x8f, 0xa0, 0xbe, 0x07, 0x6f, 0x14, 0x28, 0xe4, 0xec, 0x3b, 0x37,
+      0x77, 0x91, 0x61, 0xbe, 0xb9, 0x86, 0x90, 0xfb, 0xc8, 0xe3, 0x57, 0x5a,
+      0x9d, 0xd9, 0x41, 0x91, 0xae, 0x8e, 0x4d, 0xbe, 0x2c, 0x44, 0x39, 0x07,
+      0x69, 0xea, 0x0c, 0x08, 0x80, 0x22, 0xf2, 0xc6, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00}},
+    // The next examples requires 4 SHA blocks for the credential.
+    {
+        StaticString("0x08a25115e57d680260aafa44e674d45d43af885fffa6746b44ece71"
+                     "cd42febd2"),
+        StaticString("0x4a177f6c38543876c66573218db63de627d343f16a483a313069830"
+                     "37df79b2f"),
+        StaticString("0x95394343021474ed688e7e783063c768a3343def0f1245f1da09406"
+                     "34eb57410"),
+        StaticString("0x4953b2f11cd46c8e1673ac50ddc51665702a27e5788eca3a8bffa67"
+                     "fbdbf65ce"),
+        StaticString("0x1ca6eef3238ec5320429774f6b6b743cc868b3cfebff96c41112b36"
+                     "5638a9dc5"),
+        StaticString("0x7e303bd730d0e663621ddcaf52991ba9f744cabe161598a44b4508f"
+                     "de7bdaf2d"),
+
+        {0x60, 0x80, 0xf3, 0x09, 0x55, 0x56, 0xe5, 0x21, 0x4c, 0x5f, 0xff,
+         0x7c, 0x6d, 0x3d, 0xcb, 0x90, 0x3e, 0x2d, 0xcc, 0x45, 0x42, 0x9c,
+         0x4d, 0x81, 0xf9, 0x80, 0x8d, 0x5e, 0x7a, 0xd2, 0x14, 0x50},
+        32,
+        (uint8_t *)"20241005",
+        247,
+        {0x45, 0x72, 0x69, 0x6b, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4d, 0x75, 0x73, 0x74,
+         0x65, 0x72, 0x6d, 0x61, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x31, 0x39, 0x38, 0x30, 0x30, 0x31, 0x30, 0x31,
+         0x00, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0x00, 0x00, 0x00, 0x00,
+         0x32, 0x30, 0x32, 0x34, 0x31, 0x30, 0x30, 0x31, 0x32, 0x30, 0x32, 0x35,
+         0x31, 0x30, 0x30, 0x31, 0x3e, 0xf6, 0x39, 0x05, 0x33, 0xf8, 0xf3, 0x37,
+         0x7d, 0xe0, 0xb2, 0xb5, 0x65, 0x19, 0x93, 0x3f, 0x49, 0xe1, 0xa1, 0x41,
+         0x57, 0xa5, 0x22, 0x0e, 0xac, 0x79, 0x8a, 0xe2, 0xe2, 0xea, 0xd2, 0x0c,
+         0x9f, 0x23, 0x3d, 0x1b, 0xe2, 0x8e, 0x69, 0xc1, 0xda, 0x76, 0xec, 0xf9,
+         0xc3, 0x0c, 0xf9, 0x3b, 0xb5, 0xb6, 0x69, 0x6f, 0xc6, 0xc2, 0x8a, 0xa8,
+         0x98, 0x19, 0x7d, 0xbf, 0xea, 0x6d, 0xad, 0x40, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    },
+};
+
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_ANONCRED_SMALL_EXAMPLES_H_

data/vendor/longfellow-zk/lib/circuits/tests/anoncred/small_io.h

@@ -0,0 +1,25 @@
+// 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_TESTS_ANONCRED_SMALL_IO_H_
+#define PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_ANONCRED_SMALL_IO_H_
+
+#include <cstddef>
+namespace proofs {
+
+static constexpr size_t kDateLen = 8;
+
+}  // namespace proofs
+
+#endif  // PRIVACY_PROOFS_ZK_LIB_CIRCUITS_TESTS_ANONCRED_SMALL_IO_H_