Repository: kroma-network/tachyon Branch: main Commit: e7b13063c6f1 Files: 2064 Total size: 40.1 MB Directory structure: gitextract_hzd_88mr/ ├── .bazelignore ├── .bazelrc ├── .bazelversion ├── .clang-format ├── .dockerignore ├── .github/ │ └── workflows/ │ ├── ci.yml │ └── delete_cache.yml ├── .gitignore ├── .gitmessage ├── BUILD.bazel ├── Cargo.toml ├── LICENSE ├── LICENSE-APACHE.EF ├── LICENSE-APACHE.arkworks-rs ├── LICENSE-APACHE.era-bellman-cuda ├── LICENSE-APACHE.halo2 ├── LICENSE-APACHE.plonky3 ├── LICENSE-APACHE.scroll ├── LICENSE-APACHE.stwo ├── LICENSE-MIT.EF ├── LICENSE-MIT.arkworks-rs ├── LICENSE-MIT.era-bellman-cuda ├── LICENSE-MIT.halo2 ├── LICENSE-MIT.plonky3 ├── LICENSE-MIT.scroll ├── LICENSE.chromium ├── LICENSE.lambdaworks ├── LICENSE.tensorflow ├── LICENSE.ulvetanna ├── README.md ├── WORKSPACE ├── bazel/ │ ├── BUILD.bazel │ ├── buildifier_deps.bzl │ ├── js_deps.bzl │ ├── pybind11_deps.bzl │ ├── tachyon.bzl │ ├── tachyon_cc.bzl │ ├── tachyon_deps.bzl │ ├── tachyon_node.bzl │ ├── tachyon_py.bzl │ ├── tachyon_repo.bzl │ └── tachyon_rust.bzl ├── benchmark/ │ ├── BUILD.bazel │ ├── config.cc │ ├── config.h │ ├── ec/ │ │ ├── BUILD.bazel │ │ ├── ec_config.cc │ │ ├── ec_config.h │ │ └── ec_double_benchmark_gpu.cc │ ├── fft/ │ │ ├── BUILD.bazel │ │ ├── README.md │ │ ├── arkworks/ │ │ │ ├── BUILD.bazel │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── bellman/ │ │ │ ├── BUILD.bazel │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── fft_benchmark.cc │ │ ├── fft_benchmark_gpu.cc │ │ ├── fft_config.cc │ │ ├── fft_config.h │ │ ├── fft_runner.h │ │ └── halo2/ │ │ ├── BUILD.bazel │ │ ├── Cargo.toml │ │ └── src/ │ │ └── lib.rs │ ├── fft_batch/ │ │ ├── BUILD.bazel │ │ ├── README.md │ │ ├── fft_batch_benchmark.cc │ │ ├── fft_batch_config.cc │ │ ├── fft_batch_config.h │ │ ├── fft_batch_runner.h │ │ └── plonky3/ │ │ ├── BUILD.bazel │ │ ├── Cargo.toml │ │ └── src/ │ │ └── lib.rs │ ├── field_type.h │ ├── fri/ │ │ ├── BUILD.bazel │ │ ├── README.md │ │ ├── fri_benchmark.cc │ │ ├── fri_config.cc │ │ ├── fri_config.h │ │ ├── fri_runner.h │ │ └── plonky3/ │ │ ├── BUILD.bazel │ │ ├── Cargo.toml │ │ └── src/ │ │ └── lib.rs │ ├── msm/ │ │ ├── BUILD.bazel │ │ ├── README.md │ │ ├── arkworks/ │ │ │ ├── BUILD.bazel │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── bellman/ │ │ │ ├── BUILD.bazel │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── halo2/ │ │ │ ├── BUILD.bazel │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── msm_benchmark.cc │ │ ├── msm_benchmark_gpu.cc │ │ ├── msm_config.cc │ │ ├── msm_config.h │ │ └── msm_runner.h │ ├── poseidon/ │ │ ├── BUILD.bazel │ │ ├── README.md │ │ ├── arkworks/ │ │ │ ├── BUILD.bazel │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── poseidon_benchmark.cc │ │ ├── poseidon_benchmark_runner.h │ │ ├── poseidon_config.cc │ │ └── poseidon_config.h │ ├── poseidon2/ │ │ ├── BUILD.bazel │ │ ├── README.md │ │ ├── horizen/ │ │ │ ├── BUILD.bazel │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── plonky3/ │ │ │ ├── BUILD.bazel │ │ │ ├── Cargo.toml │ │ │ └── src/ │ │ │ └── lib.rs │ │ ├── poseidon2_benchmark.cc │ │ ├── poseidon2_benchmark_runner.h │ │ ├── poseidon2_config.cc │ │ └── poseidon2_config.h │ ├── simple_reporter.cc │ ├── simple_reporter.h │ └── vendor.h ├── docker/ │ ├── Dockerfile.base.jammy │ ├── Dockerfile.circom.jammy │ └── Dockerfile.halo2.jammy ├── docs/ │ ├── doxygen/ │ │ ├── BUILD.bazel │ │ ├── Doxyfile.in │ │ └── main_page.md │ ├── how_to_contribute/ │ │ ├── conventions.md │ │ └── math/ │ │ ├── how_to_add_elliptic_curves.md │ │ ├── how_to_add_prime_fields.md │ │ └── math_structure.md │ └── how_to_use/ │ └── how_to_build.md ├── funding.json ├── scripts/ │ └── packages/ │ ├── BUILD.bazel │ ├── copy_hdr.py │ ├── debian/ │ │ ├── BUILD.bazel │ │ ├── copyright │ │ ├── debian.bzl │ │ ├── description │ │ ├── dev/ │ │ │ ├── BUILD.bazel │ │ │ └── tachyon.pc.tpl │ │ └── runtime/ │ │ └── BUILD.bazel │ └── install_package.sh ├── tachyon/ │ ├── BUILD.bazel │ ├── base/ │ │ ├── BUILD.bazel │ │ ├── apple/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── bridging.h │ │ │ ├── bundle_locations.h │ │ │ └── bundle_locations.mm │ │ ├── auto_reset.h │ │ ├── auto_reset_unittest.cc │ │ ├── binding/ │ │ │ ├── BUILD.bazel │ │ │ ├── callable_util.h │ │ │ ├── cpp_constructor.cc │ │ │ ├── cpp_constructor.h │ │ │ ├── cpp_constructor_matcher.cc │ │ │ ├── cpp_constructor_matcher.h │ │ │ ├── cpp_raw_ptr.h │ │ │ ├── cpp_shared_ptr.h │ │ │ ├── cpp_stack_value.h │ │ │ ├── cpp_type.h │ │ │ ├── cpp_type_names.cc │ │ │ ├── cpp_type_names.h │ │ │ ├── cpp_unique_ptr.h │ │ │ ├── cpp_value.cc │ │ │ ├── cpp_value.h │ │ │ ├── cpp_value_factory.h │ │ │ ├── holder_util.h │ │ │ ├── property_util.h │ │ │ └── test/ │ │ │ ├── BUILD.bazel │ │ │ ├── adder.cc │ │ │ ├── adder.h │ │ │ ├── color.cc │ │ │ ├── color.h │ │ │ ├── colored_point.cc │ │ │ ├── colored_point.h │ │ │ ├── functions.cc │ │ │ ├── functions.h │ │ │ ├── move_only_int.cc │ │ │ ├── move_only_int.h │ │ │ ├── point.cc │ │ │ ├── point.h │ │ │ ├── rect.cc │ │ │ ├── rect.h │ │ │ ├── variant.cc │ │ │ └── variant.h │ │ ├── bit_cast.h │ │ ├── bit_cast_unittest.cc │ │ ├── bits.cc │ │ ├── bits.h │ │ ├── bits_unittest.cc │ │ ├── buffer/ │ │ │ ├── BUILD.bazel │ │ │ ├── buffer.cc │ │ │ ├── buffer.h │ │ │ ├── buffer_unittest.cc │ │ │ ├── copyable.h │ │ │ ├── copyable_forward.h │ │ │ ├── endian_auto_reset.h │ │ │ ├── read_only_buffer.cc │ │ │ ├── read_only_buffer.h │ │ │ ├── string_buffer.h │ │ │ ├── vector_buffer.cc │ │ │ └── vector_buffer.h │ │ ├── color/ │ │ │ ├── BUILD.bazel │ │ │ ├── color.cc │ │ │ ├── color.h │ │ │ ├── color_conversions.cc │ │ │ ├── color_conversions.h │ │ │ ├── color_conversions_unittest.cc │ │ │ ├── color_unittest.cc │ │ │ └── named_color.h │ │ ├── compiler_specific.h │ │ ├── console/ │ │ │ ├── BUILD.bazel │ │ │ ├── console.cc │ │ │ ├── console.h │ │ │ ├── console_stream.cc │ │ │ ├── console_stream.h │ │ │ ├── iostream.cc │ │ │ ├── iostream.h │ │ │ ├── sgr_parameter_list.h │ │ │ ├── sgr_parameters.cc │ │ │ ├── sgr_parameters.h │ │ │ ├── table_writer.cc │ │ │ └── table_writer.h │ │ ├── containers/ │ │ │ ├── BUILD.bazel │ │ │ ├── adapters.h │ │ │ ├── adapters_unittest.cc │ │ │ ├── chunked_iterator.h │ │ │ ├── circular_deque.h │ │ │ ├── circular_deque_unittest.cc │ │ │ ├── container_util.h │ │ │ ├── container_util_unittest.cc │ │ │ ├── contains.h │ │ │ ├── contains_unittest.cc │ │ │ ├── cxx20_erase.h │ │ │ ├── cxx20_erase_deque.h │ │ │ ├── cxx20_erase_forward_list.h │ │ │ ├── cxx20_erase_internal.h │ │ │ ├── cxx20_erase_list.h │ │ │ ├── cxx20_erase_map.h │ │ │ ├── cxx20_erase_set.h │ │ │ ├── cxx20_erase_string.h │ │ │ ├── cxx20_erase_unordered_map.h │ │ │ ├── cxx20_erase_unordered_set.h │ │ │ ├── cxx20_erase_vector.h │ │ │ ├── stack.h │ │ │ ├── util.h │ │ │ ├── vector_buffer.h │ │ │ ├── vector_buffer_unittest.cc │ │ │ └── zipped_iterator.h │ │ ├── cxx20_is_constant_evaluated.h │ │ ├── cxx20_is_constant_evaluated_unittest.cc │ │ ├── endian.cc │ │ ├── endian.h │ │ ├── endian_utils.h │ │ ├── endian_utils_unittest.cc │ │ ├── environment.h │ │ ├── environment_posix.cc │ │ ├── environment_unittest.cc │ │ ├── files/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── bin_file.cc │ │ │ ├── bin_file.h │ │ │ ├── file.cc │ │ │ ├── file.h │ │ │ ├── file_enumerator.cc │ │ │ ├── file_enumerator.h │ │ │ ├── file_enumerator_posix.cc │ │ │ ├── file_enumerator_unittest.cc │ │ │ ├── file_path.cc │ │ │ ├── file_path.h │ │ │ ├── file_path_flag.h │ │ │ ├── file_path_unittest.cc │ │ │ ├── file_posix.cc │ │ │ ├── file_unittest.cc │ │ │ ├── file_util.cc │ │ │ ├── file_util.h │ │ │ ├── file_util_mac.mm │ │ │ ├── file_util_posix.cc │ │ │ ├── memory_mapped_file.cc │ │ │ ├── memory_mapped_file.h │ │ │ ├── memory_mapped_file_posix.cc │ │ │ ├── platform_file.h │ │ │ ├── scoped_file.cc │ │ │ ├── scoped_file.h │ │ │ ├── scoped_file_linux.cc │ │ │ ├── scoped_file_linux_unittest.cc │ │ │ ├── scoped_temp_dir.cc │ │ │ ├── scoped_temp_dir.h │ │ │ └── scoped_temp_dir_unittest.cc │ │ ├── flag/ │ │ │ ├── BUILD.bazel │ │ │ ├── flag.cc │ │ │ ├── flag.h │ │ │ ├── flag_forward.h │ │ │ ├── flag_parser.cc │ │ │ ├── flag_parser.h │ │ │ ├── flag_parser_unittest.cc │ │ │ ├── flag_unittest.cc │ │ │ ├── flag_value_traits.h │ │ │ └── numeric_flags.h │ │ ├── functional/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── callback.h │ │ │ ├── callback_forward.h │ │ │ ├── function_ref.h │ │ │ ├── function_ref_unittest.cc │ │ │ ├── functor_traits.h │ │ │ ├── identity.h │ │ │ ├── identity_unittest.cc │ │ │ ├── invoke.h │ │ │ └── invoke_unittest.cc │ │ ├── immediate_crash.h │ │ ├── json/ │ │ │ ├── BUILD.bazel │ │ │ ├── json.h │ │ │ ├── json_unittest.cc │ │ │ ├── rapidjson_util.cc │ │ │ ├── rapidjson_util.h │ │ │ └── test/ │ │ │ └── simple_data.json │ │ ├── logging.cc │ │ ├── logging.h │ │ ├── mac/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── foundation_util.h │ │ │ ├── foundation_util.mm │ │ │ ├── mac_logging.h │ │ │ ├── mac_logging.mm │ │ │ ├── mach_logging.cc │ │ │ ├── mach_logging.h │ │ │ ├── scoped_cftyperef.h │ │ │ ├── scoped_mach_port.cc │ │ │ ├── scoped_mach_port.h │ │ │ └── scoped_typeref.h │ │ ├── maybe_owned.h │ │ ├── maybe_owned_traits.h │ │ ├── memory/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── aligned_memory.cc │ │ │ ├── aligned_memory.h │ │ │ ├── aligned_memory_unittest.cc │ │ │ └── scoped_policy.h │ │ ├── message_loop/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ └── message_pump_type.h │ │ ├── no_destructor.h │ │ ├── numerics/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── README.md │ │ │ ├── checked_math.h │ │ │ ├── checked_math_impl.h │ │ │ ├── clamped_math.h │ │ │ ├── clamped_math_impl.h │ │ │ ├── math_constants.h │ │ │ ├── ostream_operators.h │ │ │ ├── ranges.h │ │ │ ├── safe_conversions.h │ │ │ ├── safe_conversions_arm_impl.h │ │ │ ├── safe_conversions_impl.h │ │ │ ├── safe_math.h │ │ │ ├── safe_math_arm_impl.h │ │ │ ├── safe_math_clang_gcc_impl.h │ │ │ └── safe_math_shared_impl.h │ │ ├── openmp_util.h │ │ ├── optional.h │ │ ├── parallelize.h │ │ ├── parallelize_unittest.cc │ │ ├── posix/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── can_lower_nice_to.cc │ │ │ ├── can_lower_nice_to.h │ │ │ └── eintr_wrapper.h │ │ ├── process/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── process_handle.cc │ │ │ ├── process_handle.h │ │ │ └── process_handle_posix.cc │ │ ├── profiler.cc │ │ ├── profiler.h │ │ ├── random.cc │ │ ├── random.h │ │ ├── random_unittest.cc │ │ ├── range.h │ │ ├── range_unittest.cc │ │ ├── ranges/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── README.md │ │ │ ├── algorithm.h │ │ │ ├── algorithm_unittest.cc │ │ │ ├── functional.h │ │ │ ├── functional_unittest.cc │ │ │ ├── ranges.h │ │ │ └── ranges_unittest.cc │ │ ├── ref.h │ │ ├── ref_unittest.cc │ │ ├── scoped_generic.h │ │ ├── scoped_generic_unittest.cc │ │ ├── sort.h │ │ ├── sort_benchmark.cc │ │ ├── static_storage.h │ │ ├── strings/ │ │ │ ├── BUILD.bazel │ │ │ ├── rust_stringifier.h │ │ │ ├── string_number_conversions.cc │ │ │ ├── string_number_conversions.h │ │ │ ├── string_number_conversions_internal.h │ │ │ ├── string_number_conversions_unittest.cc │ │ │ ├── string_util.cc │ │ │ ├── string_util.h │ │ │ ├── string_util_impl_helpers.h │ │ │ ├── string_util_internal.h │ │ │ ├── string_util_unittest.cc │ │ │ ├── sys_string_conversions.h │ │ │ ├── sys_string_conversions_mac.mm │ │ │ ├── sys_string_conversions_mac_unittest.mm │ │ │ └── sys_string_conversions_posix.cc │ │ ├── system/ │ │ │ ├── BUILD.bazel │ │ │ ├── sys_info.h │ │ │ └── sys_info_posix.cc │ │ ├── template_util.h │ │ ├── test/ │ │ │ ├── BUILD.bazel │ │ │ ├── copy_only_int.cc │ │ │ ├── copy_only_int.h │ │ │ ├── move_only_int.h │ │ │ ├── scoped_environment.cc │ │ │ └── scoped_environment.h │ │ ├── threading/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── platform_thread.cc │ │ │ ├── platform_thread.h │ │ │ ├── platform_thread_internal_posix.cc │ │ │ ├── platform_thread_internal_posix.h │ │ │ ├── platform_thread_linux.cc │ │ │ ├── platform_thread_mac.mm │ │ │ ├── platform_thread_posix.cc │ │ │ ├── platform_thread_ref.cc │ │ │ └── platform_thread_ref.h │ │ ├── time/ │ │ │ ├── BUILD.bazel │ │ │ ├── time.cc │ │ │ ├── time.h │ │ │ ├── time_buildflags.bzl │ │ │ ├── time_conversion_posix.cc │ │ │ ├── time_delta_flag.h │ │ │ ├── time_delta_flag_unittest.cc │ │ │ ├── time_interval.cc │ │ │ ├── time_interval.h │ │ │ ├── time_interval_unittest.cc │ │ │ ├── time_mac.mm │ │ │ ├── time_mac_unittest.mm │ │ │ ├── time_now_posix.cc │ │ │ ├── time_stamp.cc │ │ │ ├── time_stamp.h │ │ │ ├── time_stamp_unittest.cc │ │ │ └── time_unittest.cc │ │ ├── type_list.h │ │ └── types/ │ │ ├── .clang-format │ │ ├── BUILD.bazel │ │ ├── always_false.h │ │ └── cxx20_is_bounded_array.h │ ├── build/ │ │ ├── BUILD.bazel │ │ ├── build_config.h │ │ ├── buildflag.bzl │ │ ├── buildflag.h │ │ ├── cc_writer.cc │ │ ├── cc_writer.h │ │ ├── lastchange.bzl │ │ ├── lastchange.py │ │ ├── version.bzl │ │ ├── write_buildflag_header.py │ │ ├── write_version_header.py │ │ ├── writer.cc │ │ └── writer.h │ ├── c/ │ │ ├── BUILD.bazel │ │ ├── api.h │ │ ├── base/ │ │ │ ├── BUILD.bazel │ │ │ ├── profiler.cc │ │ │ ├── profiler.h │ │ │ ├── profiler_type_traits.h │ │ │ └── type_traits_forward.h │ │ ├── crypto/ │ │ │ ├── BUILD.bazel │ │ │ ├── commitments/ │ │ │ │ └── fri/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── two_adic_fri_impl.h │ │ │ └── random/ │ │ │ ├── BUILD.bazel │ │ │ ├── rng.cc │ │ │ ├── rng.h │ │ │ └── rng_unittest.cc │ │ ├── examples/ │ │ │ ├── BUILD.bazel │ │ │ ├── affine_point.cc │ │ │ ├── extension_field.cc │ │ │ ├── jacobian_point.cc │ │ │ ├── msm.cc │ │ │ ├── point_xyzz.cc │ │ │ ├── prime_field.cc │ │ │ ├── projective_point.cc │ │ │ ├── rng.cc │ │ │ └── version.cc │ │ ├── export.h │ │ ├── math/ │ │ │ ├── BUILD.bazel │ │ │ ├── elliptic_curves/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── bls12/ │ │ │ │ │ └── bls12_381/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── bn/ │ │ │ │ │ └── bn254/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ └── g1_test.h │ │ │ │ ├── generator/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── build_defs.bzl │ │ │ │ │ ├── generator.cc │ │ │ │ │ ├── generator_util.cc │ │ │ │ │ ├── generator_util.h │ │ │ │ │ ├── msm.cc.tpl │ │ │ │ │ ├── msm.h.tpl │ │ │ │ │ ├── msm_gpu.cc.tpl │ │ │ │ │ ├── msm_gpu.h.tpl │ │ │ │ │ ├── point.cc.tpl │ │ │ │ │ ├── point.h.tpl │ │ │ │ │ ├── point_traits.h.tpl │ │ │ │ │ └── point_type_traits.h.tpl │ │ │ │ ├── msm/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── msm.h │ │ │ │ │ ├── msm_gpu.h │ │ │ │ │ ├── msm_gpu_replay.cc │ │ │ │ │ ├── msm_gpu_unittest.cc │ │ │ │ │ ├── msm_input_provider.h │ │ │ │ │ └── msm_unittest.cc │ │ │ │ ├── point_traits_forward.h │ │ │ │ └── short_weierstrass/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── affine_point_unittest.cc │ │ │ │ ├── jacobian_point_unittest.cc │ │ │ │ ├── point_xyzz_unittest.cc │ │ │ │ └── projective_point_unittest.cc │ │ │ ├── finite_fields/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── baby_bear/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── extension_field_unittest.cc │ │ │ │ ├── generator/ │ │ │ │ │ ├── ext_field_generator/ │ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ │ ├── build_defs.bzl │ │ │ │ │ │ ├── ext_field.cc.tpl │ │ │ │ │ │ ├── ext_field.h.tpl │ │ │ │ │ │ ├── ext_field_generator.cc │ │ │ │ │ │ └── ext_field_type_traits.h.tpl │ │ │ │ │ └── prime_field_generator/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── build_defs.bzl │ │ │ │ │ ├── prime_field.cc.tpl │ │ │ │ │ ├── prime_field.h.tpl │ │ │ │ │ ├── prime_field_generator.cc │ │ │ │ │ └── prime_field_type_traits.h.tpl │ │ │ │ └── prime_field_unittest.cc │ │ │ ├── matrix/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── baby_bear_row_major_matrix.cc │ │ │ │ ├── baby_bear_row_major_matrix.h │ │ │ │ ├── baby_bear_row_major_matrix_type_traits.h │ │ │ │ └── baby_bear_row_major_matrix_unittest.cc │ │ │ └── polynomials/ │ │ │ ├── BUILD.bazel │ │ │ ├── constants.h │ │ │ └── univariate/ │ │ │ ├── BUILD.bazel │ │ │ ├── bn254_univariate_dense_polynomial.cc │ │ │ ├── bn254_univariate_dense_polynomial.h │ │ │ ├── bn254_univariate_dense_polynomial_type_traits.h │ │ │ ├── bn254_univariate_dense_polynomial_unittest.cc │ │ │ ├── bn254_univariate_evaluation_domain.cc │ │ │ ├── bn254_univariate_evaluation_domain.h │ │ │ ├── bn254_univariate_evaluation_domain_type_traits.h │ │ │ ├── bn254_univariate_evaluation_domain_unittest.cc │ │ │ ├── bn254_univariate_evaluations.cc │ │ │ ├── bn254_univariate_evaluations.h │ │ │ ├── bn254_univariate_evaluations_type_traits.h │ │ │ ├── bn254_univariate_evaluations_unittest.cc │ │ │ ├── bn254_univariate_rational_evaluations.cc │ │ │ ├── bn254_univariate_rational_evaluations.h │ │ │ ├── bn254_univariate_rational_evaluations_type_traits.h │ │ │ └── bn254_univariate_rational_evaluations_unittest.cc │ │ ├── version.bzl │ │ ├── version.cc │ │ ├── version.h │ │ ├── version_unittest.cc │ │ └── zk/ │ │ ├── BUILD.bazel │ │ ├── air/ │ │ │ ├── BUILD.bazel │ │ │ └── sp1/ │ │ │ ├── BUILD.bazel │ │ │ ├── baby_bear_poseidon2_commitment_vec.cc │ │ │ ├── baby_bear_poseidon2_commitment_vec.h │ │ │ ├── baby_bear_poseidon2_commitment_vec_type_traits.h │ │ │ ├── baby_bear_poseidon2_constants.h │ │ │ ├── baby_bear_poseidon2_domains.cc │ │ │ ├── baby_bear_poseidon2_domains.h │ │ │ ├── baby_bear_poseidon2_domains_type_traits.h │ │ │ ├── baby_bear_poseidon2_duplex_challenger.cc │ │ │ ├── baby_bear_poseidon2_duplex_challenger.h │ │ │ ├── baby_bear_poseidon2_duplex_challenger_type_traits.h │ │ │ ├── baby_bear_poseidon2_duplex_challenger_unittest.cc │ │ │ ├── baby_bear_poseidon2_field_merkle_tree.cc │ │ │ ├── baby_bear_poseidon2_field_merkle_tree.h │ │ │ ├── baby_bear_poseidon2_field_merkle_tree_type_traits.h │ │ │ ├── baby_bear_poseidon2_field_merkle_tree_vec.cc │ │ │ ├── baby_bear_poseidon2_field_merkle_tree_vec.h │ │ │ ├── baby_bear_poseidon2_field_merkle_tree_vec_type_traits.h │ │ │ ├── baby_bear_poseidon2_fields.h │ │ │ ├── baby_bear_poseidon2_fri_proof.cc │ │ │ ├── baby_bear_poseidon2_fri_proof.h │ │ │ ├── baby_bear_poseidon2_fri_proof_type_traits.h │ │ │ ├── baby_bear_poseidon2_hintable.h │ │ │ ├── baby_bear_poseidon2_hintable_unittest.cc │ │ │ ├── baby_bear_poseidon2_lde_vec.cc │ │ │ ├── baby_bear_poseidon2_lde_vec.h │ │ │ ├── baby_bear_poseidon2_lde_vec_type_traits.h │ │ │ ├── baby_bear_poseidon2_opened_values.cc │ │ │ ├── baby_bear_poseidon2_opened_values.h │ │ │ ├── baby_bear_poseidon2_opened_values_type_traits.h │ │ │ ├── baby_bear_poseidon2_opened_values_unittest.cc │ │ │ ├── baby_bear_poseidon2_opening_points.cc │ │ │ ├── baby_bear_poseidon2_opening_points.h │ │ │ ├── baby_bear_poseidon2_opening_points_type_traits.h │ │ │ ├── baby_bear_poseidon2_two_adic_fri.cc │ │ │ ├── baby_bear_poseidon2_two_adic_fri.h │ │ │ ├── baby_bear_poseidon2_two_adic_fri_type_traits.h │ │ │ ├── baby_bear_poseidon2_two_adic_fri_unittest.cc │ │ │ ├── block.h │ │ │ └── block_unittest.cc │ │ ├── base/ │ │ │ ├── BUILD.bazel │ │ │ ├── bn254_blinder.cc │ │ │ ├── bn254_blinder.h │ │ │ └── bn254_blinder_type_traits.h │ │ └── plonk/ │ │ ├── BUILD.bazel │ │ ├── constraint_system/ │ │ │ ├── BUILD.bazel │ │ │ ├── bn254_constraint_system.cc │ │ │ ├── bn254_constraint_system.h │ │ │ ├── bn254_constraint_system_type_traits.h │ │ │ ├── bn254_constraint_system_unittest.cc │ │ │ ├── column_key.h │ │ │ ├── column_type.h │ │ │ └── phase.h │ │ ├── halo2/ │ │ │ ├── BUILD.bazel │ │ │ ├── bn254_argument_data.cc │ │ │ ├── bn254_argument_data.h │ │ │ ├── bn254_argument_data_type_traits.h │ │ │ ├── bn254_instance_columns_vec.cc │ │ │ ├── bn254_instance_columns_vec.h │ │ │ ├── bn254_instance_columns_vec_type_traits.h │ │ │ ├── bn254_prover.cc │ │ │ ├── bn254_prover.h │ │ │ ├── bn254_prover_unittest.cc │ │ │ ├── bn254_ps.h │ │ │ ├── bn254_transcript.cc │ │ │ ├── bn254_transcript.h │ │ │ ├── bn254_transcript_unittest.cc │ │ │ ├── bn254_verifier.cc │ │ │ ├── bn254_verifier.h │ │ │ ├── buffer_reader.h │ │ │ ├── constants.h │ │ │ ├── kzg_family_prover_impl.h │ │ │ ├── prover_impl_base.h │ │ │ ├── prover_replay.cc │ │ │ ├── test/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── bn254_halo2_params_data.h │ │ │ ├── verifier_impl.h │ │ │ └── verifier_replay.cc │ │ └── keys/ │ │ ├── BUILD.bazel │ │ ├── bn254_plonk_proving_key.cc │ │ ├── bn254_plonk_proving_key.h │ │ ├── bn254_plonk_proving_key_unittest.cc │ │ ├── bn254_plonk_verifying_key.cc │ │ ├── bn254_plonk_verifying_key.h │ │ ├── bn254_plonk_verifying_key_type_traits.h │ │ ├── bn254_plonk_verifying_key_unittest.cc │ │ └── proving_key_impl.h │ ├── cc/ │ │ ├── BUILD.bazel │ │ ├── api.h │ │ ├── export.h │ │ ├── math/ │ │ │ ├── BUILD.bazel │ │ │ ├── elliptic_curves/ │ │ │ │ ├── bls12/ │ │ │ │ │ └── bls12_381/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── bn/ │ │ │ │ │ └── bn254/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── generator/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── build_defs.bzl │ │ │ │ │ ├── g1.cc.tpl │ │ │ │ │ ├── g1.h.tpl │ │ │ │ │ ├── generator.cc │ │ │ │ │ ├── prime_field.cc.tpl │ │ │ │ │ └── prime_field.h.tpl │ │ │ │ └── short_weierstrass/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── affine_point_unittest.cc │ │ │ │ ├── jacobian_point_unittest.cc │ │ │ │ ├── point_xyzz_unittest.cc │ │ │ │ └── projective_point_unittest.cc │ │ │ └── finite_fields/ │ │ │ ├── BUILD.bazel │ │ │ └── prime_field_unittest.cc │ │ ├── version.bzl │ │ ├── version.cc │ │ ├── version.h │ │ └── version_unittest.cc │ ├── crypto/ │ │ ├── challenger/ │ │ │ ├── BUILD.bazel │ │ │ ├── challenger.h │ │ │ ├── challenger_traits_forward.h │ │ │ ├── duplex_challenger.h │ │ │ ├── duplex_challenger_unittest.cc │ │ │ ├── hash_challenger.h │ │ │ ├── hash_challenger_unittest.cc │ │ │ ├── multi_field32_challenger.h │ │ │ ├── multi_field32_challenger_unittest.cc │ │ │ └── multi_field32_conversions.h │ │ ├── commitments/ │ │ │ ├── BUILD.bazel │ │ │ ├── batch_commitment_state.h │ │ │ ├── fri/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── fri_config.h │ │ │ │ ├── fri_config_unittest.cc │ │ │ │ ├── fri_proof.h │ │ │ │ ├── lagrange_selectors.h │ │ │ │ ├── prove.h │ │ │ │ ├── simple_fri.h │ │ │ │ ├── simple_fri_proof.h │ │ │ │ ├── simple_fri_storage.h │ │ │ │ ├── simple_fri_unittest.cc │ │ │ │ ├── two_adic_fri.h │ │ │ │ ├── two_adic_fri_unittest.cc │ │ │ │ ├── two_adic_multiplicative_coset.h │ │ │ │ ├── two_adic_multiplicative_coset_unittest.cc │ │ │ │ └── verify.h │ │ │ ├── kzg/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── gwc.h │ │ │ │ ├── gwc_unittest.cc │ │ │ │ ├── kzg.h │ │ │ │ ├── kzg_family.h │ │ │ │ ├── kzg_family_test.h │ │ │ │ ├── kzg_unittest.cc │ │ │ │ ├── shplonk.h │ │ │ │ └── shplonk_unittest.cc │ │ │ ├── merkle_tree/ │ │ │ │ ├── binary_merkle_tree/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── binary_merkle_hasher.h │ │ │ │ │ ├── binary_merkle_proof.h │ │ │ │ │ ├── binary_merkle_tree.h │ │ │ │ │ ├── binary_merkle_tree_storage.h │ │ │ │ │ ├── binary_merkle_tree_unittest.cc │ │ │ │ │ └── simple_binary_merkle_tree_storage.h │ │ │ │ └── field_merkle_tree/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── extension_field_merkle_tree_mmcs.h │ │ │ │ ├── extension_field_merkle_tree_mmcs_unittest.cc │ │ │ │ ├── field_merkle_tree.h │ │ │ │ ├── field_merkle_tree_gpu_unittest.cc │ │ │ │ ├── field_merkle_tree_mmcs.h │ │ │ │ ├── field_merkle_tree_mmcs_unittest.cc │ │ │ │ ├── field_merkle_tree_unittest.cc │ │ │ │ └── icicle/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── icicle_mmcs.h │ │ │ │ ├── icicle_mmcs_baby_bear.cc │ │ │ │ ├── icicle_mmcs_baby_bear.h │ │ │ │ ├── icicle_mmcs_bn254.cc │ │ │ │ ├── icicle_mmcs_bn254.h │ │ │ │ └── icicle_mmcs_holder.h │ │ │ ├── mixed_matrix_commitment_scheme.h │ │ │ ├── mixed_matrix_commitment_scheme_traits_forward.h │ │ │ ├── pedersen/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── pedersen.h │ │ │ │ └── pedersen_unittest.cc │ │ │ ├── polynomial_openings.h │ │ │ ├── polynomial_openings_unittest.cc │ │ │ ├── test/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── bn254_kzg_polynomial_openings.h │ │ │ │ └── bn254_kzg_polynomial_openings.json │ │ │ ├── univariate_polynomial_commitment_scheme.h │ │ │ ├── vector_commitment_scheme.h │ │ │ └── vector_commitment_scheme_traits_forward.h │ │ ├── hashes/ │ │ │ ├── BUILD.bazel │ │ │ ├── compressor.h │ │ │ ├── hasher.h │ │ │ ├── prime_field_serializable.h │ │ │ ├── prime_field_serializable_unittest.cc │ │ │ └── sponge/ │ │ │ ├── BUILD.bazel │ │ │ ├── duplex_sponge_mode.h │ │ │ ├── duplex_sponge_mode_unittest.cc │ │ │ ├── padding_free_sponge.h │ │ │ ├── padding_free_sponge_unittest.cc │ │ │ ├── poseidon/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── poseidon.h │ │ │ │ ├── poseidon_config.h │ │ │ │ ├── poseidon_config_base.h │ │ │ │ ├── poseidon_config_entry.h │ │ │ │ ├── poseidon_config_entry_base.h │ │ │ │ ├── poseidon_config_unittest.cc │ │ │ │ ├── poseidon_grain_lfsr.h │ │ │ │ ├── poseidon_grain_lfsr_unittest.cc │ │ │ │ ├── poseidon_params.h │ │ │ │ ├── poseidon_sponge_base.h │ │ │ │ ├── poseidon_unittest.cc │ │ │ │ ├── sparse_mds_matrix.h │ │ │ │ └── sparse_mds_matrix_unittest.cc │ │ │ ├── poseidon2/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── icicle/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── icicle_poseidon2.h │ │ │ │ │ ├── icicle_poseidon2_baby_bear.cc │ │ │ │ │ ├── icicle_poseidon2_baby_bear.h │ │ │ │ │ ├── icicle_poseidon2_bn254.cc │ │ │ │ │ ├── icicle_poseidon2_bn254.h │ │ │ │ │ └── icicle_poseidon2_holder.h │ │ │ │ ├── param_traits/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── poseidon2_baby_bear.h │ │ │ │ │ ├── poseidon2_bls12_381.h │ │ │ │ │ ├── poseidon2_bn254.h │ │ │ │ │ ├── poseidon2_goldilocks.h │ │ │ │ │ ├── poseidon2_koala_bear.h │ │ │ │ │ ├── poseidon2_mersenne31.h │ │ │ │ │ ├── poseidon2_pallas.h │ │ │ │ │ └── poseidon2_vesta.h │ │ │ │ ├── poseidon2.h │ │ │ │ ├── poseidon2_config.h │ │ │ │ ├── poseidon2_config_entry.h │ │ │ │ ├── poseidon2_external_matrix.h │ │ │ │ ├── poseidon2_external_matrix_traits_forward.h │ │ │ │ ├── poseidon2_external_matrix_unittest.cc │ │ │ │ ├── poseidon2_gpu_unittest.cc │ │ │ │ ├── poseidon2_horizen_external_matrix.h │ │ │ │ ├── poseidon2_horizen_internal_matrix.h │ │ │ │ ├── poseidon2_internal_matrix_unittest.cc │ │ │ │ ├── poseidon2_param_traits_forward.h │ │ │ │ ├── poseidon2_params.h │ │ │ │ ├── poseidon2_plonky3_external_matrix.h │ │ │ │ ├── poseidon2_plonky3_internal_matrix.h │ │ │ │ ├── poseidon2_unittest.cc │ │ │ │ ├── poseidon2_vendor.cc │ │ │ │ └── poseidon2_vendor.h │ │ │ ├── sponge.h │ │ │ ├── sponge_state.h │ │ │ ├── truncated_permutation.h │ │ │ └── truncated_permutation_unittest.cc │ │ ├── random/ │ │ │ ├── BUILD.bazel │ │ │ ├── block_rng.h │ │ │ ├── cha_cha20/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── cha_cha20_rng.h │ │ │ │ └── cha_cha20_rng_unittest.cc │ │ │ ├── rng.h │ │ │ ├── rng_type.h │ │ │ └── xor_shift/ │ │ │ ├── BUILD.bazel │ │ │ ├── xor_shift_rng.h │ │ │ └── xor_shift_rng_unittest.cc │ │ ├── sumcheck/ │ │ │ └── multilinear/ │ │ │ ├── BUILD.bazel │ │ │ ├── multilinear_sumcheck.h │ │ │ ├── multilinear_sumcheck_unittest.cc │ │ │ ├── sumcheck_prover.h │ │ │ ├── sumcheck_prover_msg.h │ │ │ ├── sumcheck_prover_msg_unittest.cc │ │ │ ├── sumcheck_proving_key.h │ │ │ ├── sumcheck_proving_key_unittest.cc │ │ │ ├── sumcheck_verifier.h │ │ │ ├── sumcheck_verifier_msg.h │ │ │ ├── sumcheck_verifier_msg_unittest.cc │ │ │ ├── sumcheck_verifying_key.h │ │ │ └── sumcheck_verifying_key_unittest.cc │ │ └── transcripts/ │ │ ├── BUILD.bazel │ │ ├── simple_transcript.h │ │ ├── transcript.h │ │ └── transcript_traits.h │ ├── device/ │ │ ├── BUILD.bazel │ │ ├── allocator.cc │ │ ├── allocator.h │ │ ├── allocator_registry.cc │ │ ├── allocator_registry.h │ │ ├── gpu/ │ │ │ ├── BUILD.bazel │ │ │ ├── cuda/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── cub_helper.h │ │ │ │ ├── cuda_driver.cc │ │ │ │ ├── cuda_driver.h │ │ │ │ ├── cuda_driver_unittest.cc │ │ │ │ └── cuda_memory.h │ │ │ ├── device_perf_info.cc │ │ │ ├── device_perf_info.h │ │ │ ├── gpu_cudamallocasync_allocator.cc │ │ │ ├── gpu_cudamallocasync_allocator.h │ │ │ ├── gpu_device_functions.h │ │ │ ├── gpu_driver.cc │ │ │ ├── gpu_driver.h │ │ │ ├── gpu_enums.h │ │ │ ├── gpu_info.cc │ │ │ ├── gpu_info.h │ │ │ ├── gpu_init.cc │ │ │ ├── gpu_init.h │ │ │ ├── gpu_logging.cc │ │ │ ├── gpu_logging.h │ │ │ ├── gpu_memory.cc │ │ │ ├── gpu_memory.h │ │ │ ├── gpu_memory_unittest.cc │ │ │ ├── gpu_types.h │ │ │ ├── gpu_util.cc │ │ │ ├── gpu_util.h │ │ │ ├── platform_device_id.h │ │ │ ├── scoped_event.cc │ │ │ ├── scoped_event.h │ │ │ ├── scoped_mem_pool.cc │ │ │ ├── scoped_mem_pool.h │ │ │ ├── scoped_stream.cc │ │ │ └── scoped_stream.h │ │ ├── numa.cc │ │ ├── numa.h │ │ ├── numa_unittest.cc │ │ ├── tracking_allocator.cc │ │ └── tracking_allocator.h │ ├── examples/ │ │ ├── BUILD.bazel │ │ ├── cuda_example.cu.cc │ │ └── version.cc │ ├── export.h │ ├── math/ │ │ ├── base/ │ │ │ ├── BUILD.bazel │ │ │ ├── arithmetics.h │ │ │ ├── arithmetics_results.h │ │ │ ├── arithmetics_unittest.cc │ │ │ ├── batch_inverse_benchmark.cc │ │ │ ├── big_int.cc │ │ │ ├── big_int.h │ │ │ ├── big_int_unittest.cc │ │ │ ├── bit_iterator.h │ │ │ ├── bit_iterator_unittest.cc │ │ │ ├── bit_traits_forward.h │ │ │ ├── byinverter.h │ │ │ ├── byinverter_unittest.cc │ │ │ ├── const_init.h │ │ │ ├── egcd.h │ │ │ ├── egcd_unittest.cc │ │ │ ├── field.h │ │ │ ├── field_unittest.cc │ │ │ ├── gmp/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── bit_traits.h │ │ │ │ ├── gmp.bzl │ │ │ │ ├── gmp_util.cc │ │ │ │ ├── gmp_util.h │ │ │ │ ├── gmp_util_unittest.cc │ │ │ │ └── signed_value.h │ │ │ ├── groups.h │ │ │ ├── groups_unittest.cc │ │ │ ├── parallelize_threshold.h │ │ │ ├── rational_field.h │ │ │ ├── rational_field_unittest.cc │ │ │ ├── ring.h │ │ │ ├── semigroups.h │ │ │ ├── semigroups_unittest.cc │ │ │ ├── sign.cc │ │ │ ├── sign.h │ │ │ ├── sign_unittest.cc │ │ │ ├── simd_int.h │ │ │ ├── simd_int128_arm64.cc │ │ │ ├── simd_int128_x86.cc │ │ │ ├── simd_int256_x86.cc │ │ │ ├── simd_int512_x86.cc │ │ │ └── simd_int_unittest.cc │ │ ├── circle/ │ │ │ ├── BUILD.bazel │ │ │ ├── affine_point.h │ │ │ ├── affine_point_unittest.cc │ │ │ ├── circle.h │ │ │ ├── circle_traits_forward.h │ │ │ ├── generator/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── build_defs.bzl │ │ │ │ ├── cpu.h.tpl │ │ │ │ └── generator.cc │ │ │ └── m31/ │ │ │ └── BUILD.bazel │ │ ├── elliptic_curves/ │ │ │ ├── BUILD.bazel │ │ │ ├── bls12/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── bls12_381/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── bls12_curve.h │ │ │ │ ├── g2_prepared.h │ │ │ │ └── generator/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── build_defs.bzl │ │ │ │ ├── curve.h.tpl │ │ │ │ └── generator.cc │ │ │ ├── bn/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── bn254/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ └── halo2/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── bn254.cc │ │ │ │ │ └── bn254.h │ │ │ │ ├── bn384_small_two_adicity/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── bn_curve.h │ │ │ │ ├── g2_prepared.h │ │ │ │ └── generator/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── build_defs.bzl │ │ │ │ ├── curve.h.tpl │ │ │ │ └── generator.cc │ │ │ ├── msm/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── algorithms/ │ │ │ │ │ ├── icicle/ │ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ │ ├── icicle_msm.h │ │ │ │ │ │ ├── icicle_msm_bls12_381_g1.cc │ │ │ │ │ │ ├── icicle_msm_bls12_381_g1.h │ │ │ │ │ │ ├── icicle_msm_bls12_381_g2.cc │ │ │ │ │ │ ├── icicle_msm_bls12_381_g2.h │ │ │ │ │ │ ├── icicle_msm_bn254_g1.cc │ │ │ │ │ │ ├── icicle_msm_bn254_g1.h │ │ │ │ │ │ ├── icicle_msm_bn254_g2.cc │ │ │ │ │ │ ├── icicle_msm_bn254_g2.h │ │ │ │ │ │ ├── icicle_msm_utils.cc │ │ │ │ │ │ └── icicle_msm_utils.h │ │ │ │ │ └── pippenger/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── pippenger.h │ │ │ │ │ ├── pippenger_adapter.h │ │ │ │ │ ├── pippenger_adapter_benchmark.cc │ │ │ │ │ ├── pippenger_adapter_unittest.cc │ │ │ │ │ ├── pippenger_base.h │ │ │ │ │ ├── pippenger_benchmark.cc │ │ │ │ │ └── pippenger_unittest.cc │ │ │ │ ├── fixed_base_msm.h │ │ │ │ ├── fixed_base_msm_unittest.cc │ │ │ │ ├── glv.h │ │ │ │ ├── glv_unittest.cc │ │ │ │ ├── msm_ctx.h │ │ │ │ ├── msm_util.h │ │ │ │ ├── test/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── fixed_base_msm_test_set.h │ │ │ │ │ └── variable_base_msm_test_set.h │ │ │ │ ├── variable_base_msm.h │ │ │ │ ├── variable_base_msm_gpu.h │ │ │ │ ├── variable_base_msm_gpu_unittest.cc │ │ │ │ └── variable_base_msm_unittest.cc │ │ │ ├── pairing/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── ell_coeff.h │ │ │ │ ├── g2_prepared_base.h │ │ │ │ ├── g2_projective.h │ │ │ │ ├── pairing.h │ │ │ │ ├── pairing_friendly_curve.h │ │ │ │ ├── pairing_unittest.cc │ │ │ │ └── twist_type.h │ │ │ ├── pasta/ │ │ │ │ ├── pallas/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ └── vesta/ │ │ │ │ └── BUILD.bazel │ │ │ ├── secp/ │ │ │ │ └── secp256k1/ │ │ │ │ └── BUILD.bazel │ │ │ ├── semigroups.h │ │ │ ├── short_weierstrass/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── affine_point.h │ │ │ │ ├── affine_point_correctness_gpu_test.cc │ │ │ │ ├── affine_point_impl.h │ │ │ │ ├── affine_point_unittest.cc │ │ │ │ ├── generator/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── build_defs.bzl │ │ │ │ │ ├── cpu.h.tpl │ │ │ │ │ ├── generator.cc │ │ │ │ │ └── gpu.h.tpl │ │ │ │ ├── jacobian_point.h │ │ │ │ ├── jacobian_point_impl.h │ │ │ │ ├── jacobian_point_unittest.cc │ │ │ │ ├── kernels/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ └── elliptic_curve_ops.cu.h │ │ │ │ ├── non_affine_point_correctness_gpu_test.cc │ │ │ │ ├── point_xyzz.h │ │ │ │ ├── point_xyzz_impl.h │ │ │ │ ├── point_xyzz_unittest.cc │ │ │ │ ├── projective_point.h │ │ │ │ ├── projective_point_impl.h │ │ │ │ ├── projective_point_unittest.cc │ │ │ │ ├── sw_curve.h │ │ │ │ ├── sw_curve_traits_forward.h │ │ │ │ └── test/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── sw_curve_config.h │ │ │ └── test/ │ │ │ ├── BUILD.bazel │ │ │ └── random.h │ │ ├── finite_fields/ │ │ │ ├── BUILD.bazel │ │ │ ├── baby_bear/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── baby_bear.h │ │ │ │ ├── baby_bear4.h │ │ │ │ ├── internal/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── packed_baby_bear.h │ │ │ │ │ ├── packed_baby_bear_avx2.cc │ │ │ │ │ ├── packed_baby_bear_avx2.h │ │ │ │ │ ├── packed_baby_bear_avx512.cc │ │ │ │ │ ├── packed_baby_bear_avx512.h │ │ │ │ │ ├── packed_baby_bear_neon.cc │ │ │ │ │ └── packed_baby_bear_neon.h │ │ │ │ └── packed_baby_bear4.h │ │ │ ├── binary_fields/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── binary_field.h │ │ │ │ ├── binary_field_traits_forward.h │ │ │ │ ├── binary_fields.h │ │ │ │ ├── binary_fields_unittest.cc │ │ │ │ └── binary_tower_operations.h │ │ │ ├── carry_chain.h │ │ │ ├── cubic_extension_field.h │ │ │ ├── cubic_extension_field_unittest.cc │ │ │ ├── cyclotomic_multiplicative_subgroup.h │ │ │ ├── extended_packed_field_traits_forward.h │ │ │ ├── extension_field_base.h │ │ │ ├── extension_field_traits_forward.h │ │ │ ├── finite_field.h │ │ │ ├── finite_field_forwards.h │ │ │ ├── finite_field_traits.h │ │ │ ├── finite_field_unittest.cc │ │ │ ├── fp12.h │ │ │ ├── fp12_unittest.cc │ │ │ ├── fp2.h │ │ │ ├── fp2_unittest.cc │ │ │ ├── fp3.h │ │ │ ├── fp4.h │ │ │ ├── fp6.h │ │ │ ├── fp6_unittest.cc │ │ │ ├── generator/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── binary_field_generator/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── binary_field_config.h.tpl │ │ │ │ │ ├── binary_field_cpu.h.tpl │ │ │ │ │ ├── binary_field_generator.cc │ │ │ │ │ ├── binary_field_gpu.h.tpl │ │ │ │ │ └── build_defs.bzl │ │ │ │ ├── ext_field_generator/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── build_defs.bzl │ │ │ │ │ ├── ext_field_generator.cc │ │ │ │ │ └── fp.h.tpl │ │ │ │ ├── generator_util.cc │ │ │ │ ├── generator_util.h │ │ │ │ └── prime_field_generator/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── build_defs.bzl │ │ │ │ ├── fail.cc.tpl │ │ │ │ ├── fail.h.tpl │ │ │ │ ├── prime_field_config.cc.tpl │ │ │ │ ├── prime_field_config.h.tpl │ │ │ │ ├── prime_field_cpu.h.tpl │ │ │ │ ├── prime_field_generator.cc │ │ │ │ ├── prime_field_gpu.h.tpl │ │ │ │ ├── prime_field_x86.h.tpl │ │ │ │ ├── small_prime_field_config.cc.tpl │ │ │ │ ├── small_prime_field_config.h.tpl │ │ │ │ ├── small_prime_field_cpu.h.tpl │ │ │ │ └── small_prime_field_gpu.h.tpl │ │ │ ├── goldilocks/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── goldilocks.h │ │ │ │ ├── goldilocks_unittest.cc │ │ │ │ └── internal/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── goldilocks_prime_field_x86_special.cc │ │ │ │ └── goldilocks_prime_field_x86_special.h │ │ │ ├── kernels/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── carry_chain.h │ │ │ │ ├── prime_field_ops.cu.h │ │ │ │ └── prime_field_ops_internal.cu.h │ │ │ ├── koala_bear/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── internal/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── packed_koala_bear.h │ │ │ │ │ ├── packed_koala_bear_avx2.cc │ │ │ │ │ ├── packed_koala_bear_avx2.h │ │ │ │ │ ├── packed_koala_bear_avx512.cc │ │ │ │ │ ├── packed_koala_bear_avx512.h │ │ │ │ │ ├── packed_koala_bear_neon.cc │ │ │ │ │ └── packed_koala_bear_neon.h │ │ │ │ ├── koala_bear.h │ │ │ │ ├── koala_bear4.h │ │ │ │ └── packed_koala_bear4.h │ │ │ ├── legendre_symbol.h │ │ │ ├── mersenne31/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── internal/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── packed_mersenne31.h │ │ │ │ │ ├── packed_mersenne31_avx2.cc │ │ │ │ │ ├── packed_mersenne31_avx2.h │ │ │ │ │ ├── packed_mersenne31_avx512.cc │ │ │ │ │ ├── packed_mersenne31_avx512.h │ │ │ │ │ ├── packed_mersenne31_neon.cc │ │ │ │ │ └── packed_mersenne31_neon.h │ │ │ │ └── mersenne31.h │ │ │ ├── modulus.h │ │ │ ├── modulus_unittest.cc │ │ │ ├── packed_field_traits_forward.h │ │ │ ├── packed_prime_field32_avx2.h │ │ │ ├── packed_prime_field32_avx512.h │ │ │ ├── packed_prime_field32_neon.h │ │ │ ├── packed_prime_field_base.h │ │ │ ├── packed_prime_field_unittest.cc │ │ │ ├── prime_field_base.h │ │ │ ├── prime_field_base_unittest.cc │ │ │ ├── prime_field_conversions.h │ │ │ ├── prime_field_correctness_gpu_test.cc │ │ │ ├── prime_field_fallback.h │ │ │ ├── prime_field_generator_unittest.cc │ │ │ ├── prime_field_gpu.h │ │ │ ├── prime_field_gpu_debug.h │ │ │ ├── prime_field_gpu_unittest.cc │ │ │ ├── prime_field_ops_internal.h │ │ │ ├── prime_field_unittest.cc │ │ │ ├── prime_field_util.cc │ │ │ ├── prime_field_util.h │ │ │ ├── quadratic_extension_field.h │ │ │ ├── quadratic_extension_field_unittest.cc │ │ │ ├── quartic_extension_field.h │ │ │ ├── quartic_extension_field_unittest.cc │ │ │ ├── small_prime_field.h │ │ │ ├── small_prime_field_mont.h │ │ │ ├── square_root_algorithms/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── shanks.h │ │ │ │ └── tonelli_shanks.h │ │ │ └── test/ │ │ │ ├── BUILD.bazel │ │ │ └── finite_field_test.h │ │ ├── geometry/ │ │ │ ├── BUILD.bazel │ │ │ ├── affine_point.h │ │ │ ├── curve_type.h │ │ │ ├── dimensions.h │ │ │ ├── dimensions_unittest.cc │ │ │ ├── jacobian_point.h │ │ │ ├── point2.h │ │ │ ├── point2_unittest.cc │ │ │ ├── point3.h │ │ │ ├── point3_unittest.cc │ │ │ ├── point4.h │ │ │ ├── point4_unittest.cc │ │ │ ├── point_conversions.h │ │ │ ├── point_conversions_forward.h │ │ │ ├── point_xyzz.h │ │ │ └── projective_point.h │ │ ├── matrix/ │ │ │ ├── BUILD.bazel │ │ │ ├── cost_calculator_forward.h │ │ │ ├── gmp_num_traits.h │ │ │ ├── matrix_inverse_unittest.cc │ │ │ ├── matrix_operations.h │ │ │ ├── matrix_operations_benchmark.cc │ │ │ ├── matrix_operations_unittest.cc │ │ │ ├── matrix_types.h │ │ │ ├── matrix_types_unittest.cc │ │ │ ├── matrix_utils.h │ │ │ ├── matrix_utils_unittest.cc │ │ │ ├── prime_field_num_traits.h │ │ │ └── sparse/ │ │ │ ├── BUILD.bazel │ │ │ ├── sparse_matrix.h │ │ │ └── sparse_matrix_unittest.cc │ │ ├── polynomials/ │ │ │ ├── BUILD.bazel │ │ │ ├── evaluation_domain.h │ │ │ ├── multivariate/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── linear_combination.h │ │ │ │ ├── linear_combination_term.h │ │ │ │ ├── linear_combination_unittest.cc │ │ │ │ ├── multilinear_dense_evaluations.h │ │ │ │ ├── multilinear_dense_evaluations_unittest.cc │ │ │ │ ├── multilinear_extension.h │ │ │ │ ├── multilinear_extension_ops.h │ │ │ │ ├── multivariate_polynomial.h │ │ │ │ ├── multivariate_polynomial_ops.h │ │ │ │ ├── multivariate_polynomial_unittest.cc │ │ │ │ ├── multivariate_sparse_coefficients.h │ │ │ │ └── support_poly_operators.h │ │ │ ├── polynomial.h │ │ │ ├── polynomial_traits_forward.h │ │ │ ├── support_poly_operators.h │ │ │ └── univariate/ │ │ │ ├── BUILD.bazel │ │ │ ├── evaluations_utils.h │ │ │ ├── fft_algorithm.cc │ │ │ ├── fft_algorithm.h │ │ │ ├── icicle/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── fft_algorithm_conversion.cc │ │ │ │ ├── fft_algorithm_conversion.h │ │ │ │ ├── icicle_ntt.h │ │ │ │ ├── icicle_ntt_baby_bear.cc │ │ │ │ ├── icicle_ntt_baby_bear.h │ │ │ │ ├── icicle_ntt_bls12_381.cc │ │ │ │ ├── icicle_ntt_bls12_381.h │ │ │ │ ├── icicle_ntt_bn254.cc │ │ │ │ ├── icicle_ntt_bn254.h │ │ │ │ └── icicle_ntt_holder.h │ │ │ ├── lagrange_interpolation.h │ │ │ ├── lagrange_interpolation_unittest.cc │ │ │ ├── mixed_radix_evaluation_domain.h │ │ │ ├── naive_batch_fft.h │ │ │ ├── radix2_evaluation_domain.h │ │ │ ├── radix2_evaluation_domain_unittest.cc │ │ │ ├── radix2_twiddle_cache.h │ │ │ ├── support_poly_operators.h │ │ │ ├── two_adic_subgroup.h │ │ │ ├── two_adic_subgroup_traits_forward.h │ │ │ ├── univariate_dense_coefficients.h │ │ │ ├── univariate_dense_polynomial_unittest.cc │ │ │ ├── univariate_evaluation_domain.h │ │ │ ├── univariate_evaluation_domain_factory.h │ │ │ ├── univariate_evaluation_domain_forwards.h │ │ │ ├── univariate_evaluation_domain_gpu_unittest.cc │ │ │ ├── univariate_evaluation_domain_unittest.cc │ │ │ ├── univariate_evaluations.h │ │ │ ├── univariate_evaluations_ops.h │ │ │ ├── univariate_evaluations_unittest.cc │ │ │ ├── univariate_polynomial.h │ │ │ ├── univariate_polynomial_ops.h │ │ │ ├── univariate_sparse_coefficients.h │ │ │ └── univariate_sparse_polynomial_unittest.cc │ │ └── test/ │ │ ├── BUILD.bazel │ │ └── launch_op_macros.h │ ├── node/ │ │ ├── BUILD.bazel │ │ ├── base/ │ │ │ ├── BUILD.bazel │ │ │ ├── node_constructors.cc │ │ │ ├── node_constructors.h │ │ │ ├── node_cpp_bindable.cc │ │ │ ├── node_cpp_bindable.h │ │ │ ├── node_cpp_callable.h │ │ │ ├── node_cpp_callable_data.h │ │ │ ├── node_cpp_class.h │ │ │ ├── node_cpp_constructor.cc │ │ │ ├── node_cpp_constructor.h │ │ │ ├── node_cpp_constructor_matcher.h │ │ │ ├── node_cpp_enum.h │ │ │ ├── node_cpp_object.h │ │ │ ├── node_errors.cc │ │ │ ├── node_errors.h │ │ │ ├── node_internals.h │ │ │ ├── node_internals_forwards.h │ │ │ ├── node_module.cc │ │ │ ├── node_module.h │ │ │ └── test/ │ │ │ ├── BUILD.bazel │ │ │ ├── color.cc │ │ │ ├── color.h │ │ │ ├── enum.cc │ │ │ ├── function.cc │ │ │ ├── point.cc │ │ │ ├── point.h │ │ │ └── test.cc │ │ ├── math/ │ │ │ ├── BUILD.bazel │ │ │ ├── base/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── big_int.h │ │ │ ├── elliptic_curves/ │ │ │ │ ├── bls12/ │ │ │ │ │ └── bls12_381/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── bn/ │ │ │ │ │ └── bn254/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── generator/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── build_defs.bzl │ │ │ │ │ └── generator.cc │ │ │ │ └── short_weierstrass/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── affine_point.h │ │ │ │ ├── jacobian_point.h │ │ │ │ ├── point_xyzz.h │ │ │ │ └── projective_point.h │ │ │ ├── finite_fields/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── prime_field.h │ │ │ ├── math.cc │ │ │ └── math.h │ │ ├── tachyon.cc │ │ └── test/ │ │ ├── .aspect/ │ │ │ └── rules/ │ │ │ └── external_repository_action_cache/ │ │ │ └── npm_translate_lock_LTIxMDEzMjgwMDY= │ │ ├── .bazelignore │ │ ├── .bazelrc │ │ ├── .bazelversion │ │ ├── .prettierrc.js │ │ ├── .swcrc │ │ ├── BUILD.bazel │ │ ├── README.md │ │ ├── WORKSPACE │ │ ├── bazel/ │ │ │ ├── BUILD.bazel │ │ │ ├── tachyon_jest.bzl │ │ │ └── tachyon_ts.bzl │ │ ├── bazelignore │ │ ├── jest.config.js │ │ ├── package.json │ │ ├── src/ │ │ │ ├── base/ │ │ │ │ └── test/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── class.spec.ts │ │ │ │ ├── enum.spec.ts │ │ │ │ └── function.spec.ts │ │ │ └── math/ │ │ │ ├── elliptic_curves/ │ │ │ │ └── short_weierstrass/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── affine_point.spec.ts │ │ │ │ ├── jacobian_point.spec.ts │ │ │ │ ├── point_xyzz.spec.ts │ │ │ │ └── projective_point.spec.ts │ │ │ └── finite_fields/ │ │ │ ├── BUILD.bazel │ │ │ └── prime_field.spec.ts │ │ └── tsconfig.json │ ├── py/ │ │ ├── BUILD.bazel │ │ ├── base/ │ │ │ ├── BUILD.bazel │ │ │ └── pybind11.h │ │ ├── math/ │ │ │ ├── BUILD.bazel │ │ │ ├── base/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── big_int.h │ │ │ ├── elliptic_curves/ │ │ │ │ ├── bls12/ │ │ │ │ │ └── bls12_381/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── bn/ │ │ │ │ │ └── bn254/ │ │ │ │ │ └── BUILD.bazel │ │ │ │ ├── generator/ │ │ │ │ │ ├── BUILD.bazel │ │ │ │ │ ├── build_defs.bzl │ │ │ │ │ └── generator.cc │ │ │ │ └── short_weierstrass/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── affine_point.h │ │ │ │ ├── jacobian_point.h │ │ │ │ ├── point_xyzz.h │ │ │ │ └── projective_point.h │ │ │ ├── finite_fields/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── prime_field.h │ │ │ ├── math.cc │ │ │ └── math.h │ │ ├── tachyon.cc │ │ └── test/ │ │ ├── .bazelrc │ │ ├── .bazelversion │ │ ├── BUILD.bazel │ │ ├── WORKSPACE │ │ ├── bazel/ │ │ │ ├── BUILD.bazel │ │ │ └── tachyon_py.bzl │ │ ├── requirements_lock.txt │ │ └── tachyon/ │ │ └── math/ │ │ ├── elliptic_curves/ │ │ │ └── short_weierstrass/ │ │ │ ├── BUILD.bazel │ │ │ ├── affine_point_unittest.py │ │ │ ├── jacobian_point_unittest.py │ │ │ ├── point_xyzz_unittest.py │ │ │ ├── projective_point_unittest.py │ │ │ └── short_weierstrass_unittests.py │ │ └── finite_fields/ │ │ ├── BUILD.bazel │ │ ├── finite_fields_unittests.py │ │ └── prime_field_unittest.py │ ├── rs/ │ │ ├── BUILD.bazel │ │ ├── Cargo.toml │ │ ├── base/ │ │ │ ├── BUILD.bazel │ │ │ ├── container_util.h │ │ │ └── rust_vec.h │ │ └── src/ │ │ ├── lib.rs │ │ └── math/ │ │ ├── base/ │ │ │ └── mod.rs │ │ ├── elliptic_curves/ │ │ │ ├── bn/ │ │ │ │ ├── bn254/ │ │ │ │ │ └── mod.rs │ │ │ │ └── mod.rs │ │ │ ├── mod.rs │ │ │ └── short_weierstrass/ │ │ │ └── mod.rs │ │ ├── finite_fields/ │ │ │ ├── baby_bear/ │ │ │ │ └── mod.rs │ │ │ └── mod.rs │ │ ├── geometry/ │ │ │ └── mod.rs │ │ └── mod.rs │ ├── version.cc │ ├── version.h │ ├── version_unittest.cc │ └── zk/ │ ├── air/ │ │ ├── constraint_system/ │ │ │ ├── BUILD.bazel │ │ │ ├── constraint_system.h │ │ │ ├── constraint_system_unittest.cc │ │ │ └── variable.h │ │ └── expressions/ │ │ ├── BUILD.bazel │ │ ├── air_evaluator.h │ │ ├── expression_factory.h │ │ ├── first_row_expression.h │ │ ├── last_row_expression.h │ │ ├── transition_expression.h │ │ └── variable_expression.h │ ├── base/ │ │ ├── BUILD.bazel │ │ ├── blinded_polynomial.h │ │ ├── blinder.h │ │ ├── blinder_unittest.cc │ │ ├── commitments/ │ │ │ ├── BUILD.bazel │ │ │ ├── gwc_extension.h │ │ │ ├── shplonk_extension.h │ │ │ ├── univariate_polynomial_commitment_scheme_extension.h │ │ │ └── univariate_polynomial_commitment_scheme_extension_traits_forward.h │ │ ├── entities/ │ │ │ ├── BUILD.bazel │ │ │ ├── entity.h │ │ │ ├── prover_base.h │ │ │ └── verifier_base.h │ │ ├── nested_for_loop_openmp_benchmark.cc │ │ ├── parallelize_benchmark.cc │ │ ├── random_field_generator_base.h │ │ ├── rotation.h │ │ ├── rotation_unittest.cc │ │ ├── row_types.h │ │ ├── value.h │ │ └── value_unittest.cc │ ├── expressions/ │ │ ├── BUILD.bazel │ │ ├── constant_expression.h │ │ ├── constant_expression_unittest.cc │ │ ├── evaluator.h │ │ ├── expression.h │ │ ├── expression_factory.h │ │ ├── expression_type.cc │ │ ├── expression_type.h │ │ ├── expression_unittest.cc │ │ ├── negated_expression.h │ │ ├── negated_expression_unittest.cc │ │ ├── product_expression.h │ │ ├── product_expression_unittest.cc │ │ ├── scaled_expression.h │ │ ├── scaled_expression_unittest.cc │ │ ├── sum_expression.h │ │ └── sum_expression_unittest.cc │ ├── lookup/ │ │ ├── BUILD.bazel │ │ ├── argument.h │ │ ├── evaluator.h │ │ ├── halo2/ │ │ │ ├── BUILD.bazel │ │ │ ├── evaluator.h │ │ │ ├── opening_point_set.h │ │ │ ├── permute_expression_pair.h │ │ │ ├── permute_expression_pair_unittest.cc │ │ │ ├── prover.h │ │ │ ├── prover_impl.h │ │ │ ├── scheme.h │ │ │ ├── utils.h │ │ │ ├── verifier.h │ │ │ └── verifier_data.h │ │ ├── log_derivative_halo2/ │ │ │ ├── BUILD.bazel │ │ │ ├── evaluator.h │ │ │ ├── prover.h │ │ │ ├── prover_impl.h │ │ │ ├── scheme.h │ │ │ ├── verifier.h │ │ │ └── verifier_data.h │ │ ├── pair.h │ │ ├── prover.h │ │ ├── type.h │ │ └── verifier.h │ ├── plonk/ │ │ ├── base/ │ │ │ ├── BUILD.bazel │ │ │ ├── column_key.h │ │ │ ├── column_key_unittest.cc │ │ │ ├── column_type.cc │ │ │ ├── column_type.h │ │ │ ├── l_values.h │ │ │ ├── multi_phase_evaluations.h │ │ │ ├── multi_phase_owned_table.h │ │ │ ├── multi_phase_ref_table.h │ │ │ ├── owned_table.h │ │ │ ├── phase.h │ │ │ ├── phase_unittest.cc │ │ │ ├── ref_table.h │ │ │ ├── ref_table_unittest.cc │ │ │ └── table_base.h │ │ ├── constraint_system/ │ │ │ ├── BUILD.bazel │ │ │ ├── challenge.h │ │ │ ├── circuit.h │ │ │ ├── constraint.h │ │ │ ├── constraint_system.h │ │ │ ├── constraint_system_unittest.cc │ │ │ ├── exclusion_matrix.h │ │ │ ├── exclusion_matrix_unittest.cc │ │ │ ├── gate.h │ │ │ ├── lookup_tracker.h │ │ │ ├── query.h │ │ │ ├── selector.h │ │ │ ├── selector_assignment.h │ │ │ ├── selector_compressor.h │ │ │ ├── selector_compressor_unittest.cc │ │ │ ├── selector_description.h │ │ │ ├── selector_description_unittest.cc │ │ │ ├── selector_unittest.cc │ │ │ ├── virtual_cell.h │ │ │ └── virtual_cells.h │ │ ├── examples/ │ │ │ ├── BUILD.bazel │ │ │ ├── circuit_test.h │ │ │ ├── circuit_test_data.h │ │ │ ├── circuit_test_type_traits.h │ │ │ ├── fibonacci/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── README.md │ │ │ │ ├── fibonacci1_circuit.h │ │ │ │ ├── fibonacci1_circuit_test.cc │ │ │ │ ├── fibonacci1_circuit_test_data.h │ │ │ │ ├── fibonacci2_circuit.h │ │ │ │ ├── fibonacci2_circuit_test.cc │ │ │ │ ├── fibonacci2_circuit_test_data.h │ │ │ │ ├── fibonacci3_circuit.h │ │ │ │ ├── fibonacci3_circuit_test.cc │ │ │ │ ├── fibonacci3_circuit_test_data.h │ │ │ │ └── is_zero_chip.h │ │ │ ├── multi_lookup_circuit.h │ │ │ ├── multi_lookup_circuit_test.cc │ │ │ ├── multi_lookup_circuit_test_data.h │ │ │ ├── point.h │ │ │ ├── shuffle_api_circuit.h │ │ │ ├── shuffle_api_circuit_test.cc │ │ │ ├── shuffle_api_circuit_test_data.h │ │ │ ├── shuffle_circuit.h │ │ │ ├── shuffle_circuit_test.cc │ │ │ ├── shuffle_circuit_test_data.h │ │ │ ├── simple_circuit.h │ │ │ ├── simple_circuit_test.cc │ │ │ ├── simple_circuit_test_data.h │ │ │ ├── simple_lookup_circuit.h │ │ │ ├── simple_lookup_circuit_test.cc │ │ │ ├── simple_lookup_circuit_test_data.h │ │ │ └── tracking_testing.md │ │ ├── expressions/ │ │ │ ├── BUILD.bazel │ │ │ ├── advice_expression.h │ │ │ ├── advice_expression_unittest.cc │ │ │ ├── challenge_expression.h │ │ │ ├── challenge_expression_unittest.cc │ │ │ ├── compress_expression.h │ │ │ ├── compress_expression_unittest.cc │ │ │ ├── evaluator/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── cells_querier.h │ │ │ │ ├── identifier.h │ │ │ │ ├── selector_replacer.h │ │ │ │ ├── selector_replacer_unittest.cc │ │ │ │ ├── simple_selector_extractor.h │ │ │ │ ├── simple_selector_extractor_unittest.cc │ │ │ │ ├── simple_selector_finder.h │ │ │ │ ├── simple_selector_finder_unittest.cc │ │ │ │ └── test/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── evaluator_test.h │ │ │ ├── expression_factory.h │ │ │ ├── expression_unittest.cc │ │ │ ├── fixed_expression.h │ │ │ ├── fixed_expression_unittest.cc │ │ │ ├── instance_expression.h │ │ │ ├── instance_expression_unittest.cc │ │ │ ├── proving_evaluator.h │ │ │ ├── proving_evaluator_unittest.cc │ │ │ ├── selector_expression.h │ │ │ ├── selector_expression_unittest.cc │ │ │ ├── test/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── compress_expression_test.h │ │ │ └── verifying_evaluator.h │ │ ├── halo2/ │ │ │ ├── BUILD.bazel │ │ │ ├── README.md │ │ │ ├── argument_data.h │ │ │ ├── argument_data_unittest.cc │ │ │ ├── blake2b_transcript.h │ │ │ ├── blake2b_transcript_unittest.cc │ │ │ ├── bn254_gwc_prover_test.h │ │ │ ├── bn254_shplonk_prover_test.h │ │ │ ├── c_prover_impl_base_forward.h │ │ │ ├── config.cc │ │ │ ├── config.h │ │ │ ├── constants.h │ │ │ ├── pcs_type.h │ │ │ ├── pinned_constraint_system.h │ │ │ ├── pinned_evaluation_domain.h │ │ │ ├── pinned_gates.h │ │ │ ├── pinned_verifying_key.h │ │ │ ├── pinned_verifying_key_forward.h │ │ │ ├── poseidon_transcript.h │ │ │ ├── poseidon_transcript_unittest.cc │ │ │ ├── prime_field_conversion.h │ │ │ ├── prime_field_conversion_unittest.cc │ │ │ ├── proof.h │ │ │ ├── proof_reader.h │ │ │ ├── proof_serializer.h │ │ │ ├── proof_serializer_unittest.cc │ │ │ ├── proof_unittest.cc │ │ │ ├── prover.h │ │ │ ├── prover_test.h │ │ │ ├── proving_scheme.h │ │ │ ├── random_field_generator.h │ │ │ ├── random_field_generator_unittest.cc │ │ │ ├── sha256_transcript.h │ │ │ ├── sha256_transcript_unittest.cc │ │ │ ├── snark_verifier_poseidon_transcript.h │ │ │ ├── snark_verifier_poseidon_transcript_unittest.cc │ │ │ ├── stringifiers/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── challenge_stringifier.h │ │ │ │ ├── column_key_stringifier.h │ │ │ │ ├── column_type_stringifier.h │ │ │ │ ├── expression_stringifier.h │ │ │ │ ├── field_stringifier.h │ │ │ │ ├── lookup_argument_stringifier.h │ │ │ │ ├── lookup_tracker_stringifier.h │ │ │ │ ├── permutation_argument_stringifier.h │ │ │ │ ├── permutation_verifying_key_stringifier.h │ │ │ │ ├── phase_stringifier.h │ │ │ │ ├── point_stringifier.h │ │ │ │ ├── query_stringifier.h │ │ │ │ ├── rotation_stringifier.h │ │ │ │ ├── selector_stringifier.h │ │ │ │ └── shuffle_argument_stringifier.h │ │ │ ├── synthesizer.h │ │ │ ├── transcript_type.h │ │ │ ├── vendor.cc │ │ │ ├── vendor.h │ │ │ ├── verifier.h │ │ │ ├── witness_collection.h │ │ │ └── witness_collection_unittest.cc │ │ ├── keys/ │ │ │ ├── BUILD.bazel │ │ │ ├── assembly.h │ │ │ ├── c_proving_key_impl_forward.h │ │ │ ├── key.h │ │ │ ├── proving_key.h │ │ │ ├── proving_key_forward.h │ │ │ └── verifying_key.h │ │ ├── layout/ │ │ │ ├── BUILD.bazel │ │ │ ├── assigned_cell.h │ │ │ ├── assignment.h │ │ │ ├── cell.h │ │ │ ├── floor_planner/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── allocated_region.h │ │ │ │ ├── allocations.h │ │ │ │ ├── constant.h │ │ │ │ ├── empty_space.h │ │ │ │ ├── floor_planner.h │ │ │ │ ├── lookup_table_assigner.h │ │ │ │ ├── plan_region.h │ │ │ │ ├── scoped_region.h │ │ │ │ ├── simple_floor_planner.h │ │ │ │ ├── simple_lookup_table_layouter.h │ │ │ │ ├── single_chip_layouter.h │ │ │ │ └── v1/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── assignment_pass.h │ │ │ │ ├── measurement_pass.h │ │ │ │ ├── v1_floor_planner.h │ │ │ │ ├── v1_pass.h │ │ │ │ ├── v1_plan.h │ │ │ │ ├── v1_strategy.cc │ │ │ │ └── v1_strategy.h │ │ │ ├── layouter.h │ │ │ ├── lookup_table.h │ │ │ ├── lookup_table_column.h │ │ │ ├── lookup_table_column_unittest.cc │ │ │ ├── namespaced_layouter.h │ │ │ ├── region.h │ │ │ ├── region_column.h │ │ │ ├── region_column_unittest.cc │ │ │ ├── region_layouter.h │ │ │ └── region_shape.h │ │ ├── permutation/ │ │ │ ├── BUILD.bazel │ │ │ ├── cycle_store.cc │ │ │ ├── cycle_store.h │ │ │ ├── cycle_store_unittest.cc │ │ │ ├── grand_product_argument.h │ │ │ ├── label.h │ │ │ ├── permutation_argument.h │ │ │ ├── permutation_argument_unittest.cc │ │ │ ├── permutation_assembly.h │ │ │ ├── permutation_assembly_unittest.cc │ │ │ ├── permutation_evaluator.h │ │ │ ├── permutation_opening_point_set.h │ │ │ ├── permutation_prover.h │ │ │ ├── permutation_prover_impl.h │ │ │ ├── permutation_proving_key.h │ │ │ ├── permutation_table_store.h │ │ │ ├── permutation_table_store_unittest.cc │ │ │ ├── permutation_utils.h │ │ │ ├── permutation_utils_unittest.cc │ │ │ ├── permutation_verifier.h │ │ │ ├── permutation_verifier_data.h │ │ │ ├── permutation_verifying_key.h │ │ │ ├── permuted_table.h │ │ │ ├── unpermuted_table.h │ │ │ └── unpermuted_table_unittest.cc │ │ └── vanishing/ │ │ ├── BUILD.bazel │ │ ├── calculation.cc │ │ ├── calculation.h │ │ ├── circuit_polynomial_builder.h │ │ ├── circuit_polynomial_builder_forward.h │ │ ├── custom_gate_evaluator.h │ │ ├── evaluation_input.h │ │ ├── graph_evaluator.h │ │ ├── graph_evaluator_unittest.cc │ │ ├── value_source.cc │ │ ├── value_source.h │ │ ├── value_source_unittest.cc │ │ ├── vanishing_argument.h │ │ ├── vanishing_prover.h │ │ ├── vanishing_prover_impl.h │ │ ├── vanishing_utils.h │ │ ├── vanishing_utils_unittest.cc │ │ ├── vanishing_verifier.h │ │ └── vanishing_verifier_data.h │ ├── r1cs/ │ │ ├── constraint_system/ │ │ │ ├── BUILD.bazel │ │ │ ├── circuit.h │ │ │ ├── constraint_matrices.h │ │ │ ├── constraint_system.h │ │ │ ├── constraint_system_unittest.cc │ │ │ ├── linear_combination.h │ │ │ ├── linear_combination_unittest.cc │ │ │ ├── matrix.h │ │ │ ├── optimization_goal.h │ │ │ ├── qap_instance_map_result.h │ │ │ ├── qap_witness_map_result.h │ │ │ ├── quadratic_arithmetic_program.h │ │ │ ├── synthesis_mode.h │ │ │ ├── term.h │ │ │ ├── test/ │ │ │ │ ├── BUILD.bazel │ │ │ │ └── simple_circuit.h │ │ │ ├── variable.cc │ │ │ ├── variable.h │ │ │ └── variable_unittest.cc │ │ └── groth16/ │ │ ├── BUILD.bazel │ │ ├── groth16_unittest.cc │ │ ├── key.h │ │ ├── prepared_verifying_key.h │ │ ├── proof.h │ │ ├── prove.h │ │ ├── proving_key.h │ │ ├── toxic_waste.h │ │ ├── verify.h │ │ └── verifying_key.h │ └── shuffle/ │ ├── BUILD.bazel │ ├── argument.h │ ├── evaluator.h │ ├── opening_point_set.h │ ├── pair.h │ ├── prover.h │ ├── prover_impl.h │ ├── utils.h │ ├── verifier.h │ └── verifier_data.h ├── third_party/ │ ├── BUILD.bazel │ ├── absl/ │ │ ├── BUILD.bazel │ │ ├── add_missing_linkopts.patch │ │ └── ignore-maybe-uninitialized-warning.patch │ ├── boringssl/ │ │ ├── BUILD.bazel │ │ ├── blake2b512.patch │ │ └── chacha_core.patch │ ├── circomlib/ │ │ ├── BUILD.bazel │ │ └── workspace.bzl │ ├── clang_toolchain/ │ │ ├── BUILD.bazel │ │ ├── cc_configure_clang.bzl │ │ └── download_clang.bzl │ ├── cxx_rs/ │ │ ├── BUILD.bazel │ │ └── add_more_args_to_cxx_bridge.patch │ ├── doxygen/ │ │ ├── BUILD.bazel │ │ ├── doxygen_archive.BUILD │ │ └── workspace.bzl │ ├── eigen3/ │ │ ├── BUILD.bazel │ │ ├── Eigen/ │ │ │ ├── Cholesky │ │ │ ├── Core │ │ │ ├── Eigenvalues │ │ │ ├── LU │ │ │ ├── OrderingMethods │ │ │ ├── QR │ │ │ ├── SVD │ │ │ ├── SparseCholesky │ │ │ └── SparseCore │ │ ├── LICENSE │ │ ├── README.md │ │ ├── add_sfinae_to_num_traits.patch │ │ ├── add_sfinae_to_scalar_random_op.patch │ │ ├── allow_field_inverse.patch │ │ ├── eigen_archive.BUILD │ │ ├── unsupported/ │ │ │ └── Eigen/ │ │ │ ├── CXX11/ │ │ │ │ ├── Tensor │ │ │ │ └── ThreadPool │ │ │ ├── MatrixFunctions │ │ │ └── SpecialFunctions │ │ ├── use_faster_constant_method.patch │ │ └── workspace.bzl │ ├── env/ │ │ ├── BUILD.bazel │ │ ├── env.bzl.tpl │ │ └── env_configure.bzl │ ├── ffiasm/ │ │ ├── BUILD.bazel │ │ ├── build_defs.bzl │ │ ├── ffiasm.BUILD │ │ └── workspace.bzl │ ├── glog/ │ │ ├── BUILD.bazel │ │ ├── enable_constexpr_check_op.patch │ │ └── enable_elaborate_ostream_operator.patch │ ├── gmp/ │ │ ├── BUILD.bazel │ │ ├── gmp.BUILD │ │ ├── gmp.BUILD.tpl │ │ └── gmp_configure.bzl │ ├── goldilocks/ │ │ ├── BUILD.bazel │ │ ├── goldilocks.BUILD │ │ └── workspace.bzl │ ├── gpus/ │ │ ├── BUILD.bazel │ │ ├── check_cuda_libs.py │ │ ├── compress_find_cuda_config.py │ │ ├── compress_find_rocm_config.py │ │ ├── crosstool/ │ │ │ ├── BUILD.bazel │ │ │ ├── BUILD.rocm.tpl │ │ │ ├── BUILD.tpl │ │ │ ├── LICENSE │ │ │ ├── cc_toolchain_config.bzl.tpl │ │ │ ├── clang/ │ │ │ │ └── bin/ │ │ │ │ ├── crosstool_wrapper_driver_is_not_gcc.tpl │ │ │ │ └── crosstool_wrapper_driver_rocm.tpl │ │ │ ├── hipcc_cc_toolchain_config.bzl.tpl │ │ │ └── windows/ │ │ │ └── msvc_wrapper_for_nvcc.py.tpl │ │ ├── cuda/ │ │ │ ├── BUILD.bazel │ │ │ ├── BUILD.tpl │ │ │ ├── BUILD.windows.tpl │ │ │ ├── LICENSE │ │ │ ├── build_defs.bzl.tpl │ │ │ ├── cuda_config.h.tpl │ │ │ └── cuda_config.py.tpl │ │ ├── cuda_configure.bzl │ │ ├── find_cuda_config.py │ │ ├── find_cuda_config.py.gz.base64 │ │ ├── find_rocm_config.py │ │ ├── find_rocm_config.py.gz.base64 │ │ ├── local_config_cuda.BUILD │ │ ├── rocm/ │ │ │ ├── BUILD.bazel │ │ │ ├── BUILD.tpl │ │ │ ├── build_defs.bzl.tpl │ │ │ └── rocm_config.h.tpl │ │ └── rocm_configure.bzl │ ├── gtest/ │ │ ├── BUILD.bazel │ │ ├── add_missing_linkopts.patch │ │ └── print_with_to_string.patch │ ├── hwloc/ │ │ ├── BUILD.bazel │ │ ├── BUILD.system │ │ ├── hwloc.BUILD │ │ ├── static-components.h │ │ └── workspace.bzl │ ├── icicle/ │ │ ├── BUILD.bazel │ │ ├── build_defs.bzl │ │ ├── change_sort_function.patch │ │ ├── fix_first_digest_copy_bug.patch │ │ ├── icicle.BUILD │ │ ├── inlinize.patch │ │ ├── pragma.patch │ │ ├── remove_kernels_from_header.patch │ │ ├── rename.patch │ │ ├── separate_hash_config.patch │ │ ├── separate_merkle_tree_config.patch │ │ ├── separate_msm_config.patch │ │ ├── separate_ntt_algorithm.patch │ │ └── workspace.bzl │ ├── json/ │ │ ├── BUILD.bazel │ │ └── workspace.bzl │ ├── matplotlibcpp17/ │ │ ├── BUILD.bazel │ │ └── matplotlibcpp17.BUILD │ ├── nasm/ │ │ ├── BUILD.bazel │ │ ├── BUILD.system │ │ ├── config.h │ │ ├── nasm.BUILD │ │ └── workspace.bzl │ ├── node_addon_api/ │ │ ├── BUILD.bazel │ │ ├── BUILD.tpl │ │ ├── install_node_addon_api.bzl │ │ └── package.json │ ├── omp/ │ │ ├── BUILD.bazel │ │ ├── omp.BUILD │ │ └── omp_configure.bzl │ ├── pdqsort/ │ │ ├── BUILD.bazel │ │ ├── pdqsort.BUILD │ │ └── workspace.bzl │ ├── perfetto/ │ │ └── perfetto.BUILD │ ├── powersort/ │ │ ├── BUILD.bazel │ │ ├── fix_multiple_definitions.patch │ │ ├── fix_sign_compare_warning.patch │ │ ├── fix_static_assertion.patch │ │ ├── powersort.BUILD │ │ ├── remove_binary_function.patch │ │ └── workspace.bzl │ ├── py/ │ │ ├── BUILD.bazel │ │ ├── BUILD.tpl │ │ ├── numpy/ │ │ │ ├── BUILD │ │ │ └── LICENSE │ │ └── python_configure.bzl │ ├── rapidjson/ │ │ └── rapidjson.BUILD │ ├── rapidsnark/ │ │ ├── BUILD.bazel │ │ ├── nozk.patch │ │ ├── rapidsnark.BUILD │ │ └── workspace.bzl │ ├── remote_config/ │ │ ├── BUILD.bazel │ │ ├── BUILD.tpl │ │ ├── common.bzl │ │ └── remote_platform_configure.bzl │ └── repo.bzl └── vendors/ ├── circom/ │ ├── .bazelrc │ ├── .bazelversion │ ├── .gitignore │ ├── BUILD.bazel │ ├── README.md │ ├── WORKSPACE │ ├── benchmark/ │ │ ├── BUILD.bazel │ │ ├── README.md │ │ ├── bit_conversion.h │ │ ├── circom_benchmark.cc │ │ ├── rapidsnark_runner.h │ │ ├── runner.h │ │ ├── sha256_512.circom │ │ ├── sha256_512.zkey │ │ ├── sha256_512_verification_key.json │ │ └── tachyon_runner.h │ ├── build_defs.bzl │ ├── circom.BUILD │ ├── circomlib/ │ │ ├── CPPLINT.cfg │ │ ├── base/ │ │ │ ├── BUILD.bazel │ │ │ ├── fr_element_conversion.h │ │ │ ├── modulus.cc │ │ │ ├── modulus.h │ │ │ ├── modulus_unittest.cc │ │ │ ├── sections.h │ │ │ └── sections_unittest.cc │ │ ├── circuit/ │ │ │ ├── BUILD.bazel │ │ │ ├── adder_circuit_unittest.cc │ │ │ ├── adder_data.json │ │ │ ├── circuit.h │ │ │ ├── circuit_test.h │ │ │ ├── multiplier_3_circuit_unittest.cc │ │ │ ├── multiplier_3_data.json │ │ │ ├── quadratic_arithmetic_program.h │ │ │ └── witness_loader.h │ │ ├── generated/ │ │ │ ├── .clang-format │ │ │ ├── BUILD.bazel │ │ │ ├── README.md │ │ │ ├── bls12381/ │ │ │ │ └── BUILD.bazel │ │ │ ├── bn128/ │ │ │ │ └── BUILD.bazel │ │ │ ├── common/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── calcwit.cpp │ │ │ │ ├── calcwit.cpp.diff │ │ │ │ ├── calcwit.hpp │ │ │ │ ├── calcwit.hpp.diff │ │ │ │ ├── circom.hpp │ │ │ │ └── circom.hpp.diff │ │ │ ├── goldilocks/ │ │ │ │ └── BUILD.bazel │ │ │ ├── grumpkin/ │ │ │ │ └── BUILD.bazel │ │ │ ├── pallas/ │ │ │ │ └── BUILD.bazel │ │ │ ├── secq256r1/ │ │ │ │ └── BUILD.bazel │ │ │ └── vesta/ │ │ │ └── BUILD.bazel │ │ ├── json/ │ │ │ ├── BUILD.bazel │ │ │ ├── groth16_proof.h │ │ │ ├── groth16_proof_unittest.cc │ │ │ ├── json.h │ │ │ ├── json_converter_forward.h │ │ │ ├── points.h │ │ │ ├── prime_field.h │ │ │ └── prime_field_unittest.cc │ │ ├── r1cs/ │ │ │ ├── BUILD.bazel │ │ │ ├── constraint.h │ │ │ ├── r1cs.cc │ │ │ ├── r1cs.h │ │ │ └── r1cs_unittest.cc │ │ ├── wtns/ │ │ │ ├── BUILD.bazel │ │ │ ├── multiplier_3.wtns │ │ │ ├── wtns.cc │ │ │ ├── wtns.h │ │ │ └── wtns_unittest.cc │ │ └── zkey/ │ │ ├── BUILD.bazel │ │ ├── coefficient.h │ │ ├── proving_key.h │ │ ├── verifying_key.h │ │ ├── zkey.cc │ │ ├── zkey.h │ │ └── zkey_unittest.cc │ ├── examples/ │ │ ├── BUILD.bazel │ │ ├── adder.circom │ │ ├── adder.zkey │ │ ├── compute_witness_multiplier_3.cc │ │ ├── multiplier_2.circom │ │ ├── multiplier_3.circom │ │ ├── multiplier_3.zkey │ │ └── multiplier_n.circom │ └── prover_main.cc ├── plonky3/ │ ├── BUILD.bazel │ ├── Cargo.toml │ ├── include/ │ │ └── baby_bear_row_major_matrix.h │ └── src/ │ ├── baby_bear.rs │ ├── baby_bear_row_major_matrix.cc │ ├── lib.rs │ └── row_major_matrix.rs ├── scroll_halo2/ │ ├── BUILD.bazel │ ├── Cargo.toml │ ├── README.md │ ├── include/ │ │ ├── bn254_blake2b_writer.h │ │ ├── bn254_evals.h │ │ ├── bn254_msm.h │ │ ├── bn254_msm_gpu.h │ │ ├── bn254_poly.h │ │ ├── bn254_poseidon_writer.h │ │ ├── bn254_prover.h │ │ ├── bn254_proving_key.h │ │ ├── bn254_rational_evals.h │ │ ├── bn254_rational_evals_view.h │ │ ├── bn254_sha256_writer.h │ │ ├── bn254_snark_verifier_poseidon_writer.h │ │ ├── cha_cha20_rng.h │ │ └── xor_shift_rng.h │ └── src/ │ ├── bn254.rs │ ├── bn254_blake2b_writer.cc │ ├── bn254_evals.cc │ ├── bn254_msm.cc │ ├── bn254_msm_gpu.cc │ ├── bn254_poly.cc │ ├── bn254_poseidon_writer.cc │ ├── bn254_prover.cc │ ├── bn254_proving_key.cc │ ├── bn254_rational_evals.cc │ ├── bn254_rational_evals_view.cc │ ├── bn254_sha256_writer.cc │ ├── bn254_snark_verifier_poseidon_writer.cc │ ├── cha_cha20_rng.cc │ ├── cha_cha20_rng.rs │ ├── circuits/ │ │ ├── mod.rs │ │ ├── shuffle_circuit.rs │ │ ├── simple_circuit.rs │ │ └── simple_lookup_circuit.rs │ ├── consts.rs │ ├── lib.rs │ ├── msm.rs │ ├── prover.rs │ ├── proving_key.rs │ ├── rng.rs │ ├── sha.rs │ ├── transcript.rs │ ├── xor_shift_rng.cc │ └── xor_shift_rng.rs └── sp1/ ├── BUILD.bazel ├── Cargo.toml ├── include/ │ ├── baby_bear_poseidon2_commitment_vec.h │ ├── baby_bear_poseidon2_domains.h │ ├── baby_bear_poseidon2_duplex_challenger.h │ ├── baby_bear_poseidon2_fri_proof.h │ ├── baby_bear_poseidon2_lde_vec.h │ ├── baby_bear_poseidon2_opened_values.h │ ├── baby_bear_poseidon2_opening_points.h │ ├── baby_bear_poseidon2_opening_proof.h │ ├── baby_bear_poseidon2_prover_data.h │ ├── baby_bear_poseidon2_prover_data_vec.h │ └── baby_bear_poseidon2_two_adic_fri_pcs.h └── src/ ├── baby_bear_poseidon2.rs ├── baby_bear_poseidon2_commitment_vec.cc ├── baby_bear_poseidon2_domains.cc ├── baby_bear_poseidon2_duplex_challenger.cc ├── baby_bear_poseidon2_fri_proof.cc ├── baby_bear_poseidon2_lde_vec.cc ├── baby_bear_poseidon2_opened_values.cc ├── baby_bear_poseidon2_opening_points.cc ├── baby_bear_poseidon2_opening_proof.cc ├── baby_bear_poseidon2_prover_data.cc ├── baby_bear_poseidon2_prover_data_vec.cc ├── baby_bear_poseidon2_two_adic_fri_pcs.cc ├── challenger.rs ├── lib.rs ├── two_adic_fri_pcs.rs └── util.rs ================================================ FILE CONTENTS ================================================ ================================================ FILE: .bazelignore ================================================ tachyon/node/test tachyon/py/test vendors/circom ================================================ FILE: .bazelrc ================================================ # Tachyon Bazel configuration file. # This file tries to group and simply build option for Tachyon # # ----CONFIG OPTIONS---- # # Other build options: # dbg: Build with debug info # # Hardware support options: # cuda: Build with NVIDIA GPU support (cuda). # rocm: Build with AMD GPU support (rocm). # numa: Enable numa using hwloc. # # Default build options. These are applied first and unconditionally. # For projects which use Tachyon as part of a Bazel build process, putting # nothing in a bazelrc will default to a monolithic build. The following line # opts in to modular op registration support by default. build -c opt # Make Bazel print out all options from rc files. build --announce_rc # TODO(chokobole): Remove when `cc_shared_library` is enabled by default build --experimental_cc_shared_library # Enable platform specific configurations by default depending on host machine. common --enable_platform_specific_config build:macos_x86_64 --config=macos build:macos_x86_64 --cpu=darwin_x86_64 build:macos_x86_64 --host_cpu=darwin_x86_64 build:macos_arm64 --config=macos build:macos_arm64 --cpu=darwin_arm64 build:macos_arm64 --host_cpu=darwin_arm64 # This config refers to building sources with nvcc. build:cuda --repo_env TACHYON_NEED_CUDA=1 build:cuda --crosstool_top=@local_config_cuda//crosstool:toolchain build:cuda --@local_config_cuda//:enable_cuda build:cuda --//:has_rtti # This config refers to building sources with clang. # NOTE(chokobole): I didn't test it, though! build:cuda_clang --config=cuda build:cuda_clang --repo_env TACHYON_CUDA_CLANG=1 build:cuda_clang --@local_config_cuda//:cuda_compiler=clang # This config refers to building sources kernels. build:rocm --crosstool_top=@local_config_rocm//crosstool:toolchain build:rocm --define=using_rocm_hipcc=true build:rocm --define=tensorflow_mkldnn_contraction_kernel=0 build:rocm --repo_env TACHYON_NEED_ROCM=1 # Options extracted from configure script build:numa --//:has_numa # Fastbuild config build:fastbuild -c fastbuild # Debug config build:dbg -c dbg # Opt config build:opt -c opt build:opt --//:has_openmp build:maxopt -c opt build:maxopt --//:has_openmp build:maxopt --config=native build:maxopt --copt=-flto build:maxopt --linkopt=-flto # By default, build Tachyon in C++ 17 mode. build:linux --cxxopt=-std=c++17 build:linux --host_cxxopt=-std=c++17 build:macos --cxxopt=-std=c++17 build:macos --host_cxxopt=-std=c++17 build:macos --objccopt=-std=c++17 build:windows --cxxopt=/std:c++17 build:windows --host_cxxopt=/std:c++17 # Instruction set optimizations # TODO(chokobole): Create a feature in toolchains for avx/avx2 to # avoid having to define linux/win separately. build:avx_linux --copt=-mavx build:avx2_linux --copt=-mavx2 build:avx512_linux --copt=-mavx512f build:avx_windows --copt=/arch=AVX build:avx2_windows --copt=/arch=AVX2 build:avx512_windows --copt=/arch=AVX512 # Compile for the native architecture # WARN(batzor): this will make the build non-portable build:native --copt=-march=native # Enable googletest build with absl. # See https://github.com/google/googletest/blob/v1.13.0/BUILD.bazel#L67C1-L70 build --define absl=1 # FIXME(chokobole): If this option is enabled, gtest cannot be built with nvcc. build:cuda --define absl=0 # gmp needs exception. build --//:has_exception test --test_tag_filters -benchmark,-manual,-cuda,-rust # TODO(GideokKim): Currently, NTT operates assuming that GPU memory is always # sufficient. Until the issue is resolved, add a tag to manually test in cuda # tests. test:cuda --test_tag_filters -benchmark,-manual,-cuda,-rust,-gpu_heavy_test build:linux --build_tag_filters -objc,-cuda,-rust build:macos --build_tag_filters -cuda,-rust,-doxygen build:windows --build_tag_filters -objc,-cuda,-rust,-doxygen # Config-specific options should come above this line. # Load rc file with user-specific options. try-import %workspace%/.bazelrc.user ================================================ FILE: .bazelversion ================================================ 6.3.0 ================================================ FILE: .clang-format ================================================ BasedOnStyle: Google # This defaults to 'Auto'. Explicitly set it for a while, so that # 'vector >' in existing files gets formatted to # 'vector>'. ('Auto' means that clang-format will only use # 'int>>' if the file already contains at least one such instance.) Standard: Cpp11 # Specify the #include statement order. This implements the order mandated by # the Google C++ Style Guide: related header, C headers, C++ headers, library # headers, and finally the project headers. # # To obtain updated lists of system headers used in the below expressions, see: # http://stackoverflow.com/questions/2027991/list-of-standard-header-files-in-c-and-c/2029106#2029106. # # Reference URL: https://github.com/RobotLocomotion/drake/blob/master/.clang-format IncludeBlocks: Regroup IncludeCategories: # C system headers. The header_dependency_test.py contains a copy of this # list; be sure to update that test anytime this list changes. - Regex: '^[<"](aio|arm_neon|arpa/inet|assert|complex|cpio|ctype|curses|dirent|dlfcn|errno|fcntl|fenv|float|fmtmsg|fnmatch|ftw|glob|grp|iconv|immintrin|inttypes|iso646|langinfo|libgen|limits|locale|math|monetary|mqueue|ndbm|netdb|net/if|netinet/in|netinet/tcp|nl_types|poll|pthread|pwd|regex|sched|search|semaphore|setjmp|signal|spawn|stdalign|stdarg|stdatomic|stdbool|stddef|stdint|stdio|stdlib|stdnoreturn|string|strings|stropts|sys/ioctl|sys/ipc|syslog|sys/mman|sys/msg|sys/resource|sys/select|sys/sem|sys/shm|sys/socket|sys/stat|sys/statvfs|sys/time|sys/times|sys/types|sys/uio|sys/un|sys/utsname|sys/wait|tar|term|termios|tgmath|threads|time|trace|uchar|ulimit|uncntrl|unistd|utime|utmpx|wchar|wctype|wordexp)\.h[">]$' Priority: 20 # C++ system headers (as of C++23). The header_dependency_test.py contains a # copy of this list; be sure to update that test anytime this list changes. - Regex: '^[<"](algorithm|any|array|atomic|barrier|bit|bitset|cassert|ccomplex|cctype|cerrno|cfenv|cfloat|charconv|chrono|cinttypes|ciso646|climits|clocale|cmath|codecvt|compare|complex|concepts|condition_variable|coroutine|csetjmp|csignal|cstdalign|cstdarg|cstdbool|cstddef|cstdint|cstdio|cstdlib|cstring|ctgmath|ctime|cuchar|cwchar|cwctype|deque|exception|execution|expected|filesystem|flat_map|flat_set|format|forward_list|fstream|functional|future|generator|initializer_list|iomanip|ios|iosfwd|iostream|istream|iterator|latch|limits|list|locale|map|mdspan|memory|memory_resource|mutex|new|numbers|numeric|optional|ostream|print|queue|random|ranges|ratio|regex|scoped_allocator|semaphore|set|shared_mutex|source_location|span|spanstream|sstream|stack|stacktrace|stdexcept|stdfloat|stop_token|streambuf|string|string_view|strstream|syncstream|system_error|thread|tuple|type_traits|typeindex|typeinfo|unordered_map|unordered_set|utility|valarray|variant|vector|version)[">]$' Priority: 30 # Other libraries' h files (with angles). - Regex: '^<' Priority: 40 # Your project's h files. - Regex: '^"(circomlib|tachyon|vendors)' Priority: 50 # Other libraries' h files (with quotes). - Regex: '^"' Priority: 40 ================================================ FILE: .dockerignore ================================================ # Created by https://www.toptal.com/developers/gitignore/api/c++,vim,bazel,linux,macos,python,visualstudiocode,node # Edit at https://www.toptal.com/developers/gitignore?templates=c++,vim,bazel,linux,macos,python,visualstudiocode,node ### Bazel ### # gitignore template for Bazel build system # website: https://bazel.build/ # Ignore all bazel-* symlinks. There is no full list since this can change # based on the name of the directory bazel is cloned into. /bazel-* # Directories for the Bazel IntelliJ plugin containing the generated # IntelliJ project files and plugin configuration. Seperate directories are # for the IntelliJ, Android Studio and CLion versions of the plugin. /.ijwb/ /.aswb/ /.clwb/ ### C++ ### # Prerequisites *.d # Compiled Object files *.slo *.lo *.o *.obj # Precompiled Headers *.gch *.pch # Compiled Dynamic libraries *.so *.dylib *.dll # Fortran module files *.mod *.smod # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app ### Linux ### *~ # temporary files which can be created if a process still has a handle open of a deleted file .fuse_hidden* # KDE directory preferences .directory # Linux trash folder which might appear on any partition or disk .Trash-* # .nfs files are created when an open file is removed but is still being accessed .nfs* ### macOS ### # General .DS_Store .AppleDouble .LSOverride # Icon must end with two \r Icon # Thumbnails ._* # Files that might appear in the root of a volume .DocumentRevisions-V100 .fseventsd .Spotlight-V100 .TemporaryItems .Trashes .VolumeIcon.icns .com.apple.timemachine.donotpresent # Directories potentially created on remote AFP share .AppleDB .AppleDesktop Network Trash Folder Temporary Items .apdisk ### macOS Patch ### # iCloud generated files *.icloud ### Node ### # Logs logs *.log npm-debug.log* yarn-debug.log* yarn-error.log* lerna-debug.log* .pnpm-debug.log* # Diagnostic reports (https://nodejs.org/api/report.html) report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json # Runtime data pids *.pid *.seed *.pid.lock # Directory for instrumented libs generated by jscoverage/JSCover lib-cov # Coverage directory used by tools like istanbul coverage *.lcov # nyc test coverage .nyc_output # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) .grunt # Bower dependency directory (https://bower.io/) bower_components # node-waf configuration .lock-wscript # Compiled binary addons (https://nodejs.org/api/addons.html) build/Release # Dependency directories node_modules/ jspm_packages/ # Snowpack dependency directory (https://snowpack.dev/) web_modules/ # TypeScript cache *.tsbuildinfo # Optional npm cache directory .npm # Optional eslint cache .eslintcache # Optional stylelint cache .stylelintcache # Microbundle cache .rpt2_cache/ .rts2_cache_cjs/ .rts2_cache_es/ .rts2_cache_umd/ # Optional REPL history .node_repl_history # Output of 'npm pack' *.tgz # Yarn Integrity file .yarn-integrity # dotenv environment variable files .env .env.development.local .env.test.local .env.production.local .env.local # parcel-bundler cache (https://parceljs.org/) .cache .parcel-cache # Next.js build output .next out # Nuxt.js build / generate output .nuxt dist # Gatsby files .cache/ # Comment in the public line in if your project uses Gatsby and not Next.js # https://nextjs.org/blog/next-9-1#public-directory-support # public # vuepress build output .vuepress/dist # vuepress v2.x temp and cache directory .temp # Docusaurus cache and generated files .docusaurus # Serverless directories .serverless/ # FuseBox cache .fusebox/ # DynamoDB Local files .dynamodb/ # TernJS port file .tern-port # Stores VSCode versions used for testing VSCode extensions .vscode-test # yarn v2 .yarn/cache .yarn/unplugged .yarn/build-state.yml .yarn/install-state.gz .pnp.* ### Node Patch ### # Serverless Webpack directories .webpack/ # Optional stylelint cache # SvelteKit build / generate output .svelte-kit ### Python ### # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ cover/ # Translations *.mo *.pot # Django stuff: local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder .pybuilder/ target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv # For a library or package, you might want to ignore these files since the code is # intended to run in multiple environments; otherwise, check them in: # .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # poetry # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock # pdm # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. #pdm.lock # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it # in version control. # https://pdm.fming.dev/#use-with-ide .pdm.toml # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ # pytype static type analyzer .pytype/ # Cython debug symbols cython_debug/ # PyCharm # JetBrains specific template is maintained in a separate JetBrains.gitignore that can # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ ### Python Patch ### # Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration poetry.toml # ruff .ruff_cache/ # LSP config files pyrightconfig.json ### Vim ### # Swap [._]*.s[a-v][a-z] !*.svg # comment out if you don't need vector files [._]*.sw[a-p] [._]s[a-rt-v][a-z] [._]ss[a-gi-z] [._]sw[a-p] # Session Session.vim Sessionx.vim # Temporary .netrwhist # Auto-generated tag files tags # Persistent undo [._]*.un~ ### VisualStudioCode ### .vscode/* !.vscode/settings.json !.vscode/tasks.json !.vscode/launch.json !.vscode/extensions.json !.vscode/*.code-snippets # Local History for Visual Studio Code .history/ # Built Visual Studio Code Extensions *.vsix ### VisualStudioCode Patch ### # Ignore all local history of files .history .ionide # End of https://www.toptal.com/developers/gitignore/api/c++,vim,bazel,linux,macos,python,visualstudiocode,node !/tachyon/build !/third_party/env /.bazelrc.user docker docs /tachyon/node/test/bazel-* /tachyon/py/test/bazel-* ================================================ FILE: .github/workflows/ci.yml ================================================ name: CI on: push: branches: ["main"] pull_request: branches: ["main"] jobs: test: strategy: matrix: os: [ubuntu-latest, macos-latest-xlarge] build_flag: [fastbuild, opt] runs-on: ${{ matrix.os }} steps: - name: Free up space on linux if: matrix.os == 'ubuntu-latest' run: | df -h rm -rf /usr/share/dotnet/ rm -rf /opt/hostedtoolcache df -h - name: Free up space on macos if: matrix.os == 'macos-latest-xlarge' run: | df -h sudo rm -rf ~/Library/Caches/* df -h - name: Checkout code uses: actions/checkout@v4 - name: Set up Bazel uses: bazel-contrib/setup-bazel@0.8.5 with: # Avoid downloading Bazel every time. bazelisk-cache: true # Share a single build cache between workflows. disk-cache: ${{ matrix.os }}-${{ matrix.build_flag }}-build # Share repository cache between workflows. repository-cache: false # Cache external repositories external-cache: false - name: Setup Python uses: actions/setup-python@v5 with: python-version: "3.10" - name: Install numpy run: python3 -m pip install numpy - name: Install OpenMP on linux if: matrix.os == 'ubuntu-latest' && matrix.build_flag == 'opt' run: sudo apt-get install -y libomp-dev - name: Install OpenMP on macos if: matrix.os == 'macos-latest-xlarge' && matrix.build_flag == 'opt' run: brew install libomp - name: Add .bazelrc.user on linux if: matrix.os == 'ubuntu-latest' run: echo "build --action_env=CARGO=$HOME/.cargo/bin/cargo" >> .bazelrc.user && echo "build --@rules_rust//rust/toolchain/channel=nightly" >> .bazelrc.user - name: Add .bazelrc.user on macos if: matrix.os == 'macos-latest-xlarge' run: brew install coreutils && export PATH="/opt/homebrew/opt/coreutils/libexec/gnubin:$PATH" && echo "build --action_env=CARGO=$HOME/.cargo/bin/cargo" >> .bazelrc.user && echo "build --@rules_rust//rust/toolchain/channel=nightly" >> .bazelrc.user - name: Build run: bazel build --config ${{ matrix.build_flag }} //... - name: Test # NOTE(chokobole): Test timeouts are overridden 1.5x of the default timeout due to timeout failure on GitHub Actions. # See https://github.com/kroma-network/tachyon/actions/runs/9581476338/job/26418352737. run: bazel test --config ${{ matrix.build_flag }} --test_output=errors --test_tag_filters -benchmark,-manual,-cuda //... --test_timeout=90,450,1350,5400 - name: Test Node Binding run: | cd tachyon/node/test bazel test -c ${{ matrix.build_flag}} --test_output=errors //... - name: Test Py Binding run: | cd tachyon/py/test bazel test -c ${{ matrix.build_flag}} --test_output=errors //... - name: Test Circom run: | cd vendors/circom CARGO_BAZEL_REPIN=true bazel test --config ${{ matrix.build_flag}} --test_output=errors //... lint: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v4 with: fetch-depth: 0 - name: Set up Git run: | git config --global user.name 'github-actions' git config --global user.email 'github-actions@github.com' git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }} git fetch --all - name: Setup Python for cpplint uses: actions/setup-python@v5 with: python-version: "3.10.12" - name: Install cpplint run: pip install cpplint - name: Run cpplint if: github.event_name == 'pull_request' run: git diff --name-status HEAD origin/${{ github.base_ref }} | cut -f 2,3 | xargs cpplint --filter=-legal/copyright,-whitespace/line_length,-whitespace/indent_namespace,-build/namespaces,-runtime/references - name: Run clang-format lint uses: jidicula/clang-format-action@v4.11.0 with: clang-format-version: "17" check-path: "." - name: Install Buildifier run: | wget https://github.com/bazelbuild/buildtools/releases/download/v6.4.0/buildifier-linux-amd64 chmod +x buildifier-linux-amd64 sudo mv buildifier-linux-amd64 /usr/local/bin/buildifier - name: Run Buildifier run: | find . -iname "*.bazel" -o -iname "*.bzl" -o -name "WORKSPACE" -o -iname "*.BUILD" | xargs buildifier --lint=fix find . -iname "*.bazel" -o -iname "*.bzl" -o -name "WORKSPACE" -o -iname "*.BUILD" | xargs buildifier --mode=check git diff --exit-code ================================================ FILE: .github/workflows/delete_cache.yml ================================================ name: Delete Cache on: pull_request: branches: ["closed"] jobs: if_merged: if: github.event.pull_request.merged == true runs-on: ubuntu-latest steps: - run: | # get the ref key ref_key="refs/pull/${{ github.event.pull_request.number }}/merge" # delete cache gh cache list --ref $ref_key --limit 100 | cut -f 1 | xargs -n1 gh cache delete continue-on-error: true ================================================ FILE: .gitignore ================================================ # Created by https://www.toptal.com/developers/gitignore/api/c++,vim,bazel,linux,macos,python,visualstudiocode,node # Edit at https://www.toptal.com/developers/gitignore?templates=c++,vim,bazel,linux,macos,python,visualstudiocode,node ### Bazel ### # gitignore template for Bazel build system # website: https://bazel.build/ # Ignore all bazel-* symlinks. There is no full list since this can change # based on the name of the directory bazel is cloned into. /bazel-* # Directories for the Bazel IntelliJ plugin containing the generated # IntelliJ project files and plugin configuration. Seperate directories are # for the IntelliJ, Android Studio and CLion versions of the plugin. /.ijwb/ /.aswb/ /.clwb/ ### C++ ### # Prerequisites *.d # Compiled Object files *.slo *.lo *.o *.obj # Precompiled Headers *.gch *.pch # Compiled Dynamic libraries *.so *.dylib *.dll # Fortran module files *.mod *.smod # Compiled Static libraries *.lai *.la *.a *.lib # Executables *.exe *.out *.app ### Linux ### *~ # temporary files which can be created if a process still has a handle open of a deleted file .fuse_hidden* # KDE directory preferences .directory # Linux trash folder which might appear on any partition or disk .Trash-* # .nfs files are created when an open file is removed but is still being accessed .nfs* ### macOS ### # General .DS_Store .AppleDouble .LSOverride # Icon must end with two \r Icon # Thumbnails ._* # Files that might appear in the root of a volume .DocumentRevisions-V100 .fseventsd .Spotlight-V100 .TemporaryItems .Trashes .VolumeIcon.icns .com.apple.timemachine.donotpresent # Directories potentially created on remote AFP share .AppleDB .AppleDesktop Network Trash Folder Temporary Items .apdisk ### macOS Patch ### # iCloud generated files *.icloud ### Node ### # Logs logs *.log npm-debug.log* yarn-debug.log* yarn-error.log* lerna-debug.log* .pnpm-debug.log* # Diagnostic reports (https://nodejs.org/api/report.html) report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json # Runtime data pids *.pid *.seed *.pid.lock # Directory for instrumented libs generated by jscoverage/JSCover lib-cov # Coverage directory used by tools like Istanbul coverage *.lcov # nyc test coverage .nyc_output # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) .grunt # Bower dependency directory (https://bower.io/) bower_components # node-waf configuration .lock-wscript # Compiled binary addons (https://nodejs.org/api/addons.html) build/Release # Dependency directories node_modules/ jspm_packages/ # Snowpack dependency directory (https://snowpack.dev/) web_modules/ # TypeScript cache *.tsbuildinfo # Optional npm cache directory .npm # Optional eslint cache .eslintcache # Optional stylelint cache .stylelintcache # Microbundle cache .rpt2_cache/ .rts2_cache_cjs/ .rts2_cache_es/ .rts2_cache_umd/ # Optional REPL history .node_repl_history # Output of 'npm pack' *.tgz # Yarn Integrity file .yarn-integrity # dotenv environment variable files .env .env.development.local .env.test.local .env.production.local .env.local # parcel-bundler cache (https://parceljs.org/) .cache .parcel-cache # Next.js build output .next out # Nuxt.js build / generate output .nuxt dist # Gatsby files .cache/ # Comment in the public line if your project uses Gatsby and not Next.js # https://nextjs.org/blog/next-9-1#public-directory-support # public # vuepress build output .vuepress/dist # vuepress v2.x temp and cache directory .temp # Docusaurus cache and generated files .docusaurus # Serverless directories .serverless/ # FuseBox cache .fusebox/ # DynamoDB Local files .dynamodb/ # TernJS port file .tern-port # Stores VSCode versions used for testing VSCode extensions .vscode-test # yarn v2 .yarn/cache .yarn/unplugged .yarn/build-state.yml .yarn/install-state.gz .pnp.* ### Node Patch ### # Serverless Webpack directories .webpack/ # Optional stylelint cache # SvelteKit build / generate output .svelte-kit ### Python ### # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ cover/ # Translations *.mo *.pot # Django stuff: local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder .pybuilder/ target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv # For a library or package, you might want to ignore these files since the code is # intended to run in multiple environments; otherwise, check them in: # .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # poetry # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock # pdm # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. #pdm.lock # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it # in version control. # https://pdm.fming.dev/#use-with-ide .pdm.toml # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ # pytype static type analyzer .pytype/ # Cython debug symbols cython_debug/ # PyCharm # JetBrains specific template is maintained in a separate JetBrains.gitignore that can # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ ### Python Patch ### # Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration poetry.toml # ruff .ruff_cache/ # LSP config files pyrightconfig.json ### Vim ### # Swap [._]*.s[a-v][a-z] !*.svg # comment out if you don't need vector files [._]*.sw[a-p] [._]s[a-rt-v][a-z] [._]ss[a-gi-z] [._]sw[a-p] # Session Session.vim Sessionx.vim # Temporary .netrwhist # Auto-generated tag files tags # Persistent undo [._]*.un~ ### VisualStudioCode ### .vscode/* !.vscode/settings.json !.vscode/tasks.json !.vscode/launch.json !.vscode/extensions.json !.vscode/*.code-snippets # Local History for Visual Studio Code .history/ # Built Visual Studio Code Extensions *.vsix ### VisualStudioCode Patch ### # Ignore all local history of files .history .ionide # End of https://www.toptal.com/developers/gitignore/api/c++,vim,bazel,linux,macos,python,visualstudiocode,node !/tachyon/build !/third_party/env /.bazelrc.user /tachyon/node/test/bazel-* /tachyon/py/test/bazel-* ================================================ FILE: .gitmessage ================================================ (): # ──────────────────────────────── 80 chars ───────────────────────────────────┤ See # Resolves: # Related: # # ──────────────────────────────── 80 chars ───────────────────────────────────┤ # Example Commit Messages # ======================= # ─── Example: Simple refactor ────────────────────────────────────────────────┤ # refac: remove system dictator # # Since the owner of all contracts in this system is ProxyAdmin, SystemDictator # is no longer necessary. Additionally, the deployment scripts have been # modified to update the proxy when deploying implementation contracts. # # Resolves: #36332 # ─────────────────────────────────────────────────────────────────────────────┤ # ─── Example: Simple docs change ─────────────────────────────────────────────┤ # docs: update commit message format # ─────────────────────────────────────────────────────────────────────────────┤ # ─── Example: A bug fix ──────────────────────────────────────────────────────┤ # fix(trie): use hash once on account to compute path # # Path must be computed using poseidon hash once. But, by mistake, it # was computed using twice. # ─────────────────────────────────────────────────────────────────────────────┤ # ─── Example: A feature ──────────────────────────────────────────────────────┤ # feat!: use keccak256 for codehash # # BREAKING CHANGE: Previously, codehash was calculated using poseidon. # So the state root since this commit will be produced differently. # # See belows for details. # # - https://eips.ethereum.org/EIPS/eip-1052 # - https://github.com/scroll-tech/go-ethereum/pull/188 # ─────────────────────────────────────────────────────────────────────────────┤ # Commit Message Format # ===================== # # We have very precise rules over how our Git commit messages must be formatted. # This format leads to easier to read commit history. # # Each commit message consists of a header, a body, and a footer. # #
# # # #