Full Code of torquem-ch/silkworm for AI

gitextract_1pxu9kf7/

├── .circleci/
│   └── config.yml
├── .clang-format
├── .clang-tidy
├── .dockerignore
├── .editorconfig
├── .git-blame-ignore-revs
├── .github/
│   ├── actions/
│   │   ├── fuzzer-common-steps/
│   │   │   └── action.yml
│   │   └── perf-common-steps/
│   │       └── action.yml
│   └── workflows/
│       ├── execution-test.yml
│       ├── macOS.yml
│       ├── rpc-fuzzer-tests.yml
│       ├── rpc-integration-tests.yml
│       ├── rpc-performance-tests-light.yml
│       ├── rpc-performance-tests.yml
│       ├── run_integration_tests.sh
│       ├── snapshot-test.yml
│       ├── start_integration_rpcdaemon.sh
│       ├── stop_integration_rpcdaemon.sh
│       └── windows.yml
├── .gitignore
├── .gitmodules
├── AUTHORS
├── CMakeLists.txt
├── CMakeSettings.json
├── LICENSE
├── Makefile
├── README.md
├── cmake/
│   ├── cmake_format.cmake
│   ├── cmake_format.yaml
│   ├── common/
│   │   ├── get_all_targets.cmake
│   │   └── targets.cmake
│   ├── compiler_settings.cmake
│   ├── compiler_settings_sanitize.cmake
│   ├── compiler_warnings.cmake
│   ├── conan.cmake
│   ├── conan_quiet.cmake
│   ├── conan_quiet.sh
│   ├── copyright.cmake
│   ├── format.cmake
│   ├── parallel_jobs_count.sh
│   ├── profiles/
│   │   ├── experimental/
│   │   │   ├── linux_arm64_gcc_12_debug
│   │   │   ├── linux_arm64_gcc_12_release
│   │   │   ├── linux_x64_gcc_12_debug
│   │   │   ├── linux_x64_gcc_12_release
│   │   │   ├── macos_arm64_clang_14_debug
│   │   │   ├── macos_arm64_clang_14_release
│   │   │   ├── macos_x64_clang_14_debug
│   │   │   ├── macos_x64_clang_14_release
│   │   │   └── readme.txt
│   │   ├── linux_x64_clang_16_debug
│   │   ├── linux_x64_clang_16_release
│   │   ├── linux_x64_gcc_11_debug
│   │   ├── linux_x64_gcc_11_release
│   │   ├── macos_arm64_clang_13_debug
│   │   ├── macos_arm64_clang_13_release
│   │   ├── macos_x64_clang_13_debug
│   │   ├── macos_x64_clang_13_release
│   │   ├── wasi_release
│   │   ├── windows_msvc_193_debug
│   │   └── windows_msvc_193_release
│   ├── run_smoke_tests.cmake
│   ├── run_smoke_tests.sh
│   ├── run_unit_tests.cmake
│   ├── run_unit_tests.sh
│   ├── setup/
│   │   └── compiler_install.sh
│   └── toolchain/
│       ├── clang_libcxx.cmake
│       ├── cxx20.cmake
│       └── wasi.cmake
├── cmd/
│   ├── CMakeLists.txt
│   ├── benchmark/
│   │   ├── CMakeLists.txt
│   │   └── benchmark_test.cpp
│   ├── rpcdaemon.cpp
│   ├── sentry.cpp
│   ├── silkworm.cpp
│   └── test/
│       ├── CMakeLists.txt
│       ├── address_sanitizer_fix.hpp
│       ├── backend_kv_test.cpp
│       ├── ethereum.cpp
│       ├── fuzzer_diagnostics.cpp
│       ├── fuzzer_test.cpp
│       └── sentry_client_test.cpp
├── codecov.yml
├── conanfile.py
├── docs/
│   ├── CONTRIBUTING.md
│   ├── JSON-RPC-API.md
│   ├── code_style.md
│   ├── conan.md
│   ├── db_toolbox.md
│   ├── dev_tools.md
│   └── fuzzer.md
├── examples/
│   ├── CMakeLists.txt
│   └── get_latest_block.cpp
├── silkworm/
│   ├── CMakeLists.txt
│   ├── capi/
│   │   ├── CMakeLists.txt
│   │   ├── cli/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── execute.cpp
│   │   │   ├── main.c
│   │   │   └── sample-go-client/
│   │   │       ├── README.md
│   │   │       └── main.go
│   │   ├── common/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── common_component.hpp
│   │   │   ├── errors.h
│   │   │   ├── instance.hpp
│   │   │   ├── parse_path.cpp
│   │   │   ├── parse_path.hpp
│   │   │   └── preamble.h
│   │   ├── init.cpp
│   │   ├── init.h
│   │   ├── instance.cpp
│   │   ├── instance.hpp
│   │   ├── log_level.h
│   │   ├── make_log_settings.cpp
│   │   ├── make_log_settings.hpp
│   │   ├── silkworm.cpp
│   │   ├── silkworm.h
│   │   └── silkworm_test.cpp
│   ├── core/
│   │   ├── CMakeLists.txt
│   │   ├── chain/
│   │   │   ├── config.cpp
│   │   │   ├── config.hpp
│   │   │   ├── config_test.cpp
│   │   │   ├── dao.cpp
│   │   │   ├── dao.hpp
│   │   │   ├── genesis.cpp
│   │   │   ├── genesis.hpp
│   │   │   ├── genesis_amoy.cpp
│   │   │   ├── genesis_amoy.hpp
│   │   │   ├── genesis_amoy.json
│   │   │   ├── genesis_bor_mainnet.cpp
│   │   │   ├── genesis_bor_mainnet.hpp
│   │   │   ├── genesis_bor_mainnet.json
│   │   │   ├── genesis_holesky.cpp
│   │   │   ├── genesis_holesky.hpp
│   │   │   ├── genesis_holesky.json
│   │   │   ├── genesis_mainnet.cpp
│   │   │   ├── genesis_mainnet.hpp
│   │   │   ├── genesis_mainnet.json
│   │   │   ├── genesis_sepolia.cpp
│   │   │   ├── genesis_sepolia.hpp
│   │   │   ├── genesis_sepolia.json
│   │   │   └── genesis_test.cpp
│   │   ├── common/
│   │   │   ├── assert.cpp
│   │   │   ├── assert.hpp
│   │   │   ├── base.hpp
│   │   │   ├── block_cache.hpp
│   │   │   ├── block_cache_test.cpp
│   │   │   ├── bytes.hpp
│   │   │   ├── bytes_test.cpp
│   │   │   ├── bytes_to_string.hpp
│   │   │   ├── decoding_result.hpp
│   │   │   ├── empty_hashes.hpp
│   │   │   ├── empty_hashes_test.cpp
│   │   │   ├── endian.cpp
│   │   │   ├── endian.hpp
│   │   │   ├── endian_test.cpp
│   │   │   ├── hash_maps.hpp
│   │   │   ├── lru_cache.hpp
│   │   │   ├── lru_cache_test.cpp
│   │   │   ├── math.hpp
│   │   │   ├── math_test.cpp
│   │   │   ├── object_pool.hpp
│   │   │   ├── overloaded.hpp
│   │   │   ├── random_number.hpp
│   │   │   ├── random_number_test.cpp
│   │   │   ├── small_map.hpp
│   │   │   ├── small_map_test.cpp
│   │   │   ├── test_util.cpp
│   │   │   ├── test_util.hpp
│   │   │   ├── util.cpp
│   │   │   ├── util.hpp
│   │   │   └── util_test.cpp
│   │   ├── concurrency/
│   │   │   └── resettable_once_flag.hpp
│   │   ├── crypto/
│   │   │   ├── ecdsa.c
│   │   │   ├── ecdsa.h
│   │   │   ├── secp256k1n.cpp
│   │   │   ├── secp256k1n.hpp
│   │   │   └── secp256k1n_test.cpp
│   │   ├── execution/
│   │   │   ├── call_tracer.cpp
│   │   │   ├── call_tracer.hpp
│   │   │   ├── evm.cpp
│   │   │   ├── evm.hpp
│   │   │   ├── evm_test.cpp
│   │   │   ├── execution.hpp
│   │   │   ├── execution_test.cpp
│   │   │   ├── precompile.cpp
│   │   │   ├── precompile.hpp
│   │   │   ├── precompile_benchmark.cpp
│   │   │   ├── precompile_test.cpp
│   │   │   ├── processor.cpp
│   │   │   ├── processor.hpp
│   │   │   └── processor_test.cpp
│   │   ├── protocol/
│   │   │   ├── blockchain.cpp
│   │   │   ├── blockchain.hpp
│   │   │   ├── bor/
│   │   │   │   ├── config.cpp
│   │   │   │   ├── config.hpp
│   │   │   │   ├── config_test.cpp
│   │   │   │   ├── span.cpp
│   │   │   │   ├── span.hpp
│   │   │   │   └── span_test.cpp
│   │   │   ├── bor_rule_set.cpp
│   │   │   ├── bor_rule_set.hpp
│   │   │   ├── ethash_config.cpp
│   │   │   ├── ethash_config.hpp
│   │   │   ├── ethash_rule_set.cpp
│   │   │   ├── ethash_rule_set.hpp
│   │   │   ├── ethash_rule_set_test.cpp
│   │   │   ├── intrinsic_gas.cpp
│   │   │   ├── intrinsic_gas.hpp
│   │   │   ├── intrinsic_gas_test.cpp
│   │   │   ├── merge_rule_set.cpp
│   │   │   ├── merge_rule_set.hpp
│   │   │   ├── merge_rule_set_test.cpp
│   │   │   ├── param.hpp
│   │   │   ├── rule_set.cpp
│   │   │   ├── rule_set.hpp
│   │   │   ├── rule_set_test.cpp
│   │   │   ├── validation.cpp
│   │   │   ├── validation.hpp
│   │   │   └── validation_test.cpp
│   │   ├── rlp/
│   │   │   ├── decode.cpp
│   │   │   ├── decode.hpp
│   │   │   ├── decode_test.cpp
│   │   │   ├── decode_vector.hpp
│   │   │   ├── encode.cpp
│   │   │   ├── encode.hpp
│   │   │   ├── encode_test.cpp
│   │   │   └── encode_vector.hpp
│   │   ├── state/
│   │   │   ├── block_state.hpp
│   │   │   ├── delta.cpp
│   │   │   ├── delta.hpp
│   │   │   ├── in_memory_state.cpp
│   │   │   ├── in_memory_state.hpp
│   │   │   ├── intra_block_state.cpp
│   │   │   ├── intra_block_state.hpp
│   │   │   ├── intra_block_state_test.cpp
│   │   │   ├── object.hpp
│   │   │   └── state.hpp
│   │   ├── test_util/
│   │   │   ├── null_stream.hpp
│   │   │   └── sample_blocks.hpp
│   │   ├── trie/
│   │   │   ├── hash_builder.cpp
│   │   │   ├── hash_builder.hpp
│   │   │   ├── hash_builder_test.cpp
│   │   │   ├── nibbles.cpp
│   │   │   ├── nibbles.hpp
│   │   │   ├── nibbles_test.cpp
│   │   │   ├── node.cpp
│   │   │   ├── node.hpp
│   │   │   ├── node_test.cpp
│   │   │   ├── prefix_set.cpp
│   │   │   ├── prefix_set.hpp
│   │   │   ├── prefix_set_test.cpp
│   │   │   ├── vector_root.hpp
│   │   │   └── vector_root_test.cpp
│   │   └── types/
│   │       ├── account.cpp
│   │       ├── account.hpp
│   │       ├── address.cpp
│   │       ├── address.hpp
│   │       ├── address_test.cpp
│   │       ├── block.cpp
│   │       ├── block.hpp
│   │       ├── block_body_for_storage.hpp
│   │       ├── block_body_for_storage_test.cpp
│   │       ├── block_id.hpp
│   │       ├── block_test.cpp
│   │       ├── bloom.cpp
│   │       ├── bloom.hpp
│   │       ├── bloom_test.cpp
│   │       ├── call_traces.hpp
│   │       ├── chain_head.hpp
│   │       ├── eip_7685_requests.cpp
│   │       ├── eip_7685_requests.hpp
│   │       ├── eip_7685_requests_test.cpp
│   │       ├── evmc_bytes32.cpp
│   │       ├── evmc_bytes32.hpp
│   │       ├── hash.hpp
│   │       ├── hash_test.cpp
│   │       ├── log.cpp
│   │       ├── log.hpp
│   │       ├── log_test.cpp
│   │       ├── receipt.cpp
│   │       ├── receipt.hpp
│   │       ├── transaction.cpp
│   │       ├── transaction.hpp
│   │       ├── transaction_test.cpp
│   │       ├── withdrawal.cpp
│   │       ├── withdrawal.hpp
│   │       ├── withdrawal_test.cpp
│   │       ├── y_parity_and_chain_id.cpp
│   │       ├── y_parity_and_chain_id.hpp
│   │       └── y_parity_and_chain_id_test.cpp
│   ├── db/
│   │   ├── CMakeLists.txt
│   │   ├── access_layer.cpp
│   │   ├── access_layer.hpp
│   │   ├── access_layer_test.cpp
│   │   ├── bitmap_test.cpp
│   │   ├── blocks/
│   │   │   ├── blocks_index_builders_factory.cpp
│   │   │   ├── blocks_index_builders_factory.hpp
│   │   │   ├── bodies/
│   │   │   │   ├── body_index.cpp
│   │   │   │   ├── body_index.hpp
│   │   │   │   ├── body_queries.hpp
│   │   │   │   ├── body_segment.cpp
│   │   │   │   ├── body_segment.hpp
│   │   │   │   ├── body_segment_collation.cpp
│   │   │   │   ├── body_segment_collation.hpp
│   │   │   │   ├── body_txs_amount_query.cpp
│   │   │   │   ├── body_txs_amount_query.hpp
│   │   │   │   └── body_txs_amount_query_test.cpp
│   │   │   ├── headers/
│   │   │   │   ├── header_index.cpp
│   │   │   │   ├── header_index.hpp
│   │   │   │   ├── header_queries.hpp
│   │   │   │   ├── header_segment.cpp
│   │   │   │   ├── header_segment.hpp
│   │   │   │   ├── header_segment_collation.cpp
│   │   │   │   └── header_segment_collation.hpp
│   │   │   ├── schema_config.cpp
│   │   │   ├── schema_config.hpp
│   │   │   ├── step_block_num_converter.hpp
│   │   │   └── transactions/
│   │   │       ├── txn_index.cpp
│   │   │       ├── txn_index.hpp
│   │   │       ├── txn_queries.hpp
│   │   │       ├── txn_segment.hpp
│   │   │       ├── txn_segment_collation.cpp
│   │   │       ├── txn_segment_collation.hpp
│   │   │       ├── txn_segment_word_codec.cpp
│   │   │       ├── txn_segment_word_codec.hpp
│   │   │       ├── txn_to_block_index.cpp
│   │   │       ├── txn_to_block_index.hpp
│   │   │       ├── txs_and_bodies_query.cpp
│   │   │       └── txs_and_bodies_query.hpp
│   │   ├── buffer.cpp
│   │   ├── buffer.hpp
│   │   ├── buffer_test.cpp
│   │   ├── capi/
│   │   │   ├── component.hpp
│   │   │   ├── db.cpp
│   │   │   └── db.h
│   │   ├── chain/
│   │   │   ├── chain_storage.hpp
│   │   │   ├── local_chain_storage.cpp
│   │   │   ├── local_chain_storage.hpp
│   │   │   ├── providers.hpp
│   │   │   ├── remote_chain_storage.cpp
│   │   │   ├── remote_chain_storage.hpp
│   │   │   └── remote_chain_storage_test.cpp
│   │   ├── chain_data_init.cpp
│   │   ├── chain_data_init.hpp
│   │   ├── chain_head.cpp
│   │   ├── chain_head.hpp
│   │   ├── cli/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── check_blockhashes.cpp
│   │   │   ├── check_changes.cpp
│   │   │   ├── check_hashstate.cpp
│   │   │   ├── check_log_indices.cpp
│   │   │   ├── check_senders.cpp
│   │   │   ├── check_tx_lookup.cpp
│   │   │   ├── db_max_readers_option.cpp
│   │   │   ├── db_max_readers_option.hpp
│   │   │   ├── db_toolbox.cpp
│   │   │   ├── scan_txs.cpp
│   │   │   ├── snapshot_options.cpp
│   │   │   ├── snapshot_options.hpp
│   │   │   └── snapshots.cpp
│   │   ├── data_store.cpp
│   │   ├── data_store.hpp
│   │   ├── datastore/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── common/
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── dummy.cpp
│   │   │   │   ├── entity_name.cpp
│   │   │   │   ├── entity_name.hpp
│   │   │   │   ├── pair_get.hpp
│   │   │   │   ├── ranges/
│   │   │   │   │   ├── caching_view.hpp
│   │   │   │   │   ├── concat_view.hpp
│   │   │   │   │   ├── concat_view_test.cpp
│   │   │   │   │   ├── if_view.hpp
│   │   │   │   │   ├── lazy_view.hpp
│   │   │   │   │   ├── merge_compare_func.hpp
│   │   │   │   │   ├── merge_many_view.hpp
│   │   │   │   │   ├── merge_many_view_test.cpp
│   │   │   │   │   ├── merge_unique_view.hpp
│   │   │   │   │   ├── merge_unique_view_test.cpp
│   │   │   │   │   ├── merge_view.hpp
│   │   │   │   │   ├── merge_view_test.cpp
│   │   │   │   │   ├── owning_view.hpp
│   │   │   │   │   ├── unique_view.hpp
│   │   │   │   │   └── vector_from_range.hpp
│   │   │   │   ├── step.hpp
│   │   │   │   ├── step_test.cpp
│   │   │   │   ├── step_timestamp_converter.cpp
│   │   │   │   ├── step_timestamp_converter.hpp
│   │   │   │   ├── step_timestamp_converter_test.cpp
│   │   │   │   └── timestamp.hpp
│   │   │   ├── data_migration.cpp
│   │   │   ├── data_migration.hpp
│   │   │   ├── data_migration_command.hpp
│   │   │   ├── data_store.hpp
│   │   │   ├── domain_get_as_of_query.hpp
│   │   │   ├── domain_get_latest_query.hpp
│   │   │   ├── domain_range_as_of_query.hpp
│   │   │   ├── domain_range_latest_query.hpp
│   │   │   ├── etl/
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── buffer.hpp
│   │   │   │   ├── collector.cpp
│   │   │   │   ├── collector.hpp
│   │   │   │   ├── collector_settings.hpp
│   │   │   │   ├── file_provider.cpp
│   │   │   │   ├── file_provider.hpp
│   │   │   │   ├── in_memory_collector.hpp
│   │   │   │   ├── util.hpp
│   │   │   │   └── util_test.cpp
│   │   │   ├── history_get_query.hpp
│   │   │   ├── history_range_by_keys_query.hpp
│   │   │   ├── history_range_in_period_query.hpp
│   │   │   ├── inverted_index_range_by_key_query.hpp
│   │   │   ├── kvdb/
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── big_endian_codec.cpp
│   │   │   │   ├── big_endian_codec.hpp
│   │   │   │   ├── bitmap.cpp
│   │   │   │   ├── bitmap.hpp
│   │   │   │   ├── codec.hpp
│   │   │   │   ├── cursor_iterator.cpp
│   │   │   │   ├── cursor_iterator.hpp
│   │   │   │   ├── database.cpp
│   │   │   │   ├── database.hpp
│   │   │   │   ├── domain.hpp
│   │   │   │   ├── domain_codecs.hpp
│   │   │   │   ├── domain_delete_query.hpp
│   │   │   │   ├── domain_get_latest_query.hpp
│   │   │   │   ├── domain_get_latest_query_test.cpp
│   │   │   │   ├── domain_put_latest_query.hpp
│   │   │   │   ├── domain_put_query.hpp
│   │   │   │   ├── domain_queries.hpp
│   │   │   │   ├── domain_range_latest_query.hpp
│   │   │   │   ├── domain_range_latest_query_test.cpp
│   │   │   │   ├── etl_mdbx_collector.hpp
│   │   │   │   ├── history.hpp
│   │   │   │   ├── history_codecs.hpp
│   │   │   │   ├── history_delete_query.hpp
│   │   │   │   ├── history_get_query.hpp
│   │   │   │   ├── history_get_query_test.cpp
│   │   │   │   ├── history_put_query.hpp
│   │   │   │   ├── history_queries.hpp
│   │   │   │   ├── history_range_by_keys_query.hpp
│   │   │   │   ├── history_range_by_keys_query_test.cpp
│   │   │   │   ├── history_range_in_period_query.hpp
│   │   │   │   ├── history_range_in_period_query_test.cpp
│   │   │   │   ├── inverted_index.hpp
│   │   │   │   ├── inverted_index_put_query.hpp
│   │   │   │   ├── inverted_index_queries.hpp
│   │   │   │   ├── inverted_index_range_by_key_query.hpp
│   │   │   │   ├── inverted_index_range_by_key_query_test.cpp
│   │   │   │   ├── kvts_codec.hpp
│   │   │   │   ├── mdbx.cpp
│   │   │   │   ├── mdbx.hpp
│   │   │   │   ├── mdbx_test.cpp
│   │   │   │   ├── mdbx_version.cpp
│   │   │   │   ├── mdbx_version.hpp
│   │   │   │   ├── memory_mutation.cpp
│   │   │   │   ├── memory_mutation.hpp
│   │   │   │   ├── memory_mutation_cursor.cpp
│   │   │   │   ├── memory_mutation_cursor.hpp
│   │   │   │   ├── memory_mutation_test.cpp
│   │   │   │   ├── query_test.hpp
│   │   │   │   ├── raw_codec.hpp
│   │   │   │   ├── schema.cpp
│   │   │   │   ├── schema.hpp
│   │   │   │   └── timestamp_codec.hpp
│   │   │   ├── schema.hpp
│   │   │   ├── segment_collation.hpp
│   │   │   ├── snapshot_merger.cpp
│   │   │   ├── snapshot_merger.hpp
│   │   │   ├── snapshots/
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── basic_queries.hpp
│   │   │   │   ├── bittorrent/
│   │   │   │   │   ├── CMakeLists.txt
│   │   │   │   │   ├── client.cpp
│   │   │   │   │   ├── client.hpp
│   │   │   │   │   ├── client_test.cpp
│   │   │   │   │   ├── root_certificates.hpp
│   │   │   │   │   ├── root_certificates_test.cpp
│   │   │   │   │   ├── settings.hpp
│   │   │   │   │   ├── torrent_file.cpp
│   │   │   │   │   ├── torrent_file.hpp
│   │   │   │   │   ├── torrent_file_test.cpp
│   │   │   │   │   ├── trackers.cpp
│   │   │   │   │   ├── trackers.hpp
│   │   │   │   │   ├── web_seed_client.cpp
│   │   │   │   │   ├── web_seed_client.hpp
│   │   │   │   │   ├── web_seed_client_test.cpp
│   │   │   │   │   ├── web_session.cpp
│   │   │   │   │   ├── web_session.hpp
│   │   │   │   │   └── web_session_test.cpp
│   │   │   │   ├── bloom_filter/
│   │   │   │   │   ├── bloom_filter.cpp
│   │   │   │   │   ├── bloom_filter.hpp
│   │   │   │   │   └── bloom_filter_test.cpp
│   │   │   │   ├── btree/
│   │   │   │   │   ├── btree.cpp
│   │   │   │   │   ├── btree.hpp
│   │   │   │   │   ├── btree_index.cpp
│   │   │   │   │   ├── btree_index.hpp
│   │   │   │   │   └── btree_index_test.cpp
│   │   │   │   ├── common/
│   │   │   │   │   ├── codec.hpp
│   │   │   │   │   ├── encoding/
│   │   │   │   │   │   ├── murmur_hash3.cpp
│   │   │   │   │   │   ├── murmur_hash3.hpp
│   │   │   │   │   │   ├── murmur_hash3_test.cpp
│   │   │   │   │   │   ├── sequence.hpp
│   │   │   │   │   │   ├── sequence_test.cpp
│   │   │   │   │   │   └── util.hpp
│   │   │   │   │   ├── key_hasher.cpp
│   │   │   │   │   ├── key_hasher.hpp
│   │   │   │   │   ├── key_hasher_test.cpp
│   │   │   │   │   ├── raw_codec.hpp
│   │   │   │   │   ├── snapshot_path.cpp
│   │   │   │   │   ├── snapshot_path.hpp
│   │   │   │   │   ├── snapshot_path_test.cpp
│   │   │   │   │   └── util/
│   │   │   │   │       ├── bitmask_operators.hpp
│   │   │   │   │       └── iterator/
│   │   │   │   │           ├── index_range.hpp
│   │   │   │   │           ├── iterator_read_into_vector.hpp
│   │   │   │   │           ├── list_iterator.hpp
│   │   │   │   │           └── map_values_view.hpp
│   │   │   │   ├── config/
│   │   │   │   │   ├── chains/
│   │   │   │   │   │   ├── amoy.hpp
│   │   │   │   │   │   ├── bor_mainnet.hpp
│   │   │   │   │   │   ├── holesky.hpp
│   │   │   │   │   │   ├── mainnet.hpp
│   │   │   │   │   │   └── sepolia.hpp
│   │   │   │   │   ├── config.cpp
│   │   │   │   │   ├── config.hpp
│   │   │   │   │   ├── config_test.cpp
│   │   │   │   │   └── entry.hpp
│   │   │   │   ├── domain.hpp
│   │   │   │   ├── domain_get_latest_query.hpp
│   │   │   │   ├── domain_queries.hpp
│   │   │   │   ├── domain_range_latest_query.hpp
│   │   │   │   ├── elias_fano/
│   │   │   │   │   ├── README.md
│   │   │   │   │   ├── double_elias_fano_list.cpp
│   │   │   │   │   ├── double_elias_fano_list.hpp
│   │   │   │   │   ├── double_elias_fano_list_test.cpp
│   │   │   │   │   ├── elias_fano_common.hpp
│   │   │   │   │   ├── elias_fano_list.cpp
│   │   │   │   │   ├── elias_fano_list.hpp
│   │   │   │   │   ├── elias_fano_list_test.cpp
│   │   │   │   │   └── list_iterator.hpp
│   │   │   │   ├── history.hpp
│   │   │   │   ├── history_accessor_index.hpp
│   │   │   │   ├── history_get_query.hpp
│   │   │   │   ├── history_queries.hpp
│   │   │   │   ├── history_range_by_keys_query.hpp
│   │   │   │   ├── history_range_in_period_query.hpp
│   │   │   │   ├── index_builder.cpp
│   │   │   │   ├── index_builder.hpp
│   │   │   │   ├── index_builders_factory.cpp
│   │   │   │   ├── index_builders_factory.hpp
│   │   │   │   ├── index_salt_file.cpp
│   │   │   │   ├── index_salt_file.hpp
│   │   │   │   ├── inverted_index.hpp
│   │   │   │   ├── inverted_index_find_by_key_segment_query.hpp
│   │   │   │   ├── inverted_index_lower_bound_key_offset_segment_query.cpp
│   │   │   │   ├── inverted_index_lower_bound_key_offset_segment_query.hpp
│   │   │   │   ├── inverted_index_queries.hpp
│   │   │   │   ├── inverted_index_range_by_key_query.hpp
│   │   │   │   ├── inverted_index_seek_query.hpp
│   │   │   │   ├── inverted_index_ts_list.cpp
│   │   │   │   ├── inverted_index_ts_list.hpp
│   │   │   │   ├── inverted_index_ts_list_codec.cpp
│   │   │   │   ├── inverted_index_ts_list_codec.hpp
│   │   │   │   ├── query_cache.hpp
│   │   │   │   ├── query_caches.cpp
│   │   │   │   ├── query_caches.hpp
│   │   │   │   ├── query_caches_schema.hpp
│   │   │   │   ├── rec_split/
│   │   │   │   │   ├── accessor_index.hpp
│   │   │   │   │   ├── golomb_rice.hpp
│   │   │   │   │   ├── golomb_rice_test.cpp
│   │   │   │   │   ├── rec_split.cpp
│   │   │   │   │   ├── rec_split.hpp
│   │   │   │   │   ├── rec_split_par.hpp
│   │   │   │   │   ├── rec_split_par_test.cpp
│   │   │   │   │   ├── rec_split_seq.hpp
│   │   │   │   │   ├── rec_split_seq_test.cpp
│   │   │   │   │   └── test_util/
│   │   │   │   │       └── xoroshiro128pp.hpp
│   │   │   │   ├── schema.cpp
│   │   │   │   ├── schema.hpp
│   │   │   │   ├── segment/
│   │   │   │   │   ├── kv_segment_reader.cpp
│   │   │   │   │   ├── kv_segment_reader.hpp
│   │   │   │   │   ├── kv_segment_test.cpp
│   │   │   │   │   ├── kv_segment_writer.cpp
│   │   │   │   │   ├── kv_segment_writer.hpp
│   │   │   │   │   ├── seg/
│   │   │   │   │   │   ├── CMakeLists.txt
│   │   │   │   │   │   ├── common/
│   │   │   │   │   │   │   ├── varint.cpp
│   │   │   │   │   │   │   ├── varint.hpp
│   │   │   │   │   │   │   └── varint_test.cpp
│   │   │   │   │   │   ├── compression_kind.hpp
│   │   │   │   │   │   ├── compressor/
│   │   │   │   │   │   │   ├── bit_stream.cpp
│   │   │   │   │   │   │   ├── bit_stream.hpp
│   │   │   │   │   │   │   ├── bit_stream_test.cpp
│   │   │   │   │   │   │   ├── huffman_code.cpp
│   │   │   │   │   │   │   ├── huffman_code.hpp
│   │   │   │   │   │   │   ├── huffman_code_test.cpp
│   │   │   │   │   │   │   ├── intermediate_compressed_stream.cpp
│   │   │   │   │   │   │   ├── intermediate_compressed_stream.hpp
│   │   │   │   │   │   │   ├── intermediate_compressed_stream_test.cpp
│   │   │   │   │   │   │   ├── lcp_kasai.cpp
│   │   │   │   │   │   │   ├── lcp_kasai.hpp
│   │   │   │   │   │   │   ├── output_file_transaction.cpp
│   │   │   │   │   │   │   ├── output_file_transaction.hpp
│   │   │   │   │   │   │   ├── patricia_tree.cpp
│   │   │   │   │   │   │   ├── patricia_tree.hpp
│   │   │   │   │   │   │   ├── patricia_tree_test.cpp
│   │   │   │   │   │   │   ├── pattern_aggregator.cpp
│   │   │   │   │   │   │   ├── pattern_aggregator.hpp
│   │   │   │   │   │   │   ├── pattern_aggregator_test.cpp
│   │   │   │   │   │   │   ├── pattern_covering.cpp
│   │   │   │   │   │   │   ├── pattern_covering.hpp
│   │   │   │   │   │   │   ├── pattern_covering_test.cpp
│   │   │   │   │   │   │   ├── pattern_extractor.cpp
│   │   │   │   │   │   │   ├── pattern_extractor.hpp
│   │   │   │   │   │   │   ├── pattern_extractor_test.cpp
│   │   │   │   │   │   │   ├── positions_map.cpp
│   │   │   │   │   │   │   ├── positions_map.hpp
│   │   │   │   │   │   │   ├── raw_words_stream.cpp
│   │   │   │   │   │   │   ├── raw_words_stream.hpp
│   │   │   │   │   │   │   ├── raw_words_stream_test.cpp
│   │   │   │   │   │   │   ├── seg_stream.cpp
│   │   │   │   │   │   │   └── seg_stream.hpp
│   │   │   │   │   │   ├── compressor.cpp
│   │   │   │   │   │   ├── compressor.hpp
│   │   │   │   │   │   ├── decompressor.cpp
│   │   │   │   │   │   ├── decompressor.hpp
│   │   │   │   │   │   ├── seg_zip.cpp
│   │   │   │   │   │   └── seg_zip.hpp
│   │   │   │   │   ├── segment_reader.cpp
│   │   │   │   │   ├── segment_reader.hpp
│   │   │   │   │   ├── segment_test.cpp
│   │   │   │   │   ├── segment_writer.cpp
│   │   │   │   │   └── segment_writer.hpp
│   │   │   │   ├── segment_and_accessor_index.hpp
│   │   │   │   ├── snapshot_bundle.cpp
│   │   │   │   ├── snapshot_bundle.hpp
│   │   │   │   ├── snapshot_repository.cpp
│   │   │   │   ├── snapshot_repository.hpp
│   │   │   │   ├── snapshot_repository_ro_access.hpp
│   │   │   │   ├── snapshot_settings.hpp
│   │   │   │   ├── snapshot_size.hpp
│   │   │   │   └── test_util/
│   │   │   │       ├── sample_bloom_filter_data.hpp
│   │   │   │       └── string_codec.hpp
│   │   │   └── stage_scheduler.hpp
│   │   ├── db_utils.cpp
│   │   ├── db_utils.hpp
│   │   ├── db_utils_test.cpp
│   │   ├── etl_collector_test.cpp
│   │   ├── etl_in_memory_collector_test.cpp
│   │   ├── freezer.cpp
│   │   ├── freezer.hpp
│   │   ├── genesis.cpp
│   │   ├── genesis.hpp
│   │   ├── genesis_test.cpp
│   │   ├── kv/
│   │   │   ├── api/
│   │   │   │   ├── as_datastore_ts_range.cpp
│   │   │   │   ├── as_datastore_ts_range.hpp
│   │   │   │   ├── as_datastore_ts_range_test.cpp
│   │   │   │   ├── base_transaction.cpp
│   │   │   │   ├── base_transaction.hpp
│   │   │   │   ├── client.hpp
│   │   │   │   ├── cursor.hpp
│   │   │   │   ├── direct_client.cpp
│   │   │   │   ├── direct_client.hpp
│   │   │   │   ├── direct_service.cpp
│   │   │   │   ├── direct_service.hpp
│   │   │   │   ├── direct_service_test.cpp
│   │   │   │   ├── endpoint/
│   │   │   │   │   ├── common.hpp
│   │   │   │   │   ├── key_value.hpp
│   │   │   │   │   ├── paginated_sequence.hpp
│   │   │   │   │   ├── paginated_sequence_benchmark.cpp
│   │   │   │   │   ├── paginated_sequence_test.cpp
│   │   │   │   │   ├── sequence.hpp
│   │   │   │   │   ├── state_change.hpp
│   │   │   │   │   ├── state_changes_call.hpp
│   │   │   │   │   ├── state_changes_call_test.cpp
│   │   │   │   │   ├── temporal_point.hpp
│   │   │   │   │   ├── temporal_range.hpp
│   │   │   │   │   └── version.hpp
│   │   │   │   ├── local_cursor.cpp
│   │   │   │   ├── local_cursor.hpp
│   │   │   │   ├── local_cursor_test.cpp
│   │   │   │   ├── local_transaction.cpp
│   │   │   │   ├── local_transaction.hpp
│   │   │   │   ├── service.hpp
│   │   │   │   ├── service_router.cpp
│   │   │   │   ├── service_router.hpp
│   │   │   │   ├── state_cache.cpp
│   │   │   │   ├── state_cache.hpp
│   │   │   │   ├── state_cache_test.cpp
│   │   │   │   └── transaction.hpp
│   │   │   ├── grpc/
│   │   │   │   ├── client/
│   │   │   │   │   ├── endpoint/
│   │   │   │   │   │   ├── state_change.cpp
│   │   │   │   │   │   ├── state_change.hpp
│   │   │   │   │   │   ├── temporal_point.cpp
│   │   │   │   │   │   ├── temporal_point.hpp
│   │   │   │   │   │   ├── temporal_point_test.cpp
│   │   │   │   │   │   ├── temporal_range.cpp
│   │   │   │   │   │   ├── temporal_range.hpp
│   │   │   │   │   │   └── temporal_range_test.cpp
│   │   │   │   │   ├── remote_client.cpp
│   │   │   │   │   ├── remote_client.hpp
│   │   │   │   │   ├── remote_client_test.cpp
│   │   │   │   │   ├── remote_cursor.cpp
│   │   │   │   │   ├── remote_cursor.hpp
│   │   │   │   │   ├── remote_cursor_test.cpp
│   │   │   │   │   ├── remote_transaction.cpp
│   │   │   │   │   ├── remote_transaction.hpp
│   │   │   │   │   ├── remote_transaction_test.cpp
│   │   │   │   │   └── rpc.hpp
│   │   │   │   ├── server/
│   │   │   │   │   ├── kv_calls.cpp
│   │   │   │   │   ├── kv_calls.hpp
│   │   │   │   │   ├── kv_calls_test.cpp
│   │   │   │   │   ├── kv_server.cpp
│   │   │   │   │   ├── kv_server.hpp
│   │   │   │   │   ├── kv_server_test.cpp
│   │   │   │   │   ├── state_change_collection.cpp
│   │   │   │   │   ├── state_change_collection.hpp
│   │   │   │   │   └── state_change_collection_test.cpp
│   │   │   │   └── test_util/
│   │   │   │       └── sample_protos.hpp
│   │   │   ├── state_changes_stream.cpp
│   │   │   ├── state_changes_stream.hpp
│   │   │   ├── state_changes_stream_test.cpp
│   │   │   ├── state_reader.cpp
│   │   │   ├── state_reader.hpp
│   │   │   ├── state_reader_test.cpp
│   │   │   ├── txn_num.cpp
│   │   │   ├── txn_num.hpp
│   │   │   └── txn_num_test.cpp
│   │   ├── log_cbor.cpp
│   │   ├── log_cbor.hpp
│   │   ├── log_cbor_test.cpp
│   │   ├── mdbx_test.cpp
│   │   ├── memory_mutation_cursor_test.cpp
│   │   ├── prune_mode.cpp
│   │   ├── prune_mode.hpp
│   │   ├── receipt_cbor.cpp
│   │   ├── receipt_cbor.hpp
│   │   ├── receipt_cbor_test.cpp
│   │   ├── snapshot_benchmark.cpp
│   │   ├── snapshot_decompressor_test.cpp
│   │   ├── snapshot_index_builder_test.cpp
│   │   ├── snapshot_recompress.cpp
│   │   ├── snapshot_recompress.hpp
│   │   ├── snapshot_repository_test.cpp
│   │   ├── snapshot_sync.cpp
│   │   ├── snapshot_sync.hpp
│   │   ├── snapshot_sync_test.cpp
│   │   ├── snapshot_test.cpp
│   │   ├── stage.cpp
│   │   ├── stage.hpp
│   │   ├── stages.cpp
│   │   ├── stages.hpp
│   │   ├── state/
│   │   │   ├── account_codec.cpp
│   │   │   ├── account_codec.hpp
│   │   │   ├── account_codec_test.cpp
│   │   │   ├── account_codecs.hpp
│   │   │   ├── account_codecs_test.cpp
│   │   │   ├── accounts_domain.hpp
│   │   │   ├── address_codecs.hpp
│   │   │   ├── address_codecs_test.cpp
│   │   │   ├── code_domain.hpp
│   │   │   ├── commitment_domain.hpp
│   │   │   ├── hash_decoder.hpp
│   │   │   ├── hash_decoder_test.cpp
│   │   │   ├── log_address_inverted_index.hpp
│   │   │   ├── log_topics_inverted_index.hpp
│   │   │   ├── receipts_domain.hpp
│   │   │   ├── receipts_domain_test.cpp
│   │   │   ├── schema_config.cpp
│   │   │   ├── schema_config.hpp
│   │   │   ├── state_index_builders_factory.cpp
│   │   │   ├── state_index_builders_factory.hpp
│   │   │   ├── step_txn_id_converter.hpp
│   │   │   ├── storage_codecs.cpp
│   │   │   ├── storage_codecs.hpp
│   │   │   ├── storage_codecs_benchmark.cpp
│   │   │   ├── storage_domain.hpp
│   │   │   ├── storage_domain_test.cpp
│   │   │   ├── traces_from_inverted_index.hpp
│   │   │   └── traces_to_inverted_index.hpp
│   │   ├── tables.cpp
│   │   ├── tables.hpp
│   │   ├── test_util/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── kv_test_base.hpp
│   │   │   ├── mock_chain_storage.hpp
│   │   │   ├── mock_cursor.hpp
│   │   │   ├── mock_ro_cursor.hpp
│   │   │   ├── mock_state_cache.hpp
│   │   │   ├── mock_transaction.hpp
│   │   │   ├── mock_txn.hpp
│   │   │   ├── temp_chain_data.cpp
│   │   │   ├── temp_chain_data.hpp
│   │   │   ├── temp_snapshots.hpp
│   │   │   ├── test_database_context.cpp
│   │   │   └── test_database_context.hpp
│   │   ├── util.cpp
│   │   ├── util.hpp
│   │   └── util_test.cpp
│   ├── dev/
│   │   ├── CMakeLists.txt
│   │   ├── cli/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── embed_json.cpp
│   │   │   ├── embed_toml.cpp
│   │   │   ├── kzg_g2_uncompress.cpp
│   │   │   ├── runner.cpp
│   │   │   ├── state_transition_sample1.json
│   │   │   ├── state_transition_sample2.json
│   │   │   ├── state_transition_sample3.json
│   │   │   └── state_transition_sample4.json
│   │   ├── expected_state.cpp
│   │   ├── expected_state.hpp
│   │   ├── state_transition.cpp
│   │   └── state_transition.hpp
│   ├── execution/
│   │   ├── CMakeLists.txt
│   │   ├── api/
│   │   │   ├── active_direct_service.cpp
│   │   │   ├── active_direct_service.hpp
│   │   │   ├── client.hpp
│   │   │   ├── direct_client.cpp
│   │   │   ├── direct_client.hpp
│   │   │   ├── direct_service.cpp
│   │   │   ├── direct_service.hpp
│   │   │   ├── endpoint/
│   │   │   │   ├── assembly.hpp
│   │   │   │   ├── block.hpp
│   │   │   │   ├── checkers.hpp
│   │   │   │   ├── getters.hpp
│   │   │   │   ├── insertion.hpp
│   │   │   │   ├── range.hpp
│   │   │   │   ├── status.hpp
│   │   │   │   └── validation.hpp
│   │   │   ├── execution_engine.hpp
│   │   │   └── service.hpp
│   │   ├── block_executor.cpp
│   │   ├── block_executor.hpp
│   │   ├── domain_state.cpp
│   │   ├── domain_state.hpp
│   │   ├── domain_state_test.cpp
│   │   ├── grpc/
│   │   │   ├── client/
│   │   │   │   ├── endpoint/
│   │   │   │   │   ├── assembly.cpp
│   │   │   │   │   ├── assembly.hpp
│   │   │   │   │   ├── checkers.cpp
│   │   │   │   │   ├── checkers.hpp
│   │   │   │   │   ├── checkers_test.cpp
│   │   │   │   │   ├── getters.cpp
│   │   │   │   │   ├── getters.hpp
│   │   │   │   │   ├── getters_test.cpp
│   │   │   │   │   ├── insertion.cpp
│   │   │   │   │   ├── insertion.hpp
│   │   │   │   │   ├── insertion_test.cpp
│   │   │   │   │   ├── range.cpp
│   │   │   │   │   ├── range.hpp
│   │   │   │   │   ├── status.cpp
│   │   │   │   │   ├── status.hpp
│   │   │   │   │   ├── validation.cpp
│   │   │   │   │   └── validation.hpp
│   │   │   │   ├── remote_client.cpp
│   │   │   │   └── remote_client.hpp
│   │   │   ├── common/
│   │   │   │   ├── block.cpp
│   │   │   │   ├── block.hpp
│   │   │   │   └── block_test.cpp
│   │   │   ├── server/
│   │   │   │   ├── endpoint/
│   │   │   │   │   ├── assembly.cpp
│   │   │   │   │   ├── assembly.hpp
│   │   │   │   │   ├── checkers.cpp
│   │   │   │   │   ├── checkers.hpp
│   │   │   │   │   ├── checkers_test.cpp
│   │   │   │   │   ├── getters.cpp
│   │   │   │   │   ├── getters.hpp
│   │   │   │   │   ├── getters_test.cpp
│   │   │   │   │   ├── insertion.cpp
│   │   │   │   │   ├── insertion.hpp
│   │   │   │   │   ├── insertion_test.cpp
│   │   │   │   │   ├── range.cpp
│   │   │   │   │   ├── range.hpp
│   │   │   │   │   ├── status.cpp
│   │   │   │   │   ├── status.hpp
│   │   │   │   │   ├── validation.cpp
│   │   │   │   │   └── validation.hpp
│   │   │   │   ├── server.cpp
│   │   │   │   ├── server.hpp
│   │   │   │   ├── server_calls.cpp
│   │   │   │   └── server_calls.hpp
│   │   │   └── test_util/
│   │   │       └── sample_protos.hpp
│   │   ├── local_state.cpp
│   │   ├── local_state.hpp
│   │   ├── remote_state.cpp
│   │   ├── remote_state.hpp
│   │   ├── remote_state_test.cpp
│   │   ├── state_factory.cpp
│   │   └── state_factory.hpp
│   ├── infra/
│   │   ├── CMakeLists.txt
│   │   ├── cli/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── common.cpp
│   │   │   ├── common.hpp
│   │   │   ├── human_size_option.cpp
│   │   │   ├── human_size_option.hpp
│   │   │   ├── ip_endpoint_option.cpp
│   │   │   ├── ip_endpoint_option.hpp
│   │   │   ├── shutdown_signal.cpp
│   │   │   └── shutdown_signal.hpp
│   │   ├── common/
│   │   │   ├── application_info.cpp
│   │   │   ├── application_info.hpp
│   │   │   ├── async_binary_search.cpp
│   │   │   ├── async_binary_search.hpp
│   │   │   ├── async_binary_search_test.cpp
│   │   │   ├── binary_search.cpp
│   │   │   ├── binary_search.hpp
│   │   │   ├── binary_search_test.cpp
│   │   │   ├── bounded_buffer.hpp
│   │   │   ├── bounded_buffer_test.cpp
│   │   │   ├── clock_time.cpp
│   │   │   ├── clock_time.hpp
│   │   │   ├── clock_time_test.cpp
│   │   │   ├── decoding_exception.cpp
│   │   │   ├── decoding_exception.hpp
│   │   │   ├── directories.cpp
│   │   │   ├── directories.hpp
│   │   │   ├── directories_test.cpp
│   │   │   ├── ensure.hpp
│   │   │   ├── ensure_test.cpp
│   │   │   ├── environment.cpp
│   │   │   ├── environment.hpp
│   │   │   ├── environment_test.cpp
│   │   │   ├── filesystem.cpp
│   │   │   ├── filesystem.hpp
│   │   │   ├── log.cpp
│   │   │   ├── log.hpp
│   │   │   ├── log_test.cpp
│   │   │   ├── measure.hpp
│   │   │   ├── mem_usage.cpp
│   │   │   ├── mem_usage.hpp
│   │   │   ├── memory_mapped_file.cpp
│   │   │   ├── memory_mapped_file.hpp
│   │   │   ├── memory_mapped_file_benchmark.cpp
│   │   │   ├── memory_mapped_file_test.cpp
│   │   │   ├── os.cpp
│   │   │   ├── os.hpp
│   │   │   ├── os_test.cpp
│   │   │   ├── safe_strerror.cpp
│   │   │   ├── safe_strerror.hpp
│   │   │   ├── secp256k1_context.cpp
│   │   │   ├── secp256k1_context.hpp
│   │   │   ├── stopwatch.cpp
│   │   │   ├── stopwatch.hpp
│   │   │   ├── stopwatch_test.cpp
│   │   │   ├── terminal.cpp
│   │   │   ├── terminal.hpp
│   │   │   ├── timer.cpp
│   │   │   ├── timer.hpp
│   │   │   ├── timer_test.cpp
│   │   │   ├── unix_timestamp.cpp
│   │   │   └── unix_timestamp.hpp
│   │   ├── concurrency/
│   │   │   ├── active_component.hpp
│   │   │   ├── async_thread.cpp
│   │   │   ├── async_thread.hpp
│   │   │   ├── awaitable_condition_variable.cpp
│   │   │   ├── awaitable_condition_variable.hpp
│   │   │   ├── awaitable_condition_variable_test.cpp
│   │   │   ├── awaitable_future.hpp
│   │   │   ├── awaitable_future_test.cpp
│   │   │   ├── awaitable_wait_for_all.hpp
│   │   │   ├── awaitable_wait_for_one.hpp
│   │   │   ├── base_service.hpp
│   │   │   ├── cancellation_token.hpp
│   │   │   ├── channel.hpp
│   │   │   ├── channel_test.cpp
│   │   │   ├── containers.hpp
│   │   │   ├── context_pool.cpp
│   │   │   ├── context_pool.hpp
│   │   │   ├── context_pool_settings.hpp
│   │   │   ├── context_pool_test.cpp
│   │   │   ├── coroutine.hpp
│   │   │   ├── coroutine_test.cpp
│   │   │   ├── event_notifier.hpp
│   │   │   ├── executor_pool.hpp
│   │   │   ├── parallel_group_test.cpp
│   │   │   ├── parallel_group_utils.cpp
│   │   │   ├── parallel_group_utils.hpp
│   │   │   ├── private_service.hpp
│   │   │   ├── private_service_test.cpp
│   │   │   ├── shared_service.hpp
│   │   │   ├── shared_service_test.cpp
│   │   │   ├── signal_handler.cpp
│   │   │   ├── signal_handler.hpp
│   │   │   ├── signal_handler_test.cpp
│   │   │   ├── sleep.cpp
│   │   │   ├── sleep.hpp
│   │   │   ├── spawn.hpp
│   │   │   ├── spawn_test.cpp
│   │   │   ├── stoppable.hpp
│   │   │   ├── stoppable_test.cpp
│   │   │   ├── task.hpp
│   │   │   ├── task_group.cpp
│   │   │   ├── task_group.hpp
│   │   │   ├── task_group_test.cpp
│   │   │   ├── thread_pool.hpp
│   │   │   ├── thread_safe_queue.hpp
│   │   │   ├── timeout.cpp
│   │   │   ├── timeout.hpp
│   │   │   └── timeout_test.cpp
│   │   ├── grpc/
│   │   │   ├── client/
│   │   │   │   ├── call.hpp
│   │   │   │   ├── call_test.cpp
│   │   │   │   ├── client_context_pool.cpp
│   │   │   │   ├── client_context_pool.hpp
│   │   │   │   ├── client_context_pool_test.cpp
│   │   │   │   ├── dispatcher.hpp
│   │   │   │   ├── error.cpp
│   │   │   │   ├── error.hpp
│   │   │   │   ├── error_test.cpp
│   │   │   │   ├── reconnect.cpp
│   │   │   │   └── reconnect.hpp
│   │   │   ├── common/
│   │   │   │   ├── bytes.hpp
│   │   │   │   ├── completion_tag.hpp
│   │   │   │   ├── conversion.cpp
│   │   │   │   ├── conversion.hpp
│   │   │   │   ├── conversion_test.cpp
│   │   │   │   ├── errors.cpp
│   │   │   │   ├── errors.hpp
│   │   │   │   ├── grpc_context_pool.hpp
│   │   │   │   ├── util.hpp
│   │   │   │   ├── util_test.cpp
│   │   │   │   ├── version.cpp
│   │   │   │   ├── version.hpp
│   │   │   │   └── version_test.cpp
│   │   │   ├── server/
│   │   │   │   ├── call.hpp
│   │   │   │   ├── call_test.cpp
│   │   │   │   ├── server.hpp
│   │   │   │   ├── server_callbacks.hpp
│   │   │   │   ├── server_context_pool.cpp
│   │   │   │   ├── server_context_pool.hpp
│   │   │   │   ├── server_context_pool_test.cpp
│   │   │   │   ├── server_settings.hpp
│   │   │   │   ├── server_settings_test.cpp
│   │   │   │   └── server_test.cpp
│   │   │   └── test_util/
│   │   │       ├── grpc_actions.hpp
│   │   │       ├── grpc_matcher.hpp
│   │   │       ├── grpc_responder.hpp
│   │   │       ├── interfaces/
│   │   │       │   ├── ethbackend_mock_fix24351.grpc.pb.h
│   │   │       │   ├── kv_mock_fix24351.grpc.pb.h
│   │   │       │   ├── mining_mock_fix24351.grpc.pb.h
│   │   │       │   └── txpool_mock_fix24351.grpc.pb.h
│   │   │       └── test_runner.hpp
│   │   └── test_util/
│   │       ├── CMakeLists.txt
│   │       ├── context_test_base.cpp
│   │       ├── context_test_base.hpp
│   │       ├── fixture.hpp
│   │       ├── hex.cpp
│   │       ├── hex.hpp
│   │       ├── log.hpp
│   │       ├── task_runner.hpp
│   │       └── temporary_file.hpp
│   ├── interfaces/
│   │   ├── .gitignore
│   │   ├── 27.0/
│   │   │   ├── execution/
│   │   │   │   ├── execution.grpc.pb.cc
│   │   │   │   ├── execution.grpc.pb.h
│   │   │   │   ├── execution.pb.cc
│   │   │   │   ├── execution.pb.h
│   │   │   │   └── execution_mock.grpc.pb.h
│   │   │   ├── p2psentry/
│   │   │   │   ├── sentry.grpc.pb.cc
│   │   │   │   ├── sentry.grpc.pb.h
│   │   │   │   ├── sentry.pb.cc
│   │   │   │   ├── sentry.pb.h
│   │   │   │   └── sentry_mock.grpc.pb.h
│   │   │   ├── remote/
│   │   │   │   ├── bor.grpc.pb.cc
│   │   │   │   ├── bor.grpc.pb.h
│   │   │   │   ├── bor.pb.cc
│   │   │   │   ├── bor.pb.h
│   │   │   │   ├── bor_mock.grpc.pb.h
│   │   │   │   ├── ethbackend.grpc.pb.cc
│   │   │   │   ├── ethbackend.grpc.pb.h
│   │   │   │   ├── ethbackend.pb.cc
│   │   │   │   ├── ethbackend.pb.h
│   │   │   │   ├── ethbackend_mock.grpc.pb.h
│   │   │   │   ├── kv.grpc.pb.cc
│   │   │   │   ├── kv.grpc.pb.h
│   │   │   │   ├── kv.pb.cc
│   │   │   │   ├── kv.pb.h
│   │   │   │   └── kv_mock.grpc.pb.h
│   │   │   ├── txpool/
│   │   │   │   ├── mining.grpc.pb.cc
│   │   │   │   ├── mining.grpc.pb.h
│   │   │   │   ├── mining.pb.cc
│   │   │   │   ├── mining.pb.h
│   │   │   │   ├── mining_mock.grpc.pb.h
│   │   │   │   ├── txpool.grpc.pb.cc
│   │   │   │   ├── txpool.grpc.pb.h
│   │   │   │   ├── txpool.pb.cc
│   │   │   │   ├── txpool.pb.h
│   │   │   │   └── txpool_mock.grpc.pb.h
│   │   │   └── types/
│   │   │       ├── types.pb.cc
│   │   │       └── types.pb.h
│   │   ├── CMakeLists.txt
│   │   └── generate_grpc.cmake
│   ├── node/
│   │   ├── CMakeLists.txt
│   │   ├── backend/
│   │   │   ├── ethereum_backend.cpp
│   │   │   ├── ethereum_backend.hpp
│   │   │   └── ethereum_backend_test.cpp
│   │   ├── backend_kv_server.cpp
│   │   ├── backend_kv_server.hpp
│   │   ├── cli/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── backend_kv_server.cpp
│   │   │   ├── node_options.cpp
│   │   │   ├── node_options.hpp
│   │   │   └── staged_pipeline.cpp
│   │   ├── common/
│   │   │   └── node_settings.hpp
│   │   ├── execution/
│   │   │   ├── active_direct_service_test.cpp
│   │   │   ├── direct_service_test.cpp
│   │   │   └── header_chain_plus_exec_test.cpp
│   │   ├── node.cpp
│   │   ├── node.hpp
│   │   ├── remote/
│   │   │   └── ethbackend/
│   │   │       └── grpc/
│   │   │           └── server/
│   │   │               ├── backend_calls.cpp
│   │   │               ├── backend_calls.hpp
│   │   │               ├── backend_server.cpp
│   │   │               ├── backend_server.hpp
│   │   │               └── backend_server_test.cpp
│   │   ├── resource_usage.cpp
│   │   ├── resource_usage.hpp
│   │   ├── settings.hpp
│   │   ├── stagedsync/
│   │   │   ├── execution_engine.cpp
│   │   │   ├── execution_engine.hpp
│   │   │   ├── execution_engine_test.cpp
│   │   │   ├── execution_pipeline.cpp
│   │   │   ├── execution_pipeline.hpp
│   │   │   ├── forks/
│   │   │   │   ├── canonical_chain.cpp
│   │   │   │   ├── canonical_chain.hpp
│   │   │   │   ├── extending_fork.cpp
│   │   │   │   ├── extending_fork.hpp
│   │   │   │   ├── fork.cpp
│   │   │   │   ├── fork.hpp
│   │   │   │   ├── fork_test.cpp
│   │   │   │   ├── main_chain.cpp
│   │   │   │   ├── main_chain.hpp
│   │   │   │   └── main_chain_test.cpp
│   │   │   ├── stages/
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── stage_blockhashes.cpp
│   │   │   │   ├── stage_blockhashes.hpp
│   │   │   │   ├── stage_bodies.cpp
│   │   │   │   ├── stage_bodies.hpp
│   │   │   │   ├── stage_bodies_factory.hpp
│   │   │   │   ├── stage_bodies_test.cpp
│   │   │   │   ├── stage_call_trace_index.cpp
│   │   │   │   ├── stage_call_trace_index.hpp
│   │   │   │   ├── stage_execution.cpp
│   │   │   │   ├── stage_execution.hpp
│   │   │   │   ├── stage_finish.cpp
│   │   │   │   ├── stage_finish.hpp
│   │   │   │   ├── stage_hashstate.cpp
│   │   │   │   ├── stage_hashstate.hpp
│   │   │   │   ├── stage_headers.cpp
│   │   │   │   ├── stage_headers.hpp
│   │   │   │   ├── stage_headers_test.cpp
│   │   │   │   ├── stage_history_index.cpp
│   │   │   │   ├── stage_history_index.hpp
│   │   │   │   ├── stage_history_index_test.cpp
│   │   │   │   ├── stage_interhashes/
│   │   │   │   │   ├── _test.cpp
│   │   │   │   │   ├── trie_cursor.cpp
│   │   │   │   │   ├── trie_cursor.hpp
│   │   │   │   │   ├── trie_loader.cpp
│   │   │   │   │   └── trie_loader.hpp
│   │   │   │   ├── stage_interhashes.cpp
│   │   │   │   ├── stage_interhashes.hpp
│   │   │   │   ├── stage_log_index.cpp
│   │   │   │   ├── stage_log_index.hpp
│   │   │   │   ├── stage_senders.cpp
│   │   │   │   ├── stage_senders.hpp
│   │   │   │   ├── stage_triggers.cpp
│   │   │   │   ├── stage_triggers.hpp
│   │   │   │   ├── stage_triggers_test.cpp
│   │   │   │   ├── stage_tx_lookup.cpp
│   │   │   │   ├── stage_tx_lookup.hpp
│   │   │   │   └── stage_tx_lookup_test.cpp
│   │   │   ├── stages_factory_impl.cpp
│   │   │   ├── stages_factory_impl.hpp
│   │   │   ├── stages_test.cpp
│   │   │   ├── timer_factory.hpp
│   │   │   └── types.hpp
│   │   └── test_util/
│   │       ├── CMakeLists.txt
│   │       ├── dummy.cpp
│   │       ├── make_stages_factory.cpp
│   │       ├── make_stages_factory.hpp
│   │       ├── mock_execution_engine.hpp
│   │       └── temp_chain_data_node_settings.hpp
│   ├── rpc/
│   │   ├── CMakeLists.txt
│   │   ├── capi/
│   │   │   ├── rpcdaemon.cpp
│   │   │   └── rpcdaemon.h
│   │   ├── cli/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── grpc_toolbox.cpp
│   │   │   ├── rpcdaemon_options.cpp
│   │   │   └── rpcdaemon_options.hpp
│   │   ├── commands/
│   │   │   ├── admin_api.cpp
│   │   │   ├── admin_api.hpp
│   │   │   ├── debug_api.cpp
│   │   │   ├── debug_api.hpp
│   │   │   ├── debug_api_test.cpp
│   │   │   ├── engine_api.cpp
│   │   │   ├── engine_api.hpp
│   │   │   ├── engine_api_test.cpp
│   │   │   ├── erigon_api.cpp
│   │   │   ├── erigon_api.hpp
│   │   │   ├── erigon_api_test.cpp
│   │   │   ├── eth_api.cpp
│   │   │   ├── eth_api.hpp
│   │   │   ├── eth_api_test.cpp
│   │   │   ├── net_api.cpp
│   │   │   ├── net_api.hpp
│   │   │   ├── net_api_test.cpp
│   │   │   ├── ots_api.cpp
│   │   │   ├── ots_api.hpp
│   │   │   ├── parity_api.cpp
│   │   │   ├── parity_api.hpp
│   │   │   ├── parity_api_test.cpp
│   │   │   ├── rpc_api.hpp
│   │   │   ├── rpc_api_table.cpp
│   │   │   ├── rpc_api_table.hpp
│   │   │   ├── rpc_api_table_test.cpp
│   │   │   ├── rpc_api_test.cpp
│   │   │   ├── trace_api.cpp
│   │   │   ├── trace_api.hpp
│   │   │   ├── trace_api_test.cpp
│   │   │   ├── txpool_api.cpp
│   │   │   ├── txpool_api.hpp
│   │   │   ├── web3_api.cpp
│   │   │   ├── web3_api.hpp
│   │   │   └── web3_api_test.cpp
│   │   ├── common/
│   │   │   ├── async_task.hpp
│   │   │   ├── async_task_benchmark.cpp
│   │   │   ├── async_task_test.cpp
│   │   │   ├── compatibility.cpp
│   │   │   ├── compatibility.hpp
│   │   │   ├── constants.hpp
│   │   │   ├── interface_log.cpp
│   │   │   ├── interface_log.hpp
│   │   │   ├── interface_log_test.cpp
│   │   │   ├── tee.hpp
│   │   │   ├── util.cpp
│   │   │   ├── util.hpp
│   │   │   ├── util_test.cpp
│   │   │   └── worker_pool.hpp
│   │   ├── core/
│   │   │   ├── account_dumper.cpp
│   │   │   ├── account_dumper.hpp
│   │   │   ├── account_dumper_test.cpp
│   │   │   ├── block_reader.cpp
│   │   │   ├── block_reader.hpp
│   │   │   ├── block_reader_test.cpp
│   │   │   ├── call_many.cpp
│   │   │   ├── call_many.hpp
│   │   │   ├── estimate_gas_oracle.cpp
│   │   │   ├── estimate_gas_oracle.hpp
│   │   │   ├── estimate_gas_oracle_test.cpp
│   │   │   ├── evm_access_list_tracer.cpp
│   │   │   ├── evm_access_list_tracer.hpp
│   │   │   ├── evm_debug.cpp
│   │   │   ├── evm_debug.hpp
│   │   │   ├── evm_debug_test.cpp
│   │   │   ├── evm_executor.cpp
│   │   │   ├── evm_executor.hpp
│   │   │   ├── evm_executor_test.cpp
│   │   │   ├── evm_trace.cpp
│   │   │   ├── evm_trace.hpp
│   │   │   ├── evm_trace_test.cpp
│   │   │   ├── fee_history_oracle.cpp
│   │   │   ├── fee_history_oracle.hpp
│   │   │   ├── fee_history_oracle_test.cpp
│   │   │   ├── filter_storage.cpp
│   │   │   ├── filter_storage.hpp
│   │   │   ├── filter_storage_test.cpp
│   │   │   ├── gas_price_oracle.cpp
│   │   │   ├── gas_price_oracle.hpp
│   │   │   ├── gas_price_oracle_test.cpp
│   │   │   ├── logs_walker.cpp
│   │   │   ├── logs_walker.hpp
│   │   │   ├── override_state.cpp
│   │   │   ├── override_state.hpp
│   │   │   ├── receipts.cpp
│   │   │   ├── receipts.hpp
│   │   │   ├── receipts_cache.hpp
│   │   │   ├── receipts_test.cpp
│   │   │   ├── storage_walker.cpp
│   │   │   ├── storage_walker.hpp
│   │   │   └── storage_walker_test.cpp
│   │   ├── daemon.cpp
│   │   ├── daemon.hpp
│   │   ├── daemon_test.cpp
│   │   ├── engine/
│   │   │   ├── conversion.cpp
│   │   │   ├── conversion.hpp
│   │   │   ├── execution_engine.hpp
│   │   │   ├── remote_execution_engine.cpp
│   │   │   ├── remote_execution_engine.hpp
│   │   │   ├── validation.cpp
│   │   │   └── validation.hpp
│   │   ├── ethbackend/
│   │   │   ├── backend.hpp
│   │   │   ├── remote_backend.cpp
│   │   │   ├── remote_backend.hpp
│   │   │   └── remote_backend_test.cpp
│   │   ├── ethdb/
│   │   │   ├── bitmap.cpp
│   │   │   ├── bitmap.hpp
│   │   │   ├── cbor.cpp
│   │   │   ├── cbor.hpp
│   │   │   ├── cbor_test.cpp
│   │   │   ├── kv/
│   │   │   │   └── backend_providers.hpp
│   │   │   ├── split_cursor.cpp
│   │   │   ├── split_cursor.hpp
│   │   │   ├── split_cursor_test.cpp
│   │   │   ├── walk.cpp
│   │   │   └── walk.hpp
│   │   ├── http/
│   │   │   ├── chunker.hpp
│   │   │   ├── connection.cpp
│   │   │   ├── connection.hpp
│   │   │   ├── connection_test.cpp
│   │   │   ├── deflater.hpp
│   │   │   ├── jwt.cpp
│   │   │   ├── jwt.hpp
│   │   │   ├── jwt_test.cpp
│   │   │   ├── server.cpp
│   │   │   ├── server.hpp
│   │   │   └── zlib_compressor.hpp
│   │   ├── json/
│   │   │   ├── access_list_entry.cpp
│   │   │   ├── access_list_entry.hpp
│   │   │   ├── authorization.cpp
│   │   │   ├── authorization.hpp
│   │   │   ├── block.cpp
│   │   │   ├── block.hpp
│   │   │   ├── block_test.cpp
│   │   │   ├── cache_validation_result.cpp
│   │   │   ├── cache_validation_result.hpp
│   │   │   ├── call.cpp
│   │   │   ├── call.hpp
│   │   │   ├── call_bundle.cpp
│   │   │   ├── call_bundle.hpp
│   │   │   ├── call_bundle_test.cpp
│   │   │   ├── call_test.cpp
│   │   │   ├── client_version.cpp
│   │   │   ├── client_version.hpp
│   │   │   ├── execution_payload.cpp
│   │   │   ├── execution_payload.hpp
│   │   │   ├── execution_payload_test.cpp
│   │   │   ├── filter.cpp
│   │   │   ├── filter.hpp
│   │   │   ├── filter_test.cpp
│   │   │   ├── fork_choice.cpp
│   │   │   ├── fork_choice.hpp
│   │   │   ├── fork_choice_test.cpp
│   │   │   ├── glaze.cpp
│   │   │   ├── glaze.hpp
│   │   │   ├── glaze_test.cpp
│   │   │   ├── log.cpp
│   │   │   ├── log.hpp
│   │   │   ├── log_test.cpp
│   │   │   ├── node_info.cpp
│   │   │   ├── node_info.hpp
│   │   │   ├── node_info_test.cpp
│   │   │   ├── payload_attributes.cpp
│   │   │   ├── payload_attributes.hpp
│   │   │   ├── payload_attributes_test.cpp
│   │   │   ├── receipt.cpp
│   │   │   ├── receipt.hpp
│   │   │   ├── receipt_test.cpp
│   │   │   ├── stream.cpp
│   │   │   ├── stream.hpp
│   │   │   ├── stream_test.cpp
│   │   │   ├── transaction.cpp
│   │   │   ├── transaction.hpp
│   │   │   ├── transaction_test.cpp
│   │   │   ├── transition_configuration.cpp
│   │   │   ├── transition_configuration.hpp
│   │   │   ├── transition_configuration_test.cpp
│   │   │   ├── types.cpp
│   │   │   ├── types.hpp
│   │   │   ├── types_test.cpp
│   │   │   ├── withdrawal.cpp
│   │   │   ├── withdrawal.hpp
│   │   │   └── withdrawal_test.cpp
│   │   ├── json_rpc/
│   │   │   ├── methods.hpp
│   │   │   ├── request_handler.cpp
│   │   │   ├── request_handler.hpp
│   │   │   ├── request_handler_test.cpp
│   │   │   ├── specification.cpp
│   │   │   ├── specification.hpp
│   │   │   ├── specification.json
│   │   │   ├── validator.cpp
│   │   │   ├── validator.hpp
│   │   │   ├── validator_benchmark.cpp
│   │   │   └── validator_test.cpp
│   │   ├── protocol/
│   │   │   ├── errors.cpp
│   │   │   └── errors.hpp
│   │   ├── settings.hpp
│   │   ├── stagedsync/
│   │   │   ├── stages.cpp
│   │   │   ├── stages.hpp
│   │   │   └── stages_test.cpp
│   │   ├── test_util/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── api_test_base.hpp
│   │   │   ├── api_test_database.hpp
│   │   │   ├── dummy_client.hpp
│   │   │   ├── dummy_transaction.hpp
│   │   │   ├── mock_back_end.hpp
│   │   │   ├── mock_block_cache.hpp
│   │   │   ├── mock_estimate_gas_oracle.hpp
│   │   │   ├── mock_execution_engine.hpp
│   │   │   ├── mock_state_cache.hpp
│   │   │   ├── service_context_test_base.cpp
│   │   │   └── service_context_test_base.hpp
│   │   ├── transport/
│   │   │   ├── request_handler.hpp
│   │   │   ├── stream_writer.hpp
│   │   │   └── stream_writer_test.cpp
│   │   ├── txpool/
│   │   │   ├── miner.cpp
│   │   │   ├── miner.hpp
│   │   │   ├── miner_test.cpp
│   │   │   ├── transaction_pool.cpp
│   │   │   ├── transaction_pool.hpp
│   │   │   └── transaction_pool_test.cpp
│   │   ├── types/
│   │   │   ├── block.cpp
│   │   │   ├── block.hpp
│   │   │   ├── block_test.cpp
│   │   │   ├── cache_validation_result.hpp
│   │   │   ├── call.cpp
│   │   │   ├── call.hpp
│   │   │   ├── call_bundle.hpp
│   │   │   ├── call_test.cpp
│   │   │   ├── chain_config.cpp
│   │   │   ├── chain_config.hpp
│   │   │   ├── chain_config_test.cpp
│   │   │   ├── chain_traffic.hpp
│   │   │   ├── dump_account.cpp
│   │   │   ├── dump_account.hpp
│   │   │   ├── dump_account_test.cpp
│   │   │   ├── error.cpp
│   │   │   ├── error.hpp
│   │   │   ├── error_test.cpp
│   │   │   ├── execution_payload.cpp
│   │   │   ├── execution_payload.hpp
│   │   │   ├── execution_payload_test.cpp
│   │   │   ├── filter.cpp
│   │   │   ├── filter.hpp
│   │   │   ├── filter_test.cpp
│   │   │   ├── issuance.cpp
│   │   │   ├── issuance.hpp
│   │   │   ├── issuance_test.cpp
│   │   │   ├── log.cpp
│   │   │   ├── log.hpp
│   │   │   ├── log_test.cpp
│   │   │   ├── node_info.hpp
│   │   │   ├── peer_info.hpp
│   │   │   ├── receipt.cpp
│   │   │   ├── receipt.hpp
│   │   │   ├── receipt_test.cpp
│   │   │   ├── syncing_data.hpp
│   │   │   ├── transaction.cpp
│   │   │   ├── transaction.hpp
│   │   │   └── transaction_test.cpp
│   │   └── ws/
│   │       ├── connection.cpp
│   │       └── connection.hpp
│   ├── sentry/
│   │   ├── CMakeLists.txt
│   │   ├── api/
│   │   │   ├── common/
│   │   │   │   ├── message_from_peer.hpp
│   │   │   │   ├── message_id_set.hpp
│   │   │   │   ├── node_info.hpp
│   │   │   │   ├── peer_event.hpp
│   │   │   │   ├── peer_filter.hpp
│   │   │   │   ├── peer_info.hpp
│   │   │   │   ├── sentry_client.hpp
│   │   │   │   └── service.hpp
│   │   │   └── router/
│   │   │       ├── direct_service.cpp
│   │   │       ├── direct_service.hpp
│   │   │       ├── messages_call.hpp
│   │   │       ├── peer_call.hpp
│   │   │       ├── peer_events_call.hpp
│   │   │       ├── send_message_call.hpp
│   │   │       └── service_router.hpp
│   │   ├── capi/
│   │   │   ├── component.hpp
│   │   │   ├── sentry.cpp
│   │   │   └── sentry.h
│   │   ├── cli/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── sentry_options.cpp
│   │   │   └── sentry_options.hpp
│   │   ├── common/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── atomic_value.hpp
│   │   │   ├── crypto/
│   │   │   │   ├── ecdsa_signature.cpp
│   │   │   │   ├── ecdsa_signature.hpp
│   │   │   │   ├── xor.cpp
│   │   │   │   └── xor.hpp
│   │   │   ├── ecc_key_pair.cpp
│   │   │   ├── ecc_key_pair.hpp
│   │   │   ├── ecc_key_pair_test.cpp
│   │   │   ├── ecc_public_key.cpp
│   │   │   ├── ecc_public_key.hpp
│   │   │   ├── enode_url.cpp
│   │   │   ├── enode_url.hpp
│   │   │   ├── enode_url_test.cpp
│   │   │   ├── error.hpp
│   │   │   ├── message.hpp
│   │   │   ├── random.cpp
│   │   │   ├── random.hpp
│   │   │   ├── socket_stream.cpp
│   │   │   └── socket_stream.hpp
│   │   ├── discovery/
│   │   │   ├── bootnodes.cpp
│   │   │   ├── bootnodes.hpp
│   │   │   ├── common/
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── node_address.cpp
│   │   │   │   └── node_address.hpp
│   │   │   ├── disc_v4/
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── common/
│   │   │   │   │   ├── ip_classify.cpp
│   │   │   │   │   ├── ip_classify.hpp
│   │   │   │   │   ├── ip_classify_test.cpp
│   │   │   │   │   ├── ipv6_unsupported_error.hpp
│   │   │   │   │   ├── message_expiration.cpp
│   │   │   │   │   ├── message_expiration.hpp
│   │   │   │   │   ├── node_distance.cpp
│   │   │   │   │   ├── node_distance.hpp
│   │   │   │   │   ├── node_distance_test.cpp
│   │   │   │   │   └── packet_type.hpp
│   │   │   │   ├── discovery.cpp
│   │   │   │   ├── discovery.hpp
│   │   │   │   ├── enr/
│   │   │   │   │   ├── enr_request_handler.cpp
│   │   │   │   │   ├── enr_request_handler.hpp
│   │   │   │   │   ├── enr_request_message.cpp
│   │   │   │   │   ├── enr_request_message.hpp
│   │   │   │   │   ├── enr_response_message.cpp
│   │   │   │   │   ├── enr_response_message.hpp
│   │   │   │   │   ├── enr_response_message_test.cpp
│   │   │   │   │   ├── fetch_enr_record.cpp
│   │   │   │   │   ├── fetch_enr_record.hpp
│   │   │   │   │   ├── message_handler.hpp
│   │   │   │   │   └── message_sender.hpp
│   │   │   │   ├── find/
│   │   │   │   │   ├── find_neighbors.cpp
│   │   │   │   │   ├── find_neighbors.hpp
│   │   │   │   │   ├── find_node_handler.cpp
│   │   │   │   │   ├── find_node_handler.hpp
│   │   │   │   │   ├── find_node_message.cpp
│   │   │   │   │   ├── find_node_message.hpp
│   │   │   │   │   ├── lookup.cpp
│   │   │   │   │   ├── lookup.hpp
│   │   │   │   │   ├── message_handler.hpp
│   │   │   │   │   ├── message_sender.hpp
│   │   │   │   │   ├── neighbors_message.cpp
│   │   │   │   │   └── neighbors_message.hpp
│   │   │   │   ├── message_codec.cpp
│   │   │   │   ├── message_codec.hpp
│   │   │   │   ├── message_codec_test.cpp
│   │   │   │   ├── message_handler.hpp
│   │   │   │   ├── message_sender.hpp
│   │   │   │   ├── ping/
│   │   │   │   │   ├── message_handler.hpp
│   │   │   │   │   ├── message_sender.hpp
│   │   │   │   │   ├── ping_check.cpp
│   │   │   │   │   ├── ping_check.hpp
│   │   │   │   │   ├── ping_handler.cpp
│   │   │   │   │   ├── ping_handler.hpp
│   │   │   │   │   ├── ping_message.cpp
│   │   │   │   │   ├── ping_message.hpp
│   │   │   │   │   ├── pong_message.cpp
│   │   │   │   │   └── pong_message.hpp
│   │   │   │   ├── server.cpp
│   │   │   │   └── server.hpp
│   │   │   ├── discovery.cpp
│   │   │   ├── discovery.hpp
│   │   │   ├── enr/
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── enr_codec.cpp
│   │   │   │   ├── enr_codec.hpp
│   │   │   │   ├── enr_record.hpp
│   │   │   │   ├── enr_url.cpp
│   │   │   │   ├── enr_url.hpp
│   │   │   │   └── enr_url_test.cpp
│   │   │   └── node_db/
│   │   │       ├── CMakeLists.txt
│   │   │       ├── node_db.hpp
│   │   │       ├── node_db_sqlite.cpp
│   │   │       ├── node_db_sqlite.hpp
│   │   │       ├── node_db_sqlite_test.cpp
│   │   │       ├── serial_node_db.cpp
│   │   │       └── serial_node_db.hpp
│   │   ├── eth/
│   │   │   ├── fork_id.cpp
│   │   │   ├── fork_id.hpp
│   │   │   ├── fork_id_test.cpp
│   │   │   ├── message_id.cpp
│   │   │   ├── message_id.hpp
│   │   │   ├── protocol.cpp
│   │   │   ├── protocol.hpp
│   │   │   ├── status_data.hpp
│   │   │   ├── status_data_provider.cpp
│   │   │   ├── status_data_provider.hpp
│   │   │   ├── status_message.cpp
│   │   │   └── status_message.hpp
│   │   ├── grpc/
│   │   │   ├── client/
│   │   │   │   ├── sentry_client.cpp
│   │   │   │   └── sentry_client.hpp
│   │   │   ├── interfaces/
│   │   │   │   ├── eth_version.cpp
│   │   │   │   ├── eth_version.hpp
│   │   │   │   ├── message.cpp
│   │   │   │   ├── message.hpp
│   │   │   │   ├── node_info.cpp
│   │   │   │   ├── node_info.hpp
│   │   │   │   ├── peer_event.cpp
│   │   │   │   ├── peer_event.hpp
│   │   │   │   ├── peer_id.cpp
│   │   │   │   ├── peer_id.hpp
│   │   │   │   ├── peer_info.cpp
│   │   │   │   ├── peer_info.hpp
│   │   │   │   ├── sent_peer_ids.cpp
│   │   │   │   ├── sent_peer_ids.hpp
│   │   │   │   ├── status_data.cpp
│   │   │   │   └── status_data.hpp
│   │   │   └── server/
│   │   │       ├── server.cpp
│   │   │       ├── server.hpp
│   │   │       └── server_calls.hpp
│   │   ├── grpc_requests.http
│   │   ├── message_receiver.cpp
│   │   ├── message_receiver.hpp
│   │   ├── message_sender.cpp
│   │   ├── message_sender.hpp
│   │   ├── multi_sentry_client.cpp
│   │   ├── multi_sentry_client.hpp
│   │   ├── nat/
│   │   │   ├── address_util.cpp
│   │   │   ├── address_util.hpp
│   │   │   ├── address_util_test.cpp
│   │   │   ├── ip_resolver.cpp
│   │   │   ├── ip_resolver.hpp
│   │   │   ├── local_ip_resolver.cpp
│   │   │   ├── local_ip_resolver.hpp
│   │   │   ├── nat_option.cpp
│   │   │   ├── nat_option.hpp
│   │   │   ├── stun_ip_resolver.cpp
│   │   │   └── stun_ip_resolver.hpp
│   │   ├── node_key_config.cpp
│   │   ├── node_key_config.hpp
│   │   ├── node_key_config_test.cpp
│   │   ├── peer_discovery_feedback.cpp
│   │   ├── peer_discovery_feedback.hpp
│   │   ├── peer_manager.cpp
│   │   ├── peer_manager.hpp
│   │   ├── peer_manager_api.cpp
│   │   ├── peer_manager_api.hpp
│   │   ├── peer_manager_observer.hpp
│   │   ├── rlpx/
│   │   │   ├── auth/
│   │   │   │   ├── auth_ack_message.cpp
│   │   │   │   ├── auth_ack_message.hpp
│   │   │   │   ├── auth_initiator.cpp
│   │   │   │   ├── auth_initiator.hpp
│   │   │   │   ├── auth_keys.hpp
│   │   │   │   ├── auth_message.cpp
│   │   │   │   ├── auth_message.hpp
│   │   │   │   ├── auth_message_error.hpp
│   │   │   │   ├── auth_recipient.cpp
│   │   │   │   ├── auth_recipient.hpp
│   │   │   │   ├── ecies_cipher.cpp
│   │   │   │   ├── ecies_cipher.hpp
│   │   │   │   ├── ecies_cipher_error.hpp
│   │   │   │   ├── ecies_cipher_test.cpp
│   │   │   │   ├── handshake.cpp
│   │   │   │   ├── handshake.hpp
│   │   │   │   ├── hello_message.cpp
│   │   │   │   └── hello_message.hpp
│   │   │   ├── client.cpp
│   │   │   ├── client.hpp
│   │   │   ├── common/
│   │   │   │   ├── disconnect_message.cpp
│   │   │   │   ├── disconnect_message.hpp
│   │   │   │   ├── disconnect_message_test.cpp
│   │   │   │   └── disconnect_reason.hpp
│   │   │   ├── crypto/
│   │   │   │   ├── aes.cpp
│   │   │   │   ├── aes.hpp
│   │   │   │   ├── hmac.cpp
│   │   │   │   ├── hmac.hpp
│   │   │   │   ├── sha256.cpp
│   │   │   │   ├── sha256.hpp
│   │   │   │   ├── sha3_hasher.cpp
│   │   │   │   ├── sha3_hasher.hpp
│   │   │   │   └── sha3_hasher_test.cpp
│   │   │   ├── framing/
│   │   │   │   ├── framing_cipher.cpp
│   │   │   │   ├── framing_cipher.hpp
│   │   │   │   ├── message_frame_codec.cpp
│   │   │   │   ├── message_frame_codec.hpp
│   │   │   │   ├── message_stream.cpp
│   │   │   │   └── message_stream.hpp
│   │   │   ├── peer.cpp
│   │   │   ├── peer.hpp
│   │   │   ├── ping_message.cpp
│   │   │   ├── ping_message.hpp
│   │   │   ├── protocol.hpp
│   │   │   ├── server.cpp
│   │   │   └── server.hpp
│   │   ├── sentry.cpp
│   │   ├── sentry.hpp
│   │   ├── sentry_client_factory.cpp
│   │   ├── sentry_client_factory.hpp
│   │   ├── session_sentry_client.cpp
│   │   ├── session_sentry_client.hpp
│   │   ├── settings.hpp
│   │   ├── status_manager.cpp
│   │   └── status_manager.hpp
│   ├── sync/
│   │   ├── CMakeLists.txt
│   │   ├── README.md
│   │   ├── block_exchange.cpp
│   │   ├── block_exchange.hpp
│   │   ├── chain_sync.cpp
│   │   ├── chain_sync.hpp
│   │   ├── internals/
│   │   │   ├── algorithm.hpp
│   │   │   ├── algorithm_test.cpp
│   │   │   ├── body_retrieval.cpp
│   │   │   ├── body_retrieval.hpp
│   │   │   ├── body_sequence.cpp
│   │   │   ├── body_sequence.hpp
│   │   │   ├── body_sequence_test.cpp
│   │   │   ├── chain_elements.hpp
│   │   │   ├── chain_elements_test.cpp
│   │   │   ├── chain_fork_view.cpp
│   │   │   ├── chain_fork_view.hpp
│   │   │   ├── header_chain.cpp
│   │   │   ├── header_chain.hpp
│   │   │   ├── header_chain_test.cpp
│   │   │   ├── header_only_state.cpp
│   │   │   ├── header_only_state.hpp
│   │   │   ├── header_retrieval.cpp
│   │   │   ├── header_retrieval.hpp
│   │   │   ├── header_retrieval_test.cpp
│   │   │   ├── preverified_hashes/
│   │   │   │   ├── preverified_hashes.cpp
│   │   │   │   ├── preverified_hashes.hpp
│   │   │   │   └── preverified_hashes_mainnet.cpp
│   │   │   ├── priority_queue.hpp
│   │   │   ├── priority_queue_test.cpp
│   │   │   ├── random_number.hpp
│   │   │   ├── statistics.cpp
│   │   │   ├── statistics.hpp
│   │   │   ├── types.cpp
│   │   │   └── types.hpp
│   │   ├── messages/
│   │   │   ├── inbound_block_bodies.cpp
│   │   │   ├── inbound_block_bodies.hpp
│   │   │   ├── inbound_block_headers.cpp
│   │   │   ├── inbound_block_headers.hpp
│   │   │   ├── inbound_get_block_bodies.cpp
│   │   │   ├── inbound_get_block_bodies.hpp
│   │   │   ├── inbound_get_block_headers.cpp
│   │   │   ├── inbound_get_block_headers.hpp
│   │   │   ├── inbound_message.cpp
│   │   │   ├── inbound_message.hpp
│   │   │   ├── inbound_new_block.cpp
│   │   │   ├── inbound_new_block.hpp
│   │   │   ├── inbound_new_block_hashes.cpp
│   │   │   ├── inbound_new_block_hashes.hpp
│   │   │   ├── internal_message.hpp
│   │   │   ├── internal_message_test.cpp
│   │   │   ├── message.hpp
│   │   │   ├── outbound_block_bodies.cpp
│   │   │   ├── outbound_block_bodies.hpp
│   │   │   ├── outbound_block_headers.cpp
│   │   │   ├── outbound_block_headers.hpp
│   │   │   ├── outbound_get_block_bodies.cpp
│   │   │   ├── outbound_get_block_bodies.hpp
│   │   │   ├── outbound_get_block_headers.cpp
│   │   │   ├── outbound_get_block_headers.hpp
│   │   │   ├── outbound_message.cpp
│   │   │   ├── outbound_message.hpp
│   │   │   ├── outbound_new_block.cpp
│   │   │   ├── outbound_new_block.hpp
│   │   │   ├── outbound_new_block_hashes.cpp
│   │   │   └── outbound_new_block_hashes.hpp
│   │   ├── packets/
│   │   │   ├── block_bodies_packet.hpp
│   │   │   ├── block_headers_packet.hpp
│   │   │   ├── get_block_bodies_packet.hpp
│   │   │   ├── get_block_headers_packet.hpp
│   │   │   ├── hash_or_number.hpp
│   │   │   ├── new_block_hashes_packet.hpp
│   │   │   ├── new_block_packet.hpp
│   │   │   ├── packet_coding_test.cpp
│   │   │   ├── rlp_decoding.cpp
│   │   │   ├── rlp_encoding.cpp
│   │   │   └── rlp_eth66_packet_coding.hpp
│   │   ├── sentry_client.cpp
│   │   ├── sentry_client.hpp
│   │   ├── settings.hpp
│   │   ├── sync.cpp
│   │   ├── sync.hpp
│   │   ├── sync_pos.cpp
│   │   ├── sync_pos.hpp
│   │   ├── sync_pos_test.cpp
│   │   ├── sync_pow.cpp
│   │   ├── sync_pow.hpp
│   │   └── test_util/
│   │       ├── mock_block_exchange.hpp
│   │       └── mock_execution_client.hpp
│   └── wasm/
│       ├── CMakeLists.txt
│       ├── exception_handling_stub.cpp
│       ├── silkworm_wasm_api.cpp
│       └── silkworm_wasm_api.hpp
├── tests/
│   ├── docker/
│   │   ├── Dockerfile
│   │   ├── README.md
│   │   └── run-docker.sh
│   ├── perf/
│   │   ├── run_with_perf.sh
│   │   ├── run_with_toplev.sh
│   │   ├── vegeta_attack_getLogs_rpcdaemon.sh
│   │   └── vegeta_attack_getLogs_silkrpc.sh
│   └── unit/
│       ├── README.md
│       └── run_unit_test_loop.py
├── third_party/
│   ├── CMakeLists.txt
│   ├── asio-grpc/
│   │   └── CMakeLists.txt
│   ├── blst/
│   │   └── CMakeLists.txt
│   ├── cbor-cpp/
│   │   └── CMakeLists.txt
│   ├── clang-format/
│   │   ├── LICENSE.TXT
│   │   ├── darwin-x64/
│   │   │   └── clang-format
│   │   └── linux-x64/
│   │       └── clang-format
│   ├── clang-tidy/
│   │   ├── clang-tidy-diff.py
│   │   └── clang-tidy-diff.sh
│   ├── cmake-conan/
│   │   ├── LICENSE
│   │   ├── conan_provider.cmake
│   │   └── readme.txt
│   ├── cpp-base64/
│   │   └── CMakeLists.txt
│   ├── erigon-mdbx-go/
│   │   └── CMakeLists.txt
│   ├── ethash/
│   │   └── CMakeLists.txt
│   ├── evmone/
│   │   └── CMakeLists.txt
│   ├── glaze/
│   │   └── CMakeLists.txt
│   ├── gmp/
│   │   └── CMakeLists.txt
│   ├── intx/
│   │   └── CMakeLists.txt
│   ├── libff/
│   │   └── CMakeLists.txt
│   ├── llvm/
│   │   ├── CMakeLists.txt
│   │   ├── README.md
│   │   ├── lib_libc++/
│   │   │   └── clang/
│   │   │       └── 16.0.6/
│   │   │           └── lib/
│   │   │               └── x86_64-linux/
│   │   │                   ├── libclang_rt.fuzzer.a
│   │   │                   ├── libclang_rt.fuzzer_interceptors.a
│   │   │                   └── libclang_rt.fuzzer_no_main.a
│   │   └── llvm.sh
│   ├── sais-lite/
│   │   ├── CMakeLists.txt
│   │   └── sais-lite/
│   │       ├── README.md
│   │       ├── sais.c
│   │       └── sais.h
│   ├── secp256k1/
│   │   └── CMakeLists.txt
│   ├── stbrumme-crc32/
│   │   └── CMakeLists.txt
│   ├── stbrumme-keccak/
│   │   ├── CMakeLists.txt
│   │   └── stbrumme-keccak/
│   │       ├── LICENSE
│   │       ├── keccak.cpp
│   │       └── keccak.h
│   ├── stun-msg/
│   │   └── CMakeLists.txt
│   └── wasmer/
│       └── install.sh
└── tools/
    ├── deps.py
    ├── lint/
    │   ├── ci_format.sh
    │   ├── clang_tidy_report.sh
    │   ├── copyright_replace.sh
    │   └── log_macros_fix.sh
    └── sanitizer/
        └── tsan_suppressions.txt

SYMBOL INDEX (10898 symbols across 1622 files)

FILE: cmd/rpcdaemon.cpp
  function main (line 15) | int main(int argc, char* argv[]) {

FILE: cmd/sentry.cpp
  function Settings (line 26) | Settings sentry_parse_cli_settings(int argc, char* argv[]) {
  function sentry_main (line 48) | void sentry_main(Settings settings) {
  function main (line 82) | int main(int argc, char* argv[]) {

FILE: cmd/silkworm.cpp
  type PruneModeValidator (line 47) | struct PruneModeValidator : public CLI::Validator {
    method PruneModeValidator (line 48) | explicit PruneModeValidator() {
  function add_rpc_server_settings (line 58) | void add_rpc_server_settings(CLI::App& cli, rpc::ServerSettings& server_...
  function parse_silkworm_command_line (line 64) | void parse_silkworm_command_line(CLI::App& cli, int argc, char* argv[], ...
  function main (line 186) | int main(int argc, char* argv[]) {

FILE: cmd/test/backend_kv_test.cpp
  type UnaryStats (line 36) | struct UnaryStats {
  class AsyncCall (line 59) | class AsyncCall {
    method AsyncCall (line 61) | explicit AsyncCall(grpc::CompletionQueue* queue) : queue_(queue) {}
    method peer (line 64) | std::string peer() const { return client_context_.peer(); }
    method latency (line 66) | std::chrono::steady_clock::duration latency() const { return end_time_...
    method status (line 68) | grpc::Status status() const { return status_; }
  class AsyncUnaryCall (line 86) | class AsyncUnaryCall : public AsyncCall {
    method UnaryStats (line 90) | static UnaryStats stats() { return unary_stats_; }
    method AsyncUnaryCall (line 92) | explicit AsyncUnaryCall(grpc::CompletionQueue* queue, StubInterface* s...
    method start (line 99) | void start(const Request& request) {
    method Reply (line 109) | Reply reply() const { return reply_; }
    method process_finish (line 112) | void process_finish(bool ok) {
    method handle_finish (line 126) | virtual void handle_finish(bool /*ok*/) {}
  type ServerStreamingStats (line 136) | struct ServerStreamingStats {
  class AsyncServerStreamingCall (line 170) | class AsyncServerStreamingCall : public AsyncCall {
    method ServerStreamingStats (line 172) | static ServerStreamingStats stats() { return server_streaming_stats_; }
    method AsyncServerStreamingCall (line 174) | explicit AsyncServerStreamingCall(grpc::CompletionQueue* queue, StubIn...
    method start (line 182) | void start(const Request& request) {
    method cancel (line 191) | void cancel() {
    method read (line 199) | virtual void read() {
    method finish (line 205) | virtual void finish() {
    method process_start (line 211) | void process_start(bool ok) {
    method process_read (line 226) | void process_read(bool ok) {
    method process_finish (line 242) | void process_finish(bool ok) {
  type BidirectionalStreamingStats (line 276) | struct BidirectionalStreamingStats {
  class AsyncBidirectionalStreamingCall (line 307) | class AsyncBidirectionalStreamingCall : public AsyncCall {
    method BidirectionalStreamingStats (line 309) | static BidirectionalStreamingStats stats() { return bidi_streaming_sta...
    method AsyncBidirectionalStreamingCall (line 311) | explicit AsyncBidirectionalStreamingCall(grpc::CompletionQueue* queue,...
    method start (line 321) | void start() {
    method read (line 332) | void read() {
    method write (line 338) | void write() {
    method writes_done (line 344) | void writes_done() {
    method finish (line 350) | void finish() {
    method process_start (line 356) | void process_start(bool ok) {
    method process_read (line 379) | void process_read(bool ok) {
    method process_write (line 403) | void process_write(bool ok) {
    method process_writes_done (line 427) | void process_writes_done(bool ok) {
    method process_finish (line 442) | void process_finish(bool ok) {
    type State (line 466) | enum class State {
  class AsyncEtherbaseCall (line 489) | class AsyncEtherbaseCall : public AsyncUnaryCall<
    method AsyncEtherbaseCall (line 494) | explicit AsyncEtherbaseCall(grpc::CompletionQueue* queue, remote::ETHB...
    method handle_finish (line 497) | void handle_finish(bool ok) override {
  class AsyncNetVersionCall (line 514) | class AsyncNetVersionCall : public AsyncUnaryCall<
    method AsyncNetVersionCall (line 520) | explicit AsyncNetVersionCall(grpc::CompletionQueue* queue, remote::ETH...
    method handle_finish (line 523) | void handle_finish(bool ok) override {
  class AsyncNetPeerCountCall (line 534) | class AsyncNetPeerCountCall : public AsyncUnaryCall<
    method AsyncNetPeerCountCall (line 540) | explicit AsyncNetPeerCountCall(grpc::CompletionQueue* queue, remote::E...
    method handle_finish (line 543) | void handle_finish(bool ok) override {
  class AsyncBackEndVersionCall (line 554) | class AsyncBackEndVersionCall : public AsyncUnaryCall<
    method AsyncBackEndVersionCall (line 560) | explicit AsyncBackEndVersionCall(grpc::CompletionQueue* queue, remote:...
    method handle_finish (line 563) | void handle_finish(bool ok) override {
  class AsyncProtocolVersionCall (line 577) | class AsyncProtocolVersionCall : public AsyncUnaryCall<
    method AsyncProtocolVersionCall (line 583) | explicit AsyncProtocolVersionCall(grpc::CompletionQueue* queue, remote...
    method handle_finish (line 586) | void handle_finish(bool ok) override {
  class AsyncClientVersionCall (line 597) | class AsyncClientVersionCall : public AsyncUnaryCall<
    method AsyncClientVersionCall (line 603) | explicit AsyncClientVersionCall(grpc::CompletionQueue* queue, remote::...
    method handle_finish (line 606) | void handle_finish(bool ok) override {
  class AsyncSubscribeCall (line 617) | class AsyncSubscribeCall : public AsyncServerStreamingCall<remote::Subsc...
    method AsyncSubscribeCall (line 621) | explicit AsyncSubscribeCall(grpc::CompletionQueue* queue, remote::ETHB...
    method handle_read (line 624) | void handle_read() override {
    method handle_finish (line 628) | void handle_finish() override {
  class AsyncNodeInfoCall (line 638) | class AsyncNodeInfoCall : public AsyncUnaryCall<
    method AsyncNodeInfoCall (line 644) | explicit AsyncNodeInfoCall(grpc::CompletionQueue* queue, remote::ETHBA...
    method handle_finish (line 647) | void handle_finish(bool ok) override {
  class AsyncKvVersionCall (line 658) | class AsyncKvVersionCall : public AsyncUnaryCall<
    method AsyncKvVersionCall (line 664) | explicit AsyncKvVersionCall(grpc::CompletionQueue* queue, remote::KV::...
    method handle_finish (line 667) | void handle_finish(bool ok) override {
  type remote (line 681) | namespace remote {
    function pair_to_string (line 683) | std::string pair_to_string(const Pair& kv_pair) {
  class AsyncTxCall (line 697) | class AsyncTxCall
    method AsyncTxCall (line 701) | explicit AsyncTxCall(grpc::CompletionQueue* queue, remote::KV::StubInt...
    method handle_start (line 704) | bool handle_start() override {
    method handle_read (line 709) | bool handle_read() override {
    method handle_write (line 745) | bool handle_write() override {
    method handle_finish (line 750) | void handle_finish() override {
  class AsyncStateChangesCall (line 769) | class AsyncStateChangesCall
    method num_pending_calls (line 773) | static size_t num_pending_calls() { return pending_calls_.size(); }
    method add_pending_call (line 775) | static void add_pending_call(AsyncStateChangesCall* call) {
    method remove_pending_call (line 779) | static void remove_pending_call(AsyncStateChangesCall* call) {
    method cancel_pending_calls (line 784) | static void cancel_pending_calls() {
    method AsyncStateChangesCall (line 792) | explicit AsyncStateChangesCall(grpc::CompletionQueue* queue, remote::K...
    method handle_read (line 795) | void handle_read() override {
    method handle_finish (line 802) | void handle_finish() override {
  type Rpc (line 815) | enum class Rpc {
  type BatchOptions (line 829) | struct BatchOptions {
    method is_configured (line 834) | bool is_configured(Rpc call) const {
    method contains_call (line 839) | bool contains_call(Rpc call) const {
  class AsyncCallFactory (line 844) | class AsyncCallFactory {
    method AsyncCallFactory (line 846) | AsyncCallFactory(const std::shared_ptr<grpc::Channel>& channel, grpc::...
    method start_batch (line 851) | void start_batch(std::atomic_bool& stop, const BatchOptions& batch_opt...
  function print_stats (line 928) | void print_stats(const BatchOptions& batch_options) {
  function main (line 964) | int main(int argc, char* argv[]) {

FILE: cmd/test/ethereum.cpp
  type Status (line 76) | enum class Status {
  function Status (line 82) | Status run_block(const nlohmann::json& json_block, Blockchain& blockchai...
  function post_check (line 122) | bool post_check(const InMemoryState& state, const nlohmann::json& expect...
  type RunResults (line 191) | struct [[nodiscard]] RunResults {
    method RunResults (line 196) | constexpr RunResults() = default;
    method RunResults (line 199) | constexpr RunResults(Status status) {
    method RunResults (line 213) | RunResults& operator+=(const RunResults& rhs) {
  function RunResults (line 222) | RunResults blockchain_test(const nlohmann::json& json_test) {
    method RunResults (line 196) | constexpr RunResults() = default;
    method RunResults (line 199) | constexpr RunResults(Status status) {
    method RunResults (line 213) | RunResults& operator+=(const RunResults& rhs) {
  function print_test_status (line 266) | static void print_test_status(std::string_view key, const RunResults& re...
  function run_test_file (line 286) | void run_test_file(const fs::path& file_path, RunnerFunc runner, std::st...
  function RunResults (line 318) | RunResults transaction_test(const nlohmann::json& j) {
    method RunResults (line 196) | constexpr RunResults() = default;
    method RunResults (line 199) | constexpr RunResults(Status status) {
    method RunResults (line 213) | RunResults& operator+=(const RunResults& rhs) {
  function Status (line 392) | Status individual_difficulty_test(const nlohmann::json& j, const ChainCo...
  function RunResults (line 422) | RunResults difficulty_tests(const nlohmann::json& outer) {
    method RunResults (line 196) | constexpr RunResults() = default;
    method RunResults (line 199) | constexpr RunResults(Status status) {
    method RunResults (line 213) | RunResults& operator+=(const RunResults& rhs) {
  function exclude_test (line 441) | bool exclude_test(const fs::path& p, const fs::path& root_dir, bool incl...
  function main (line 447) | int main(int argc, char* argv[]) {

FILE: cmd/test/fuzzer_diagnostics.cpp
  function print_stack_trace (line 17) | void print_stack_trace() {
  function main (line 48) | int main(int argc, char* argv[]) {

FILE: cmd/test/fuzzer_test.cpp
  function LLVMFuzzerTestOneInput (line 15) | int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size) {

FILE: cmd/test/sentry_client_test.cpp
  function run (line 18) | Task<void> run(sentry::api::SentryClient& client) {
  function main (line 36) | int main() {

FILE: conanfile.py
  class SilkwormRecipe (line 7) | class SilkwormRecipe(ConanFile):
    method requirements (line 11) | def requirements(self):
    method configure (line 42) | def configure(self):
    method configure_boost (line 52) | def configure_boost(self):
    method boost_components_unused (line 71) | def boost_components_unused() -> set[str]:

FILE: examples/get_latest_block.cpp
  function latest_block (line 34) | Task<std::optional<uint64_t>> latest_block(db::kv::api::Service& service) {
  function get_latest_block (line 53) | std::optional<uint64_t> get_latest_block(boost::asio::io_context& ioc, d...
  function main (line 65) | int main(int argc, char* argv[]) {

FILE: silkworm/capi/cli/execute.cpp
  type ExecuteBlocksSettings (line 34) | struct ExecuteBlocksSettings {
  type BuildIndexesSettings (line 44) | struct BuildIndexesSettings {
  type Settings (line 48) | struct Settings {
  function parse_command_line (line 56) | void parse_command_line(int argc, char* argv[], CLI::App& app, Settings&...
  function collect_all_snapshot_bundles (line 135) | std::vector<SilkwormBlocksSnapshotBundle> collect_all_snapshot_bundles(c...
  function execute_with_internal_txn (line 213) | int execute_with_internal_txn(SilkwormHandle handle, ExecuteBlocksSettin...
  function execute_with_external_txn (line 242) | int execute_with_external_txn(SilkwormHandle handle, ExecuteBlocksSettin...
  function execute_blocks (line 271) | int execute_blocks(SilkwormHandle handle, ExecuteBlocksSettings settings...
  function build_indexes (line 311) | int build_indexes(SilkwormHandle handle, const BuildIndexesSettings& set...
  function start_rpcdaemon (line 352) | int start_rpcdaemon(SilkwormHandle handle, const rpc::DaemonSettings& /*...
  function main (line 383) | int main(int argc, char* argv[]) {

FILE: silkworm/capi/cli/main.c
  function main (line 8) | int main(int argc, char* argv[]) {

FILE: silkworm/capi/cli/sample-go-client/main.go
  function main (line 26) | func main() {

FILE: silkworm/capi/common/common_component.hpp
  type silkworm::capi (line 11) | namespace silkworm::capi {
    type CommonComponent (line 13) | struct CommonComponent {

FILE: silkworm/capi/common/instance.hpp
  type silkworm::db::capi (line 10) | namespace silkworm::db::capi {
    type Component (line 11) | struct Component
  type silkworm::rpc (line 14) | namespace silkworm::rpc {
    class Daemon (line 15) | class Daemon
  type silkworm::sentry::capi (line 18) | namespace silkworm::sentry::capi {
    type Component (line 19) | struct Component
  type capi_todo (line 22) | namespace capi_todo {
    type SilkwormInstance (line 24) | struct SilkwormInstance {

FILE: silkworm/capi/common/parse_path.cpp
  type silkworm::capi (line 8) | namespace silkworm::capi {
    function parse_path (line 10) | std::filesystem::path parse_path(const char data_dir_path[SILKWORM_PAT...

FILE: silkworm/capi/common/parse_path.hpp
  type silkworm::capi (line 10) | namespace silkworm::capi {

FILE: silkworm/capi/common/preamble.h
  type SilkwormInstance (line 26) | struct SilkwormInstance
  type SilkwormInstance (line 27) | struct SilkwormInstance

FILE: silkworm/capi/init.cpp
  function log_args_for_version (line 23) | static log::Args log_args_for_version() {
  function SILKWORM_EXPORT (line 34) | SILKWORM_EXPORT int silkworm_init(SilkwormHandle* handle, const struct S...
  function SILKWORM_EXPORT (line 105) | SILKWORM_EXPORT int silkworm_fini(SilkwormHandle handle) SILKWORM_NOEXCE...

FILE: silkworm/capi/init.h
  type SilkwormSettings (line 21) | struct SilkwormSettings {
  type SilkwormSettings (line 42) | struct SilkwormSettings

FILE: silkworm/capi/instance.cpp
  type capi_todo (line 10) | namespace capi_todo {

FILE: silkworm/capi/instance.hpp
  type SilkwormInstance (line 13) | struct SilkwormInstance : public capi_todo::SilkwormInstance {
    type ExecutionResult (line 17) | struct ExecutionResult {

FILE: silkworm/capi/log_level.h
  type SilkwormLogLevel (line 13) | typedef enum {  // NOLINT(performance-enum-size)

FILE: silkworm/capi/make_log_settings.cpp
  function make_log_level (line 9) | static silkworm::log::Level make_log_level(const SilkwormLogLevel c_log_...
  function make_log_settings (line 37) | silkworm::log::Settings make_log_settings(const SilkwormLogLevel c_log_l...

FILE: silkworm/capi/silkworm.cpp
  type ExecutionProgress (line 58) | struct ExecutionProgress {
  function log_args_for_exec_flush (line 69) | static log::Args log_args_for_exec_flush(const db::Buffer& state_buffer,...
  function log_args_for_exec_commit (line 80) | static log::Args log_args_for_exec_commit(StopWatch::Duration elapsed, c...
  function log_args_for_exec_progress (line 89) | static log::Args log_args_for_exec_progress(ExecutionProgress& progress,...
  function update_execution_progress (line 125) | static void update_execution_progress(ExecutionProgress& progress, const...
  class SignalHandlerGuard (line 141) | class SignalHandlerGuard {
    method SignalHandlerGuard (line 143) | SignalHandlerGuard() { SignalHandler::init(/*custom_handler=*/{}, /*si...
  class BlockProvider (line 147) | class BlockProvider {
    method BlockProvider (line 151) | BlockProvider(BoundedBuffer<std::optional<Block>>* block_buffer,
  function signal_check (line 202) | inline bool signal_check(SteadyTimePoint& signal_check_time) {
  function SILKWORM_EXPORT (line 214) | SILKWORM_EXPORT
  function SILKWORM_EXPORT (line 330) | SILKWORM_EXPORT
  function SILKWORM_EXPORT (line 464) | SILKWORM_EXPORT int silkworm_execute_txn(SilkwormHandle handle, MDBX_txn...
  function SILKWORM_EXPORT (line 594) | SILKWORM_EXPORT int silkworm_block_exec_start(SilkwormHandle handle, MDB...
  function SILKWORM_EXPORT (line 611) | SILKWORM_EXPORT int silkworm_block_exec_end(SilkwormHandle handle, MDBX_...

FILE: silkworm/capi/silkworm.h
  type MDBX_env (line 26) | typedef struct MDBX_env MDBX_env;
  type MDBX_txn (line 27) | typedef struct MDBX_txn MDBX_txn;
  type SilkwormBytes32 (line 29) | struct SilkwormBytes32 {
  type SilkwormBytes32 (line 98) | struct SilkwormBytes32
  type SilkwormBytes32 (line 108) | struct SilkwormBytes32

FILE: silkworm/capi/silkworm_test.cpp
  type silkworm (line 28) | namespace silkworm {
    type CApiTest (line 34) | struct CApiTest {
    function c_string_copy (line 45) | static void c_string_copy(char dst[N], const char* src) {
    function copy_git_version (line 51) | static void copy_git_version(char dst[SILKWORM_GIT_VERSION_SIZE], cons...
    function copy_path (line 56) | static void copy_path(char dst[SILKWORM_PATH_SIZE], const char* src) {
    type SilkwormLibrary (line 118) | struct SilkwormLibrary {
      method SilkwormLibrary (line 119) | explicit SilkwormLibrary(const std::filesystem::path& env_path) {
      type ExecutionResult (line 129) | struct ExecutionResult {
      method ExecutionResult (line 135) | ExecutionResult execute_blocks(MDBX_txn* txn,
      method ExecutionResult (line 152) | ExecutionResult execute_blocks_perpetual(MDBX_env* env,
      method execute_txn (line 169) | int execute_txn(MDBX_txn* tx, uint64_t block_num, silkworm::Hash hea...
      method add_blocks_snapshot_bundle (line 176) | int add_blocks_snapshot_bundle(SilkwormBlocksSnapshotBundle* bundle)...
      method add_state_snapshot_bundle_latest (line 180) | int add_state_snapshot_bundle_latest(SilkwormStateSnapshotBundleLate...
      method add_state_snapshot_bundle_historical (line 184) | int add_state_snapshot_bundle_historical(SilkwormStateSnapshotBundle...
      method start_rpcdaemon (line 188) | int start_rpcdaemon(MDBX_env* env, const SilkwormRpcSettings* settin...
      method stop_rpcdaemon (line 192) | int stop_rpcdaemon() const {
    function insert_block (line 268) | static void insert_block(mdbx::env& env, Block& block) {
    function SilkwormRpcSettings (line 1046) | static SilkwormRpcSettings make_rpc_settings_for_test(uint16_t api_lis...

FILE: silkworm/core/chain/config.cpp
  type silkworm (line 15) | namespace silkworm {
    function member_to_json (line 19) | static void member_to_json(nlohmann::json& json, const std::string& ke...
    function read_json_config_member (line 25) | static void read_json_config_member(
    function evmc_revision (line 183) | evmc_revision ChainConfig::revision(uint64_t block_num, uint64_t block...

FILE: silkworm/core/chain/config.hpp
  type silkworm (line 24) | namespace silkworm {
    type protocol (line 26) | namespace protocol {
      type NoPreMergeConfig (line 29) | struct NoPreMergeConfig {
    type ChainConfig (line 40) | struct ChainConfig {

FILE: silkworm/core/chain/config_test.cpp
  type silkworm (line 14) | namespace silkworm {

FILE: silkworm/core/chain/dao.cpp
  type silkworm (line 131) | namespace silkworm {
    function transfer_dao_balances (line 133) | void transfer_dao_balances(IntraBlockState& state) {

FILE: silkworm/core/chain/dao.hpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/chain/genesis.cpp
  type silkworm (line 21) | namespace silkworm {
    function read_genesis_data (line 23) | std::string_view read_genesis_data(ChainId chain_id) {
    function BlockHeader (line 40) | BlockHeader read_genesis_header(const nlohmann::json& genesis, const e...
    function InMemoryState (line 83) | InMemoryState read_genesis_allocation(const nlohmann::json& alloc) {

FILE: silkworm/core/chain/genesis.hpp
  type silkworm (line 16) | namespace silkworm {

FILE: silkworm/core/chain/genesis_amoy.cpp
  type silkworm (line 5332) | namespace silkworm {

FILE: silkworm/core/chain/genesis_amoy.hpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/chain/genesis_bor_mainnet.cpp
  type silkworm (line 4557) | namespace silkworm {

FILE: silkworm/core/chain/genesis_bor_mainnet.hpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/chain/genesis_holesky.cpp
  type silkworm (line 2417) | namespace silkworm {

FILE: silkworm/core/chain/genesis_holesky.hpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/chain/genesis_mainnet.cpp
  type silkworm (line 44318) | namespace silkworm {

FILE: silkworm/core/chain/genesis_mainnet.hpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/chain/genesis_sepolia.cpp
  type silkworm (line 122) | namespace silkworm {

FILE: silkworm/core/chain/genesis_sepolia.hpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/chain/genesis_test.cpp
  type silkworm (line 13) | namespace silkworm {
    function test_genesis_config (line 15) | void test_genesis_config(const ChainConfig& x) {
    function sanity_checked_json (line 32) | nlohmann::json sanity_checked_json(uint64_t chain_id) {
    function state_root (line 46) | evmc::bytes32 state_root(const nlohmann::json& genesis_json) {

FILE: silkworm/core/common/assert.cpp
  type silkworm (line 9) | namespace silkworm {
    function abort_due_to_assertion_failure (line 11) | void abort_due_to_assertion_failure(char const* expr, char const* file...

FILE: silkworm/core/common/assert.hpp
  type silkworm (line 6) | namespace silkworm {

FILE: silkworm/core/common/base.hpp
  type silkworm (line 24) | namespace silkworm {
    type TxnIdRange (line 36) | struct TxnIdRange {
      method TxnIdRange (line 39) | TxnIdRange(TxnId start1, TxnId end1) : start(start1), end(end1) {}
      method contains (line 41) | bool contains(TxnId num) const { return (start <= num) && (num < end...
      method contains_range (line 42) | bool contains_range(TxnIdRange range) const { return (start <= range...
      method TxnId (line 43) | TxnId size() const { return end - start; }
      method to_string (line 44) | std::string to_string() const { return std::string("[") + std::to_st...
    type BlockNumRange (line 51) | struct BlockNumRange {
      method BlockNumRange (line 54) | BlockNumRange(BlockNum start1, BlockNum end1) : start(start1), end(e...
      method contains (line 56) | bool contains(BlockNum block_num) const { return (start <= block_num...
      method contains_range (line 57) | bool contains_range(BlockNumRange range) const { return (start <= ra...
      method BlockNum (line 58) | BlockNum size() const { return end - start; }
      method to_string (line 59) | std::string to_string() const { return std::string("[") + std::to_st...

FILE: silkworm/core/common/block_cache.hpp
  type silkworm (line 15) | namespace silkworm {
    class BlockCache (line 17) | class BlockCache {
      method BlockCache (line 19) | explicit BlockCache(size_t capacity = 1024, bool shared_cache = true)
      method get (line 22) | std::shared_ptr<BlockWithHash> get(const evmc::bytes32& key) {
      method insert (line 30) | void insert(const evmc::bytes32& key, const std::shared_ptr<BlockWit...

FILE: silkworm/core/common/block_cache_test.cpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/common/bytes.hpp
  type silkworm (line 12) | namespace silkworm {
    class ByteView (line 16) | class ByteView : public evmc::bytes_view {
      method ByteView (line 18) | constexpr ByteView() noexcept = default;
      method ByteView (line 21) | constexpr ByteView(const evmc::bytes_view& other) noexcept
      method ByteView (line 25) | ByteView(const Bytes& str) noexcept : evmc::bytes_view{str.data(), s...
      method ByteView (line 27) | constexpr ByteView(const uint8_t* data, size_type size) noexcept
      method ByteView (line 32) | constexpr ByteView(const uint8_t (&array)[N]) noexcept : evmc::bytes...
      method ByteView (line 36) | constexpr ByteView(const std::array<uint8_t, N>& array) noexcept
      method ByteView (line 41) | constexpr ByteView(std::span<const uint8_t, Extent> span) noexcept
      method is_null (line 44) | bool is_null() const noexcept { return data() == nullptr; }
    type BytesOrByteView (line 54) | struct BytesOrByteView : public std::variant<Bytes, ByteView> {
      method holds_bytes (line 57) | bool holds_bytes() const { return std::holds_alternative<Bytes>(*thi...
      method BytesOrByteView (line 59) | BytesOrByteView substr(size_t offset) {

FILE: silkworm/core/common/bytes_test.cpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/common/bytes_to_string.hpp
  type silkworm (line 14) | namespace silkworm {
    function Bytes (line 22) | inline Bytes string_to_bytes(const std::string& s) { return {s.begin()...
    function ByteView (line 23) | inline ByteView string_view_to_byte_view(std::string_view v) { return ...
    function ByteView (line 26) | ByteView array_to_byte_view(const std::array<unsigned char, Size>& arr...
    function bytes_to_string (line 30) | inline std::string bytes_to_string(Bytes b) { return {b.begin(), b.end...
    function byte_view_to_string_view (line 31) | inline std::string_view byte_view_to_string_view(ByteView v) { return ...
    function byte_view_to_str_span (line 32) | inline std::span<const char> byte_view_to_str_span(ByteView v) { retur...

FILE: silkworm/core/common/decoding_result.hpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/common/empty_hashes.hpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/common/empty_hashes_test.cpp
  type silkworm (line 15) | namespace silkworm {

FILE: silkworm/core/common/endian.cpp
  type silkworm::endian (line 8) | namespace silkworm::endian {
    function ByteView (line 10) | ByteView to_big_compact(const uint64_t value) {
    function ByteView (line 19) | ByteView to_big_compact(const intx::uint256& value) {

FILE: silkworm/core/common/endian.hpp
  type silkworm::endian (line 20) | namespace silkworm::endian {
    function DecodingResult (line 88) | static DecodingResult from_big_compact(ByteView data, T& out) {

FILE: silkworm/core/common/endian_test.cpp
  type silkworm::endian (line 12) | namespace silkworm::endian {
    function hex_endian_swap (line 67) | static std::string hex_endian_swap(const std::string& native_hex) {

FILE: silkworm/core/common/hash_maps.hpp
  type silkworm (line 18) | namespace silkworm {

FILE: silkworm/core/common/lru_cache.hpp
  type silkworm (line 49) | namespace silkworm {
    class LruCache (line 62) | class LruCache {
      method LruCache (line 67) | explicit LruCache(size_t max_size, bool thread_safe = false) : max_s...
      method LruCache (line 68) | LruCache(const LruCache&) = default;
      method LruCache (line 69) | LruCache(LruCache&&) noexcept = default;
      method put (line 71) | void put(const key_t& key, const value_t& value) {
      method value_t (line 90) | const value_t* get(const key_t& key) {
      method get_as_copy (line 95) | std::optional<value_t> get_as_copy(const key_t& key) {
      method remove (line 104) | bool remove(const key_t& key) {
      method size (line 117) | size_t size() const noexcept {
      method max_size (line 122) | size_t max_size() const noexcept {
      method clear (line 126) | void clear() noexcept {
      method value_t (line 133) | const value_t* get_internal(const key_t& key) {

FILE: silkworm/core/common/lru_cache_test.cpp
  type silkworm (line 35) | namespace silkworm {

FILE: silkworm/core/common/math.hpp
  type silkworm::math (line 9) | namespace silkworm::math {
    function T (line 13) | constexpr T int_ceil(double num) {

FILE: silkworm/core/common/math_test.cpp
  type silkworm::math (line 8) | namespace silkworm::math {

FILE: silkworm/core/common/object_pool.hpp
  type silkworm (line 26) | namespace silkworm {
    class ObjectPool (line 29) | class ObjectPool {
      method ObjectPool (line 31) | explicit ObjectPool(bool thread_safe = false) : thread_safe_{thread_...
      method ObjectPool (line 34) | ObjectPool(const ObjectPool&) = delete;
      method ObjectPool (line 35) | ObjectPool& operator=(const ObjectPool&) = delete;
      method add (line 37) | void add(gsl::owner<T*> t) {
      method acquire (line 42) | gsl::owner<T*> acquire() {
      method empty (line 52) | bool empty() const {
      method size (line 57) | size_t size() const {

FILE: silkworm/core/common/overloaded.hpp
  type silkworm (line 6) | namespace silkworm {
    type Overloaded (line 11) | struct Overloaded : Ts... {

FILE: silkworm/core/common/random_number.hpp
  type silkworm (line 9) | namespace silkworm {
    class RandomNumber (line 11) | class RandomNumber {
      method RandomNumber (line 14) | explicit RandomNumber(uint64_t a = 0, uint64_t b = std::numeric_limi...
      method RandomNumber (line 17) | RandomNumber(const RandomNumber&) = delete;
      method RandomNumber (line 18) | RandomNumber& operator=(const RandomNumber&) = delete;
      method generate_one (line 20) | uint64_t generate_one() { return distr_(generator_); }

FILE: silkworm/core/common/random_number_test.cpp
  type silkworm (line 10) | namespace silkworm {

FILE: silkworm/core/common/small_map.hpp
  type silkworm (line 16) | namespace silkworm {
    class SmallMap (line 20) | class SmallMap {
      method SmallMap (line 24) | constexpr SmallMap() noexcept = default;
      method SmallMap (line 26) | constexpr SmallMap(std::initializer_list<ValueType> init) : size_(in...
      method SmallMap (line 35) | constexpr SmallMap(InputIt first, InputIt last) {
      method SmallMap (line 43) | constexpr SmallMap(const SmallMap& other) : size_{other.size_} {
      method SmallMap (line 48) | constexpr SmallMap& operator=(const SmallMap& other) {
      method empty (line 59) | constexpr bool empty() const noexcept {
      method size (line 63) | constexpr size_t size() const noexcept {
      method max_size (line 67) | static constexpr size_t max_size() noexcept {
      method begin (line 71) | constexpr auto begin() const noexcept {
      method end (line 75) | constexpr auto end() const noexcept {
      method T (line 79) | constexpr const T* find(const Key& key) const noexcept {
      method to_std_map (line 90) | std::map<NewKeyType, T> to_std_map() const {
      method sort (line 99) | constexpr void sort() {

FILE: silkworm/core/common/small_map_test.cpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/common/test_util.cpp
  type silkworm::test (line 9) | namespace silkworm::test {
    function sample_transactions (line 11) | std::vector<Transaction> sample_transactions() {
    function sample_receipts (line 45) | std::vector<Receipt> sample_receipts() {

FILE: silkworm/core/common/test_util.hpp
  type silkworm::test (line 11) | namespace silkworm::test {

FILE: silkworm/core/common/util.cpp
  type silkworm (line 12) | namespace silkworm {
    function ByteView (line 48) | ByteView zeroless_view(ByteView data) {
    function to_hex (line 54) | std::string to_hex(ByteView bytes, bool with_prefix) {
    function abridge (line 69) | std::string abridge(std::string_view input, size_t length) {
    function unhex_lut (line 76) | static uint8_t unhex_lut(uint8_t x) { return kUnhexTable[x]; }
    function unhex_lut4 (line 77) | static uint8_t unhex_lut4(uint8_t x) { return kUnhexTable4[x]; }
    function decode_hex_digit (line 79) | std::optional<uint8_t> decode_hex_digit(char ch) noexcept {
    function from_hex (line 87) | std::optional<Bytes> from_hex(std::string_view hex) noexcept {
    function case_insensitive_char_comparer (line 140) | inline bool case_insensitive_char_comparer(char a, char b) { return (t...
    function iequals (line 142) | bool iequals(const std::string_view a, const std::string_view b) {
    function parse_size (line 146) | std::optional<uint64_t> parse_size(const std::string& sizestr) {
    function human_size (line 190) | std::string human_size(uint64_t bytes, const char* unit) {
    function prefix_length (line 206) | size_t prefix_length(ByteView a, ByteView b) {
    function to_float (line 216) | float to_float(const intx::uint256& n) noexcept {
    function snake_to_camel (line 226) | std::string snake_to_camel(std::string_view snake) {

FILE: silkworm/core/common/util.hpp
  type intx (line 22) | namespace intx {
  type silkworm (line 32) | namespace silkworm {
    function has_hex_prefix (line 39) | inline bool has_hex_prefix(std::string_view s) {
    function is_valid_hex (line 43) | inline bool is_valid_hex(std::string_view s) {
    function is_valid_dec (line 48) | inline bool is_valid_dec(std::string_view s) {
    function is_valid_hash (line 53) | inline bool is_valid_hash(std::string_view s) {
    function is_valid_address (line 60) | inline bool is_valid_address(std::string_view s) {
    function to_hex (line 73) | std::string to_hex(T value, bool with_prefix = false) {
    function keccak256 (line 103) | inline ethash::hash256 keccak256(ByteView view) { return ethash::kecca...
    function Int (line 107) | constexpr Int from_string_sci(const char* str) {

FILE: silkworm/core/common/util_test.cpp
  type silkworm (line 11) | namespace silkworm {

FILE: silkworm/core/concurrency/resettable_once_flag.hpp
  type silkworm (line 13) | namespace silkworm {
    class ResettableOnceFlag (line 21) | class ResettableOnceFlag {
      method ResettableOnceFlag (line 23) | constexpr ResettableOnceFlag() = default;
      method ResettableOnceFlag (line 25) | ResettableOnceFlag(const ResettableOnceFlag& other) {
      method ResettableOnceFlag (line 34) | ResettableOnceFlag& operator=(const ResettableOnceFlag& other) {
      method reset (line 48) | void reset() {
      method call_once (line 53) | void call_once(Callable&& fn, Args&&... args) {
      method ResettableOnceFlag (line 73) | constexpr ResettableOnceFlag() = default;
      method ResettableOnceFlag (line 75) | ResettableOnceFlag(const ResettableOnceFlag&) = default;
      method ResettableOnceFlag (line 76) | ResettableOnceFlag& operator=(const ResettableOnceFlag&) = default;
      method reset (line 78) | void reset() { done_ = false; }
      method call_once (line 81) | void call_once(Callable&& fn, Args&&... args) {
    class ResettableOnceFlag (line 71) | class ResettableOnceFlag {
      method ResettableOnceFlag (line 23) | constexpr ResettableOnceFlag() = default;
      method ResettableOnceFlag (line 25) | ResettableOnceFlag(const ResettableOnceFlag& other) {
      method ResettableOnceFlag (line 34) | ResettableOnceFlag& operator=(const ResettableOnceFlag& other) {
      method reset (line 48) | void reset() {
      method call_once (line 53) | void call_once(Callable&& fn, Args&&... args) {
      method ResettableOnceFlag (line 73) | constexpr ResettableOnceFlag() = default;
      method ResettableOnceFlag (line 75) | ResettableOnceFlag(const ResettableOnceFlag&) = default;
      method ResettableOnceFlag (line 76) | ResettableOnceFlag& operator=(const ResettableOnceFlag&) = default;
      method reset (line 78) | void reset() { done_ = false; }
      method call_once (line 81) | void call_once(Callable&& fn, Args&&... args) {

FILE: silkworm/core/crypto/ecdsa.c
  function recover (line 13) | static bool recover(uint8_t public_key[65], const uint8_t message[32], c...
  function public_key_to_address (line 32) | static bool public_key_to_address(uint8_t out[20], const uint8_t public_...
  function silkworm_recover_address (line 42) | bool silkworm_recover_address(uint8_t out[20], const uint8_t message[32]...

FILE: silkworm/core/crypto/secp256k1n.cpp
  type silkworm (line 6) | namespace silkworm {
    function is_valid_signature (line 8) | bool is_valid_signature(const intx::uint256& r, const intx::uint256& s...

FILE: silkworm/core/crypto/secp256k1n.hpp
  type silkworm (line 13) | namespace silkworm {

FILE: silkworm/core/crypto/secp256k1n_test.cpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/execution/call_tracer.cpp
  function evmc_status_code (line 23) | evmc_status_code check_requirements(
  function check_memory_gas (line 65) | int64_t check_memory_gas(int64_t gas_left, Memory& memory, uint64_t new_...
  function check_memory_gas (line 81) | bool check_memory_gas(int64_t& gas_left, Memory& memory, const uint256& ...
  function check_memory_gas (line 95) | inline bool check_memory_gas(int64_t& gas_left, Memory& memory, const ui...
  function evmc_status_code (line 109) | inline evmc_status_code check_preconditions(const intx::uint256* stack_t...
  type silkworm (line 115) | namespace silkworm {
    function on_create_start (line 131) | void on_create_start(const intx::uint256* stack_top, int stack_height,...

FILE: silkworm/core/execution/call_tracer.hpp
  type silkworm (line 13) | namespace silkworm {
    class CallTracer (line 16) | class CallTracer : public EvmTracer {
      method CallTracer (line 18) | explicit CallTracer(CallTraces& traces) : traces_{traces} {}
      method CallTracer (line 20) | CallTracer(const CallTracer&) = delete;
      method CallTracer (line 21) | CallTracer& operator=(const CallTracer&) = delete;

FILE: silkworm/core/execution/evm.cpp
  type silkworm (line 22) | namespace silkworm {
    class DelegatingTracer (line 24) | class DelegatingTracer : public evmone::Tracer {
      method DelegatingTracer (line 26) | explicit DelegatingTracer(EvmTracer& tracer, IntraBlockState& intra_...
      method on_execution_start (line 30) | void on_execution_start(evmc_revision rev, const evmc_message& msg, ...
      method on_instruction_start (line 34) | void on_instruction_start(uint32_t pc, const intx::uint256* stack_to...
      method on_execution_end (line 39) | void on_execution_end(const evmc_result& result) noexcept override {
    function CallResult (line 65) | CallResult EVM::execute(const Transaction& txn, uint64_t gas) noexcept {
    function evmc_result (line 267) | evmc_result EVM::execute(const evmc_message& message, ByteView code, c...
    function evmc_result (line 277) | evmc_result EVM::execute_with_baseline_interpreter(evmc_revision rev, ...
    function evmc_revision (line 300) | evmc_revision EVM::revision() const noexcept {
    function evmc_access_status (line 322) | evmc_access_status EvmHost::access_account(const evmc::address& addres...
    function evmc_access_status (line 331) | evmc_access_status EvmHost::access_storage(const evmc::address& addres...
    function evmc_storage_status (line 339) | evmc_storage_status EvmHost::set_storage(const evmc::address& address,...
    function evmc_tx_context (line 448) | evmc_tx_context EvmHost::get_tx_context() const noexcept {

FILE: silkworm/core/execution/evm.hpp
  type silkworm (line 27) | namespace silkworm {
    type CallResult (line 29) | struct CallResult {
    class EvmTracer (line 39) | class EvmTracer {
      method on_block_start (line 43) | virtual void on_block_start(const Block& /*block*/) noexcept {}
      method on_execution_start (line 45) | virtual void on_execution_start(evmc_revision /*rev*/, const evmc_me...
      method on_instruction_start (line 47) | virtual void on_instruction_start(uint32_t /*pc*/, const intx::uint2...
      method on_execution_end (line 51) | virtual void on_execution_end(const evmc_result& /*result*/, const I...
      method on_creation_completed (line 54) | virtual void on_creation_completed(const evmc_result& /*result*/, co...
      method on_precompiled_run (line 56) | virtual void on_precompiled_run(const evmc_result& /*result*/, const...
      method on_reward_granted (line 58) | virtual void on_reward_granted(const CallResult& /*result*/, const I...
      method on_self_destruct (line 60) | virtual void on_self_destruct(const evmc::address& /*address*/, cons...
      method on_block_end (line 62) | virtual void on_block_end(const Block& /*block*/) noexcept {}
    function standard_transfer (line 73) | inline void standard_transfer(IntraBlockState& state, const evmc::addr...
    class EVM (line 82) | class EVM {
      method EVM (line 85) | EVM(const EVM&) = delete;
      method EVM (line 86) | EVM& operator=(const EVM&) = delete;
      method Block (line 101) | const Block& block() const noexcept { return block_; }
      method ChainConfig (line 103) | const ChainConfig& config() const noexcept { return config_; }
      method IntraBlockState (line 105) | IntraBlockState& state() noexcept { return state_; }
      method IntraBlockState (line 106) | const IntraBlockState& state() const noexcept { return state_; }
      method EvmTracers (line 115) | const EvmTracers& tracers() const noexcept { return tracers_; }
    class EvmHost (line 156) | class EvmHost : public evmc::Host {
      method EvmHost (line 158) | explicit EvmHost(EVM& evm) noexcept : evm_{evm} {}

FILE: silkworm/core/execution/evm_test.cpp
  type silkworm (line 19) | namespace silkworm {
    class TestTracer (line 535) | class TestTracer : public EvmTracer {
      method TestTracer (line 537) | explicit TestTracer(std::optional<evmc::address> contract_address = ...
      method on_execution_start (line 541) | void on_execution_start(evmc_revision rev, const evmc_message& msg, ...
      method on_instruction_start (line 547) | void on_instruction_start(uint32_t pc, const intx::uint256* /*stack_...
      method on_execution_end (line 557) | void on_execution_end(const evmc_result& res, const IntraBlockState&...
      method on_creation_completed (line 568) | void on_creation_completed(const evmc_result& /*result*/, const Intr...
      method on_self_destruct (line 571) | void on_self_destruct(const evmc::address& /*address*/, const evmc::...
      method reset (line 575) | void reset() {
      method execution_start_called (line 591) | bool execution_start_called() const { return execution_start_called_; }
      method execution_end_called (line 592) | bool execution_end_called() const { return execution_end_called_; }
      method creation_completed_called (line 593) | bool creation_completed_called() const { return creation_completed_c...
      method self_destruct_called (line 594) | bool self_destruct_called() const { return self_destruct_called_; }
      method Bytes (line 595) | const Bytes& bytecode() const { return bytecode_; }
      method evmc_revision (line 596) | const evmc_revision& rev() const { return rev_; }
      method CallResult (line 601) | const CallResult& result() const { return result_; }

FILE: silkworm/core/execution/execution.hpp
  type silkworm (line 16) | namespace silkworm {
    function ValidationResult (line 28) | inline ValidationResult execute_block(
    function ValidationResult (line 57) | inline ValidationResult execute_block(

FILE: silkworm/core/execution/execution_test.cpp
  type silkworm (line 19) | namespace silkworm {
    class BlockTracer (line 111) | class BlockTracer : public EvmTracer {
      method BlockTracer (line 113) | explicit BlockTracer() = default;
      method on_block_start (line 115) | void on_block_start(const silkworm::Block& /*block*/) noexcept overr...
      method on_block_end (line 118) | void on_block_end(const silkworm::Block& /*block*/) noexcept override {
      method block_start_called (line 122) | bool block_start_called() const { return block_start_called_; }
      method block_end_called (line 123) | bool block_end_called() const { return block_end_called_; }

FILE: silkworm/core/execution/precompile.cpp
  type silkworm::precompile (line 34) | namespace silkworm::precompile {
    function right_pad (line 36) | static void right_pad(Bytes& str, const size_t min_size) noexcept {
    function ecrec_gas (line 42) | uint64_t ecrec_gas(ByteView, evmc_revision) noexcept { return 3'000; }
    function ecrec_run (line 44) | std::optional<Bytes> ecrec_run(ByteView input) noexcept {
    function sha256_gas (line 69) | uint64_t sha256_gas(ByteView input, evmc_revision) noexcept {
    function sha256_run (line 73) | std::optional<Bytes> sha256_run(ByteView input) noexcept {
    function rip160_gas (line 81) | uint64_t rip160_gas(ByteView input, evmc_revision) noexcept {
    function rip160_run (line 85) | std::optional<Bytes> rip160_run(ByteView input) noexcept {
    function id_gas (line 94) | uint64_t id_gas(ByteView input, evmc_revision) noexcept {
    function id_run (line 98) | std::optional<Bytes> id_run(ByteView input) noexcept {
    function mult_complexity_eip198 (line 102) | static intx::uint256 mult_complexity_eip198(const intx::uint256& x) no...
    function mult_complexity_eip2565 (line 113) | static intx::uint256 mult_complexity_eip2565(const intx::uint256& max_...
    function expmod_gas (line 118) | uint64_t expmod_gas(ByteView input_view, evmc_revision rev) noexcept {
    function expmod_run (line 181) | std::optional<Bytes> expmod_run(ByteView input_view) noexcept {
    function init_libff (line 254) | static void init_libff() noexcept {
    function Scalar (line 264) | static Scalar to_scalar(const uint8_t bytes_be[32]) noexcept {
    function valid_element_of_fp (line 275) | static bool valid_element_of_fp(const Scalar& x) noexcept {
    function decode_g1_element (line 279) | static std::optional<libff::alt_bn128_G1> decode_g1_element(const uint...
    function decode_fp2_element (line 301) | static std::optional<libff::alt_bn128_Fq2> decode_fp2_element(const ui...
    function decode_g2_element (line 313) | static std::optional<libff::alt_bn128_G2> decode_g2_element(const uint...
    function Bytes (line 341) | static Bytes encode_g1_element(libff::alt_bn128_G1 p) noexcept {
    function bn_add_gas (line 362) | uint64_t bn_add_gas(ByteView, evmc_revision rev) noexcept {
    function bn_add_run (line 366) | std::optional<Bytes> bn_add_run(ByteView input_view) noexcept {
    function bn_mul_gas (line 386) | uint64_t bn_mul_gas(ByteView, evmc_revision rev) noexcept {
    function bn_mul_run (line 390) | std::optional<Bytes> bn_mul_run(ByteView input_view) noexcept {
    function snarkv_gas (line 409) | uint64_t snarkv_gas(ByteView input, evmc_revision rev) noexcept {
    function snarkv_run (line 414) | std::optional<Bytes> snarkv_run(ByteView input) noexcept {
    function blake2_f_gas (line 450) | uint64_t blake2_f_gas(ByteView input, evmc_revision) noexcept {
    function blake2_f_run (line 458) | std::optional<Bytes> blake2_f_run(ByteView input) noexcept {
    function point_evaluation_gas (line 484) | uint64_t point_evaluation_gas(ByteView, evmc_revision) noexcept {
    function point_evaluation_run (line 489) | std::optional<Bytes> point_evaluation_run(ByteView input) noexcept {
    function is_precompile (line 514) | bool is_precompile(const evmc::address& address, evmc_revision rev) no...

FILE: silkworm/core/execution/precompile.hpp
  type silkworm::precompile (line 13) | namespace silkworm::precompile {
    type Contract (line 18) | struct Contract {
    type SupportedContract (line 60) | struct SupportedContract {

FILE: silkworm/core/execution/precompile_benchmark.cpp
  function ec_recovery (line 9) | static void ec_recovery(benchmark::State& state) {

FILE: silkworm/core/execution/precompile_test.cpp
  type silkworm::precompile (line 10) | namespace silkworm::precompile {

FILE: silkworm/core/execution/processor.cpp
  type silkworm (line 13) | namespace silkworm {
    class StateView (line 14) | class StateView final : public evmone::state::StateView {
      method StateView (line 18) | explicit StateView(IntraBlockState& state) noexcept : state_{state} {}
      method get_account (line 20) | std::optional<Account> get_account(const evmc::address& addr) const ...
      method get_account_code (line 39) | evmone::bytes get_account_code(const evmc::address& addr) const noex...
      method get_storage (line 43) | evmc::bytes32 get_storage(const evmc::address& addr, const evmc::byt...
    class BlockHashes (line 49) | class BlockHashes final : public evmone::state::BlockHashes {
      method BlockHashes (line 53) | explicit BlockHashes(EVM& evm) noexcept : evm_{evm} {}
      method get_block_hash (line 54) | evmc::bytes32 get_block_hash(int64_t block_number) const noexcept ov...
    function check_evm1_execution_result (line 61) | void check_evm1_execution_result(const evmone::state::StateDiff& state...
    function CallResult (line 272) | CallResult ExecutionProcessor::call(const Transaction& txn, const std:...
    function ValidationResult (line 385) | ValidationResult ExecutionProcessor::execute_block_no_post_validation(...
    function ValidationResult (line 421) | ValidationResult ExecutionProcessor::execute_block(std::vector<Receipt...

FILE: silkworm/core/execution/processor.hpp
  type silkworm (line 18) | namespace silkworm {
    class ExecutionProcessor (line 20) | class ExecutionProcessor {
      method ExecutionProcessor (line 22) | ExecutionProcessor(const ExecutionProcessor&) = delete;
      method ExecutionProcessor (line 23) | ExecutionProcessor& operator=(const ExecutionProcessor&) = delete;
      method EVM (line 45) | EVM& evm() noexcept { return evm_; }
      method EVM (line 46) | const EVM& evm() const noexcept { return evm_; }
      method IntraBlockState (line 47) | IntraBlockState& intra_block_state() { return state_; }
      method IntraBlockState (line 48) | const IntraBlockState& intra_block_state() const { return state_; }

FILE: silkworm/core/execution/processor_test.cpp
  type silkworm (line 14) | namespace silkworm {

FILE: silkworm/core/protocol/blockchain.cpp
  type silkworm::protocol (line 11) | namespace silkworm::protocol {
    function ValidationResult (line 18) | ValidationResult Blockchain::insert_block(Block& block, bool check_sta...
    function ValidationResult (line 80) | ValidationResult Blockchain::execute_block(const Block& block, bool ch...

FILE: silkworm/core/protocol/blockchain.hpp
  type silkworm::protocol (line 16) | namespace silkworm::protocol {
    class Blockchain (line 23) | class Blockchain {
      method Blockchain (line 33) | Blockchain(const Blockchain&) = delete;
      method Blockchain (line 34) | Blockchain& operator=(const Blockchain&) = delete;

FILE: silkworm/core/protocol/bor/config.cpp
  type silkworm::protocol::bor (line 14) | namespace silkworm::protocol::bor {

FILE: silkworm/core/protocol/bor/config.hpp
  type silkworm::protocol::bor (line 15) | namespace silkworm::protocol::bor {
    type Config (line 17) | struct Config {
    function T (line 47) | constexpr const T* config_value_lookup(const SmallMap<BlockNum, T>& co...

FILE: silkworm/core/protocol/bor/config_test.cpp
  type silkworm::protocol::bor (line 12) | namespace silkworm::protocol::bor {

FILE: silkworm/core/protocol/bor/span.cpp
  type silkworm::protocol::bor (line 8) | namespace silkworm::protocol::bor {
    function get_current_span (line 10) | std::optional<Span> get_current_span(EVM& evm, const evmc_address& val...

FILE: silkworm/core/protocol/bor/span.hpp
  type silkworm::protocol::bor (line 11) | namespace silkworm::protocol::bor {
    type Span (line 13) | struct Span {

FILE: silkworm/core/protocol/bor/span_test.cpp
  type silkworm::protocol::bor (line 11) | namespace silkworm::protocol::bor {

FILE: silkworm/core/protocol/bor_rule_set.cpp
  type silkworm::protocol (line 13) | namespace silkworm::protocol {
    function is_sprint_start (line 15) | static bool is_sprint_start(BlockNum block_num, uint64_t sprint_size) {
    function ValidationResult (line 21) | ValidationResult BorRuleSet::validate_block_header(const BlockHeader& ...
    function ValidationResult (line 47) | ValidationResult BorRuleSet::validate_extra_data(const BlockHeader& he...
    function ecrecover (line 75) | static std::optional<evmc::address> ecrecover(const BlockHeader& heade...
    function rewrite_code_if_needed (line 95) | static void rewrite_code_if_needed(const SmallMap<BlockNum, SmallMap<e...
    function ValidationResult (line 106) | ValidationResult BorRuleSet::finalize(IntraBlockState& state, const Bl...
    function ValidationResult (line 118) | ValidationResult BorRuleSet::validate_difficulty_and_seal(const BlockH...
    function add_transfer_log (line 135) | void add_transfer_log(IntraBlockState& state, const evmc::bytes32& eve...
    function bor_transfer (line 166) | void bor_transfer(IntraBlockState& state, const evmc::address& sender,...
    function TransferFunc (line 195) | TransferFunc* BorRuleSet::transfer_func() const {

FILE: silkworm/core/protocol/bor_rule_set.hpp
  type silkworm::protocol (line 8) | namespace silkworm::protocol {
    class BorRuleSet (line 11) | class BorRuleSet : public RuleSet {
      method BorRuleSet (line 13) | explicit BorRuleSet(const ChainConfig& chain_config) : RuleSet(chain...
      method initialize (line 18) | void initialize(EVM&) override {}

FILE: silkworm/core/protocol/ethash_config.cpp
  type silkworm::protocol (line 6) | namespace silkworm::protocol {

FILE: silkworm/core/protocol/ethash_config.hpp
  type silkworm::protocol (line 8) | namespace silkworm::protocol {
    type EthashConfig (line 11) | struct EthashConfig {

FILE: silkworm/core/protocol/ethash_rule_set.cpp
  type silkworm::protocol (line 12) | namespace silkworm::protocol {
    function ValidationResult (line 15) | ValidationResult EthashRuleSet::validate_difficulty_and_seal(const Blo...
    function ValidationResult (line 42) | ValidationResult EthashRuleSet::validate_extra_data(const BlockHeader&...
    function ValidationResult (line 61) | ValidationResult EthashRuleSet::finalize(IntraBlockState& state, const...
    function block_reward_base (line 70) | static intx::uint256 block_reward_base(const evmc_revision rev) {
    function BlockReward (line 80) | BlockReward EthashRuleSet::compute_reward(const Block& block) {

FILE: silkworm/core/protocol/ethash_rule_set.hpp
  type silkworm::protocol (line 12) | namespace silkworm::protocol {
    class EthashRuleSet (line 15) | class EthashRuleSet : public RuleSet {
      method EthashRuleSet (line 17) | explicit EthashRuleSet(const ChainConfig& chain_config) : RuleSet(ch...

FILE: silkworm/core/protocol/ethash_rule_set_test.cpp
  type silkworm::protocol (line 8) | namespace silkworm::protocol {

FILE: silkworm/core/protocol/intrinsic_gas.cpp
  type silkworm::protocol (line 10) | namespace silkworm::protocol {
    function intrinsic_gas (line 12) | intx::uint128 intrinsic_gas(const UnsignedTransaction& txn, const evmc...
    function floor_cost (line 51) | uint64_t floor_cost(const UnsignedTransaction& txn) noexcept {

FILE: silkworm/core/protocol/intrinsic_gas.hpp
  type silkworm (line 10) | namespace silkworm {
    function num_words (line 13) | constexpr uint64_t num_words(uint64_t num_bytes) noexcept {
    type protocol (line 17) | namespace protocol {

FILE: silkworm/core/protocol/intrinsic_gas_test.cpp
  type silkworm (line 12) | namespace silkworm {
    type protocol (line 27) | namespace protocol {

FILE: silkworm/core/protocol/merge_rule_set.cpp
  type silkworm::protocol (line 14) | namespace silkworm::protocol {
    function ValidationResult (line 21) | ValidationResult MergeRuleSet::pre_validate_block_body(const Block& bl...
    function ValidationResult (line 31) | ValidationResult MergeRuleSet::validate_block_header(const BlockHeader...
    function ValidationResult (line 64) | ValidationResult MergeRuleSet::validate_difficulty_and_seal(const Bloc...
    function ValidationResult (line 102) | ValidationResult MergeRuleSet::finalize(IntraBlockState& state, const ...
    function ValidationResult (line 131) | ValidationResult MergeRuleSet::validate_ommers(const Block& block, con...
    function BlockReward (line 141) | BlockReward MergeRuleSet::compute_reward(const Block& block) {

FILE: silkworm/core/protocol/merge_rule_set.hpp
  type silkworm::protocol (line 10) | namespace silkworm::protocol {
    class MergeRuleSet (line 14) | class MergeRuleSet : public RuleSet {

FILE: silkworm/core/protocol/merge_rule_set_test.cpp
  type silkworm::protocol (line 13) | namespace silkworm::protocol {

FILE: silkworm/core/protocol/param.hpp
  type silkworm::protocol (line 12) | namespace silkworm::protocol {
    type fee (line 15) | namespace fee {

FILE: silkworm/core/protocol/rule_set.cpp
  type silkworm::protocol (line 17) | namespace silkworm::protocol {
    function ValidationResult (line 19) | ValidationResult RuleSet::pre_validate_block_body(const Block& block, ...
    function ValidationResult (line 77) | ValidationResult RuleSet::validate_ommers(const Block& block, const Bl...
    function ValidationResult (line 111) | ValidationResult RuleSet::validate_block_header(const BlockHeader& hea...
    function ValidationResult (line 203) | ValidationResult RuleSet::validate_extra_data(const BlockHeader& heade...
    function BlockReward (line 246) | BlockReward RuleSet::compute_reward(const Block&) {
    function RuleSetPtr (line 255) | static RuleSetPtr pre_merge_rule_set(const ChainConfig& chain_config) {
    function RuleSetPtr (line 265) | RuleSetPtr rule_set_factory(const ChainConfig& chain_config) {

FILE: silkworm/core/protocol/rule_set.hpp
  type silkworm::protocol (line 19) | namespace silkworm::protocol {
    type BlockReward (line 21) | struct BlockReward {
    class RuleSet (line 32) | class RuleSet {
      method RuleSet (line 35) | RuleSet(RuleSet&& other) = default;
      method RuleSet (line 36) | RuleSet& operator=(RuleSet&& other) = default;
      method TransferFunc (line 84) | virtual TransferFunc* transfer_func() const { return standard_transf...
      method RuleSet (line 87) | explicit RuleSet(const ChainConfig& chain_config, bool prohibit_ommers)

FILE: silkworm/core/protocol/rule_set_test.cpp
  type silkworm::protocol (line 11) | namespace silkworm::protocol {

FILE: silkworm/core/protocol/validation.cpp
  type silkworm::protocol (line 18) | namespace silkworm::protocol {
    function transaction_type_is_supported (line 20) | bool transaction_type_is_supported(TransactionType type, evmc_revision...
    function ValidationResult (line 32) | ValidationResult pre_validate_transaction(const Transaction& txn, cons...
    function ValidationResult (line 61) | ValidationResult validate_transaction(const Transaction& txn, const In...
    function ValidationResult (line 96) | ValidationResult pre_validate_transactions(const Block& block, const C...
    function ValidationResult (line 112) | ValidationResult validate_call_precheck(const Transaction& txn, const ...
    function ValidationResult (line 141) | ValidationResult pre_validate_common_base(const Transaction& txn, evmc...
    function ValidationResult (line 173) | ValidationResult pre_validate_common_forks(const Transaction& txn, con...
    function ValidationResult (line 221) | ValidationResult validate_call_funds(const Transaction& txn, const EVM...
    function compute_call_cost (line 240) | intx::uint256 compute_call_cost(const Transaction& txn, const intx::ui...
    function expected_base_fee_per_gas (line 260) | intx::uint256 expected_base_fee_per_gas(const BlockHeader& parent) {
    function calc_excess_blob_gas (line 291) | uint64_t calc_excess_blob_gas(const BlockHeader& parent, evmc_revision...
    function compute_transaction_root (line 303) | evmc::bytes32 compute_transaction_root(const BlockBody& body) {
    function compute_withdrawals_root (line 310) | std::optional<evmc::bytes32> compute_withdrawals_root(const BlockBody&...
    function compute_ommers_hash (line 321) | evmc::bytes32 compute_ommers_hash(const BlockBody& body) {
    function ValidationResult (line 331) | ValidationResult validate_requests_root(const BlockHeader& header, con...

FILE: silkworm/core/protocol/validation.hpp
  type silkworm (line 14) | namespace silkworm {
    class EVM (line 16) | class EVM
    type protocol (line 115) | namespace protocol {

FILE: silkworm/core/protocol/validation_test.cpp
  type silkworm::protocol (line 14) | namespace silkworm::protocol {

FILE: silkworm/core/rlp/decode.cpp
  type silkworm::rlp (line 11) | namespace silkworm::rlp {
    function decode_header (line 13) | tl::expected<Header, DecodingError> decode_header(ByteView& from) noex...
    function DecodingResult (line 77) | DecodingResult decode(ByteView& from, Bytes& to, Leftover mode) noexce...
    function DecodingResult (line 93) | DecodingResult decode(ByteView& from, bool& to, Leftover mode) noexcept {

FILE: silkworm/core/rlp/decode.hpp
  type silkworm::rlp (line 20) | namespace silkworm::rlp {
    type Leftover (line 24) | enum class Leftover {
    function DecodingResult (line 36) | DecodingResult decode(ByteView& from, T& to, Leftover mode = Leftover:...
    function DecodingResult (line 57) | DecodingResult decode(ByteView& from, std::span<uint8_t, N> to, Leftov...
    function DecodingResult (line 80) | DecodingResult decode(ByteView& from, uint8_t (&to)[N], Leftover mode ...
    function DecodingResult (line 85) | DecodingResult decode(ByteView& from, std::array<uint8_t, N>& to, Left...

FILE: silkworm/core/rlp/decode_test.cpp
  type silkworm::rlp (line 12) | namespace silkworm::rlp {
    function T (line 15) | static T decode_success(std::string_view hex) {
    function DecodingError (line 24) | static DecodingError decode_failure(std::string_view hex) {

FILE: silkworm/core/rlp/decode_vector.hpp
  type silkworm::rlp (line 11) | namespace silkworm::rlp {
    function DecodingResult (line 15) | DecodingResult decode(ByteView& from, std::vector<T>& to, Leftover mod...
    function DecodingResult (line 42) | DecodingResult decode_items(ByteView& from, Arg1& arg1, Arg2& arg2) no...
    function DecodingResult (line 50) | DecodingResult decode_items(ByteView& from, Arg1& arg1, Arg2& arg2, Ar...
    function DecodingResult (line 59) | DecodingResult decode(ByteView& from, Leftover mode, Arg1& arg1, Arg2&...
    function DecodingResult (line 88) | inline DecodingResult decode(ByteView& from, std::vector<RlpByteView>&...

FILE: silkworm/core/rlp/encode.cpp
  type silkworm::rlp (line 6) | namespace silkworm::rlp {
    function encode_header (line 8) | void encode_header(Bytes& to, Header header) {
    function length_of_length (line 20) | size_t length_of_length(uint64_t payload_length) noexcept {
    function encode (line 27) | void encode(Bytes& to, bool x) {
    function encode (line 31) | void encode(Bytes& to, ByteView s) {
    function length (line 38) | size_t length(ByteView s) noexcept {

FILE: silkworm/core/rlp/encode.hpp
  type silkworm::rlp (line 15) | namespace silkworm::rlp {
    type Header (line 17) | struct Header {
    function encode (line 30) | void encode(Bytes& to, const T& n) {
    function length (line 49) | size_t length(const T& n) noexcept {
    function length (line 57) | inline size_t length(bool) noexcept {

FILE: silkworm/core/rlp/encode_test.cpp
  type silkworm (line 9) | namespace silkworm {
    function Bytes (line 12) | static Bytes encoded(const T& x) {

FILE: silkworm/core/rlp/encode_vector.hpp
  type silkworm::rlp (line 12) | namespace silkworm::rlp {
    function length_items (line 17) | size_t length_items(const std::span<const T>& v) {
    function length (line 22) | size_t length(const std::span<const T>& v) {
    function encode_items (line 28) | void encode_items(Bytes& to, const std::span<const T>& v) {
    function encode (line 35) | void encode(Bytes& to, const std::span<const T>& v) {
    function length_items (line 45) | size_t length_items(const std::vector<T>& v) {
    function length (line 50) | size_t length(const std::vector<T>& v) {
    function encode_items (line 55) | void encode_items(Bytes& to, const std::vector<T>& v) {
    function encode (line 60) | void encode(Bytes& to, const std::vector<T>& v) {
    function length_items (line 67) | size_t length_items(const Arg1& arg1, const Arg2& arg2) {
    function length_items (line 72) | size_t length_items(const Arg1& arg1, const Arg2& arg2, const Args&......
    function length (line 77) | size_t length(const Arg1& arg1, const Arg2& arg2, const Args&... args) {
    function encode_items (line 83) | void encode_items(Bytes& to, const Arg1& arg1, const Arg2& arg2) {
    function encode_items (line 89) | void encode_items(Bytes& to, const Arg1& arg1, const Arg2& arg2, const...
    function encode (line 95) | void encode(Bytes& to, const Arg1& arg1, const Arg2& arg2, const Args&...
    type RlpBytes (line 109) | struct RlpBytes {
      method RlpBytes (line 111) | explicit RlpBytes(Bytes data1) : data(std::move(data1)) {}
    type RlpByteView (line 115) | struct RlpByteView {
      method RlpByteView (line 117) | explicit RlpByteView(ByteView data1) : data(data1) {}
    function encode (line 121) | inline void encode(Bytes& to, const std::span<const RlpByteView>& v) {
    function encode (line 135) | inline void encode(Bytes& to, const std::vector<RlpByteView>& v) {
    function encode (line 140) | inline void encode(Bytes& to, const std::span<const RlpBytes>& v) {
    function encode (line 150) | inline void encode(Bytes& to, const std::vector<RlpBytes>& v) {

FILE: silkworm/core/state/block_state.hpp
  type silkworm (line 13) | namespace silkworm {
    class BlockState (line 15) | class BlockState {

FILE: silkworm/core/state/delta.cpp
  type silkworm::state (line 10) | namespace silkworm::state {

FILE: silkworm/core/state/delta.hpp
  type silkworm (line 9) | namespace silkworm {
    class IntraBlockState (line 11) | class IntraBlockState
    type state (line 13) | namespace state {
      class Delta (line 16) | class Delta {
        method Delta (line 18) | Delta(const Delta&) = delete;
        method Delta (line 19) | Delta& operator=(const Delta&) = delete;
        method Delta (line 26) | Delta() = default;
      class CreateDelta (line 30) | class CreateDelta : public Delta {
      class UpdateDelta (line 41) | class UpdateDelta : public Delta {
      class UpdateBalanceDelta (line 54) | class UpdateBalanceDelta : public Delta {
      class SuicideDelta (line 66) | class SuicideDelta : public Delta {
      class TouchDelta (line 77) | class TouchDelta : public Delta {
      class StorageChangeDelta (line 88) | class StorageChangeDelta : public Delta {
      class StorageWipeDelta (line 102) | class StorageWipeDelta : public Delta {
      class StorageCreateDelta (line 114) | class StorageCreateDelta : public Delta {
      class StorageAccessDelta (line 125) | class StorageAccessDelta : public Delta {
      class AccountAccessDelta (line 137) | class AccountAccessDelta : public Delta {
      class TransientStorageChangeDelta (line 148) | class TransientStorageChangeDelta : public Delta {

FILE: silkworm/core/state/in_memory_state.cpp
  type silkworm (line 17) | namespace silkworm {
    function ByteView (line 27) | ByteView InMemoryState::read_code(const evmc::address& /*address*/, co...
    function BlockNum (line 94) | BlockNum InMemoryState::current_canonical_block() const {

FILE: silkworm/core/state/in_memory_state.hpp
  type silkworm (line 12) | namespace silkworm {
    class InMemoryState (line 15) | class InMemoryState : public State {
      method Storage (line 77) | const Storage& storage() const { return storage_; }

FILE: silkworm/core/state/intra_block_state.cpp
  type silkworm (line 11) | namespace silkworm {
    function ByteView (line 203) | ByteView IntraBlockState::get_code(const evmc::address& address) const...
    function evmc_access_status (line 247) | evmc_access_status IntraBlockState::access_account(const evmc::address...
    function evmc_access_status (line 255) | evmc_access_status IntraBlockState::access_storage(const evmc::address...

FILE: silkworm/core/state/intra_block_state.hpp
  type silkworm (line 19) | namespace silkworm {
    class IntraBlockState (line 21) | class IntraBlockState {
      class Snapshot (line 23) | class Snapshot {
        method Snapshot (line 26) | Snapshot(Snapshot&&) = default;
        method Snapshot (line 27) | Snapshot& operator=(Snapshot&&) = default;
        method Snapshot (line 32) | Snapshot() = default;
      method IntraBlockState (line 39) | IntraBlockState(const IntraBlockState&) = delete;
      method IntraBlockState (line 40) | IntraBlockState& operator=(const IntraBlockState&) = delete;
      method IntraBlockState (line 42) | explicit IntraBlockState(State& db) noexcept : db_{db} {}
      method State (line 44) | State& db() { return db_; }
      method number_of_self_destructs (line 59) | size_t number_of_self_destructs() const noexcept { return self_destr...

FILE: silkworm/core/state/intra_block_state_test.cpp
  type silkworm (line 17) | namespace silkworm {
    function random_address (line 21) | static evmc::address random_address() {
    function Bytes (line 29) | static Bytes random_code() {

FILE: silkworm/core/state/object.hpp
  type silkworm::state (line 12) | namespace silkworm::state {
    type Object (line 14) | struct Object {
    type CommittedValue (line 19) | struct CommittedValue {
    type Storage (line 24) | struct Storage {

FILE: silkworm/core/state/state.hpp
  type silkworm (line 11) | namespace silkworm {
    class State (line 13) | class State : public BlockState {
      method State (line 15) | State() = default;
      method State (line 18) | State(State&& other) = default;
      method State (line 19) | State& operator=(State&& other) = default;

FILE: silkworm/core/test_util/null_stream.hpp
  type silkworm::test_util (line 8) | namespace silkworm::test_util {
    type NullBuf (line 12) | struct NullBuf : public std::streambuf {
      method overflow (line 13) | int overflow(int c) override { return c; }
    type NullStream (line 15) | struct NullStream : public std::ostream {
      method NullStream (line 16) | NullStream() : std::ostream(&null_buf) {}

FILE: silkworm/core/test_util/sample_blocks.hpp
  type silkworm::test_util (line 18) | namespace silkworm::test_util {
    function BlockHeader (line 39) | inline BlockHeader sample_block_header() {
    function Transaction (line 59) | inline Transaction sample_tx0() {
    function Transaction (line 74) | inline Transaction sample_tx1() {
    function BlockHeader (line 101) | inline BlockHeader sample_ommer0() {
    function BlockBody (line 130) | inline BlockBody sample_block_body() {
    function Block (line 147) | inline Block sample_block() {
    function generate_sample_child_blocks (line 153) | inline std::shared_ptr<Block> generate_sample_child_blocks(const Block...

FILE: silkworm/core/trie/hash_builder.cpp
  type silkworm::trie (line 17) | namespace silkworm::trie {
    function Bytes (line 21) | static Bytes encode_path(ByteView nibbles, bool terminating) {
    function ByteView (line 41) | ByteView HashBuilder::leaf_node_rlp(ByteView path, ByteView value) {
    function ByteView (line 51) | ByteView HashBuilder::extension_node_rlp(ByteView path, ByteView child...
    function Bytes (line 61) | static Bytes wrap_hash(std::span<const uint8_t, kHashLength> hash) {
    function Bytes (line 68) | static Bytes node_ref(ByteView rlp) {

FILE: silkworm/core/trie/hash_builder.hpp
  type silkworm::trie (line 15) | namespace silkworm::trie {
    class HashBuilder (line 23) | class HashBuilder {
      method HashBuilder (line 25) | HashBuilder() = default;
      method HashBuilder (line 28) | HashBuilder(const HashBuilder&) = delete;
      method HashBuilder (line 29) | HashBuilder& operator=(const HashBuilder&) = delete;

FILE: silkworm/core/trie/hash_builder_test.cpp
  type silkworm::trie (line 16) | namespace silkworm::trie {

FILE: silkworm/core/trie/nibbles.cpp
  type silkworm::trie (line 6) | namespace silkworm::trie {
    function Bytes (line 8) | Bytes pack_nibbles(ByteView unpacked) {
    function Bytes (line 28) | Bytes unpack_nibbles(ByteView data) {

FILE: silkworm/core/trie/nibbles.hpp
  type silkworm::trie (line 8) | namespace silkworm::trie {

FILE: silkworm/core/trie/nibbles_test.cpp
  type silkworm::trie (line 11) | namespace silkworm::trie {

FILE: silkworm/core/trie/node.cpp
  type silkworm::trie (line 12) | namespace silkworm::trie {
    function Bytes (line 28) | Bytes Node::encode_for_storage() const {
    function DecodingResult (line 49) | DecodingResult Node::decode_from_storage(ByteView raw, Node& node) {

FILE: silkworm/core/trie/node.hpp
  type silkworm::trie (line 14) | namespace silkworm::trie {
    class Node (line 22) | class Node {
      method Node (line 24) | Node() = default;
      method Node (line 29) | Node(const Node& other) = default;
      method Node (line 30) | Node& operator=(const Node& other) = default;
      method state_mask (line 32) | uint16_t state_mask() const { return state_mask_; }
      method tree_mask (line 33) | uint16_t tree_mask() const { return tree_mask_; }
      method hash_mask (line 34) | uint16_t hash_mask() const { return hash_mask_; }
    function is_subset (line 60) | inline bool is_subset(uint16_t sub, uint16_t sup) { return (sub & sup)...

FILE: silkworm/core/trie/node_test.cpp
  type silkworm::trie (line 13) | namespace silkworm::trie {

FILE: silkworm/core/trie/prefix_set.cpp
  type silkworm::trie (line 9) | namespace silkworm::trie {

FILE: silkworm/core/trie/prefix_set.hpp
  type silkworm::trie (line 11) | namespace silkworm::trie {
    class PrefixSet (line 18) | class PrefixSet {
      method PrefixSet (line 21) | PrefixSet() = default;
      method PrefixSet (line 24) | PrefixSet(const PrefixSet& other) = default;
      method PrefixSet (line 25) | PrefixSet& operator=(const PrefixSet& other) = default;
      method size (line 42) | size_t size() const { return keys_.size(); }
      method empty (line 43) | bool empty() const { return keys_.empty(); }
      method clear (line 45) | void clear() noexcept {

FILE: silkworm/core/trie/prefix_set_test.cpp
  type silkworm::trie (line 11) | namespace silkworm::trie {

FILE: silkworm/core/trie/vector_root.hpp
  type silkworm::trie (line 13) | namespace silkworm::trie {
    function adjust_index_for_rlp (line 17) | inline size_t adjust_index_for_rlp(size_t i, size_t len) {
    function root_hash (line 30) | evmc::bytes32 root_hash(const std::vector<Value>& v, const Encoder& va...

FILE: silkworm/core/trie/vector_root_test.cpp
  type silkworm::trie (line 14) | namespace silkworm::trie {

FILE: silkworm/core/types/account.cpp
  type silkworm (line 10) | namespace silkworm {
    function Bytes (line 12) | Bytes Account::rlp(const evmc::bytes32& storage_root) const {

FILE: silkworm/core/types/account.hpp
  type silkworm (line 12) | namespace silkworm {
    type Account (line 19) | struct Account {

FILE: silkworm/core/types/address.cpp
  type silkworm (line 12) | namespace silkworm {
    type rlp (line 14) | namespace rlp {
      function encode (line 16) | void encode(Bytes& to, const evmc::address& address) {
      function DecodingResult (line 20) | DecodingResult decode(ByteView& from, evmc::address& address, Leftov...
      function length (line 25) | size_t length(const evmc::address& address) noexcept {
    function create_address (line 31) | evmc::address create_address(const evmc::address& caller, uint64_t non...
    function create2_address (line 47) | evmc::address create2_address(const evmc::address& caller, const evmc:...
    function bytes_to_address (line 64) | evmc::address bytes_to_address(ByteView bytes) {
    function hex_to_address (line 73) | evmc::address hex_to_address(std::string_view hex, bool return_zero_on...
    function address_to_hex (line 84) | std::string address_to_hex(const evmc::address& address) {
  type evmc (line 90) | namespace evmc {

FILE: silkworm/core/types/address.hpp
  type silkworm (line 17) | namespace silkworm {
    type rlp (line 36) | namespace rlp {
  type evmc (line 44) | namespace evmc {

FILE: silkworm/core/types/address_test.cpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/types/block.cpp
  type silkworm (line 14) | namespace silkworm {
    function fake_exponential (line 34) | static intx::uint256 fake_exponential(const intx::uint256& factor,
    function calc_blob_gas_price (line 46) | intx::uint256 calc_blob_gas_price(uint64_t excess_blob_gas, evmc_revis...
    type rlp (line 63) | namespace rlp {
      function Header (line 65) | static Header rlp_header(const BlockHeader& header, bool for_sealing...
      function length (line 111) | size_t length(const BlockHeader& header) {
      function encode (line 116) | void encode(Bytes& to, const BlockHeader& header, bool for_sealing, ...
      function DecodingResult (line 161) | DecodingResult decode(ByteView& from, BlockHeader& to, Leftover mode...
      function Header (line 242) | static Header rlp_header_body(const BlockBody& b) {
      function length (line 252) | size_t length(const BlockBody& block_body) {
      function encode (line 257) | void encode(Bytes& to, const BlockBody& block_body) {
      function DecodingResult (line 266) | DecodingResult decode(ByteView& from, BlockBody& to, Leftover mode) ...
      function DecodingResult (line 298) | DecodingResult decode(ByteView& from, Block& to, Leftover mode) noex...
      function Header (line 330) | static Header rlp_header(const Block& b) {
      function length (line 336) | size_t length(const Block& block) {
      function encode (line 341) | void encode(Bytes& to, const Block& block) {

FILE: silkworm/core/types/block.hpp
  type silkworm (line 22) | namespace silkworm {
    type BlockHeader (line 28) | struct BlockHeader {
    type BlockBody (line 75) | struct BlockBody {
    type Block (line 83) | struct Block : public BlockBody {
      method BlockBody (line 86) | BlockBody copy_body() const {
    type BlockWithHash (line 91) | struct BlockWithHash {
    type rlp (line 96) | namespace rlp {

FILE: silkworm/core/types/block_body_for_storage.hpp
  type silkworm (line 19) | namespace silkworm {
    type BlockBodyForStorage (line 22) | struct BlockBodyForStorage {
    function Bytes (line 37) | inline Bytes BlockBodyForStorage::encode() const {
    function DecodingResult (line 58) | inline DecodingResult decode_stored_block_body(ByteView& from, BlockBo...
    function decode_stored_block_body (line 90) | inline tl::expected<BlockBodyForStorage, DecodingError> decode_stored_...

FILE: silkworm/core/types/block_body_for_storage_test.cpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/types/block_id.hpp
  type silkworm (line 9) | namespace silkworm {
    type BlockId (line 11) | struct BlockId {

FILE: silkworm/core/types/block_test.cpp
  type silkworm (line 11) | namespace silkworm {

FILE: silkworm/core/types/bloom.cpp
  type silkworm (line 10) | namespace silkworm {
    function m3_2048 (line 12) | void m3_2048(Bloom& bloom, ByteView x) {
    function Bloom (line 20) | Bloom logs_bloom(const std::vector<Log>& logs) {

FILE: silkworm/core/types/bloom.hpp
  type silkworm (line 13) | namespace silkworm {
    function join (line 24) | inline void join(Bloom& sum, const Bloom& addend) {
    function to_string (line 30) | inline std::string_view to_string(const Bloom& bloom) {

FILE: silkworm/core/types/bloom_test.cpp
  type silkworm (line 10) | namespace silkworm {

FILE: silkworm/core/types/call_traces.hpp
  type silkworm (line 10) | namespace silkworm {
    type CallTraces (line 12) | struct CallTraces {

FILE: silkworm/core/types/chain_head.hpp
  type silkworm (line 13) | namespace silkworm {
    type ChainHead (line 15) | struct ChainHead {
    function BlockId (line 31) | inline BlockId to_block_id(const ChainHead& head) {

FILE: silkworm/core/types/eip_7685_requests.cpp
  type silkworm (line 13) | namespace silkworm {
    function Bytes (line 15) | Bytes extract_deposit(const Bytes& data) {
    function ByteView (line 61) | ByteView FlatRequests::preview_data_by_type(FlatRequestType type) const {
    function Hash (line 65) | Hash FlatRequests::calculate_sha256() const {

FILE: silkworm/core/types/eip_7685_requests.hpp
  type silkworm (line 13) | namespace silkworm {
    type FlatRequestType (line 21) | enum class FlatRequestType : uint8_t {
    type FlatRequests (line 27) | struct FlatRequests {

FILE: silkworm/core/types/eip_7685_requests_test.cpp
  type silkworm (line 13) | namespace silkworm {

FILE: silkworm/core/types/evmc_bytes32.cpp
  type silkworm (line 12) | namespace silkworm {
    function to_bytes32 (line 14) | evmc::bytes32 to_bytes32(ByteView bytes) {
    function to_hex (line 23) | std::string to_hex(const evmc::bytes32& value, bool with_prefix) {
  type silkworm::rlp (line 29) | namespace silkworm::rlp {
    function encode (line 31) | void encode(Bytes& to, const evmc::bytes32& value) {
    function length (line 35) | size_t length(const evmc::bytes32& value) noexcept {
    function DecodingResult (line 39) | DecodingResult decode(ByteView& from, evmc::bytes32& to, Leftover mode...

FILE: silkworm/core/types/evmc_bytes32.hpp
  type silkworm (line 13) | namespace silkworm {
  type silkworm::rlp (line 23) | namespace silkworm::rlp {
  type evmc (line 32) | namespace evmc {

FILE: silkworm/core/types/hash.hpp
  type silkworm (line 18) | namespace silkworm {
    class Hash (line 20) | class Hash : public evmc::bytes32 {
      method Hash (line 24) | Hash() = default;
      method Hash (line 25) | explicit Hash(ByteView bv) {
      method size (line 30) | static constexpr size_t size() { return sizeof(evmc::bytes32); }
      method to_hex (line 32) | std::string to_hex() const { return silkworm::to_hex(*this); }
      method from_hex (line 33) | static std::optional<Hash> from_hex(const std::string& hex) { return...
    type rlp (line 45) | namespace rlp {
      function DecodingResult (line 46) | inline DecodingResult decode(ByteView& from, Hash& to, Leftover mode...
  type std (line 53) | namespace std {
    type hash<silkworm::Hash> (line 56) | struct hash<silkworm::Hash> : public std::hash<evmc::bytes32>  // to u...

FILE: silkworm/core/types/hash_test.cpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/core/types/log.cpp
  type silkworm::rlp (line 10) | namespace silkworm::rlp {
    function Header (line 12) | static Header header(const Log& l) {
    function length (line 21) | size_t length(const Log& l) {
    function encode (line 26) | void encode(Bytes& to, const Log& l) {

FILE: silkworm/core/types/log.hpp
  type silkworm (line 12) | namespace silkworm {
    type Log (line 14) | struct Log {
    type rlp (line 20) | namespace rlp {

FILE: silkworm/core/types/log_test.cpp
  type silkworm (line 14) | namespace silkworm {

FILE: silkworm/core/types/receipt.cpp
  type silkworm::rlp (line 9) | namespace silkworm::rlp {
    function Header (line 11) | static Header header(const Receipt& r) {
    function encode (line 21) | void encode(Bytes& to, const Receipt& r) {

FILE: silkworm/core/types/receipt.hpp
  type silkworm (line 12) | namespace silkworm {
    type Receipt (line 14) | struct Receipt {
    type rlp (line 22) | namespace rlp {

FILE: silkworm/core/types/transaction.cpp
  type silkworm (line 21) | namespace silkworm {
    type rlp (line 84) | namespace rlp {
      function Header (line 86) | static Header header(const AccessListEntry& e) {
      function length (line 90) | size_t length(const AccessListEntry& e) {
      function encode (line 95) | void encode(Bytes& to, const AccessListEntry& e) {
      function Header (line 101) | static Header header(const Authorization& authorization) {
      function length (line 113) | size_t length(const Authorization& authorization) {
      function encode (line 118) | void encode(Bytes& to, const Authorization& authorization) {
      function encode_for_signing (line 128) | void encode_for_signing(Bytes& to, const Authorization& authorizatio...
      function DecodingResult (line 144) | DecodingResult decode(ByteView& from, AccessListEntry& to, Leftover ...
      function DecodingResult (line 148) | DecodingResult decode(ByteView& from, Authorization& to, Leftover mo...
      function Header (line 152) | static Header header_base(const UnsignedTransaction& txn) {
      function Header (line 183) | static Header header(const UnsignedTransaction& txn) {
      function Header (line 191) | static Header header(const Transaction& txn) {
      function length (line 205) | size_t length(const Transaction& txn, bool wrap_eip2718_into_string) {
      function legacy_encode_base (line 214) | static void legacy_encode_base(Bytes& to, const UnsignedTransaction&...
      function eip2718_encode_for_signing (line 227) | static void eip2718_encode_for_signing(Bytes& to, const UnsignedTran...
      function encode (line 265) | void encode(Bytes& to, const Transaction& txn, bool wrap_eip2718_int...
      function DecodingResult (line 280) | static DecodingResult legacy_decode_items(ByteView& from, Transactio...
      function DecodingResult (line 311) | static DecodingResult eip2718_decode(ByteView& from, Transaction& to...
      function DecodingResult (line 377) | DecodingResult decode_transaction(ByteView& from, Transaction& to, E...
      function DecodingResult (line 450) | DecodingResult decode_transaction_header_and_type(ByteView& from, He...

FILE: silkworm/core/types/transaction.hpp
  type silkworm (line 18) | namespace silkworm {
    type AccessListEntry (line 21) | struct AccessListEntry {
    class Transaction (line 28) | class Transaction
    type Authorization (line 31) | struct Authorization {
    type eip7702 (line 44) | namespace eip7702 {
      function is_code_delegated (line 48) | constexpr bool is_code_delegated(ByteView code) noexcept {
    type TransactionType (line 55) | enum class TransactionType : uint8_t {
    type UnsignedTransaction (line 67) | struct UnsignedTransaction {
    class Transaction (line 102) | class Transaction : public UnsignedTransaction {
    type rlp (line 135) | namespace rlp {
      type Eip2718Wrapping (line 154) | enum class Eip2718Wrapping {
      function DecodingResult (line 163) | inline DecodingResult decode(ByteView& from, Transaction& to, Leftov...

FILE: silkworm/core/types/transaction_test.cpp
  type silkworm (line 11) | namespace silkworm {

FILE: silkworm/core/types/withdrawal.cpp
  type silkworm::rlp (line 10) | namespace silkworm::rlp {
    function Header (line 12) | static Header header(const Withdrawal& w) {
    function length (line 21) | size_t length(const Withdrawal& w) {
    function encode (line 26) | void encode(Bytes& to, const Withdrawal& w) {
    function DecodingResult (line 34) | DecodingResult decode(ByteView& from, Withdrawal& to, Leftover mode) n...

FILE: silkworm/core/types/withdrawal.hpp
  type silkworm (line 11) | namespace silkworm {
    type Withdrawal (line 13) | struct Withdrawal {
    type rlp (line 22) | namespace rlp {

FILE: silkworm/core/types/withdrawal_test.cpp
  type silkworm (line 12) | namespace silkworm {

FILE: silkworm/core/types/y_parity_and_chain_id.cpp
  type silkworm (line 6) | namespace silkworm {
    function y_parity_and_chain_id_to_v (line 8) | intx::uint256 y_parity_and_chain_id_to_v(bool odd, const std::optional...
    function v_to_y_parity_and_chain_id (line 15) | std::optional<YParityAndChainId> v_to_y_parity_and_chain_id(const intx...

FILE: silkworm/core/types/y_parity_and_chain_id.hpp
  type silkworm (line 13) | namespace silkworm {
    type YParityAndChainId (line 15) | struct YParityAndChainId {

FILE: silkworm/core/types/y_parity_and_chain_id_test.cpp
  type silkworm (line 8) | namespace silkworm {

FILE: silkworm/db/access_layer.cpp
  type silkworm::db (line 23) | namespace silkworm::db {
    function read_schema_version (line 29) | std::optional<VersionBase> read_schema_version(ROTxn& txn) {
    function write_schema_version (line 45) | void write_schema_version(RWTxn& txn, const VersionBase& schema_versio...
    function write_build_info_block_num (line 65) | void write_build_info_block_num(RWTxn& txn, const Bytes& key, BlockNum...
    function read_header (line 71) | std::optional<BlockHeader> read_header(ROTxn& txn, BlockNum block_num,...
    function read_header (line 75) | std::optional<BlockHeader> read_header(ROTxn& txn, BlockNum block_num,...
    function read_header (line 80) | std::optional<BlockHeader> read_header(ROTxn& txn, ByteView key) {
    function Bytes (line 91) | Bytes read_header_raw(ROTxn& txn, ByteView key) {
    function read_header (line 100) | std::optional<BlockHeader> read_header(ROTxn& txn, const evmc::bytes32...
    function read_header (line 108) | bool read_header(ROTxn& txn, const evmc::bytes32& hash, BlockNum block...
    function read_headers (line 119) | std::vector<BlockHeader> read_headers(ROTxn& txn, BlockNum block_num) {
    function read_headers (line 127) | size_t read_headers(ROTxn& txn, BlockNum block_num, std::function<void...
    function write_header (line 145) | void write_header(RWTxn& txn, const BlockHeader& header, bool with_hea...
    function write_header_ex (line 149) | evmc::bytes32 write_header_ex(RWTxn& txn, const BlockHeader& header, b...
    function delete_header (line 165) | void delete_header(RWTxn& txn, BlockNum block_num, const evmc::bytes32...
    function read_stored_header_number_after (line 171) | std::optional<BlockNum> read_stored_header_number_after(ROTxn& txn, Bl...
    function read_canonical_header (line 181) | std::optional<BlockHeader> read_canonical_header(ROTxn& txn, BlockNum ...
    function Bytes (line 189) | static Bytes header_numbers_key(evmc::bytes32 hash) {
    function read_block_num (line 193) | std::optional<BlockNum> read_block_num(ROTxn& txn, const evmc::bytes32...
    function write_header_number (line 207) | void write_header_number(RWTxn& txn, const uint8_t (&hash)[kHashLength...
    function delete_header_number (line 213) | void delete_header_number(RWTxn& txn, const evmc::bytes32& hash) {
    function read_total_difficulty (line 219) | std::optional<intx::uint256> read_total_difficulty(ROTxn& txn, BlockNu...
    function read_total_difficulty (line 223) | std::optional<intx::uint256> read_total_difficulty(
    function read_total_difficulty (line 231) | std::optional<intx::uint256> read_total_difficulty(ROTxn& txn, ByteVie...
    function write_total_difficulty (line 243) | void write_total_difficulty(RWTxn& txn, const Bytes& key, const intx::...
    function write_total_difficulty (line 252) | void write_total_difficulty(
    function write_total_difficulty (line 261) | void write_total_difficulty(
    function read_canonical_head (line 270) | std::tuple<BlockNum, evmc::bytes32> read_canonical_head(ROTxn& txn) {
    function read_canonical_header_hash (line 286) | std::optional<evmc::bytes32> read_canonical_header_hash(ROTxn& txn, Bl...
    function write_canonical_header (line 301) | void write_canonical_header(RWTxn& txn, const BlockHeader& header) {
    function write_canonical_header_hash (line 305) | void write_canonical_header_hash(RWTxn& txn, const uint8_t (&hash)[kHa...
    function read_transactions (line 311) | void read_transactions(ROTxn& txn, uint64_t base_id, uint64_t count, s...
    function write_transactions (line 320) | void write_transactions(RWTxn& txn, const std::vector<Transaction>& tr...
    function read_transactions (line 337) | void read_transactions(ROCursor& txn_table, uint64_t base_id, uint64_t...
    function read_rlp_transactions (line 354) | static void read_rlp_transactions(ROTxn& txn, uint64_t base_id, uint64...
    function delete_transactions (line 370) | void delete_transactions(RWTxn& txn, uint64_t base_id, uint64_t count) {
    function read_block_by_number (line 379) | bool read_block_by_number(ROTxn& txn, BlockNum block_num, bool read_se...
    function read_block (line 393) | bool read_block(ROTxn& txn, const evmc::bytes32& hash, BlockNum block_...
    function read_block (line 400) | bool read_block(
    function read_blocks (line 418) | size_t read_blocks(ROTxn& txn, BlockNum block_num, std::function<void(...
    function read_body (line 452) | bool read_body(ROTxn& txn, const evmc::bytes32& h, BlockNum block_num,...
    function read_body (line 456) | bool read_body(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[k...
    function read_body_for_storage (line 462) | std::optional<BlockBodyForStorage> read_body_for_storage(ROTxn& txn, c...
    function read_raw_body_for_storage (line 473) | std::optional<Bytes> read_raw_body_for_storage(ROTxn& txn, const Bytes...
    function read_body (line 482) | bool read_body(ROTxn& txn, const Bytes& key, bool read_senders, BlockB...
    function read_rlp_transactions (line 499) | bool read_rlp_transactions(ROTxn& txn, BlockNum block_num, const evmc:...
    function read_body (line 511) | bool read_body(ROTxn& txn, const evmc::bytes32& hash, BlockBody& body) {
    function read_canonical_body (line 519) | bool read_canonical_body(ROTxn& txn, BlockNum block_num, bool read_sen...
    function read_canonical_body_for_storage (line 525) | std::optional<BlockBodyForStorage> read_canonical_body_for_storage(ROT...
    function read_raw_canonical_body_for_storage (line 531) | std::optional<Bytes> read_raw_canonical_body_for_storage(ROTxn& txn, B...
    function read_canonical_block (line 537) | bool read_canonical_block(ROTxn& txn, BlockNum block_num, Block& block) {
    function has_body (line 547) | bool has_body(ROTxn& txn, BlockNum block_num, const uint8_t (&hash)[kH...
    function has_body (line 553) | bool has_body(ROTxn& txn, BlockNum block_num, const evmc::bytes32& has...
    function write_body (line 557) | void write_body(RWTxn& txn, const BlockBody& body, const evmc::bytes32...
    function write_body (line 561) | void write_body(RWTxn& txn, const BlockBody& body, const uint8_t (&has...
    function write_raw_body (line 577) | void write_raw_body(RWTxn& txn, const BlockBody& body, const evmc::byt...
    function delete_body (line 593) | void delete_body(RWTxn& txn, const evmc::bytes32& hash, BlockNum block...
    function ByteView (line 599) | static ByteView read_senders_raw(ROTxn& txn, const Bytes& key) {
    function read_senders (line 605) | std::vector<evmc::address> read_senders(ROTxn& txn, BlockNum block_num...
    function read_senders (line 610) | std::vector<evmc::address> read_senders(ROTxn& txn, const Bytes& key) {
    function parse_senders (line 621) | void parse_senders(ROTxn& txn, const Bytes& key, std::vector<Transacti...
    function write_senders (line 639) | void write_senders(RWTxn& txn, const evmc::bytes32& hash, const BlockN...
    function delete_senders (line 654) | void delete_senders(RWTxn& txn, const evmc::bytes32& hash, const Block...
    function write_tx_lookup (line 660) | void write_tx_lookup(RWTxn& txn, const Block& block) {
    function write_receipts (line 669) | void write_receipts(RWTxn& txn, const std::vector<silkworm::Receipt>& ...
    function read_code (line 676) | std::optional<ByteView> read_code(ROTxn& txn, const evmc::bytes32& cod...
    function historical_account (line 687) | static std::optional<ByteView> historical_account(ROTxn& txn, const ev...
    function historical_storage (line 707) | static std::optional<ByteView> historical_storage(ROTxn& txn, const ev...
    function read_account (line 735) | std::optional<Account> read_account(ROTxn& txn, const evmc::address& a...
    function read_storage (line 766) | evmc::bytes32 read_storage(ROTxn& txn, const evmc::address& address, u...
    function historical_previous_incarnation (line 787) | static std::optional<uint64_t> historical_previous_incarnation(ROTxn& ...
    function read_previous_incarnation (line 799) | std::optional<uint64_t> read_previous_incarnation(ROTxn& txn, const ev...
    function AccountChanges (line 814) | AccountChanges read_account_changes(ROTxn& txn, BlockNum block_num) {
    function StorageChanges (line 832) | StorageChanges read_storage_changes(ROTxn& txn, BlockNum block_num) {
    function read_chain_config (line 865) | std::optional<ChainConfig> read_chain_config(ROTxn& txn) {
    function update_chain_config (line 884) | void update_chain_config(RWTxn& txn, const ChainConfig& config) {
    function ByteView (line 894) | static ByteView head_header_key() {
    function write_head_header_hash (line 898) | void write_head_header_hash(RWTxn& txn, const evmc::bytes32& hash) {
    function write_head_header_hash (line 902) | void write_head_header_hash(RWTxn& txn, const uint8_t (&hash)[kHashLen...
    function read_head_header_hash (line 910) | std::optional<evmc::bytes32> read_head_header_hash(ROTxn& txn) {
    function write_canonical_hash (line 921) | void write_canonical_hash(RWTxn& txn, BlockNum block_num, const evmc::...
    function delete_canonical_hash (line 930) | void delete_canonical_hash(RWTxn& txn, BlockNum block_num) {
    function increment_map_sequence (line 937) | uint64_t increment_map_sequence(RWTxn& txn, std::string_view map_name,...
    function read_map_sequence (line 950) | uint64_t read_map_sequence(ROTxn& txn, std::string_view map_name) {
    function reset_map_sequence (line 963) | uint64_t reset_map_sequence(RWTxn& txn, std::string_view map_name, uin...
    function read_last_fcu_field (line 979) | std::optional<evmc::bytes32> read_last_fcu_field(ROTxn& txn, std::stri...
    function write_last_fcu_field (line 992) | void write_last_fcu_field(RWTxn& txn, std::string_view field, const ev...
    function read_last_head_block (line 1001) | std::optional<evmc::bytes32> read_last_head_block(ROTxn& txn) {
    function read_last_safe_block (line 1005) | std::optional<evmc::bytes32> read_last_safe_block(ROTxn& txn) {
    function read_last_finalized_block (line 1009) | std::optional<evmc::bytes32> read_last_finalized_block(ROTxn& txn) {
    function write_last_head_block (line 1013) | void write_last_head_block(RWTxn& txn, const evmc::bytes32& hash) {
    function write_last_safe_block (line 1017) | void write_last_safe_block(RWTxn& txn, const evmc::bytes32& hash) {
    function write_last_finalized_block (line 1021) | void write_last_finalized_block(RWTxn& txn, const evmc::bytes32& hash) {
    function BlockNum (line 1038) | BlockNum DataModel::max_block_num() const {
    function BlockNum (line 1055) | BlockNum DataModel::max_frozen_block_num() const {

FILE: silkworm/db/access_layer.hpp
  type silkworm::snapshots (line 28) | namespace silkworm::snapshots {
    class SnapshotRepository (line 29) | class SnapshotRepository
  type silkworm::db (line 32) | namespace silkworm::db {
    class DataModel (line 276) | class DataModel {
      method DataModel (line 278) | DataModel(
    class DataModelFactory (line 381) | class DataModelFactory {
      method DataModelFactory (line 383) | explicit DataModelFactory(DataStoreRef data_store)
      method DataModel (line 386) | DataModel operator()(ROTxn& tx) const {
      method DataModelFactory (line 391) | static DataModelFactory null() {
      method DataModelFactory (line 397) | DataModelFactory()

FILE: silkworm/db/access_layer_test.cpp
  type silkworm (line 24) | namespace silkworm {
    function BlockBody (line 26) | static BlockBody sample_block_body() {
    function BlockBody (line 76) | static BlockBody block_body_17035047() {
  type silkworm::db (line 103) | namespace silkworm::db {
    function expect_mock_ro_cursor (line 812) | static void expect_mock_ro_cursor(test_util::MockROTxn& mock_ro_txn, t...
    type AccessLayerTest (line 819) | struct AccessLayerTest {
      method AccessLayerTest (line 820) | explicit AccessLayerTest() {

FILE: silkworm/db/bitmap_test.cpp
  type silkworm::datastore::kvdb::bitmap (line 14) | namespace silkworm::datastore::kvdb::bitmap {
    function cut_everything (line 18) | static void cut_everything(roaring::Roaring& bm, uint64_t limit) {

FILE: silkworm/db/blocks/blocks_index_builders_factory.cpp
  type silkworm::db::blocks (line 14) | namespace silkworm::db::blocks {
    function SnapshotPathList (line 43) | SnapshotPathList BlocksIndexBuildersFactory::index_dependency_paths(co...

FILE: silkworm/db/blocks/blocks_index_builders_factory.hpp
  type silkworm::db::blocks (line 9) | namespace silkworm::db::blocks {
    class BlocksIndexBuildersFactory (line 11) | class BlocksIndexBuildersFactory : public snapshots::IndexBuildersFact...
      method BlocksIndexBuildersFactory (line 13) | explicit BlocksIndexBuildersFactory(snapshots::Schema::RepositoryDef...

FILE: silkworm/db/blocks/bodies/body_index.cpp
  type silkworm::snapshots (line 8) | namespace silkworm::snapshots {
    function Bytes (line 10) | Bytes BodyIndex::KeyFactory::make(ByteView /*key_data*/, uint64_t i) {

FILE: silkworm/db/blocks/bodies/body_index.hpp
  type silkworm::snapshots (line 18) | namespace silkworm::snapshots {
    class BodyIndex (line 20) | class BodyIndex {
      method IndexBuilder (line 22) | static IndexBuilder make(SnapshotPath segment_path, std::optional<Me...
      type KeyFactory (line 28) | struct KeyFactory : IndexKeyFactory {
      method IndexDescriptor (line 34) | static IndexDescriptor make_descriptor(const SnapshotPath& segment_p...

FILE: silkworm/db/blocks/bodies/body_queries.hpp
  type silkworm::snapshots (line 12) | namespace silkworm::snapshots {
    type BodyFindByBlockNumQuery (line 17) | struct BodyFindByBlockNumQuery : public FindByTimestampMapQuery<BodyFi...
      method exec (line 19) | std::optional<BlockBodyForStorage> exec(BlockNum block_num) {
    type RawBodyFindByBlockNumQuery (line 24) | struct RawBodyFindByBlockNumQuery : public FindByTimestampMapQuery<Raw...
      method exec (line 26) | std::optional<Bytes> exec(BlockNum block_num) {

FILE: silkworm/db/blocks/bodies/body_segment.cpp
  type silkworm::snapshots (line 8) | namespace silkworm::snapshots {
    function encode_word_from_body (line 10) | void encode_word_from_body(Bytes& word, const BlockBodyForStorage& bod...
    function decode_word_into_body (line 14) | void decode_word_into_body(ByteView word, BlockBodyForStorage& body) {

FILE: silkworm/db/blocks/bodies/body_segment.hpp
  type silkworm::snapshots (line 13) | namespace silkworm::snapshots {
    type BodySegmentWordEncoder (line 18) | struct BodySegmentWordEncoder : public Encoder {
      method ByteView (line 24) | ByteView encode_word() override {
    type BodySegmentWordDecoder (line 33) | struct BodySegmentWordDecoder : public Decoder {
      method decode_word (line 38) | void decode_word(Word& word) override {

FILE: silkworm/db/blocks/bodies/body_segment_collation.cpp
  type silkworm::db (line 13) | namespace silkworm::db {

FILE: silkworm/db/blocks/bodies/body_segment_collation.hpp
  type silkworm::db (line 8) | namespace silkworm::db {
    class BodySegmentCollation (line 10) | class BodySegmentCollation : public datastore::SegmentCollation {

FILE: silkworm/db/blocks/bodies/body_txs_amount_query.cpp
  type silkworm::snapshots (line 10) | namespace silkworm::snapshots {

FILE: silkworm/db/blocks/bodies/body_txs_amount_query.hpp
  type silkworm::snapshots (line 10) | namespace silkworm::snapshots {
    class BodyTxsAmountSegmentQuery (line 12) | class BodyTxsAmountSegmentQuery {
      type Result (line 14) | struct Result {
      method BodyTxsAmountSegmentQuery (line 19) | explicit BodyTxsAmountSegmentQuery(const segment::SegmentFileReader&...

FILE: silkworm/db/blocks/bodies/body_txs_amount_query_test.cpp
  type silkworm::snapshots (line 14) | namespace silkworm::snapshots {

FILE: silkworm/db/blocks/headers/header_index.cpp
  type silkworm::snapshots (line 9) | namespace silkworm::snapshots {
    function Bytes (line 11) | Bytes HeaderIndex::KeyFactory::make(ByteView key_data, uint64_t i) {

FILE: silkworm/db/blocks/headers/header_index.hpp
  type silkworm::snapshots (line 18) | namespace silkworm::snapshots {
    class HeaderIndex (line 20) | class HeaderIndex {
      method IndexBuilder (line 22) | static IndexBuilder make(SnapshotPath segment_path, std::optional<Me...
      type KeyFactory (line 28) | struct KeyFactory : IndexKeyFactory {
      method IndexDescriptor (line 34) | static IndexDescriptor make_descriptor(const SnapshotPath& segment_p...

FILE: silkworm/db/blocks/headers/header_queries.hpp
  type silkworm::snapshots (line 11) | namespace silkworm::snapshots {
    type HeaderFindByBlockNumQuery (line 15) | struct HeaderFindByBlockNumQuery : public FindByTimestampMapQuery<Head...
      method exec (line 17) | std::optional<BlockHeader> exec(BlockNum block_num) {

FILE: silkworm/db/blocks/headers/header_segment.cpp
  type silkworm::snapshots (line 11) | namespace silkworm::snapshots {
    function encode_word_from_header (line 13) | void encode_word_from_header(Bytes& word, const BlockHeader& header) {
    function decode_word_into_header (line 20) | void decode_word_into_header(ByteView word, BlockHeader& header) {
    function check_sanity_of_header_with_metadata (line 31) | void check_sanity_of_header_with_metadata(

FILE: silkworm/db/blocks/headers/header_segment.hpp
  type silkworm::snapshots (line 12) | namespace silkworm::snapshots {
    type HeaderSegmentWordEncoder (line 21) | struct HeaderSegmentWordEncoder : public Encoder {
      method ByteView (line 27) | ByteView encode_word() override {
    type HeaderSegmentWordDecoder (line 36) | struct HeaderSegmentWordDecoder : public Decoder {
      method decode_word (line 41) | void decode_word(Word& word) override {
      method check_sanity_with_metadata (line 45) | void check_sanity_with_metadata(const SnapshotPath& path, const data...

FILE: silkworm/db/blocks/headers/header_segment_collation.cpp
  type silkworm::db (line 13) | namespace silkworm::db {

FILE: silkworm/db/blocks/headers/header_segment_collation.hpp
  type silkworm::db (line 8) | namespace silkworm::db {
    class HeaderSegmentCollation (line 10) | class HeaderSegmentCollation : public datastore::SegmentCollation {

FILE: silkworm/db/blocks/schema_config.cpp
  type silkworm::db::blocks (line 9) | namespace silkworm::db::blocks {
    function make_blocks_repository_schema (line 11) | snapshots::Schema::RepositoryDef make_blocks_repository_schema() {
    function make_blocks_index_builders_factory (line 44) | std::unique_ptr<snapshots::IndexBuildersFactory> make_blocks_index_bui...
    function make_blocks_repository (line 48) | snapshots::SnapshotRepository make_blocks_repository(

FILE: silkworm/db/blocks/schema_config.hpp
  type silkworm::db::blocks (line 14) | namespace silkworm::db::blocks {
    type BundleDataRef (line 66) | struct BundleDataRef {

FILE: silkworm/db/blocks/step_block_num_converter.hpp
  type silkworm::db::blocks (line 8) | namespace silkworm::db::blocks {

FILE: silkworm/db/blocks/transactions/txn_index.cpp
  type silkworm::snapshots (line 12) | namespace silkworm::snapshots {
    function Bytes (line 14) | Bytes TransactionKeyFactory::make(ByteView key_data, uint64_t i) {

FILE: silkworm/db/blocks/transactions/txn_index.hpp
  type silkworm::snapshots (line 18) | namespace silkworm::snapshots {
    type TransactionKeyFactory (line 20) | struct TransactionKeyFactory : IndexKeyFactory {
      method TransactionKeyFactory (line 21) | explicit TransactionKeyFactory(uint64_t first_tx_id) : first_tx_id_(...
    class TransactionIndex (line 30) | class TransactionIndex {
      method IndexBuilder (line 32) | static IndexBuilder make(
      method IndexBuilder (line 40) | static IndexBuilder make(
      method IndexDescriptor (line 56) | static IndexDescriptor make_descriptor(const SnapshotPath& segment_p...

FILE: silkworm/db/blocks/transactions/txn_queries.hpp
  type silkworm::snapshots (line 16) | namespace silkworm::snapshots {
    class TransactionBlockNumByTxnHashSegmentQuery (line 27) | class TransactionBlockNumByTxnHashSegmentQuery {
      method TransactionBlockNumByTxnHashSegmentQuery (line 29) | TransactionBlockNumByTxnHashSegmentQuery(
      method TransactionBlockNumByTxnHashSegmentQuery (line 35) | explicit TransactionBlockNumByTxnHashSegmentQuery(
      method exec (line 40) | std::optional<std::pair<BlockNum, TxnId>> exec(const Hash& hash) {
      method TransactionBlockNumByTxnHashSegmentQuery (line 48) | static TransactionBlockNumByTxnHashSegmentQuery make(db::blocks::Bun...

FILE: silkworm/db/blocks/transactions/txn_segment.hpp
  type silkworm::snapshots (line 11) | namespace silkworm::snapshots {

FILE: silkworm/db/blocks/transactions/txn_segment_collation.cpp
  type silkworm::db (line 13) | namespace silkworm::db {

FILE: silkworm/db/blocks/transactions/txn_segment_collation.hpp
  type silkworm::db (line 8) | namespace silkworm::db {
    class TransactionSegmentCollation (line 10) | class TransactionSegmentCollation : public datastore::SegmentCollation {

FILE: silkworm/db/blocks/transactions/txn_segment_word_codec.cpp
  type silkworm::snapshots (line 20) | namespace silkworm::snapshots {
    function TransactionSegmentWord (line 22) | TransactionSegmentWord slice_tx_data(ByteView buffer) {
    function ByteView (line 43) | ByteView slice_tx_payload(ByteView tx_rlp) {
    function Transaction (line 70) | Transaction empty_system_tx() {
    function encode_word_from_tx (line 77) | void encode_word_from_tx(Bytes& word, const Transaction& tx) {
    function decode_word_into_tx (line 92) | void decode_word_into_tx(ByteView word, Transaction& tx) {
    function Hash (line 105) | Hash tx_buffer_hash(ByteView tx_buffer, uint64_t tx_id) {

FILE: silkworm/db/blocks/transactions/txn_segment_word_codec.hpp
  type silkworm::snapshots (line 15) | namespace silkworm::snapshots {
    type TransactionSegmentWord (line 17) | struct TransactionSegmentWord {
    type TransactionSegmentWordEncoder (line 37) | struct TransactionSegmentWordEncoder : public Encoder {
      method ByteView (line 43) | ByteView encode_word() override {
    type TransactionSegmentWordDecoder (line 52) | struct TransactionSegmentWordDecoder : public Decoder {
      method decode_word (line 57) | void decode_word(Word& word) override {
    type TransactionSegmentWordPayloadRlpDecoder (line 65) | struct TransactionSegmentWordPayloadRlpDecoder : public Decoder {
      method decode_word (line 70) | void decode_word(Word& word) override {

FILE: silkworm/db/blocks/transactions/txn_to_block_index.cpp
  type silkworm::snapshots (line 8) | namespace silkworm::snapshots {
    function query_entry (line 10) | static IndexInputDataQuery::Iterator::value_type query_entry(TxsAndBod...
    function IndexBuilder (line 46) | IndexBuilder TransactionToBlockIndex::make(

FILE: silkworm/db/blocks/transactions/txn_to_block_index.hpp
  type silkworm::snapshots (line 20) | namespace silkworm::snapshots {
    class TransactionToBlockIndexInputDataQuery (line 22) | class TransactionToBlockIndexInputDataQuery : public IndexInputDataQue...
      method TransactionToBlockIndexInputDataQuery (line 24) | explicit TransactionToBlockIndexInputDataQuery(TxsAndBodiesSegmentQu...
    class TransactionToBlockIndex (line 37) | class TransactionToBlockIndex {
      method IndexBuilder (line 39) | static IndexBuilder make(
      method IndexBuilder (line 52) | static IndexBuilder make(
      method IndexBuilder (line 64) | static IndexBuilder make(
      method IndexDescriptor (line 87) | static IndexDescriptor make_descriptor(const SnapshotPath& segment_p...

FILE: silkworm/db/blocks/transactions/txs_and_bodies_query.cpp
  type silkworm::snapshots (line 12) | namespace silkworm::snapshots {

FILE: silkworm/db/blocks/transactions/txs_and_bodies_query.hpp
  type silkworm::snapshots (line 20) | namespace silkworm::snapshots {
    class TxsAndBodiesSegmentQuery (line 22) | class TxsAndBodiesSegmentQuery {
      class Iterator (line 24) | class Iterator {
        type value_type (line 37) | struct value_type {
        method reference (line 49) | reference operator*() { return value_; }
        method pointer (line 50) | pointer operator->() { return &value_; }
        method Iterator (line 52) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
      method TxsAndBodiesSegmentQuery (line 75) | TxsAndBodiesSegmentQuery(
      method expected_tx_count (line 94) | uint64_t expected_tx_count() const { return expected_tx_count_; }

FILE: silkworm/db/buffer.cpp
  type silkworm::db (line 20) | namespace silkworm::db {
    function flat_hash_map_memory_size (line 25) | size_t flat_hash_map_memory_size(size_t capacity) {
    function flat_hash_map_capacity_for_size (line 29) | static size_t flat_hash_map_capacity_for_size(size_t size, size_t curr...
    function flat_hash_map_memory_size_after_inserts (line 39) | size_t flat_hash_map_memory_size_after_inserts(const TFlatHashMap& map...
    function ByteView (line 520) | ByteView Buffer::read_code(const evmc::address& /*address*/, const evm...

FILE: silkworm/db/buffer.hpp
  type silkworm::db (line 26) | namespace silkworm::db {
    type BufferDataModel (line 28) | struct BufferDataModel {
    class BufferROTxDataModel (line 34) | class BufferROTxDataModel : public BufferDataModel {
      method BufferROTxDataModel (line 36) | explicit BufferROTxDataModel(ROTxn& tx) : tx_{tx} {}
      method read_header (line 38) | std::optional<BlockHeader> read_header(BlockNum block_num, const Has...
      method read_body (line 41) | [[nodiscard]] bool read_body(BlockNum block_num, HashAsArray hash, b...
    class BufferFullDataModel (line 49) | class BufferFullDataModel : public BufferDataModel {
      method BufferFullDataModel (line 51) | explicit BufferFullDataModel(DataModel data_model) : data_model_{dat...
      method read_header (line 53) | std::optional<BlockHeader> read_header(BlockNum block_num, const Has...
      method read_body (line 56) | [[nodiscard]] bool read_body(BlockNum block_num, HashAsArray hash, b...
    class Buffer (line 64) | class Buffer : public State {
      method Buffer (line 66) | explicit Buffer(
      method set_prune_history_threshold (line 75) | void set_prune_history_threshold(BlockNum prune_history_threshold) {
      method set_historical_block (line 79) | void set_historical_block(BlockNum historical_block) {
      method set_memory_limit (line 83) | void set_memory_limit(size_t memory_limit) {
      method current_batch_state_size (line 169) | size_t current_batch_state_size() const noexcept { return batch_stat...
      class MemoryLimitError (line 183) | class MemoryLimitError : public std::runtime_error {
        method MemoryLimitError (line 185) | MemoryLimitError() : std::runtime_error("db::Buffer::MemoryLimitEr...

FILE: silkworm/db/buffer_test.cpp
  type silkworm::db (line 18) | namespace silkworm::db {

FILE: silkworm/db/capi/component.hpp
  type silkworm::db::capi (line 14) | namespace silkworm::db::capi {
    type Component (line 16) | struct Component {
      method DataStoreRef (line 23) | DataStoreRef data_store() {
      method DataModelFactory (line 34) | DataModelFactory data_model_factory() {

FILE: silkworm/db/capi/db.cpp
  function MemoryMappedRegion (line 24) | static MemoryMappedRegion make_region(const SilkwormMemoryMappedFile& mm...
  class InvalidSnapshotPathException (line 28) | class InvalidSnapshotPathException : public std::runtime_error {
    method InvalidSnapshotPathException (line 30) | explicit InvalidSnapshotPathException(const std::string& invalid_path)
  function SnapshotPath (line 34) | static SnapshotPath parse_snapshot_path(const char* file_path) {
  function build_inverted_index_bundle_data (line 44) | static void build_inverted_index_bundle_data(
  function build_inverted_index_bundle_data (line 65) | static snapshots::SnapshotBundleEntityData build_inverted_index_bundle_d...
  function build_domain_bundle_data (line 74) | static snapshots::SnapshotBundleEntityData build_domain_bundle_data(
  function build_history_bundle_data (line 111) | static snapshots::SnapshotBundleEntityData build_history_bundle_data(
  function build_state_snapshot_bundle_latest (line 134) | static snapshots::SnapshotBundle build_state_snapshot_bundle_latest(
  function build_state_snapshot_bundle_historical (line 164) | static snapshots::SnapshotBundle build_state_snapshot_bundle_historical(
  function SILKWORM_EXPORT (line 202) | SILKWORM_EXPORT int silkworm_build_recsplit_indexes(SilkwormHandle handl...
  function build_blocks_snapshot_bundle (line 294) | static snapshots::SnapshotBundle build_blocks_snapshot_bundle(
  function SILKWORM_EXPORT (line 357) | SILKWORM_EXPORT int silkworm_add_blocks_snapshot_bundle(
  function SILKWORM_EXPORT (line 379) | SILKWORM_EXPORT int silkworm_add_state_snapshot_bundle_latest(
  function SILKWORM_EXPORT (line 404) | SILKWORM_EXPORT int silkworm_add_state_snapshot_bundle_historical(
  function SILKWORM_EXPORT (line 426) | SILKWORM_EXPORT const char* silkworm_libmdbx_version() SILKWORM_NOEXCEPT {

FILE: silkworm/db/capi/db.h
  type MDBX_env (line 17) | typedef struct MDBX_env MDBX_env;
  type MDBX_txn (line 18) | typedef struct MDBX_txn MDBX_txn;
  type SilkwormMemoryMappedFile (line 20) | struct SilkwormMemoryMappedFile {
  type SilkwormHeadersSnapshot (line 26) | struct SilkwormHeadersSnapshot {
  type SilkwormBodiesSnapshot (line 31) | struct SilkwormBodiesSnapshot {
  type SilkwormTransactionsSnapshot (line 36) | struct SilkwormTransactionsSnapshot {
  type SilkwormBlocksSnapshotBundle (line 42) | struct SilkwormBlocksSnapshotBundle {
  type SilkwormInvertedIndexSnapshot (line 48) | struct SilkwormInvertedIndexSnapshot {
  type SilkwormHistorySnapshot (line 53) | struct SilkwormHistorySnapshot {
  type SilkwormDomainSnapshot (line 59) | struct SilkwormDomainSnapshot {
  type SilkwormStateSnapshotBundleLatest (line 67) | struct SilkwormStateSnapshotBundleLatest {
  type SilkwormStateSnapshotBundleHistorical (line 75) | struct SilkwormStateSnapshotBundleHistorical {
  type SilkwormMemoryMappedFile (line 94) | struct SilkwormMemoryMappedFile
  type SilkwormBlocksSnapshotBundle (line 102) | struct SilkwormBlocksSnapshotBundle
  type SilkwormStateSnapshotBundleLatest (line 110) | struct SilkwormStateSnapshotBundleLatest
  type SilkwormStateSnapshotBundleHistorical (line 118) | struct SilkwormStateSnapshotBundleHistorical

FILE: silkworm/db/chain/chain_storage.hpp
  type silkworm::db::chain (line 12) | namespace silkworm::db::chain {
    class ChainStorage (line 16) | class ChainStorage {

FILE: silkworm/db/chain/local_chain_storage.cpp
  type silkworm::db::chain (line 10) | namespace silkworm::db::chain {

FILE: silkworm/db/chain/local_chain_storage.hpp
  type silkworm::db::chain (line 10) | namespace silkworm::db::chain {
    class LocalChainStorage (line 14) | class LocalChainStorage : public ChainStorage {

FILE: silkworm/db/chain/providers.hpp
  type silkworm::db::chain (line 16) | namespace silkworm::db::chain {
    type Providers (line 24) | struct Providers {
    function CanonicalBodyForStorageProvider (line 32) | inline CanonicalBodyForStorageProvider canonical_body_provider_from_ch...

FILE: silkworm/db/chain/remote_chain_storage.cpp
  type silkworm::db::chain (line 15) | namespace silkworm::db::chain {

FILE: silkworm/db/chain/remote_chain_storage.hpp
  type silkworm::db::chain (line 13) | namespace silkworm::db::chain {
    class RemoteChainStorage (line 17) | class RemoteChainStorage : public ChainStorage {
      method Providers (line 65) | Providers& providers() { return providers_; }

FILE: silkworm/db/chain/remote_chain_storage_test.cpp
  type silkworm::db::chain (line 18) | namespace silkworm::db::chain {
    function make_null_providers (line 36) | static chain::Providers make_null_providers() {
    class RemoteChainStorageForTest (line 45) | class RemoteChainStorageForTest : public RemoteChainStorage {
    type RemoteChainStorageTest (line 51) | struct RemoteChainStorageTest : public silkworm::test_util::ContextTes...

FILE: silkworm/db/chain_data_init.cpp
  type silkworm::db (line 14) | namespace silkworm::db {
    function ChainConfig (line 16) | ChainConfig chain_data_init(const ChainDataInitSettings& node_settings) {

FILE: silkworm/db/chain_data_init.hpp
  type silkworm::db (line 10) | namespace silkworm::db {
    type ChainDataInitSettings (line 12) | struct ChainDataInitSettings {

FILE: silkworm/db/chain_head.cpp
  type silkworm::db (line 12) | namespace silkworm::db {
    function ChainHead (line 16) | ChainHead read_chain_head(ROTxn& txn) {
    function ChainHead (line 40) | ChainHead read_chain_head(datastore::kvdb::ROAccess db_access) {

FILE: silkworm/db/chain_head.hpp
  type silkworm::db (line 9) | namespace silkworm::db {

FILE: silkworm/db/cli/check_blockhashes.cpp
  function main (line 16) | int main(int argc, char* argv[]) {

FILE: silkworm/db/cli/check_changes.cpp
  function print_storage_locations (line 32) | static void print_storage_locations(const db::ChangedLocations& changed_...
  function print_storage_incarnations (line 39) | static void print_storage_incarnations(const db::ChangedIncarnations& ch...
  function print_storage_changes (line 46) | static void print_storage_changes(const evmc::address& address, const db...
  function print_all_storage_changes (line 51) | static void print_all_storage_changes(const db::StorageChanges& s) {
  function main (line 57) | int main(int argc, char* argv[]) {

FILE: silkworm/db/cli/check_hashstate.cpp
  type Operation (line 17) | enum Operation {
  function get_tables_for_checking (line 23) | std::pair<MapConfig, MapConfig> get_tables_for_checking(Operation operat...
  function check (line 34) | void check(mdbx::txn& txn, Operation operation) {
  function main (line 109) | int main(int argc, char* argv[]) {

FILE: silkworm/db/cli/check_log_indices.cpp
  type TargetIndex (line 35) | enum class TargetIndex {
  type Settings (line 41) | struct Settings {
  function Settings (line 51) | Settings parse_cli_settings(int argc, char* argv[]) {
  function block_num_range_str (line 105) | std::string block_num_range_str(const Settings& settings) {
  function trace (line 118) | void trace(const Log& log) {
  function check_address_index (line 127) | void check_address_index(BlockNum block_num, const evmc::address& log_ad...
  function check_topic_index (line 145) | void check_topic_index(BlockNum block_num, const evmc::bytes32& log_topi...
  function main (line 163) | int main(int argc, char* argv[]) {

FILE: silkworm/db/cli/check_senders.cpp
  function main (line 27) | int main(int argc, char* argv[]) {

FILE: silkworm/db/cli/check_tx_lookup.cpp
  function main (line 18) | int main(int argc, char* argv[]) {

FILE: silkworm/db/cli/db_max_readers_option.cpp
  type silkworm::cmd::common (line 8) | namespace silkworm::cmd::common {
    function add_option_db_max_readers (line 10) | void add_option_db_max_readers(CLI::App& cli, uint32_t& max_readers) {

FILE: silkworm/db/cli/db_max_readers_option.hpp
  type silkworm::cmd::common (line 8) | namespace silkworm::cmd::common {

FILE: silkworm/db/cli/db_toolbox.cpp
  class Progress (line 49) | class Progress {
    method Progress (line 51) | explicit Progress(uint32_t width) : bar_width_{width}, percent_step_{1...
    method percent (line 55) | uint32_t percent() const {
    method step (line 65) | void step() { ++current_counter_; }
    method set_current (line 66) | void set_current(size_t count) { current_counter_ = std::max(count, cu...
    method get_current (line 67) | size_t get_current() const noexcept { return current_counter_; }
    method get_increment_count (line 68) | size_t get_increment_count() const noexcept { return bar_width_ ? (max...
    method reset (line 70) | void reset() {
    method set_task_count (line 74) | void set_task_count(size_t iterations) {
    method print_interval (line 80) | std::string print_interval(char c = '.') {
    method print_progress (line 91) | [[maybe_unused]] std::string print_progress(char c = '.') const {
  type DbTableInfo (line 109) | struct DbTableInfo {
    method pages (line 114) | size_t pages() const noexcept {
    method size (line 117) | size_t size() const noexcept { return pages() * stat.ms_psize; }
  function DbComparisonResult (line 126) | DbComparisonResult compare(const DbTableInfo& lhs, const DbTableInfo& rh...
  type DbInfo (line 168) | struct DbInfo {
  type DbFreeEntry (line 176) | struct DbFreeEntry {
  type DbFreeInfo (line 182) | struct DbFreeInfo {
  function cursor_for_each (line 188) | void cursor_for_each(mdbx::cursor& cursor, WalkFuncRef walker) {
  function print_header (line 197) | static void print_header(const BlockHeader& header) {
  function print_body (line 222) | static void print_body(const BlockBodyForStorage& body) {
  function user_confirmation (line 230) | bool user_confirmation(const std::string& message = {"Confirm ?"}) {
  function table_get (line 249) | void table_get(EnvConfig& config, const std::string& table, const std::o...
  function do_clear (line 279) | void do_clear(EnvConfig& config, bool dry, bool always_yes, const std::v...
  function DbFreeInfo (line 330) | DbFreeInfo get_free_info(::mdbx::txn& txn) {
  function DbInfo (line 353) | DbInfo get_tables_info(::mdbx::txn& txn) {
  function do_scan (line 398) | void do_scan(EnvConfig& config) {
  function do_migrations (line 468) | void do_migrations(EnvConfig& config) {
  function do_tables (line 501) | void do_tables(EnvConfig& config) {
  function do_freelist (line 548) | void do_freelist(EnvConfig& config, bool detail) {
  function do_schema (line 573) | void do_schema(EnvConfig& config, bool force_update) {
  function do_compact (line 590) | void do_compact(EnvConfig& config, const std::string& work_dir, bool rep...
  function do_copy (line 660) | void do_copy(EnvConfig& src_config, const std::string& target_dir, bool ...
  function print_multi_table_diff (line 836) | static size_t print_multi_table_diff(ROCursorDupSort* cursor1, ROCursorD...
  function print_single_table_diff (line 936) | static size_t print_single_table_diff(ROCursor* cursor1, ROCursor* curso...
  function print_table_diff (line 996) | static void print_table_diff(ROTxn& txn1, ROTxn& txn2, const DbTableInfo...
  function find_table (line 1049) | static std::optional<DbTableInfo> find_table(const DbInfo& db_info, std:...
  function DbComparisonResult (line 1055) | static DbComparisonResult compare_db_schema(const DbInfo& db1_info, cons...
  function DbComparisonResult (line 1080) | static DbComparisonResult compare_table_content(ROTxn& txn1, ROTxn& txn2...
  function DbComparisonResult (line 1098) | static DbComparisonResult compare_db_content(ROTxn& txn1, ROTxn& txn2, c...
  function compare (line 1114) | void compare(EnvConfig& config, const fs::path& target_datadir_path, boo...
  function do_init_genesis (line 1168) | void do_init_genesis(DataDirectory& data_dir, const std::string&& json_f...
  function do_chainconfig (line 1212) | void do_chainconfig(EnvConfig& config) {
  function print_canonical_blocks (line 1225) | void print_canonical_blocks(EnvConfig& config, BlockNum from, std::optio...
  function print_blocks (line 1281) | void print_blocks(EnvConfig& config, BlockNum from, std::optional<BlockN...
  function do_first_byte_analysis (line 1330) | void do_first_byte_analysis(EnvConfig& config) {
  function do_extract_headers (line 1391) | void do_extract_headers(EnvConfig& config, const std::string& file_name,...
  function do_freeze (line 1439) | void do_freeze(EnvConfig& config, const DataDirectory& data_dir, bool ke...
  function main (line 1491) | int main(int argc, char* argv[]) {

FILE: silkworm/db/cli/scan_txs.cpp
  function main (line 15) | int main(int argc, char* argv[]) {

FILE: silkworm/db/cli/snapshot_options.cpp
  type silkworm::cmd::common (line 6) | namespace silkworm::cmd::common {
    function add_snapshot_options (line 8) | void add_snapshot_options(CLI::App& cli, snapshots::SnapshotSettings& ...

FILE: silkworm/db/cli/snapshot_options.hpp
  type silkworm::cmd::common (line 10) | namespace silkworm::cmd::common {

FILE: silkworm/db/cli/snapshots.cpp
  type SnapshotSubcommandSettings (line 61) | struct SnapshotSubcommandSettings {
  type DownloadSettings (line 75) | struct DownloadSettings {
  type SnapshotTool (line 88) | enum class SnapshotTool {  // NOLINT(performance-enum-size)
  type SnapshotToolboxSettings (line 109) | struct SnapshotToolboxSettings {
  type HashValidator (line 116) | struct HashValidator : public CLI::Validator {
    method HashValidator (line 117) | explicit HashValidator() {
  type BlockNumValidator (line 126) | struct BlockNumValidator : public CLI::Validator {
    method BlockNumValidator (line 127) | explicit BlockNumValidator() {
  function parse_command_line (line 140) | void parse_command_line(int argc, char* argv[], CLI::App& app, SnapshotT...
  function duration_as (line 252) | auto duration_as(const std::chrono::duration<R, P>& elapsed) {
  function as_milliseconds (line 259) | auto as_milliseconds(const std::chrono::duration<R, P>& elapsed) {
  function as_seconds (line 266) | auto as_seconds(const std::chrono::duration<R, P>& elapsed) {
  function decode_segment (line 270) | void decode_segment(const SnapshotSubcommandSettings& settings, int repe...
  function SnapshotRepository (line 284) | static SnapshotRepository make_repository(const SnapshotSettings& settin...
  function BodyCounters (line 290) | BodyCounters count_bodies_in_one(const SnapshotSubcommandSettings& setti...
  function BodyCounters (line 312) | BodyCounters count_bodies_in_all(const SnapshotSubcommandSettings& setti...
  function count_bodies (line 325) | void count_bodies(const SnapshotSubcommandSettings& settings, int repeti...
  function count_headers_in_one (line 343) | int count_headers_in_one(const SnapshotSubcommandSettings& settings, con...
  function count_headers_in_all (line 359) | int count_headers_in_all(const SnapshotSubcommandSettings& settings) {
  function count_headers (line 370) | void count_headers(const SnapshotSubcommandSettings& settings, int repet...
  function create_index (line 388) | void create_index(const SnapshotSubcommandSettings& settings, int repeti...
  function open_index (line 407) | void open_index(const SnapshotSubcommandSettings& settings) {
  function open_btree_index (line 443) | void open_btree_index(const SnapshotSubcommandSettings& settings) {
  function open_existence_index (line 489) | void open_existence_index(const SnapshotSubcommandSettings& settings) {
  function TorrentInfoPtrList (line 566) | static TorrentInfoPtrList download_web_seed(const DownloadSettings& sett...
  function download_bittorrent (line 595) | static void download_bittorrent(bittorrent::BitTorrentClient& client) {
  function download (line 604) | void download(const DownloadSettings& settings) {
  function print_header (line 635) | static void print_header(const BlockHeader& header, const std::string& f...
  function lookup_header_by_hash (line 661) | void lookup_header_by_hash(const SnapshotSubcommandSettings& settings) {
  function lookup_header_by_number (line 693) | void lookup_header_by_number(const SnapshotSubcommandSettings& settings) {
  function lookup_header (line 716) | void lookup_header(const SnapshotSubcommandSettings& settings) {
  function print_body (line 725) | static void print_body(const BlockBodyForStorage& body, const std::strin...
  function lookup_body_in_one (line 732) | void lookup_body_in_one(const SnapshotSubcommandSettings& settings, Bloc...
  function lookup_body_in_all (line 754) | void lookup_body_in_all(const SnapshotSubcommandSettings& settings, Bloc...
  function lookup_body (line 775) | void lookup_body(const SnapshotSubcommandSettings& settings) {
  function print_txn (line 787) | static void print_txn(const Transaction& txn, const std::string& filenam...
  function lookup_txn_by_hash_in_one (line 850) | void lookup_txn_by_hash_in_one(const SnapshotSubcommandSettings& setting...
  function lookup_txn_by_hash_in_all (line 874) | void lookup_txn_by_hash_in_all(const SnapshotSubcommandSettings& setting...
  function lookup_txn_by_hash (line 900) | void lookup_txn_by_hash(const SnapshotSubcommandSettings& settings, cons...
  function lookup_txn_by_id_in_one (line 912) | void lookup_txn_by_id_in_one(const SnapshotSubcommandSettings& settings,...
  function lookup_txn_by_id_in_all (line 936) | void lookup_txn_by_id_in_all(const SnapshotSubcommandSettings& settings,...
  function lookup_txn_by_id (line 962) | void lookup_txn_by_id(const SnapshotSubcommandSettings& settings, uint64...
  function lookup_transaction (line 972) | void lookup_transaction(const SnapshotSubcommandSettings& settings) {
  function merge (line 981) | void merge(const SnapshotSettings& settings) {
  function sync (line 989) | void sync(const SnapshotSettings& settings) {
  function main (line 1024) | int main(int argc, char* argv[]) {

FILE: silkworm/db/data_store.cpp
  type silkworm::db (line 6) | namespace silkworm::db {

FILE: silkworm/db/data_store.hpp
  type silkworm::db (line 12) | namespace silkworm::db {
    type DataStoreRef (line 14) | struct DataStoreRef {
      method state_db (line 16) | state::StateDatabaseRef state_db() const { return {chaindata}; }
    class DataStore (line 23) | class DataStore {
      method DataStore (line 24) | DataStore(
      method DataStore (line 40) | explicit DataStore(datastore::DataStore store) : store_{std::move(st...
      method DataStore (line 42) | DataStore(
      method DataStore (line 52) | DataStore(
      method DataStoreRef (line 60) | DataStoreRef ref() const {

FILE: silkworm/db/datastore/common/dummy.cpp
  function datastore_common_dummy (line 5) | void datastore_common_dummy() {}

FILE: silkworm/db/datastore/common/entity_name.cpp
  type silkworm::datastore (line 10) | namespace silkworm::datastore {

FILE: silkworm/db/datastore/common/entity_name.hpp
  type silkworm::datastore (line 12) | namespace silkworm::datastore {
    type EntityName (line 14) | struct EntityName {
      method EntityName (line 17) | explicit EntityName(std::string_view name1) : name{intern(name1)} {}
      method to_string (line 29) | std::string to_string() const { return std::string{name}; }
  type std (line 41) | namespace std {
    type hash<silkworm::datastore::EntityName> (line 45) | struct hash<silkworm::datastore::EntityName> {

FILE: silkworm/db/datastore/common/pair_get.hpp
  type silkworm (line 8) | namespace silkworm {
    type PairGetFirst (line 11) | struct PairGetFirst {
      method T1 (line 12) | constexpr const T1& operator()(const std::pair<T1, T2>& p) const noe...
    type PairGetSecond (line 18) | struct PairGetSecond {
      method T2 (line 19) | constexpr const T2& operator()(const std::pair<T1, T2>& p) const noe...

FILE: silkworm/db/datastore/common/ranges/caching_view.hpp
  type silkworm::views (line 12) | namespace silkworm::views {
    class CachingView (line 21) | class CachingView : public std::ranges::view_interface<CachingView<TRa...
      class Iterator (line 23) | class Iterator {
        method Iterator (line 34) | Iterator(
        method Iterator (line 40) | Iterator()
        method reference (line 44) | reference operator*() const {
        method Iterator (line 51) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 52) | Iterator& operator++() {
      method CachingView (line 79) | explicit CachingView(TRange&& range)
      method CachingView (line 82) | CachingView()
      method CachingView (line 86) | CachingView(CachingView&&) = default;
      method CachingView (line 87) | CachingView& operator=(CachingView&&) noexcept = default;
      method Iterator (line 89) | Iterator begin() { return Iterator{std::ranges::begin(range_), std::...
        method Iterator (line 34) | Iterator(
        method Iterator (line 40) | Iterator()
        method reference (line 44) | reference operator*() const {
        method Iterator (line 51) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 52) | Iterator& operator++() {
      method end (line 90) | std::default_sentinel_t end() const { return std::default_sentinel; }
    type CachingViewFactory (line 96) | struct CachingViewFactory {

FILE: silkworm/db/datastore/common/ranges/concat_view.hpp
  type silkworm::views::concat_view::builtin (line 21) | namespace silkworm::views::concat_view::builtin {
  type silkworm::views::concat_view::fallback (line 29) | namespace silkworm::views::concat_view::fallback {
    class ConcatView (line 32) | class ConcatView : public std::ranges::view_interface<ConcatView<Range...
      class Iterator (line 34) | class Iterator {
        method Iterator (line 50) | Iterator() = default;
        method Iterator (line 51) | Iterator(Range1* range1, Range2* range2)
        method reference (line 68) | reference operator*() const {
        method Iterator (line 75) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 76) | Iterator& operator++() {
      method ConcatView (line 130) | ConcatView(Range1 range1, Range2 range2)
      method ConcatView (line 133) | ConcatView() = default;
      method ConcatView (line 135) | ConcatView(ConcatView&&) = default;
      method ConcatView (line 136) | ConcatView& operator=(ConcatView&&) noexcept = default;
      method Iterator (line 138) | Iterator begin() { return Iterator{&range1_, &range2_}; }
        method Iterator (line 50) | Iterator() = default;
        method Iterator (line 51) | Iterator(Range1* range1, Range2* range2)
        method reference (line 68) | reference operator*() const {
        method Iterator (line 75) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 76) | Iterator& operator++() {
      method end (line 139) | std::default_sentinel_t end() const { return std::default_sentinel; }
  type silkworm::views (line 148) | namespace silkworm::views {
    function concat (line 157) | ConcatView<Range1, Range2> concat(Range1&& v1, Range2&& v2) {

FILE: silkworm/db/datastore/common/ranges/concat_view_test.cpp
  type silkworm::views (line 11) | namespace silkworm::views {

FILE: silkworm/db/datastore/common/ranges/if_view.hpp
  type silkworm::views (line 15) | namespace silkworm::views {
    class IfView (line 18) | class IfView : public std::ranges::view_interface<IfView<Range1, Range...
      class Iterator (line 20) | class Iterator {
        method Iterator (line 36) | Iterator() = default;
        method Iterator (line 37) | Iterator(
        method reference (line 47) | reference operator*() const {
        method Iterator (line 54) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 55) | Iterator& operator++() {
      method IfView (line 84) | IfView(bool cond, Range1 range1, Range2 range2)
      method IfView (line 88) | IfView() = default;
      method IfView (line 90) | IfView(IfView&&) = default;
      method IfView (line 91) | IfView& operator=(IfView&&) noexcept = default;
      method Iterator (line 93) | Iterator begin() {
        method Iterator (line 36) | Iterator() = default;
        method Iterator (line 37) | Iterator(
        method reference (line 47) | reference operator*() const {
        method Iterator (line 54) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 55) | Iterator& operator++() {
      method end (line 110) | std::default_sentinel_t end() const { return std::default_sentinel; }
    function if_view (line 119) | IfView<Range1, Range2> if_view(bool cond, Range1&& v1, Range2&& v2) {

FILE: silkworm/db/datastore/common/ranges/lazy_view.hpp
  type silkworm::ranges (line 10) | namespace silkworm::ranges {
    class LazyView (line 13) | class LazyView : public std::ranges::view_interface<LazyView<TRangeFac...
      method LazyView (line 15) | LazyView() = default;
      method LazyView (line 17) | explicit LazyView(TRangeFactory&& range_factory) : range_factory_{st...
      method LazyView (line 19) | LazyView(LazyView&&) = default;
      method LazyView (line 21) | LazyView& operator=(LazyView&& other) noexcept {
      method begin (line 27) | std::ranges::iterator_t<TRange> begin() { return std::ranges::begin(...
      method end (line 28) | std::ranges::sentinel_t<TRange> end() { return std::ranges::end(rang...
      method TRange (line 31) | TRange& range() {
    function lazy (line 43) | LazyView<TRangeFactory> lazy(TRangeFactory&& range_factory) {

FILE: silkworm/db/datastore/common/ranges/merge_compare_func.hpp
  type silkworm::views (line 8) | namespace silkworm::views {
    type MergeCompareFunc (line 10) | struct MergeCompareFunc {

FILE: silkworm/db/datastore/common/ranges/merge_many_view.hpp
  type silkworm::views (line 22) | namespace silkworm::views {
    class MergeManyView (line 30) | class MergeManyView : public std::ranges::view_interface<MergeManyView...
      class Iterator (line 32) | class Iterator {
        method Iterator (line 45) | Iterator() = default;
        method Iterator (line 46) | Iterator(std::vector<Range>& ranges, const Comp* comp, Proj proj)
        method reference (line 64) | reference operator*() const {
        method Iterator (line 69) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 70) | Iterator& operator++() {
        method advance (line 75) | void advance() {
        method next (line 115) | void next() {
        method it_ended (line 128) | bool it_ended(size_t i) const {
        method less (line 132) | bool less(size_t lhs, size_t rhs) const {
        method order_compare_func (line 142) | auto order_compare_func() const {
        method value_type (line 152) | value_type move_it_value(size_t i) {
      method MergeManyView (line 166) | MergeManyView(
      method MergeManyView (line 172) | MergeManyView() = default;
      method MergeManyView (line 174) | MergeManyView(MergeManyView&&) = default;
      method MergeManyView (line 175) | MergeManyView& operator=(MergeManyView&&) noexcept = default;
      method Iterator (line 177) | Iterator begin() { return Iterator{ranges_, &comp_, proj_}; }
        method Iterator (line 45) | Iterator() = default;
        method Iterator (line 46) | Iterator(std::vector<Range>& ranges, const Comp* comp, Proj proj)
        method reference (line 64) | reference operator*() const {
        method Iterator (line 69) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 70) | Iterator& operator++() {
        method advance (line 75) | void advance() {
        method next (line 115) | void next() {
        method it_ended (line 128) | bool it_ended(size_t i) const {
        method less (line 132) | bool less(size_t lhs, size_t rhs) const {
        method order_compare_func (line 142) | auto order_compare_func() const {
        method value_type (line 152) | value_type move_it_value(size_t i) {
      method end (line 178) | std::default_sentinel_t end() const { return std::default_sentinel; }
    function merge_many (line 191) | MergeManyView<Ranges, Range, Comp, Proj> merge_many(
    function merge_unique_many (line 206) | MergeManyView<Ranges, Range, Comp, Proj, /* kUnique = */ true> merge_u...

FILE: silkworm/db/datastore/common/ranges/merge_many_view_test.cpp
  type silkworm::views (line 11) | namespace silkworm::views {
    function ranges (line 18) | std::vector<TRange> ranges(TRange r1, TRange r2) {

FILE: silkworm/db/datastore/common/ranges/merge_unique_view.hpp
  type silkworm::views (line 19) | namespace silkworm::views {
    class MergeUniqueView (line 25) | class MergeUniqueView : public std::ranges::view_interface<MergeUnique...
      class Iterator (line 27) | class Iterator {
        method Iterator (line 43) | Iterator() = default;
        method Iterator (line 44) | Iterator(
        method reference (line 57) | reference operator*() const {
        method Iterator (line 62) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 63) | Iterator& operator++() {
        method advance (line 68) | void advance() {
        method it1_ended (line 110) | bool it1_ended() const {
        method it2_ended (line 113) | bool it2_ended() const {
        method select (line 116) | char select(bool it1_ended, bool it2_ended) const {
        method value_type (line 126) | value_type move_it_value(char selector) {
      method MergeUniqueView (line 150) | MergeUniqueView(
      method MergeUniqueView (line 158) | MergeUniqueView() = default;
      method MergeUniqueView (line 160) | MergeUniqueView(MergeUniqueView&&) = default;
      method MergeUniqueView (line 161) | MergeUniqueView& operator=(MergeUniqueView&&) noexcept = default;
      method Iterator (line 163) | Iterator begin() { return Iterator{range1_, range2_, &comp_, proj1_,...
        method Iterator (line 43) | Iterator() = default;
        method Iterator (line 44) | Iterator(
        method reference (line 57) | reference operator*() const {
        method Iterator (line 62) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 63) | Iterator& operator++() {
        method advance (line 68) | void advance() {
        method it1_ended (line 110) | bool it1_ended() const {
        method it2_ended (line 113) | bool it2_ended() const {
        method select (line 116) | char select(bool it1_ended, bool it2_ended) const {
        method value_type (line 126) | value_type move_it_value(char selector) {
      method end (line 164) | std::default_sentinel_t end() const { return std::default_sentinel; }
    function merge_unique (line 178) | MergeUniqueView<Range1, Range2, Comp, Proj1, Proj2> merge_unique(

FILE: silkworm/db/datastore/common/ranges/merge_unique_view_test.cpp
  type silkworm::views (line 13) | namespace silkworm::views {

FILE: silkworm/db/datastore/common/ranges/merge_view.hpp
  type silkworm::views (line 15) | namespace silkworm::views {
    class MergeView (line 21) | class MergeView : public std::ranges::view_interface<MergeView<Range1,...
      class Iterator (line 23) | class Iterator {
        method Iterator (line 39) | Iterator() = default;
        method Iterator (line 40) | Iterator(
        method reference (line 52) | reference operator*() const {
        method Iterator (line 64) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 65) | Iterator& operator++() {
        method it1_ended (line 96) | bool it1_ended() const {
        method it2_ended (line 99) | bool it2_ended() const {
        method select (line 102) | char select(bool it1_ended, bool it2_ended) const {
      method MergeView (line 122) | MergeView(
      method MergeView (line 130) | MergeView() = default;
      method MergeView (line 132) | MergeView(MergeView&&) = default;
      method MergeView (line 133) | MergeView& operator=(MergeView&&) noexcept = default;
      method Iterator (line 135) | Iterator begin() { return Iterator{range1_, range2_, comp_, proj1_, ...
        method Iterator (line 39) | Iterator() = default;
        method Iterator (line 40) | Iterator(
        method reference (line 52) | reference operator*() const {
        method Iterator (line 64) | Iterator operator++(int) { return std::exchange(*this, ++Iterator{...
        method Iterator (line 65) | Iterator& operator++() {
        method it1_ended (line 96) | bool it1_ended() const {
        method it2_ended (line 99) | bool it2_ended() const {
        method select (line 102) | char select(bool it1_ended, bool it2_ended) const {
      method end (line 136) | std::default_sentinel_t end() const { return std::default_sentinel; }
    function merge (line 150) | MergeView<Range1, Range2, Comp, Proj1, Proj2> merge(

FILE: silkworm/db/datastore/common/ranges/merge_view_test.cpp
  type silkworm::views (line 11) | namespace silkworm::views {

FILE: silkworm/db/datastore/common/ranges/owning_view.hpp
  type silkworm::ranges::builtin (line 16) | namespace silkworm::ranges::builtin {
  type silkworm::ranges::fallback (line 24) | namespace silkworm::ranges::fallback {
    class OwningView (line 29) | class OwningView : public std::ranges::view_interface<OwningView<TRang...
      method OwningView (line 31) | OwningView()
      method OwningView (line 35) | explicit constexpr OwningView(TRange&& range) : range_{std::move(ran...
      method OwningView (line 37) | OwningView(OwningView&&) = default;
      method OwningView (line 38) | OwningView& operator=(OwningView&&) = default;
      method TRange (line 40) | constexpr TRange& base() & noexcept { return range_; }
      method TRange (line 41) | constexpr const TRange& base() const& noexcept { return range_; }
      method TRange (line 42) | constexpr TRange&& base() && noexcept { return std::move(range_); }
      method TRange (line 43) | constexpr const TRange&& base() const&& noexcept { return std::move(...
      method begin (line 45) | constexpr std::ranges::iterator_t<TRange> begin() { return std::rang...
      method end (line 46) | constexpr std::ranges::sentinel_t<TRange> end() { return std::ranges...
      method begin (line 48) | constexpr auto begin() const
      method end (line 52) | constexpr auto end() const
      method empty (line 56) | constexpr bool empty()
      method empty (line 60) | constexpr bool empty() const
      method size (line 64) | constexpr auto size()
      method size (line 68) | constexpr auto size() const
      method data (line 72) | constexpr auto data()
      method data (line 76) | constexpr auto data() const
  type silkworm::ranges (line 86) | namespace silkworm::ranges {
    function owning_view (line 95) | OwningView<TRange> owning_view(TRange&& range) {

FILE: silkworm/db/datastore/common/ranges/unique_view.hpp
  type silkworm::views (line 8) | namespace silkworm::views {
    type UniqueViewFactory (line 17) | struct UniqueViewFactory {

FILE: silkworm/db/datastore/common/ranges/vector_from_range.hpp
  type silkworm (line 11) | namespace silkworm {
    function vector_from_range (line 14) | std::vector<Value> vector_from_range(Range&& range) {
    function vector_from_range_copy (line 23) | std::vector<Value> vector_from_range_copy(Range&& range) {

FILE: silkworm/db/datastore/common/step.hpp
  type silkworm::datastore (line 12) | namespace silkworm::datastore {
    type Step (line 14) | struct Step {
      method Step (line 17) | constexpr explicit Step(size_t value1) : value(value1) {}
      method to_string (line 21) | std::string to_string() const { return std::to_string(value) + "st"; }
    type StepRange (line 26) | struct StepRange {
      method StepRange (line 30) | StepRange(Step start1, Step end1) : start(start1), end(end1) {
      method contains (line 34) | bool contains(Step x) const { return (start <= x) && (x < end); }
      method contains_range (line 35) | bool contains_range(StepRange range) const { return (start <= range....
      method size (line 36) | size_t size() const { return end.value - start.value; }
      method to_string (line 37) | std::string to_string() const { return std::string("[") + start.to_s...

FILE: silkworm/db/datastore/common/step_test.cpp
  type silkworm::datastore (line 8) | namespace silkworm::datastore {

FILE: silkworm/db/datastore/common/step_timestamp_converter.cpp
  type silkworm::datastore (line 8) | namespace silkworm::datastore {
    function Step (line 10) | Step StepToTimestampConverter::step_from_timestamp(Timestamp t) const {
    function Timestamp (line 15) | Timestamp StepToTimestampConverter::timestamp_from_step(Step s) const {
    function StepRange (line 20) | StepRange StepToTimestampConverter::step_range_from_timestamp_range(Ti...

FILE: silkworm/db/datastore/common/step_timestamp_converter.hpp
  type silkworm::datastore (line 9) | namespace silkworm::datastore {
    type StepToTimestampConverter (line 11) | struct StepToTimestampConverter {
      method TimestampRange (line 18) | TimestampRange timestamp_range_from_step_range(StepRange range) const {

FILE: silkworm/db/datastore/common/step_timestamp_converter_test.cpp
  type silkworm::datastore (line 8) | namespace silkworm::datastore {

FILE: silkworm/db/datastore/common/timestamp.hpp
  type silkworm::datastore (line 10) | namespace silkworm::datastore {
    type TimestampRange (line 16) | struct TimestampRange {
      method TimestampRange (line 19) | TimestampRange(Timestamp start1, Timestamp end1) : start(start1), en...
      method contains (line 21) | bool contains(Timestamp value) const { return (start <= value) && (v...
      method contains_predicate (line 22) | auto contains_predicate() const {
      method contains_range (line 25) | bool contains_range(TimestampRange range) const { return (start <= r...
      method Timestamp (line 26) | Timestamp size() const { return end - start; }
      method to_string (line 27) | std::string to_string() const { return std::string("[") + std::to_st...

FILE: silkworm/db/datastore/data_migration.cpp
  type silkworm::datastore (line 11) | namespace silkworm::datastore {

FILE: silkworm/db/datastore/data_migration.hpp
  type silkworm::datastore (line 12) | namespace silkworm::datastore {
    type DataMigrationResult (line 14) | struct DataMigrationResult {
    type DataMigration (line 18) | struct DataMigration {

FILE: silkworm/db/datastore/data_migration_command.hpp
  type silkworm::datastore (line 8) | namespace silkworm::datastore {
    type DataMigrationCommand (line 10) | struct DataMigrationCommand {

FILE: silkworm/db/datastore/data_store.hpp
  type silkworm::datastore (line 14) | namespace silkworm::datastore {
    class DataStore (line 16) | class DataStore {
      method DataStore (line 18) | DataStore(
      method Schema (line 28) | const Schema& schema() const { return schema_; }

FILE: silkworm/db/datastore/domain_get_as_of_query.hpp
  type silkworm::datastore (line 9) | namespace silkworm::datastore {
    type DomainGetAsOfQuery (line 15) | struct DomainGetAsOfQuery {
      method DomainGetAsOfQuery (line 16) | DomainGetAsOfQuery(
      method DomainGetAsOfQuery (line 25) | DomainGetAsOfQuery(
      method exec (line 37) | std::optional<Value> exec(const Key& key, std::optional<Timestamp> t...

FILE: silkworm/db/datastore/domain_get_latest_query.hpp
  type silkworm::datastore (line 10) | namespace silkworm::datastore {
    type DomainGetLatestQuery (line 15) | struct DomainGetLatestQuery {
      method DomainGetLatestQuery (line 16) | DomainGetLatestQuery(
      method DomainGetLatestQuery (line 25) | DomainGetLatestQuery(
      method exec (line 48) | std::optional<Result> exec(const Key& key) {

FILE: silkworm/db/datastore/domain_range_as_of_query.hpp
  type silkworm::datastore (line 13) | namespace silkworm::datastore {
    type DomainRangeAsOfQuery (line 19) | struct DomainRangeAsOfQuery {
      method DomainRangeAsOfQuery (line 20) | DomainRangeAsOfQuery(
      method DomainRangeAsOfQuery (line 29) | DomainRangeAsOfQuery(
      method exec (line 41) | auto exec(const Key& key_start, const Key& key_end, std::optional<Ti...
      method exec (line 48) | auto exec(const Key& key_start, const Key& key_end, Timestamp timest...

FILE: silkworm/db/datastore/domain_range_latest_query.hpp
  type silkworm::datastore (line 17) | namespace silkworm::datastore {
    type DomainRangeLatestQuery (line 23) | struct DomainRangeLatestQuery {
      method DomainRangeLatestQuery (line 24) | DomainRangeLatestQuery(
      method DomainRangeLatestQuery (line 32) | DomainRangeLatestQuery(
      method ResultItem (line 63) | static ResultItem decode_kv_pair(std::pair<Bytes, Bytes>&& kv_pair) {
      method exec (line 85) | auto exec(const Key& key_start, const Key& key_end, bool ascending) {

FILE: silkworm/db/datastore/etl/buffer.hpp
  type silkworm::datastore::etl (line 13) | namespace silkworm::datastore::etl {
    class Buffer (line 18) | class Buffer {
      method Buffer (line 21) | Buffer(const Buffer&) = delete;
      method Buffer (line 22) | Buffer& operator=(const Buffer&) = delete;
      method Buffer (line 24) | explicit Buffer(size_t optimal_size) : optimal_size_(optimal_size) {...
      method put (line 26) | void put(Entry entry) {
      method clear (line 32) | void clear() noexcept {
      method overflows (line 38) | bool overflows() const noexcept {
      method sort (line 43) | void sort() {
      method size (line 48) | size_t size() const noexcept {

FILE: silkworm/db/datastore/etl/collector.cpp
  type silkworm::datastore::etl (line 16) | namespace silkworm::datastore::etl {

FILE: silkworm/db/datastore/etl/collector.hpp
  type silkworm::datastore::etl (line 25) | namespace silkworm::datastore::etl {
    class Collector (line 33) | class Collector {
      method Collector (line 36) | Collector(const Collector&) = delete;
      method Collector (line 37) | Collector& operator=(const Collector&) = delete;
      method Collector (line 39) | explicit Collector(
      method Collector (line 44) | explicit Collector(const std::filesystem::path& work_path, size_t bu...
      method Collector (line 46) | explicit Collector(size_t buffer_size = kOptimalBufferSize)
      method size (line 62) | size_t size() const { return size_; }
      method bytes_size (line 65) | size_t bytes_size() const { return bytes_size_; }
      method empty (line 68) | bool empty() const { return size_ == 0; }
      method clear (line 71) | void clear() {
      method get_load_key (line 79) | std::string get_load_key() const {
      method set_loading_key (line 89) | void set_loading_key(ByteView key) {

FILE: silkworm/db/datastore/etl/collector_settings.hpp
  type silkworm::datastore::etl (line 8) | namespace silkworm::datastore::etl {
    type CollectorSettings (line 10) | struct CollectorSettings {

FILE: silkworm/db/datastore/etl/file_provider.cpp
  type silkworm::datastore::etl (line 11) | namespace silkworm::datastore::etl {

FILE: silkworm/db/datastore/etl/file_provider.hpp
  type silkworm::datastore::etl (line 13) | namespace silkworm::datastore::etl {
    class FileProvider (line 19) | class FileProvider {

FILE: silkworm/db/datastore/etl/in_memory_collector.hpp
  type silkworm::datastore::etl (line 26) | namespace silkworm::datastore::etl {
    type MapStorage (line 32) | struct MapStorage : public std::map<Bytes, Bytes> {
      method reserve (line 33) | void reserve(size_t) {}
      method emplace (line 34) | void emplace(const Bytes& key, const Bytes& value) { std::map<Bytes,...
      method emplace (line 35) | void emplace(Bytes&& key, Bytes&& value) { std::map<Bytes, Bytes>::e...
      method sort (line 36) | void sort() {}
    type VectorStorage (line 40) | struct VectorStorage : public std::vector<std::pair<Bytes, Bytes>> {
      method emplace (line 41) | void emplace(const Bytes& key, const Bytes& value) { emplace_back(ke...
      method emplace (line 42) | void emplace(Bytes&& key, Bytes&& value) { emplace_back(std::move(ke...
      method sort (line 43) | void sort() { std::sort(begin(), end()); }
    class InMemoryCollector (line 48) | class InMemoryCollector {
      method InMemoryCollector (line 51) | InMemoryCollector(const InMemoryCollector&) = delete;
      method InMemoryCollector (line 52) | InMemoryCollector& operator=(const InMemoryCollector&) = delete;
      method InMemoryCollector (line 54) | explicit InMemoryCollector() = default;
      method InMemoryCollector (line 56) | explicit InMemoryCollector(const CollectorSettings& settings) {
      method InMemoryCollector (line 59) | explicit InMemoryCollector(const std::filesystem::path&, size_t opti...
      method InMemoryCollector (line 62) | explicit InMemoryCollector(size_t optimal_size) {
      method collect (line 66) | void collect(Entry entry) {
      method collect (line 72) | void collect(Bytes key, Bytes value) {
      method load (line 78) | void load(const KVLoadFunc& load_func) {
      method size (line 105) | size_t size() const { return size_; }
      method bytes_size (line 108) | size_t bytes_size() const { return bytes_size_; }
      method empty (line 111) | bool empty() const { return size_ == 0; }
      method clear (line 114) | void clear() {
      method get_load_key (line 121) | std::string get_load_key() const {
      method sort_entries (line 132) | void sort_entries() {
      method set_loading_key (line 137) | void set_loading_key(ByteView key) {

FILE: silkworm/db/datastore/etl/util.hpp
  type silkworm::datastore::etl (line 11) | namespace silkworm::datastore::etl {
    class EtlError (line 13) | class EtlError : public std::runtime_error {
    type Entry (line 25) | struct Entry {
      method Entry (line 26) | Entry() = default;
      method Entry (line 27) | Entry(const Entry&) = default;
      method Entry (line 28) | Entry(Entry&&) = default;
      method Entry (line 29) | Entry(Bytes k, Bytes v) : key(std::move(k)), value(std::move(v)) {}
      method Entry (line 30) | Entry& operator=(const Entry&) = default;
      method Entry (line 31) | Entry& operator=(Entry&&) = default;
      method size (line 37) | size_t size() const noexcept { return key.size() + value.size(); }

FILE: silkworm/db/datastore/etl/util_test.cpp
  type silkworm::datastore::etl (line 10) | namespace silkworm::datastore::etl {

FILE: silkworm/db/datastore/history_get_query.hpp
  type silkworm::datastore (line 10) | namespace silkworm::datastore {
    type HistoryGetQuery (line 16) | struct HistoryGetQuery {
      method HistoryGetQuery (line 17) | HistoryGetQuery(
      method HistoryGetQuery (line 25) | HistoryGetQuery(
      method exec (line 47) | std::optional<Value> exec(const Key& key, Timestamp timestamp) {

FILE: silkworm/db/datastore/history_range_by_keys_query.hpp
  type silkworm::datastore (line 17) | namespace silkworm::datastore {
    type HistoryRangeByKeysQuery (line 23) | struct HistoryRangeByKeysQuery {
      method HistoryRangeByKeysQuery (line 24) | HistoryRangeByKeysQuery(
      method HistoryRangeByKeysQuery (line 32) | HistoryRangeByKeysQuery(
      method ResultItem (line 61) | static ResultItem decode_kv_pair(std::pair<Bytes, Bytes>&& kv_pair) {
      method exec (line 83) | auto exec(const Key& key_start, const Key& key_end, Timestamp timest...

FILE: silkworm/db/datastore/history_range_in_period_query.hpp
  type silkworm::datastore (line 16) | namespace silkworm::datastore {
    type HistoryRangeInPeriodQuery (line 21) | struct HistoryRangeInPeriodQuery {
      method HistoryRangeInPeriodQuery (line 22) | HistoryRangeInPeriodQuery(
      method HistoryRangeInPeriodQuery (line 30) | HistoryRangeInPeriodQuery(
      method exec (line 46) | auto exec(TimestampRange ts_range, bool ascending) {

FILE: silkworm/db/datastore/inverted_index_range_by_key_query.hpp
  type silkworm::datastore (line 12) | namespace silkworm::datastore {
    type InvertedIndexRangeByKeyQuery (line 15) | struct InvertedIndexRangeByKeyQuery {
      method InvertedIndexRangeByKeyQuery (line 16) | InvertedIndexRangeByKeyQuery(
      method InvertedIndexRangeByKeyQuery (line 24) | InvertedIndexRangeByKeyQuery(
      method exec (line 41) | auto exec(Key key, TimestampRange ts_range, bool ascending) {

FILE: silkworm/db/datastore/kvdb/big_endian_codec.cpp
  type silkworm::datastore::kvdb (line 8) | namespace silkworm::datastore::kvdb {
    function Slice (line 10) | Slice BigEndianU64Codec::encode() {

FILE: silkworm/db/datastore/kvdb/big_endian_codec.hpp
  type silkworm::datastore::kvdb (line 8) | namespace silkworm::datastore::kvdb {
    type BigEndianU64Codec (line 10) | struct BigEndianU64Codec : public Codec {
      method BigEndianU64Codec (line 14) | BigEndianU64Codec() = default;
      method BigEndianU64Codec (line 15) | explicit BigEndianU64Codec(uint64_t value1) : value{value1} {}

FILE: silkworm/db/datastore/kvdb/bitmap.cpp
  type silkworm::datastore::kvdb::bitmap (line 16) | namespace silkworm::datastore::kvdb::bitmap {
    function Bytes (line 19) | Bytes upper_bound_suffix(BlockUpperBound value) {
    function RoaringMap (line 27) | RoaringMap parse_impl(const mdbx::slice& data) {
    function RoaringMap (line 32) | RoaringMap parse_impl(const ByteView data) {
    function remove_range_impl (line 45) | [[maybe_unused]] void remove_range_impl(roaring::Roaring64Map& bm, uin...
    function RoaringMap (line 52) | RoaringMap cut_left_impl(RoaringMap& bm, uint64_t size_limit) {
    function flush_bitmaps_impl (line 262) | void flush_bitmaps_impl(absl::btree_map<Bytes, RoaringMap>& bitmaps, d...
    function seek (line 282) | std::optional<uint64_t> seek(const roaring::Roaring64Map& bitmap, uint...
    function cut_left (line 290) | roaring::Roaring cut_left(roaring::Roaring& bitmap, uint64_t size_limi...
    function cut_left (line 294) | roaring::Roaring64Map cut_left(roaring::Roaring64Map& bitmap, uint64_t...
    function Bytes (line 299) | Bytes bitmap_to_bytes(RoaringMap& bitmap) {
    function Bytes (line 308) | Bytes to_bytes(roaring::Roaring64Map& bitmap) {
    function Bytes (line 312) | Bytes to_bytes(roaring::Roaring& bitmap) {
    function parse (line 316) | roaring::Roaring64Map parse(const mdbx::slice& data) {
    function parse (line 320) | roaring::Roaring64Map parse(const ByteView data) {
    function parse32 (line 324) | roaring::Roaring parse32(const mdbx::slice& data) {

FILE: silkworm/db/datastore/kvdb/bitmap.hpp
  type silkworm::datastore::etl (line 30) | namespace silkworm::datastore::etl {
    class Collector (line 31) | class Collector
  type silkworm::datastore::kvdb (line 34) | namespace silkworm::datastore::kvdb {
    class Collector (line 35) | class Collector
  type silkworm::datastore::kvdb::bitmap (line 38) | namespace silkworm::datastore::kvdb::bitmap {
    class IndexLoader (line 40) | class IndexLoader {
      method IndexLoader (line 42) | explicit IndexLoader(const MapConfig& index_config) : index_config_{...
      method get_current_key (line 66) | std::string get_current_key() const {

FILE: silkworm/db/datastore/kvdb/codec.hpp
  type silkworm::datastore::kvdb (line 8) | namespace silkworm::datastore::kvdb {
    type Encoder (line 10) | struct Encoder {
    type Decoder (line 20) | struct Decoder {
    type Codec (line 30) | struct Codec : public Encoder, public Decoder {

FILE: silkworm/db/datastore/kvdb/cursor_iterator.cpp
  type silkworm::datastore::kvdb (line 8) | namespace silkworm::datastore::kvdb {

FILE: silkworm/db/datastore/kvdb/cursor_iterator.hpp
  type silkworm::datastore::kvdb (line 14) | namespace silkworm::datastore::kvdb {
    class CursorMoveIterator (line 16) | class CursorMoveIterator {
      method CursorMoveIterator (line 24) | CursorMoveIterator() = default;
      method CursorMoveIterator (line 26) | CursorMoveIterator(
      method value_type (line 32) | const value_type& operator*() const { return cursor_; }
      method value_type (line 33) | const value_type* operator->() const { return &cursor_; }
      method CursorMoveIterator (line 35) | CursorMoveIterator operator++(int) { return std::exchange(*this, ++C...
      method CursorMoveIterator (line 36) | CursorMoveIterator& operator++() {
    class CursorIterator (line 61) | class CursorIterator {
      method CursorIterator (line 69) | CursorIterator() = default;
      method CursorIterator (line 71) | CursorIterator(
      method value_type (line 82) | value_type operator*() const { return decoders_; }
      method value_type (line 83) | const value_type* operator->() const { return &decoders_; }
      method CursorIterator (line 85) | CursorIterator operator++(int) { return std::exchange(*this, ++Curso...
      method CursorIterator (line 86) | CursorIterator& operator++() {
    class CursorKVIterator (line 102) | class CursorKVIterator {
      method CursorKVIterator (line 111) | CursorKVIterator() = default;
      method CursorKVIterator (line 113) | explicit CursorKVIterator(CursorIterator it)
      method CursorKVIterator (line 116) | static CursorKVIterator make(std::unique_ptr<ROCursor> cursor, MoveO...
      method CursorKVIterator (line 120) | static CursorKVIterator make(
      method value_type (line 128) | value_type operator*() const { return value(); }
      method value_type_owned (line 130) | value_type_owned move_value() const {
      method CursorKVIterator (line 135) | CursorKVIterator operator++(int) { return std::exchange(*this, ++Cur...
      method CursorKVIterator (line 136) | CursorKVIterator& operator++() {
      method value_type (line 145) | value_type value() const {
    class CursorKeysIterator (line 159) | class CursorKeysIterator {
      method CursorKeysIterator (line 167) | CursorKeysIterator() = default;
      method CursorKeysIterator (line 169) | explicit CursorKeysIterator(CursorIterator it)
      method CursorKeysIterator (line 172) | static CursorKeysIterator make(std::unique_ptr<ROCursor> cursor, Mov...
      method CursorKeysIterator (line 176) | static CursorKeysIterator make(
      method reference (line 183) | reference operator*() const { return value(); }
      method pointer (line 184) | pointer operator->() const { return &value(); }
      method CursorKeysIterator (line 186) | CursorKeysIterator operator++(int) { return std::exchange(*this, ++C...
      method CursorKeysIterator (line 187) | CursorKeysIterator& operator++() {
      method value_type (line 196) | value_type& value() const {
    class CursorValuesIterator (line 207) | class CursorValuesIterator {
      method CursorValuesIterator (line 215) | CursorValuesIterator() = default;
      method CursorValuesIterator (line 217) | explicit CursorValuesIterator(CursorIterator it)
      method CursorValuesIterator (line 220) | static CursorValuesIterator make(std::unique_ptr<ROCursor> cursor, M...
      method CursorValuesIterator (line 224) | static CursorValuesIterator make(
      method reference (line 231) | reference operator*() const { return value(); }
      method pointer (line 232) | pointer operator->() const { return &value(); }
      method CursorValuesIterator (line 234) | CursorValuesIterator operator++(int) { return std::exchange(*this, +...
      method CursorValuesIterator (line 235) | CursorValuesIterator& operator++() {
      method value_type (line 244) | value_type& value() const {

FILE: silkworm/db/datastore/kvdb/database.cpp
  type silkworm::datastore::kvdb (line 6) | namespace silkworm::datastore::kvdb {
    function MapConfig (line 8) | static MapConfig make_table_config(const Schema::TableDef& table) {
    function make_table_configs (line 16) | static EntityMap<MapConfig> make_table_configs(
    function make_entities (line 25) | DatabaseRef::EntitiesMap make_entities(
    function Domain (line 45) | Domain DatabaseRef::domain(datastore::EntityName name) const {
    function InvertedIndex (line 63) | InvertedIndex DatabaseRef::inverted_index(datastore::EntityName name) ...

FILE: silkworm/db/datastore/kvdb/database.hpp
  type silkworm::datastore::kvdb (line 13) | namespace silkworm::datastore::kvdb {
    class Database (line 15) | class Database
      method Database (line 50) | Database(
      method ROAccess (line 57) | ROAccess access_ro() const { return ref().access_ro(); }
      method RWAccess (line 58) | RWAccess access_rw() const { return ref().access_rw(); }
      method Domain (line 60) | Domain domain(datastore::EntityName name) const { return ref().domai...
      method InvertedIndex (line 61) | InvertedIndex inverted_index(datastore::EntityName name) const { ret...
      method DatabaseRef (line 63) | DatabaseRef ref() const { return {env_, schema_, entities_}; }
    class DatabaseUnmanaged (line 16) | class DatabaseUnmanaged
      method DatabaseUnmanaged (line 75) | DatabaseUnmanaged(
      method ROAccess (line 82) | ROAccess access_ro() const { return ref().access_ro(); }
      method RWAccess (line 83) | RWAccess access_rw() const { return ref().access_rw(); }
      method Domain (line 85) | Domain domain(datastore::EntityName name) const { return ref().domai...
      method InvertedIndex (line 86) | InvertedIndex inverted_index(datastore::EntityName name) const { ret...
      method DatabaseRef (line 88) | DatabaseRef ref() const { return {env_, schema_, entities_}; }
    class DatabaseRef (line 18) | class DatabaseRef {
      method ROAccess (line 22) | ROAccess access_ro() const { return ROAccess{env_}; }
      method RWAccess (line 23) | RWAccess access_rw() const { return RWAccess{env_}; }
      method DatabaseRef (line 30) | DatabaseRef(
    class Database (line 48) | class Database {
      method Database (line 50) | Database(
      method ROAccess (line 57) | ROAccess access_ro() const { return ref().access_ro(); }
      method RWAccess (line 58) | RWAccess access_rw() const { return ref().access_rw(); }
      method Domain (line 60) | Domain domain(datastore::EntityName name) const { return ref().domai...
      method InvertedIndex (line 61) | InvertedIndex inverted_index(datastore::EntityName name) const { ret...
      method DatabaseRef (line 63) | DatabaseRef ref() const { return {env_, schema_, entities_}; }
    class DatabaseUnmanaged (line 73) | class DatabaseUnmanaged {
      method DatabaseUnmanaged (line 75) | DatabaseUnmanaged(
      method ROAccess (line 82) | ROAccess access_ro() const { return ref().access_ro(); }
      method RWAccess (line 83) | RWAccess access_rw() const { return ref().access_rw(); }
      method Domain (line 85) | Domain domain(datastore::EntityName name) const { return ref().domai...
      method InvertedIndex (line 86) | InvertedIndex inverted_index(datastore::EntityName name) const { ret...
      method DatabaseRef (line 88) | DatabaseRef ref() const { return {env_, schema_, entities_}; }

FILE: silkworm/db/datastore/kvdb/domain.hpp
  type silkworm::datastore::kvdb (line 10) | namespace silkworm::datastore::kvdb {
    type Domain (line 12) | struct Domain {

FILE: silkworm/db/datastore/kvdb/domain_codecs.hpp
  type silkworm::datastore::kvdb (line 10) | namespace silkworm::datastore::kvdb {
    type InvertedStepCodec (line 12) | struct InvertedStepCodec : public Codec {
      method Slice (line 19) | Slice encode() override {
      method decode (line 24) | void decode(Slice slice) override {

FILE: silkworm/db/datastore/kvdb/domain_delete_query.hpp
  type silkworm::datastore::kvdb (line 8) | namespace silkworm::datastore::kvdb {
    type DomainDeleteQuery (line 11) | struct DomainDeleteQuery {
      method exec (line 18) | void exec(

FILE: silkworm/db/datastore/kvdb/domain_get_latest_query.hpp
  type silkworm::datastore::kvdb (line 14) | namespace silkworm::datastore::kvdb {
    type DomainGetLatestQuery (line 17) | struct DomainGetLatestQuery {
      type Result (line 24) | struct Result {
      method exec (line 29) | std::optional<Result> exec(const Key& key) {

FILE: silkworm/db/datastore/kvdb/domain_get_latest_query_test.cpp
  type silkworm::datastore::kvdb (line 13) | namespace silkworm::datastore::kvdb {
    type DomainPutEntry (line 15) | struct DomainPutEntry {

FILE: silkworm/db/datastore/kvdb/domain_put_latest_query.hpp
  type silkworm::datastore::kvdb (line 11) | namespace silkworm::datastore::kvdb {
    type DomainPutLatestQuery (line 14) | struct DomainPutLatestQuery {
      method exec (line 21) | void exec(const Key& key, const Value& value, Step step) {

FILE: silkworm/db/datastore/kvdb/domain_put_query.hpp
  type silkworm::datastore::kvdb (line 10) | namespace silkworm::datastore::kvdb {
    type DomainPutQuery (line 13) | struct DomainPutQuery {
      method exec (line 20) | void exec(

FILE: silkworm/db/datastore/kvdb/domain_range_latest_query.hpp
  type silkworm::datastore::kvdb (line 21) | namespace silkworm::datastore::kvdb {
    type DomainRangeLatestQuery (line 26) | struct DomainRangeLatestQuery {
      method ResultItem (line 35) | static ResultItem decode_kv_pair(const std::pair<ByteView, ByteView>...
      method exec_with_eager_begin (line 51) | auto exec_with_eager_begin(Bytes key_start, Bytes key_end, bool asce...
      method exec (line 85) | auto exec(const Key& key_start, const Key& key_end, bool ascending) {

FILE: silkworm/db/datastore/kvdb/domain_range_latest_query_test.cpp
  type silkworm::datastore::kvdb (line 15) | namespace silkworm::datastore::kvdb {
    type DomainPutEntry (line 17) | struct DomainPutEntry {

FILE: silkworm/db/datastore/kvdb/etl_mdbx_collector.hpp
  type silkworm::datastore::kvdb (line 10) | namespace silkworm::datastore::kvdb {
    class Collector (line 15) | class Collector : public datastore::etl::Collector {
      method load (line 23) | void load(

FILE: silkworm/db/datastore/kvdb/history.hpp
  type silkworm::datastore::kvdb (line 8) | namespace silkworm::datastore::kvdb {
    type History (line 10) | struct History {

FILE: silkworm/db/datastore/kvdb/history_codecs.hpp
  type silkworm::datastore::kvdb (line 10) | namespace silkworm::datastore::kvdb {

FILE: silkworm/db/datastore/kvdb/history_delete_query.hpp
  type silkworm::datastore::kvdb (line 8) | namespace silkworm::datastore::kvdb {
    type HistoryDeleteQuery (line 11) | struct HistoryDeleteQuery {
      method exec (line 17) | void exec(const Key& key, Timestamp timestamp) {

FILE: silkworm/db/datastore/kvdb/history_get_query.hpp
  type silkworm::datastore::kvdb (line 13) | namespace silkworm::datastore::kvdb {
    type HistoryGetQuery (line 16) | struct HistoryGetQuery {
      method exec (line 28) | tl::expected<Value, NoValueReason> exec(const Key& key, Timestamp ti...

FILE: silkworm/db/datastore/kvdb/history_get_query_test.cpp
  type silkworm::datastore::kvdb (line 13) | namespace silkworm::datastore::kvdb {
    type HistoryPutEntry (line 15) | struct HistoryPutEntry {

FILE: silkworm/db/datastore/kvdb/history_put_query.hpp
  type silkworm::datastore::kvdb (line 12) | namespace silkworm::datastore::kvdb {
    type HistoryPutQuery (line 15) | struct HistoryPutQuery {
      method exec (line 22) | void exec(const Key& key, const Value& value, Timestamp timestamp) {

FILE: silkworm/db/datastore/kvdb/history_range_by_keys_query.hpp
  type silkworm::datastore::kvdb (line 21) | namespace silkworm::datastore::kvdb {
    type HistoryRangeByKeysQuery (line 26) | struct HistoryRangeByKeysQuery {
      method as_bool_predicate (line 36) | static constexpr bool as_bool_predicate(const T& v) {
      method ResultItem (line 40) | static ResultItem kv_pair_from_cursor(std::shared_ptr<ROCursor> curs...
      method kv_pair_from_cursor_func (line 56) | static auto kv_pair_from_cursor_func(bool has_large_values) {
      method exec_with_eager_begin (line 62) | auto exec_with_eager_begin(Bytes key_start, Bytes key_end, Timestamp...
      method exec (line 144) | auto exec(const Key& key_start, const Key& key_end, Timestamp timest...

FILE: silkworm/db/datastore/kvdb/history_range_by_keys_query_test.cpp
  type silkworm::datastore::kvdb (line 15) | namespace silkworm::datastore::kvdb {
    type Entry (line 17) | struct Entry {

FILE: silkworm/db/datastore/kvdb/history_range_in_period_query.hpp
  type silkworm::datastore::kvdb (line 20) | namespace silkworm::datastore::kvdb {
    type HistoryRangeInPeriodQuery (line 23) | struct HistoryRangeInPeriodQuery {
      method as_bool_predicate (line 32) | static constexpr bool as_bool_predicate(const T& v) {
      method ResultItem (line 36) | static ResultItem kv_pair_from_cursor(std::shared_ptr<ROCursor> curs...
      method kv_pair_from_cursor_func (line 52) | static auto kv_pair_from_cursor_func(bool has_large_values) {
      method exec_with_eager_begin (line 58) | auto exec_with_eager_begin(TimestampRange ts_range, bool ascending) {
      method exec (line 142) | auto exec(TimestampRange ts_range, bool ascending) {

FILE: silkworm/db/datastore/kvdb/history_range_in_period_query_test.cpp
  type silkworm::datastore::kvdb (line 13) | namespace silkworm::datastore::kvdb {
    type HistoryPutEntry (line 15) | struct HistoryPutEntry {

FILE: silkworm/db/datastore/kvdb/inverted_index.hpp
  type silkworm::datastore::kvdb (line 6) | namespace silkworm::datastore::kvdb {
    type MapConfig (line 8) | struct MapConfig
    type InvertedIndex (line 10) | struct InvertedIndex {

FILE: silkworm/db/datastore/kvdb/inverted_index_put_query.hpp
  type silkworm::datastore::kvdb (line 11) | namespace silkworm::datastore::kvdb {
    type InvertedIndexPutQuery (line 14) | struct InvertedIndexPutQuery {
      method exec (line 20) | void exec(const Key& key, const Timestamp timestamp, bool with_index...
      method exec (line 25) | void exec(const Key& key, const TTimestamp& timestamp, bool with_ind...

FILE: silkworm/db/datastore/kvdb/inverted_index_range_by_key_query.hpp
  type silkworm::datastore::kvdb (line 17) | namespace silkworm::datastore::kvdb {
    type InvertedIndexRangeByKeyQuery (line 20) | struct InvertedIndexRangeByKeyQuery {
      method begin (line 31) | CursorValuesIterator<TimestampDecoder> begin(Key key, TimestampRange...
      method Timestamps (line 66) | Timestamps exec_with_eager_begin(Key key, TimestampRange ts_range, b...
      method exec (line 72) | auto exec(Key key, TimestampRange ts_range, bool ascending) {

FILE: silkworm/db/datastore/kvdb/inverted_index_range_by_key_query_test.cpp
  type silkworm::datastore::kvdb (line 14) | namespace silkworm::datastore::kvdb {
    type Entry (line 16) | struct Entry {

FILE: silkworm/db/datastore/kvdb/kvts_codec.hpp
  type silkworm::datastore::kvdb (line 9) | namespace silkworm::datastore::kvdb {
    class KVTSKeyEncoder (line 12) | class KVTSKeyEncoder : public Encoder {
      method KVTSKeyEncoder (line 19) | explicit KVTSKeyEncoder(bool has_large_values)
      method Slice (line 23) | Slice encode() override {
    class KVTSValueEncoder (line 40) | class KVTSValueEncoder : public Encoder {
      method KVTSValueEncoder (line 47) | explicit KVTSValueEncoder(bool has_large_values)
      method Slice (line 51) | Slice encode() override {
    class KVTSKeyDecoder (line 71) | class KVTSKeyDecoder : public Decoder {
      method KVTSKeyDecoder (line 78) | explicit KVTSKeyDecoder(bool has_large_values)
      method decode (line 82) | void decode(Slice data) override {
    class KVTSValueDecoder (line 98) | class KVTSValueDecoder : public Decoder {
      method KVTSValueDecoder (line 105) | explicit KVTSValueDecoder(bool has_large_values)
      method decode (line 109) | void decode(Slice slice) override {

FILE: silkworm/db/datastore/kvdb/mdbx.cpp
  type silkworm::datastore::kvdb (line 10) | namespace silkworm::datastore::kvdb {
    type detail (line 12) | namespace detail {
      function dump_mdbx_result (line 13) | std::string dump_mdbx_result(const CursorResult& result) {
      function slice_as_hex (line 23) | std::string slice_as_hex(const Slice& data) {
      function log_args_for_commit_latency (line 27) | log::Args log_args_for_commit_latency(const MDBX_commit_latency& com...
    function CursorResult (line 47) | static CursorResult adjust_cursor_position_if_unpositioned(
    function CursorResult (line 60) | static CursorResult strict_lower_bound(ROCursor& cursor, const ByteVie...
    function move_operation (line 69) | static mdbx::cursor::move_operation move_operation(CursorMoveDirection...
    function open_env (line 75) | ::mdbx::env_managed open_env(const EnvConfig& config) {
    function open_map (line 190) | ::mdbx::map_handle open_map(::mdbx::txn& tx, const MapConfig& config) {
    function open_cursor (line 197) | ::mdbx::cursor_managed open_cursor(::mdbx::txn& tx, const MapConfig& c...
    function max_value_size_for_leaf_page (line 201) | size_t max_value_size_for_leaf_page(const size_t page_size, const size...
    function max_value_size_for_leaf_page (line 230) | size_t max_value_size_for_leaf_page(const mdbx::txn& txn, const size_t...
    function PooledCursor (line 292) | PooledCursor& PooledCursor::operator=(PooledCursor&& other) noexcept {
    function MDBX_stat (line 340) | MDBX_stat PooledCursor::get_map_stat() const {
    function MDBX_db_flags_t (line 347) | MDBX_db_flags_t PooledCursor::get_map_flags() const {
    function CursorResult (line 368) | CursorResult PooledCursor::to_first() {
    function CursorResult (line 372) | CursorResult PooledCursor::to_first(bool throw_notfound) {
    function CursorResult (line 376) | CursorResult PooledCursor::to_previous() {
    function CursorResult (line 380) | CursorResult PooledCursor::to_previous(bool throw_notfound) {
    function CursorResult (line 384) | CursorResult PooledCursor::current() const {
    function CursorResult (line 388) | CursorResult PooledCursor::current(bool throw_notfound) const {
    function CursorResult (line 392) | CursorResult PooledCursor::to_next() {
    function CursorResult (line 396) | CursorResult PooledCursor::to_next(bool throw_notfound) {
    function CursorResult (line 400) | CursorResult PooledCursor::to_last() {
    function CursorResult (line 404) | CursorResult PooledCursor::to_last(bool throw_notfound) {
    function CursorResult (line 408) | CursorResult PooledCursor::find(const Slice& key) {
    function CursorResult (line 412) | CursorResult PooledCursor::find(const Slice& key, bool throw_notfound) {
    function CursorResult (line 416) | CursorResult PooledCursor::lower_bound(const Slice& key) {
    function CursorResult (line 420) | CursorResult PooledCursor::lower_bound(const Slice& key, bool throw_no...
    function MoveResult (line 424) | MoveResult PooledCursor::move(MoveOperation operation, bool throw_notf...
    function MoveResult (line 428) | MoveResult PooledCursor::move(MoveOperation operation, const Slice& ke...
    function CursorResult (line 448) | CursorResult PooledCursor::to_previous_last_multi() {
    function CursorResult (line 452) | CursorResult PooledCursor::to_previous_last_multi(bool throw_notfound) {
    function CursorResult (line 456) | CursorResult PooledCursor::to_current_first_multi() {
    function CursorResult (line 460) | CursorResult PooledCursor::to_current_first_multi(bool throw_notfound) {
    function CursorResult (line 464) | CursorResult PooledCursor::to_current_prev_multi() {
    function CursorResult (line 468) | CursorResult PooledCursor::to_current_prev_multi(bool throw_notfound) {
    function CursorResult (line 472) | CursorResult PooledCursor::to_current_next_multi() {
    function CursorResult (line 476) | CursorResult PooledCursor::to_current_next_multi(bool throw_notfound) {
    function CursorResult (line 480) | CursorResult PooledCursor::to_current_last_multi() {
    function CursorResult (line 484) | CursorResult PooledCursor::to_current_last_multi(bool throw_notfound) {
    function CursorResult (line 488) | CursorResult PooledCursor::to_next_first_multi() {
    function CursorResult (line 492) | CursorResult PooledCursor::to_next_first_multi(bool throw_notfound) {
    function CursorResult (line 496) | CursorResult PooledCursor::find_multivalue(const Slice& key, const Sli...
    function CursorResult (line 500) | CursorResult PooledCursor::find_multivalue(const Slice& key, const Sli...
    function CursorResult (line 504) | CursorResult PooledCursor::lower_bound_multivalue(const Slice& key, co...
    function CursorResult (line 508) | CursorResult PooledCursor::lower_bound_multivalue(const Slice& key, co...
    function MoveResult (line 512) | MoveResult PooledCursor::move(MoveOperation operation, const Slice& ke...
    function MDBX_error_t (line 520) | MDBX_error_t PooledCursor::put(const Slice& key, Slice* value, MDBX_pu...
    function has_map (line 561) | bool has_map(::mdbx::txn& tx, std::string_view map_name) {
    function list_maps (line 572) | std::vector<std::string> list_maps(::mdbx::txn& tx, bool throw_notfoun...
    function cursor_for_each (line 582) | size_t cursor_for_each(ROCursor& cursor, WalkFuncRef walker, const Cur...
    function cursor_for_prefix (line 593) | size_t cursor_for_prefix(ROCursor& cursor, const ByteView prefix, Walk...
    function cursor_erase_prefix (line 608) | size_t cursor_erase_prefix(RWCursor& cursor, const ByteView prefix) {
    function cursor_for_count (line 622) | size_t cursor_for_count(ROCursor& cursor, WalkFuncRef walker, size_t c...
    function cursor_erase (line 635) | size_t cursor_erase(RWCursor& cursor, const ByteView set_key, const Cu...

FILE: silkworm/db/datastore/kvdb/mdbx.hpp
  type silkworm::datastore::kvdb (line 29) | namespace silkworm::datastore::kvdb {
    type detail (line 55) | namespace detail {
      type CursorHandleDeleter (line 56) | struct CursorHandleDeleter {  // default deleter for pooled cursors
        method CursorHandleDeleter (line 57) | constexpr CursorHandleDeleter() noexcept = default;
    class ROTxn (line 65) | class ROTxn
      method id (line 204) | uint64_t id() const { return txn_ref_.id(); }
      method is_open (line 205) | virtual bool is_open() const { return txn_ref_.txn::operator bool(); }
      method db (line 206) | virtual mdbx::env db() const { return txn_ref_.env(); }
      method ROTxn (line 214) | explicit ROTxn(::mdbx::txn& txn_ref) : txn_ref_{txn_ref} {}
    type MapConfig (line 66) | struct MapConfig
      method name_str (line 190) | std::string name_str() const { return std::string{name}; }
    class ROCursor (line 69) | class ROCursor {
      method empty (line 83) | bool empty() const { return size() == 0; }
    class ROCursorDupSort (line 117) | class ROCursorDupSort : public virtual ROCursor {
    class RWCursor (line 144) | class RWCursor : public virtual ROCursor {
    class RWCursorDupSort (line 164) | class RWCursorDupSort : public RWCursor, public ROCursorDupSort {
    type MapConfig (line 185) | struct MapConfig {
      method name_str (line 190) | std::string name_str() const { return std::string{name}; }
    class ROTxn (line 195) | class ROTxn {
      method id (line 204) | uint64_t id() const { return txn_ref_.id(); }
      method is_open (line 205) | virtual bool is_open() const { return txn_ref_.txn::operator bool(); }
      method db (line 206) | virtual mdbx::env db() const { return txn_ref_.env(); }
      method ROTxn (line 214) | explicit ROTxn(::mdbx::txn& txn_ref) : txn_ref_{txn_ref} {}
    class ROTxnManaged (line 222) | class ROTxnManaged : public ROTxn {
      method ROTxnManaged (line 224) | explicit ROTxnManaged() : ROTxn{managed_txn_} {}
      method ROTxnManaged (line 225) | explicit ROTxnManaged(mdbx::env& env) : ROTxn{managed_txn_}, managed...
      method ROTxnManaged (line 226) | explicit ROTxnManaged(mdbx::env&& env) : ROTxn{managed_txn_}, manage...
      method ROTxnManaged (line 230) | ROTxnManaged(const ROTxnManaged&) = delete;
      method ROTxnManaged (line 231) | ROTxnManaged& operator=(const ROTxnManaged&) = delete;
      method ROTxnManaged (line 234) | ROTxnManaged(ROTxnManaged&& source) noexcept : ROTxn{managed_txn_}, ...
      method ROTxnManaged (line 235) | ROTxnManaged& operator=(ROTxnManaged&& other) noexcept {
      method abort (line 240) | void abort() override { managed_txn_.abort(); }
      method ROTxnManaged (line 243) | explicit ROTxnManaged(mdbx::txn_managed&& source) : ROTxn{managed_tx...
    class ROTxnUnmanaged (line 250) | class ROTxnUnmanaged : public ROTxn, protected ::mdbx::txn {
      method ROTxnUnmanaged (line 252) | explicit ROTxnUnmanaged(MDBX_txn* ptr) : ROTxn{static_cast<::mdbx::t...
      method abort (line 255) | void abort() override {}
    class RWTxn (line 262) | class RWTxn : public ROTxn {
      method commit_disabled (line 266) | bool commit_disabled() const { return commit_disabled_; }
      method disable_commit (line 268) | void disable_commit() { commit_disabled_ = true; }
      method enable_commit (line 269) | void enable_commit() { commit_disabled_ = false; }
      method RWTxn (line 278) | explicit RWTxn(::mdbx::txn& txn_ref, bool commit_disabled = false)
    class RWTxnManaged (line 286) | class RWTxnManaged : public RWTxn {
      method RWTxnManaged (line 288) | explicit RWTxnManaged() : RWTxn{managed_txn_} {}
      method RWTxnManaged (line 289) | explicit RWTxnManaged(mdbx::env& env) : RWTxn{managed_txn_}, managed...
      method RWTxnManaged (line 290) | explicit RWTxnManaged(mdbx::env&& env) : RWTxn{managed_txn_}, manage...
      method RWTxnManaged (line 294) | RWTxnManaged(const RWTxnManaged&) = delete;
      method RWTxnManaged (line 295) | RWTxnManaged& operator=(const RWTxnManaged&) = delete;
      method RWTxnManaged (line 298) | RWTxnManaged(RWTxnManaged&& source) noexcept
      method RWTxnManaged (line 300) | RWTxnManaged& operator=(RWTxnManaged&& other) noexcept {
      method abort (line 306) | void abort() override { managed_txn_.abort(); }
      method reopen (line 311) | void reopen(mdbx::env& env) { managed_txn_ = env.start_write(); }
      method RWTxnManaged (line 314) | explicit RWTxnManaged(mdbx::txn_managed&& source) : RWTxn{managed_tx...
    class RWTxnUnmanaged (line 321) | class RWTxnUnmanaged : public RWTxn, protected ::mdbx::txn {
      method RWTxnUnmanaged (line 323) | explicit RWTxnUnmanaged(MDBX_txn* ptr) : RWTxn{static_cast<::mdbx::t...
      method abort (line 326) | void abort() override { throw std::runtime_error{"RWTxnUnmanaged mus...
      method commit_and_renew (line 327) | void commit_and_renew() override { throw std::runtime_error{"RWTxnUn...
      method commit_and_stop (line 328) | void commit_and_stop() override { throw std::runtime_error{"RWTxnUnm...
    class ROAccess (line 332) | class ROAccess {
      method ROAccess (line 334) | explicit ROAccess(const mdbx::env& env) : env_{env} {}
      method ROAccess (line 335) | explicit ROAccess(mdbx::env&& env) : env_{std::move(env)} {}
      method ROAccess (line 336) | ROAccess(const ROAccess&) noexcept = default;
      method ROAccess (line 337) | ROAccess(ROAccess&&) noexcept = default;
      method ROTxnManaged (line 339) | ROTxnManaged start_ro_tx() { return ROTxnManaged(env_); }
    class RWAccess (line 348) | class RWAccess : public ROAccess {
      method RWAccess (line 350) | explicit RWAccess(const mdbx::env& env) : ROAccess{env} {}
      method RWAccess (line 351) | explicit RWAccess(mdbx::env&& env) : ROAccess{std::move(env)} {}
      method RWAccess (line 352) | RWAccess(const RWAccess&) noexcept = default;
      method RWAccess (line 353) | RWAccess(RWAccess&&) noexcept = default;
      method RWTxnManaged (line 355) | RWTxnManaged start_rw_tx() { return RWTxnManaged(env_); }
    type EnvConfig (line 362) | struct EnvConfig {
    type EnvUnmanaged (line 380) | struct EnvUnmanaged : public ::mdbx::env {
      method EnvUnmanaged (line 381) | explicit EnvUnmanaged(MDBX_env* ptr) : ::mdbx::env{ptr} {}
    class PooledCursor (line 415) | class PooledCursor : public RWCursorDupSort, protected ::mdbx::cursor {
      method PooledCursor (line 420) | explicit PooledCursor(ROTxn& txn, const MapConfig& config) : PooledC...
      method PooledCursor (line 426) | PooledCursor(const PooledCursor&) = delete;
      method PooledCursor (line 427) | PooledCursor& operator=(const PooledCursor&) = delete;
      method bind (line 435) | void bind(ROTxn& txn, const MapConfig& config) override { bind(*txn,...
    function get_datafile_path (line 530) | inline std::filesystem::path get_datafile_path(const std::filesystem::...
    type CursorMoveDirection (line 535) | enum class CursorMoveDirection : uint8_t {
    function Slice (line 589) | inline Slice to_slice(ByteView value) {
    function ByteView (line 593) | inline ByteView from_slice(const Slice slice) {

FILE: silkworm/db/datastore/kvdb/mdbx_test.cpp
  type silkworm::datastore::kvdb (line 11) | namespace silkworm::datastore::kvdb {

FILE: silkworm/db/datastore/kvdb/mdbx_version.cpp
  type silkworm::datastore::kvdb (line 15) | namespace silkworm::datastore::kvdb {
    function is_compatible_mdbx_version (line 21) | bool is_compatible_mdbx_version(std::string_view their_version, std::s...

FILE: silkworm/db/datastore/kvdb/mdbx_version.hpp
  type silkworm::datastore::kvdb (line 9) | namespace silkworm::datastore::kvdb {
    type MdbxVersionCheck (line 18) | enum class MdbxVersionCheck : uint8_t {

FILE: silkworm/db/datastore/kvdb/memory_mutation.cpp
  type silkworm::datastore::kvdb (line 13) | namespace silkworm::datastore::kvdb {
    function MapConfig (line 57) | MapConfig MemoryOverlay::sequence_map_config() {

FILE: silkworm/db/datastore/kvdb/memory_mutation.hpp
  type silkworm::datastore::kvdb (line 13) | namespace silkworm::datastore::kvdb {
    class MemoryDatabase (line 15) | class MemoryDatabase {
      method MemoryDatabase (line 20) | MemoryDatabase(MemoryDatabase&& other) noexcept = default;
      method MemoryDatabase (line 21) | MemoryDatabase& operator=(MemoryDatabase&&) noexcept = default;
    class MemoryOverlay (line 29) | class MemoryOverlay {
      method MemoryOverlay (line 37) | MemoryOverlay(MemoryOverlay&& other) noexcept = default;
      method MemoryOverlay (line 38) | MemoryOverlay& operator=(MemoryOverlay&&) noexcept = default;
      method ROTxn (line 40) | ROTxn* external_txn() const { return txn_; }
    class MemoryMutationCursor (line 55) | class MemoryMutationCursor
    class MemoryMutation (line 57) | class MemoryMutation : public RWTxnManaged {
      method MemoryMutation (line 61) | MemoryMutation(MemoryMutation&& other) noexcept = default;
      method MemoryMutation (line 62) | MemoryMutation& operator=(MemoryMutation&&) noexcept = delete;
      method ROTxn (line 71) | ROTxn* external_txn() const { return overlay_.external_txn(); }

FILE: silkworm/db/datastore/kvdb/memory_mutation_cursor.cpp
  type silkworm::datastore::kvdb (line 8) | namespace silkworm::datastore::kvdb {
    function CursorResult (line 58) | CursorResult MemoryMutationCursor::to_first() {
    function CursorResult (line 62) | CursorResult MemoryMutationCursor::to_first(bool throw_notfound) {
    function CursorResult (line 137) | CursorResult MemoryMutationCursor::to_previous() {
    function CursorResult (line 141) | CursorResult MemoryMutationCursor::to_previous(bool throw_notfound) {
    function CursorResult (line 212) | CursorResult MemoryMutationCursor::current() const {
    function CursorResult (line 216) | CursorResult MemoryMutationCursor::current(bool throw_notfound) const {
    function CursorResult (line 229) | CursorResult MemoryMutationCursor::to_next() {
    function CursorResult (line 233) | CursorResult MemoryMutationCursor::to_next(bool throw_notfound) {
    function CursorResult (line 263) | CursorResult MemoryMutationCursor::to_last() {
    function CursorResult (line 267) | CursorResult MemoryMutationCursor::to_last(bool throw_notfound) {
    function CursorResult (line 336) | CursorResult MemoryMutationCursor::find(const Slice& key) {
    function CursorResult (line 343) | CursorResult MemoryMutationCursor::find(const Slice& key, bool throw_n...
    function CursorResult (line 373) | CursorResult MemoryMutationCursor::lower_bound(const Slice& key) {
    function CursorResult (line 377) | CursorResult MemoryMutationCursor::lower_bound(const Slice& key, bool ...
    function MoveResult (line 394) | MoveResult MemoryMutationCursor::move(MoveOperation operation, bool th...
    function MoveResult (line 421) | MoveResult MemoryMutationCursor::move(MoveOperation /*operation*/, con...
    function CursorResult (line 461) | CursorResult MemoryMutationCursor::to_previous_last_multi() {
    function CursorResult (line 465) | CursorResult MemoryMutationCursor::to_previous_last_multi(bool throw_n...
    function CursorResult (line 487) | CursorResult MemoryMutationCursor::to_current_first_multi() {
    function CursorResult (line 491) | CursorResult MemoryMutationCursor::to_current_first_multi(bool throw_n...
    function CursorResult (line 495) | CursorResult Mem

[
  {
    "path": ".circleci/config.yml",
    "chars": 15952,
    "preview": "version: 2.1\norbs:\n  codecov: codecov/codecov@3.3.0\n\ncommands:\n  checkout_with_submodules:\n    parameters:\n      ethereu"
  },
  {
    "path": ".clang-format",
    "chars": 1111,
    "preview": "BasedOnStyle: Google\nColumnLimit: 0\nIndentWidth: 4\nAccessModifierOffset: -2\nNamespaceIndentation: Inner\nAllowShortEnumsO"
  },
  {
    "path": ".clang-tidy",
    "chars": 4574,
    "preview": "FormatStyle: file\nHeaderFilterRegex: 'silkworm/(capi|core|db|execution|infra|node|rpc|sentry|sync|wasm)/.+\\.hpp$'\nWarnin"
  },
  {
    "path": ".dockerignore",
    "chars": 647,
    "preview": "# Include any files or directories that you don't want to be copied to your\n# container here (e.g., local build artifact"
  },
  {
    "path": ".editorconfig",
    "chars": 307,
    "preview": "# EditorConfig helps developers define and maintain consistent\n# coding styles between different editors and IDEs\n# http"
  },
  {
    "path": ".git-blame-ignore-revs",
    "chars": 81,
    "preview": "# Reformat everything with Clang format\n9ba211a89d6d2f5b0820b6ee806cf5b15e556900\n"
  },
  {
    "path": ".github/actions/fuzzer-common-steps/action.yml",
    "chars": 3712,
    "preview": "name: QA - RPC Fuzzer Common Steps\ndescription: Common steps for running Silkworm fuzzer tests\n\ninputs:\n  fuzzer_sanitiz"
  },
  {
    "path": ".github/actions/perf-common-steps/action.yml",
    "chars": 11432,
    "preview": "name: QA - RPC Performance Common Steps\ndescription: Common steps for running Silkworm performance tests\n\ninputs:\n  acti"
  },
  {
    "path": ".github/workflows/execution-test.yml",
    "chars": 3990,
    "preview": "name: QA - Execution Test\n\non:\n  workflow_dispatch:\n    inputs:\n      stop_at_block:\n        description: 'Block number "
  },
  {
    "path": ".github/workflows/macOS.yml",
    "chars": 2405,
    "preview": "name: macOS\n\non:\n  push:\n    branches:\n      - master\n      - 'ci/**'\n\nconcurrency:\n  group: ${{ github.workflow }}-${{ "
  },
  {
    "path": ".github/workflows/rpc-fuzzer-tests.yml",
    "chars": 2635,
    "preview": "name: QA - RPC Fuzzer Tests\n\non:\n  workflow_dispatch:\n  schedule:\n    - cron: '0 0 * * 0'  # Runs every Sunday at 00:00 "
  },
  {
    "path": ".github/workflows/rpc-integration-tests.yml",
    "chars": 4487,
    "preview": "name: QA - RPC Integration Tests\n\non:\n  pull_request:\n    branches:\n      - master\n    types:\n      - opened\n      - rea"
  },
  {
    "path": ".github/workflows/rpc-performance-tests-light.yml",
    "chars": 966,
    "preview": "name: QA - RPC Performance Tests Light\n\non:\n  workflow_dispatch:\n    inputs:\n      measure_erigon:\n        description: "
  },
  {
    "path": ".github/workflows/rpc-performance-tests.yml",
    "chars": 806,
    "preview": "name: QA - RPC Performance Tests\n\non:\n  workflow_dispatch:\n  schedule:\n    - cron: '0 0 * * 1-6'  # Runs every day from "
  },
  {
    "path": ".github/workflows/run_integration_tests.sh",
    "chars": 1523,
    "preview": "#!/bin/bash\n\nif [ \"$#\" -ne 3 ]; then\n  echo \"Usage: $0 <integration_dir> <jwt_file> <failed_tests_dir>\"\n  exit 1\nfi\n\n# T"
  },
  {
    "path": ".github/workflows/snapshot-test.yml",
    "chars": 3313,
    "preview": "name: QA - Snapshot Test\n\non:\n  workflow_dispatch:\n\njobs:\n  execution-test-suite:\n    runs-on: [ self-hosted, Erigon2 ] "
  },
  {
    "path": ".github/workflows/start_integration_rpcdaemon.sh",
    "chars": 496,
    "preview": "#!/bin/bash\n\nset -e\nset -o pipefail\n\ntrap : SIGTERM SIGINT\n\nif [ \"$#\" -ne 2 ]; then\n  echo \"Usage: $0 <data dir> <jwt_fi"
  },
  {
    "path": ".github/workflows/stop_integration_rpcdaemon.sh",
    "chars": 372,
    "preview": "#!/bin/bash\n\nset -e\nset -o pipefail\n\nif [ \"$#\" -ne 1 ]; then\n  echo \"Usage: $0 <rpcdaemon_pid>\"\n  exit 1\nfi\n\n# Clean up "
  },
  {
    "path": ".github/workflows/windows.yml",
    "chars": 2105,
    "preview": "name: Windows\n\non:\n  push:\n    branches:\n      - master\n      - 'ci/**'\n\nconcurrency:\n  group: ${{ github.workflow }}-${"
  },
  {
    "path": ".gitignore",
    "chars": 88,
    "preview": "build*\nvenv\nxcode\n*.code-workspace\n.DS_Store\n.idea\n.vscode\n.vs\nCMakeFiles\ncmake-build-*\n"
  },
  {
    "path": ".gitmodules",
    "chars": 1968,
    "preview": "[submodule \"asio-grpc\"]\n\tpath = third_party/asio-grpc/asio-grpc\n\turl = https://github.com/Tradias/asio-grpc.git\n[submodu"
  },
  {
    "path": "AUTHORS",
    "chars": 132,
    "preview": "# This is the official list of Silkworm authors for copyright purposes.\n\nhttps://github.com/erigontech/silkworm/graphs/c"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 4235,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\ncmake_minimum_required(VERSION 3.24.0)\n\nif("
  },
  {
    "path": "CMakeSettings.json",
    "chars": 1014,
    "preview": "{\n  \"configurations\": [\n    {\n      \"name\": \"x64-Debug\",\n      \"generator\": \"Visual Studio 17 2022 Win64\",\n      \"config"
  },
  {
    "path": "LICENSE",
    "chars": 10173,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "Makefile",
    "chars": 831,
    "preview": ".PHONY: default help fmt lint_copyright lint build run_smoke_tests run_unit_tests test\n\nSILKWORM_BUILD_DIR = build\n\ndefa"
  },
  {
    "path": "README.md",
    "chars": 9931,
    "preview": "# Silkworm - C++ Ethereum Execution Client\n\nC++ implementation of the [Ethereum] Execution Layer (EL) protocol based on "
  },
  {
    "path": "cmake/cmake_format.cmake",
    "chars": 905,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nfind_program(CMAKE_FORMAT cmake-format)\nif("
  },
  {
    "path": "cmake/cmake_format.yaml",
    "chars": 669,
    "preview": "parse:\n  additional_commands:\n    conan_cmake_install:\n      kwargs:\n        PATH_OR_REFERENCE: '*'\n        INSTALL_FOLD"
  },
  {
    "path": "cmake/common/get_all_targets.cmake",
    "chars": 690,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\n# https://stackoverflow.com/a/62311397/1009"
  },
  {
    "path": "cmake/common/targets.cmake",
    "chars": 1687,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nfind_package(Catch2 REQUIRED)\n\nmacro(list_f"
  },
  {
    "path": "cmake/compiler_settings.cmake",
    "chars": 5250,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\ninclude(${CMAKE_CURRENT_LIST_DIR}/compiler_"
  },
  {
    "path": "cmake/compiler_settings_sanitize.cmake",
    "chars": 295,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nif(SILKWORM_SANITIZE)\n  # cmake-format: off"
  },
  {
    "path": "cmake/compiler_warnings.cmake",
    "chars": 2466,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nif(MSVC)\n  add_compile_options(/wd4127) # S"
  },
  {
    "path": "cmake/conan.cmake",
    "chars": 6162,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\ninclude(${CMAKE_CURRENT_LIST_DIR}/compiler_"
  },
  {
    "path": "cmake/conan_quiet.cmake",
    "chars": 1183,
    "preview": "# Reduce verbosity of CMakeDeps conan generator\n# do not edit, regenerate with conan_quiet.sh\n\nset(ZLIB_FIND_QUIETLY YES"
  },
  {
    "path": "cmake/conan_quiet.sh",
    "chars": 424,
    "preview": "#!/bin/bash\n\nscript_dir=$(dirname \"${BASH_SOURCE[0]}\")\nproject_dir=\"$script_dir/..\"\nbuild_dir=\"$1\"\n\nif [[ -z \"$build_dir"
  },
  {
    "path": "cmake/copyright.cmake",
    "chars": 1984,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nset(COPYRIGHT_HEADER_TEMPLATE_C\n    \"// Cop"
  },
  {
    "path": "cmake/format.cmake",
    "chars": 858,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nstring(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} OS"
  },
  {
    "path": "cmake/parallel_jobs_count.sh",
    "chars": 290,
    "preview": "#!/bin/bash\n\nset -e\nset -o pipefail\n\ncase $(uname -s) in\n\tLinux)\n\t\tnproc\n\t\t;;\n\tDarwin)\n\t\tperf_cores=$(sysctl -n hw.perfl"
  },
  {
    "path": "cmake/profiles/experimental/linux_arm64_gcc_12_debug",
    "chars": 128,
    "preview": "[settings]\nos=Linux\narch=armv8\ncompiler=gcc\ncompiler.version=12\ncompiler.libcxx=libstdc++11\ncompiler.cppstd=17\nbuild_typ"
  },
  {
    "path": "cmake/profiles/experimental/linux_arm64_gcc_12_release",
    "chars": 130,
    "preview": "[settings]\nos=Linux\narch=armv8\ncompiler=gcc\ncompiler.version=12\ncompiler.libcxx=libstdc++11\ncompiler.cppstd=17\nbuild_typ"
  },
  {
    "path": "cmake/profiles/experimental/linux_x64_gcc_12_debug",
    "chars": 129,
    "preview": "[settings]\nos=Linux\narch=x86_64\ncompiler=gcc\ncompiler.version=12\ncompiler.libcxx=libstdc++11\ncompiler.cppstd=17\nbuild_ty"
  },
  {
    "path": "cmake/profiles/experimental/linux_x64_gcc_12_release",
    "chars": 131,
    "preview": "[settings]\nos=Linux\narch=x86_64\ncompiler=gcc\ncompiler.version=12\ncompiler.libcxx=libstdc++11\ncompiler.cppstd=17\nbuild_ty"
  },
  {
    "path": "cmake/profiles/experimental/macos_arm64_clang_14_debug",
    "chars": 131,
    "preview": "[settings]\nos=Macos\narch=armv8\ncompiler=apple-clang\ncompiler.version=14\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild_"
  },
  {
    "path": "cmake/profiles/experimental/macos_arm64_clang_14_release",
    "chars": 133,
    "preview": "[settings]\nos=Macos\narch=armv8\ncompiler=apple-clang\ncompiler.version=14\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild_"
  },
  {
    "path": "cmake/profiles/experimental/macos_x64_clang_14_debug",
    "chars": 132,
    "preview": "[settings]\nos=Macos\narch=x86_64\ncompiler=apple-clang\ncompiler.version=14\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild"
  },
  {
    "path": "cmake/profiles/experimental/macos_x64_clang_14_release",
    "chars": 134,
    "preview": "[settings]\nos=Macos\narch=x86_64\ncompiler=apple-clang\ncompiler.version=14\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild"
  },
  {
    "path": "cmake/profiles/experimental/readme.txt",
    "chars": 565,
    "preview": "There are very few binary packages for gcc 12+ and clang 14+ on ConanCenter.\nThe supported platforms are listed here: ht"
  },
  {
    "path": "cmake/profiles/linux_x64_clang_16_debug",
    "chars": 126,
    "preview": "[settings]\nos=Linux\narch=x86_64\ncompiler=clang\ncompiler.version=16\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild_type="
  },
  {
    "path": "cmake/profiles/linux_x64_clang_16_release",
    "chars": 128,
    "preview": "[settings]\nos=Linux\narch=x86_64\ncompiler=clang\ncompiler.version=16\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild_type="
  },
  {
    "path": "cmake/profiles/linux_x64_gcc_11_debug",
    "chars": 129,
    "preview": "[settings]\nos=Linux\narch=x86_64\ncompiler=gcc\ncompiler.version=11\ncompiler.libcxx=libstdc++11\ncompiler.cppstd=17\nbuild_ty"
  },
  {
    "path": "cmake/profiles/linux_x64_gcc_11_release",
    "chars": 131,
    "preview": "[settings]\nos=Linux\narch=x86_64\ncompiler=gcc\ncompiler.version=11\ncompiler.libcxx=libstdc++11\ncompiler.cppstd=17\nbuild_ty"
  },
  {
    "path": "cmake/profiles/macos_arm64_clang_13_debug",
    "chars": 131,
    "preview": "[settings]\nos=Macos\narch=armv8\ncompiler=apple-clang\ncompiler.version=13\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild_"
  },
  {
    "path": "cmake/profiles/macos_arm64_clang_13_release",
    "chars": 133,
    "preview": "[settings]\nos=Macos\narch=armv8\ncompiler=apple-clang\ncompiler.version=13\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild_"
  },
  {
    "path": "cmake/profiles/macos_x64_clang_13_debug",
    "chars": 132,
    "preview": "[settings]\nos=Macos\narch=x86_64\ncompiler=apple-clang\ncompiler.version=13\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild"
  },
  {
    "path": "cmake/profiles/macos_x64_clang_13_release",
    "chars": 134,
    "preview": "[settings]\nos=Macos\narch=x86_64\ncompiler=apple-clang\ncompiler.version=13\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild"
  },
  {
    "path": "cmake/profiles/wasi_release",
    "chars": 240,
    "preview": "[settings]\nos=Emscripten\narch=wasm\ncompiler=clang\ncompiler.version=14\ncompiler.libcxx=libc++\ncompiler.cppstd=17\nbuild_ty"
  },
  {
    "path": "cmake/profiles/windows_msvc_193_debug",
    "chars": 160,
    "preview": "[settings]\nos=Windows\narch=x86_64\ncompiler=msvc\ncompiler.version=193\ncompiler.runtime=dynamic\ncompiler.runtime_type=Rele"
  },
  {
    "path": "cmake/profiles/windows_msvc_193_release",
    "chars": 162,
    "preview": "[settings]\nos=Windows\narch=x86_64\ncompiler=msvc\ncompiler.version=193\ncompiler.runtime=dynamic\ncompiler.runtime_type=Rele"
  },
  {
    "path": "cmake/run_smoke_tests.cmake",
    "chars": 1464,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nif(NOT SILKWORM_BUILD_DIR)\n  set(SILKWORM_B"
  },
  {
    "path": "cmake/run_smoke_tests.sh",
    "chars": 195,
    "preview": "#!/bin/bash\n\nset -e\nset -o pipefail\n\nif test `uname -s` = Linux\nthen\n    ulimit -s unlimited\nfi\n\nscript_dir=`dirname \"$0"
  },
  {
    "path": "cmake/run_unit_tests.cmake",
    "chars": 1825,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nif(NOT SILKWORM_BUILD_DIR)\n  set(SILKWORM_B"
  },
  {
    "path": "cmake/run_unit_tests.sh",
    "chars": 349,
    "preview": "#!/bin/bash\n\nset -e\nset -o pipefail\n\nif test \"$(uname -s)\" = Linux\nthen\n    ulimit -s unlimited\nfi\n\nscript_dir=$(dirname"
  },
  {
    "path": "cmake/setup/compiler_install.sh",
    "chars": 2748,
    "preview": "#!/bin/bash\n\n# $1 - compiler ID: gcc or clang\n# $2 - compiler version\n\nset -e\nset -o pipefail\n\nscript_dir=$(dirname \"${B"
  },
  {
    "path": "cmake/toolchain/clang_libcxx.cmake",
    "chars": 234,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\ninclude(${CMAKE_CURRENT_LIST_DIR}/cxx20.cma"
  },
  {
    "path": "cmake/toolchain/cxx20.cmake",
    "chars": 417,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nset(CMAKE_CXX_STANDARD_REQUIRED YES)\nset(CM"
  },
  {
    "path": "cmake/toolchain/wasi.cmake",
    "chars": 299,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nset(CMAKE_C_COMPILER /opt/wasi-sdk/bin/clan"
  },
  {
    "path": "cmd/CMakeLists.txt",
    "chars": 1166,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\n# Tests\nadd_subdirectory(test)\n\nif(NOT SILK"
  },
  {
    "path": "cmd/benchmark/CMakeLists.txt",
    "chars": 471,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nfind_package(benchmark REQUIRED)\n\nfile(GLOB"
  },
  {
    "path": "cmd/benchmark/benchmark_test.cpp",
    "chars": 131,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <benchmark/benchmark.h>\n\nBENCHMA"
  },
  {
    "path": "cmd/rpcdaemon.cpp",
    "chars": 1092,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <CLI/CLI.hpp>\n\n#include <silkwor"
  },
  {
    "path": "cmd/sentry.cpp",
    "chars": 2897,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <memory>\n\n#include <CLI/CLI.hpp>"
  },
  {
    "path": "cmd/silkworm.cpp",
    "chars": 10779,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <memory>\n#include <optional>\n#in"
  },
  {
    "path": "cmd/test/CMakeLists.txt",
    "chars": 2298,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nfind_package(magic_enum REQUIRED)\n\nif(NOT S"
  },
  {
    "path": "cmd/test/address_sanitizer_fix.hpp",
    "chars": 862,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n// There is a bug in LLVM's address sanit"
  },
  {
    "path": "cmd/test/backend_kv_test.cpp",
    "chars": 43571,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <chrono>\n#include <condition_var"
  },
  {
    "path": "cmd/test/ethereum.cpp",
    "chars": 19451,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <algorithm>\n#include <atomic>\n#i"
  },
  {
    "path": "cmd/test/fuzzer_diagnostics.cpp",
    "chars": 3322,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <execinfo.h>\n\n#include <cstdlib>"
  },
  {
    "path": "cmd/test/fuzzer_test.cpp",
    "chars": 870,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <string>\n\n#include <nlohmann/jso"
  },
  {
    "path": "cmd/test/sentry_client_test.cpp",
    "chars": 1861,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <boost/asio/co_spawn.hpp>\n#inclu"
  },
  {
    "path": "codecov.yml",
    "chars": 141,
    "preview": "coverage:\n  status:\n    project:\n      default:\n        informational: true\n\nignore:\n  - \"**/*_test.cpp\"\n  - \"cmd\"\n  - \""
  },
  {
    "path": "conanfile.py",
    "chars": 4095,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nfrom conan import ConanFile\n\n\nclass Silkwor"
  },
  {
    "path": "docs/CONTRIBUTING.md",
    "chars": 10839,
    "preview": "# Contributing Guide\n\nWe use the [ISO Standard C++][cpp-standard-iso] programming language, specifically C++20.\nIf you c"
  },
  {
    "path": "docs/JSON-RPC-API.md",
    "chars": 23805,
    "preview": "## RPC API Implementation Status\n\nThe following table shows the current [JSON RPC API](https://eth.wiki/json-rpc/API) im"
  },
  {
    "path": "docs/code_style.md",
    "chars": 13282,
    "preview": "# Silkworm code style\n\nThe codebase respects:\n1. [C++ Core Guidelines][cpp-core-guidelines]\n1. [Google's C++ Style Guide"
  },
  {
    "path": "docs/conan.md",
    "chars": 7744,
    "preview": "# Conan package manager\n\nConan is a Python-based meta-build system package management tool.\nSilkworm uses it for third p"
  },
  {
    "path": "docs/db_toolbox.md",
    "chars": 23818,
    "preview": "# db_toolbox\n\nSilkworm keeps recent chain data in MDBX database for faster access.\nThe `db_toolbox` tool is a collection"
  },
  {
    "path": "docs/dev_tools.md",
    "chars": 7560,
    "preview": "# Silkworm development tools\n\n## Check Log Indices\n\n### Overview\n\nSilkworm maintains transaction log address/topic indic"
  },
  {
    "path": "docs/fuzzer.md",
    "chars": 2655,
    "preview": "# Fuzz Tests in Silkworm\n\nSIlkworm uses [libFuzzer](https://llvm.org/docs/LibFuzzer.html) to execute its fuzzy tests. Th"
  },
  {
    "path": "examples/CMakeLists.txt",
    "chars": 471,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nif(NOT SILKWORM_CORE_ONLY)\n\n  find_package("
  },
  {
    "path": "examples/get_latest_block.cpp",
    "chars": 4188,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <functional>\n#include <future>\n#"
  },
  {
    "path": "silkworm/CMakeLists.txt",
    "chars": 470,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\n# Silkworm itself\nadd_subdirectory(core)\n\ni"
  },
  {
    "path": "silkworm/capi/CMakeLists.txt",
    "chars": 1658,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\ninclude(\"${SILKWORM_MAIN_DIR}/cmake/common/"
  },
  {
    "path": "silkworm/capi/cli/CMakeLists.txt",
    "chars": 766,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\nfind_package(Boost REQUIRED COMPONENTS head"
  },
  {
    "path": "silkworm/capi/cli/execute.cpp",
    "chars": 20055,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <limits>\n#include <stdexcept>\n\n#"
  },
  {
    "path": "silkworm/capi/cli/main.c",
    "chars": 614,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <stdio.h>\n\n#include <silkworm/ca"
  },
  {
    "path": "silkworm/capi/cli/sample-go-client/README.md",
    "chars": 334,
    "preview": "# A sample go application that loads Silkworm API library\n\n## Prerequisites\n- C compiler toolchain (required to compile "
  },
  {
    "path": "silkworm/capi/cli/sample-go-client/main.go",
    "chars": 1480,
    "preview": "package main\n\n// #cgo LDFLAGS: -lsilkworm_capi\n// #cgo LDFLAGS: -L${SRCDIR}/../../../../build/silkworm/capi\n// #cgo LDFL"
  },
  {
    "path": "silkworm/capi/common/CMakeLists.txt",
    "chars": 176,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\ninclude(\"${SILKWORM_MAIN_DIR}/cmake/common/"
  },
  {
    "path": "silkworm/capi/common/common_component.hpp",
    "chars": 463,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <filesystem>\n\n#inc"
  },
  {
    "path": "silkworm/capi/common/errors.h",
    "chars": 934,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef SILKWORM_CAPI_ERRORS_H_\n#define S"
  },
  {
    "path": "silkworm/capi/common/instance.hpp",
    "chars": 640,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <memory>\n\n#include"
  },
  {
    "path": "silkworm/capi/common/parse_path.cpp",
    "chars": 540,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"parse_path.hpp\"\n\n#include <cstr"
  },
  {
    "path": "silkworm/capi/common/parse_path.hpp",
    "chars": 355,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <filesystem>\n\n#inc"
  },
  {
    "path": "silkworm/capi/common/preamble.h",
    "chars": 772,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef SILKWORM_CAPI_PREAMBLE_H_\n#define"
  },
  {
    "path": "silkworm/capi/init.cpp",
    "chars": 3972,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"init.h\"\n\n#include <silkworm/bui"
  },
  {
    "path": "silkworm/capi/init.h",
    "chars": 1639,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef SILKWORM_CAPI_INIT_H_\n#define SIL"
  },
  {
    "path": "silkworm/capi/instance.cpp",
    "chars": 419,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"common/instance.hpp\"\n\n#include "
  },
  {
    "path": "silkworm/capi/instance.hpp",
    "chars": 747,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <memory>\n\n#include"
  },
  {
    "path": "silkworm/capi/log_level.h",
    "chars": 606,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef SILKWORM_CAPI_LOG_LEVEL_H_\n#defin"
  },
  {
    "path": "silkworm/capi/make_log_settings.cpp",
    "chars": 1574,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"make_log_settings.hpp\"\n\n#includ"
  },
  {
    "path": "silkworm/capi/make_log_settings.hpp",
    "chars": 313,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <silkworm/infra/co"
  },
  {
    "path": "silkworm/capi/silkworm.cpp",
    "chars": 27150,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"silkworm.h\"\n\n#include <charconv"
  },
  {
    "path": "silkworm/capi/silkworm.h",
    "chars": 6694,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef SILKWORM_H_\n#define SILKWORM_H_\n\n"
  },
  {
    "path": "silkworm/capi/silkworm_test.cpp",
    "chars": 54681,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"silkworm.h\"\n\n#include <cstring>"
  },
  {
    "path": "silkworm/core/CMakeLists.txt",
    "chars": 1749,
    "preview": "# Copyright 2025 The Silkworm Authors\n# SPDX-License-Identifier: Apache-2.0\n\ninclude(\"${SILKWORM_MAIN_DIR}/cmake/common/"
  },
  {
    "path": "silkworm/core/chain/config.cpp",
    "chars": 150195,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"config.hpp\"\n\n#include <algorith"
  },
  {
    "path": "silkworm/core/chain/config.hpp",
    "chars": 6276,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <cstdint>\n#include"
  },
  {
    "path": "silkworm/core/chain/config_test.cpp",
    "chars": 9827,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"config.hpp\"\n\n#include <vector>\n"
  },
  {
    "path": "silkworm/core/chain/dao.cpp",
    "chars": 7053,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"dao.hpp\"\n\n#include <evmc/evmc.h"
  },
  {
    "path": "silkworm/core/chain/dao.hpp",
    "chars": 283,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <silkworm/core/sta"
  },
  {
    "path": "silkworm/core/chain/genesis.cpp",
    "chars": 4740,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"genesis.hpp\"\n\n#include <bit>\n\n#"
  },
  {
    "path": "silkworm/core/chain/genesis.hpp",
    "chars": 748,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <string_view>\n\n#in"
  },
  {
    "path": "silkworm/core/chain/genesis_amoy.cpp",
    "chars": 511760,
    "preview": "/* Generated from genesis_amoy.json using silkworm embed_json tool */\n#include \"genesis_amoy.hpp\"\nconstexpr char kGenesi"
  },
  {
    "path": "silkworm/core/chain/genesis_amoy.hpp",
    "chars": 198,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <string_view>\n\nnam"
  },
  {
    "path": "silkworm/core/chain/genesis_amoy.json",
    "chars": 86479,
    "preview": "{\n    \"alloc\": {\n        \"0000000000000000000000000000000000001000\": {\n            \"balance\": \"0x0\",\n            \"code\":"
  },
  {
    "path": "silkworm/core/chain/genesis_bor_mainnet.cpp",
    "chars": 437362,
    "preview": "/* Generated from genesis_bor_mainnet.json using silkworm embed_json tool */\n#include \"genesis_bor_mainnet.hpp\"\nconstexp"
  },
  {
    "path": "silkworm/core/chain/genesis_bor_mainnet.hpp",
    "chars": 204,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <string_view>\n\nnam"
  },
  {
    "path": "silkworm/core/chain/genesis_bor_mainnet.json",
    "chars": 74243,
    "preview": "{\n    \"alloc\": {\n        \"0000000000000000000000000000000000001000\": {\n            \"balance\": \"0x0\",\n            \"code\":"
  },
  {
    "path": "silkworm/core/chain/genesis_holesky.cpp",
    "chars": 231920,
    "preview": "/* Generated from genesis_holesky.json using silkworm embed_json tool */\n#include \"genesis_holesky.hpp\"\nconstexpr char k"
  },
  {
    "path": "silkworm/core/chain/genesis_holesky.hpp",
    "chars": 201,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <string_view>\n\nnam"
  },
  {
    "path": "silkworm/core/chain/genesis_holesky.json",
    "chars": 49858,
    "preview": "{\n    \"alloc\": {\n        \"0x0000000000000000000000000000000000000000\": {\n            \"balance\": \"0x1\"\n        },\n       "
  },
  {
    "path": "silkworm/core/chain/genesis_mainnet.cpp",
    "chars": 4254374,
    "preview": "/* Generated from genesis_mainnet.json using silkworm embed_json tool */\n#include \"genesis_mainnet.hpp\"\nconstexpr char k"
  },
  {
    "path": "silkworm/core/chain/genesis_mainnet.hpp",
    "chars": 201,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <string_view>\n\nnam"
  },
  {
    "path": "silkworm/core/chain/genesis_mainnet.json",
    "chars": 878152,
    "preview": "{\n  \"alloc\": {\n    \"3282791d6fd713f1e94f4bfd565eaa78b3a0599d\": {\n      \"balance\": \"1337000000000000000000\"\n    },\n    \"1"
  },
  {
    "path": "silkworm/core/chain/genesis_sepolia.cpp",
    "chars": 11618,
    "preview": "/* Generated from genesis_sepolia.json using silkworm embed_json tool */\n#include \"genesis_sepolia.hpp\"\nconstexpr char k"
  },
  {
    "path": "silkworm/core/chain/genesis_sepolia.hpp",
    "chars": 201,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <string_view>\n\nnam"
  },
  {
    "path": "silkworm/core/chain/genesis_sepolia.json",
    "chars": 2617,
    "preview": "{\n    \"alloc\": {\n        \"0xa2A6d93439144FFE4D27c9E088dCD8b783946263\": {\n            \"balance\": \"0xD3C21BCECCEDA1000000\""
  },
  {
    "path": "silkworm/core/chain/genesis_test.cpp",
    "chars": 5225,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <catch2/catch_test_macros.hpp>\n#"
  },
  {
    "path": "silkworm/core/common/assert.cpp",
    "chars": 390,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"assert.hpp\"\n\n#include <cstdlib>"
  },
  {
    "path": "silkworm/core/common/assert.hpp",
    "chars": 521,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\nnamespace silkworm {\n[[nore"
  },
  {
    "path": "silkworm/core/common/base.hpp",
    "chars": 3242,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n// The most common and basi"
  },
  {
    "path": "silkworm/core/common/block_cache.hpp",
    "chars": 921,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <cstddef>\n#include"
  },
  {
    "path": "silkworm/core/common/block_cache_test.cpp",
    "chars": 1719,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"block_cache.hpp\"\n\n#include <cat"
  },
  {
    "path": "silkworm/core/common/bytes.hpp",
    "chars": 2319,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <cstdint>\n#include"
  },
  {
    "path": "silkworm/core/common/bytes_test.cpp",
    "chars": 472,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"bytes.hpp\"\n\n#include <catch2/ca"
  },
  {
    "path": "silkworm/core/common/bytes_to_string.hpp",
    "chars": 1401,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n// Utilities for type casti"
  },
  {
    "path": "silkworm/core/common/decoding_result.hpp",
    "chars": 828,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <tl/expected.hpp>\n"
  },
  {
    "path": "silkworm/core/common/empty_hashes.hpp",
    "chars": 828,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <evmc/evmc.hpp>\n\nn"
  },
  {
    "path": "silkworm/core/common/empty_hashes_test.cpp",
    "chars": 1006,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"empty_hashes.hpp\"\n\n#include <bi"
  },
  {
    "path": "silkworm/core/common/endian.cpp",
    "chars": 674,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"endian.hpp\"\n\n#include <silkworm"
  },
  {
    "path": "silkworm/core/common/endian.hpp",
    "chars": 4163,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n/*\nFacilities to deal with "
  },
  {
    "path": "silkworm/core/common/endian_test.cpp",
    "chars": 4300,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"endian.hpp\"\n\n#include <bit>\n\n#i"
  },
  {
    "path": "silkworm/core/common/hash_maps.hpp",
    "chars": 1200,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#if defined(SILKWORM_CORE_U"
  },
  {
    "path": "silkworm/core/common/lru_cache.hpp",
    "chars": 4703,
    "preview": "/*\nCopyright (c) 2014, lamerman\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without"
  },
  {
    "path": "silkworm/core/common/lru_cache_test.cpp",
    "chars": 3623,
    "preview": "/*\nCopyright (c) 2014, lamerman\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without"
  },
  {
    "path": "silkworm/core/common/math.hpp",
    "chars": 648,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <concepts>\n#includ"
  },
  {
    "path": "silkworm/core/common/math_test.cpp",
    "chars": 1392,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"math.hpp\"\n\n#include <catch2/cat"
  },
  {
    "path": "silkworm/core/common/object_pool.hpp",
    "chars": 1596,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <memory>\n#include "
  },
  {
    "path": "silkworm/core/common/overloaded.hpp",
    "chars": 380,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\nnamespace silkworm {\n\n// He"
  },
  {
    "path": "silkworm/core/common/random_number.hpp",
    "chars": 759,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <limits>\n#include "
  },
  {
    "path": "silkworm/core/common/random_number_test.cpp",
    "chars": 478,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"random_number.hpp\"\n\n#include <a"
  },
  {
    "path": "silkworm/core/common/small_map.hpp",
    "chars": 3061,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <algorithm>\n#inclu"
  },
  {
    "path": "silkworm/core/common/small_map_test.cpp",
    "chars": 873,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"small_map.hpp\"\n\n#include <catch"
  },
  {
    "path": "silkworm/core/common/test_util.cpp",
    "chars": 2583,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"test_util.hpp\"\n\n#include <silkw"
  },
  {
    "path": "silkworm/core/common/test_util.hpp",
    "chars": 12022,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <silkworm/core/cha"
  },
  {
    "path": "silkworm/core/common/util.cpp",
    "chars": 9898,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"util.hpp\"\n\n#include <algorithm>"
  },
  {
    "path": "silkworm/core/common/util.hpp",
    "chars": 5011,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <cmath>\n#include <"
  },
  {
    "path": "silkworm/core/common/util_test.cpp",
    "chars": 8881,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"util.hpp\"\n\n#include <catch2/cat"
  },
  {
    "path": "silkworm/core/concurrency/resettable_once_flag.hpp",
    "chars": 3191,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <functional>\n#incl"
  },
  {
    "path": "silkworm/core/crypto/ecdsa.c",
    "chars": 1742,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"ecdsa.h\"\n\n#include <string.h>\n\n"
  },
  {
    "path": "silkworm/core/crypto/ecdsa.h",
    "chars": 931,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n// See Yellow Paper, Append"
  },
  {
    "path": "silkworm/core/crypto/secp256k1n.cpp",
    "chars": 512,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"secp256k1n.hpp\"\n\nnamespace silk"
  },
  {
    "path": "silkworm/core/crypto/secp256k1n.hpp",
    "chars": 992,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n// See Yellow Paper, Append"
  },
  {
    "path": "silkworm/core/crypto/secp256k1n_test.cpp",
    "chars": 1512,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"secp256k1n.hpp\"\n\n#include <catc"
  },
  {
    "path": "silkworm/core/execution/call_tracer.cpp",
    "chars": 9718,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"call_tracer.hpp\"\n\n#include <evm"
  },
  {
    "path": "silkworm/core/execution/call_tracer.hpp",
    "chars": 1230,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#pragma GCC diagnostic push"
  },
  {
    "path": "silkworm/core/execution/evm.cpp",
    "chars": 19676,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"evm.hpp\"\n\n#include <algorithm>\n"
  },
  {
    "path": "silkworm/core/execution/evm.hpp",
    "chars": 7718,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <functional>\n#incl"
  },
  {
    "path": "silkworm/core/execution/evm_test.cpp",
    "chars": 54811,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"evm.hpp\"\n\n#include <map>\n#inclu"
  },
  {
    "path": "silkworm/core/execution/execution.hpp",
    "chars": 2590,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <vector>\n\n#include"
  },
  {
    "path": "silkworm/core/execution/execution_test.cpp",
    "chars": 6713,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"execution.hpp\"\n\n#include <catch"
  },
  {
    "path": "silkworm/core/execution/precompile.cpp",
    "chars": 15296,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"precompile.hpp\"\n\n#include <gmp."
  },
  {
    "path": "silkworm/core/execution/precompile.hpp",
    "chars": 3429,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <optional>\n\n#inclu"
  },
  {
    "path": "silkworm/core/execution/precompile_benchmark.cpp",
    "chars": 734,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include <benchmark/benchmark.h>\n\n#includ"
  },
  {
    "path": "silkworm/core/execution/precompile_test.cpp",
    "chars": 47941,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"precompile.hpp\"\n\n#include <catc"
  },
  {
    "path": "silkworm/core/execution/processor.cpp",
    "chars": 19631,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"processor.hpp\"\n\n#include <evmon"
  },
  {
    "path": "silkworm/core/execution/processor.hpp",
    "chars": 3060,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <cstdint>\n#include"
  },
  {
    "path": "silkworm/core/execution/processor_test.cpp",
    "chars": 18419,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"processor.hpp\"\n\n#include <catch"
  },
  {
    "path": "silkworm/core/protocol/blockchain.cpp",
    "chars": 6236,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"blockchain.hpp\"\n\n#include <silk"
  },
  {
    "path": "silkworm/core/protocol/blockchain.hpp",
    "chars": 1927,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <unordered_map>\n#i"
  },
  {
    "path": "silkworm/core/protocol/bor/config.cpp",
    "chars": 4225,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"config.hpp\"\n\n#include <set>\n#in"
  },
  {
    "path": "silkworm/core/protocol/bor/config.hpp",
    "chars": 1776,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <optional>\n#includ"
  },
  {
    "path": "silkworm/core/protocol/bor/config_test.cpp",
    "chars": 3101,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"config.hpp\"\n\n#include <string_v"
  },
  {
    "path": "silkworm/core/protocol/bor/span.cpp",
    "chars": 1412,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"span.hpp\"\n\n#include <silkworm/c"
  },
  {
    "path": "silkworm/core/protocol/bor/span.hpp",
    "chars": 507,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <optional>\n\n#inclu"
  },
  {
    "path": "silkworm/core/protocol/bor/span_test.cpp",
    "chars": 684,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"span.hpp\"\n\n#include <catch2/cat"
  },
  {
    "path": "silkworm/core/protocol/bor_rule_set.cpp",
    "chars": 8863,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"bor_rule_set.hpp\"\n\n#include <si"
  },
  {
    "path": "silkworm/core/protocol/bor_rule_set.hpp",
    "chars": 1470,
    "preview": "// Copyright 2025 The Silkworm Authors\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include <silkworm/core/pro"
  }
]

// ... and 1617 more files (download for full content)