2a:I[49813,["/_next/static/chunks/3z--bwudlglfp.js","/_next/static/chunks/2u04xn-9yg2co.js","/_next/static/chunks/1b5-8ftwqgmtb.js","/_next/static/chunks/3nqo6bdos11l6.js","/_next/static/chunks/0fz0mlrjifmq7.js","/_next/static/chunks/034_kq3j28m99.js","/_next/static/chunks/29v1ttach42xh.js","/_next/static/chunks/3meo7law-jljp.js","/_next/static/chunks/1hplpmn3-d0tx.js"],"CodeWorkspace"] 2b:T685d,/** * Copyright (c) 2011-2026 libbitcoin developers * * This file is part of libbitcoin. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see . */ #ifndef LIBBITCOIN_SYSTEM_HASH_SHA_ALGORITHM_HPP #define LIBBITCOIN_SYSTEM_HASH_SHA_ALGORITHM_HPP #include #include #include #include #include #include // algorithm.hpp file is the common include for sha. #include #include #include #include // Based on: // FIPS PUB 180-4 [Secure Hash Standard (SHS)]. // All aspects of FIPS180 are supported within the implmentation. // nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf namespace libbitcoin { namespace system { namespace sha { // Hacking our way around an MSVC compiler bug. #define CLASSIF algorithm #if !defined(CLASSIF) // minimum reproduction of compiler bug template class foo { static constexpr bar = 1; template = true> void f(); }; template template ::bar == 1, bool>> void foo::f() {} // <= incompatible declaration error #endif // !CLASSIF /// SHA hashing algorithm. /// Vectorization of message schedules and merkle hashes. /// Native sha160/sha256, and sha512 (single lane). template = true> class algorithm : algorithm_t { public: /// Types. /// ----------------------------------------------------------------------- /// Aliases. using H = SHA; using K = typename SHA::K; using word_t = typename SHA::word_t; using state_t = typename SHA::state_t; using byte_t = uint8_t; /// Word-based types. using chunk_t = std_array; using words_t = std_array; using buffer_t = std_array; /// Byte-based types. template using bytes_t = std_array; using quart_t = bytes_t; using half_t = bytes_t; using block_t = bytes_t; using digest_t = bytes_t>; /// Collection types. template using ablocks_t = std_array; using iblocks_t = iterable; using digests_t = std::vector; /// Count types. /// ----------------------------------------------------------------------- /// count_t is uint64_t (sha160/256) or uint128_t (sha512). /// All extended integer intrinsics currently have a "64 on 32" limit. static constexpr auto count_bits = SHA::block_words * SHA::word_bytes; static constexpr auto count_bytes = bytes; using count_t = unsigned_exact_type>; static constexpr auto limit_bits = maximum - count_bits; static constexpr auto limit_bytes = to_floored_bytes(limit_bits); static constexpr auto big_end_count = true; /// Number of bytes available for data in the last sha block. static constexpr auto space = sub1(array_count - count_bytes); /// Single hashing. /// ----------------------------------------------------------------------- template static constexpr digest_t hash(const ablocks_t& blocks) NOEXCEPT; static constexpr digest_t hash(const block_t& block) NOEXCEPT; static constexpr digest_t hash(const half_t& half) NOEXCEPT; static constexpr digest_t hash(const half_t& left, const half_t& right) NOEXCEPT; static constexpr digest_t hash(const quart_t& left, const quart_t& right) NOEXCEPT; static constexpr digest_t hash(uint8_t byte) NOEXCEPT; static digest_t hash(iblocks_t&& blocks) NOEXCEPT; /// Hash array of any size up to the space available in a single sha block. /// This allows for variable length constexpr hashing (avoids accumulator). template = true> static constexpr digest_t simple_hash(const bytes_t& bytes) NOEXCEPT; /// Same as hash but returns state_t instead of converting it to digest_t. static constexpr state_t midstate(const half_t& left, const half_t& right) NOEXCEPT; /// Hash of three halves following a one block midstate. static constexpr digest_t hash(const state_t& midstate, const half_t& first, const half_t& second, const half_t& third) NOEXCEPT; /// Hash of up to one block of bytes, following a one block midstate. template = true> static constexpr digest_t hash(const state_t& midstate, const bytes_t& bytes) NOEXCEPT; /// Double hashing (sha256/512). /// ----------------------------------------------------------------------- template static constexpr digest_t double_hash(const ablocks_t& blocks) NOEXCEPT; static constexpr digest_t double_hash(const block_t& block) NOEXCEPT; static constexpr digest_t double_hash(const half_t& half) NOEXCEPT; static constexpr digest_t double_hash(const half_t& left, const half_t& right) NOEXCEPT; static digest_t double_hash(iblocks_t&& blocks) NOEXCEPT; /// Streamed hashing (explicitly finalized). /// ----------------------------------------------------------------------- static void accumulate(state_t& state, iblocks_t&& blocks) NOEXCEPT; static constexpr void accumulate(state_t& state, const block_t& block) NOEXCEPT; static constexpr digest_t normalize(const state_t& state) NOEXCEPT; template static constexpr digest_t finalize(state_t& state) NOEXCEPT; static constexpr digest_t finalize(state_t& state, size_t blocks) NOEXCEPT; static constexpr digest_t finalize_second(const state_t& state) NOEXCEPT; static constexpr digest_t finalize_double(state_t& state, size_t blocks) NOEXCEPT; /// Merkle hashing (sha256/512). /// ----------------------------------------------------------------------- static constexpr digests_t& merkle_hash(digests_t& digests) NOEXCEPT; static constexpr digest_t merkle_root(digests_t&& digests) NOEXCEPT; protected: /// Intrinsics constants. /// ----------------------------------------------------------------------- static constexpr auto use_128 = Vector && bc::have_128; static constexpr auto use_256 = Vector && bc::have_256; static constexpr auto use_512 = Vector && bc::have_512; static constexpr auto use_sha = Native && bc::have_sha; static constexpr auto use_sha512 = Native && bc::have_sha512; template static constexpr auto is_valid_lanes = (Lanes == 16u || Lanes == 8u || Lanes == 4u || Lanes == 2u); static constexpr auto min_lanes = (use_128 ? bytes<128> : (use_256 ? bytes<256> : (use_512 ? bytes<512> : 0))) / SHA::word_bytes; /// Intrinsics types. /// ----------------------------------------------------------------------- /// Expand is multiple of buffer/state for Lane concurrent blocks. /// Multiple blocks are "striped" across the expanded buffer in xWords. template > = true> using xblock_t = std_array; template = true> using xbuffer_t = aligned_array; template = true> using xstate_t = aligned_array; template = true> using xchunk_t = aligned_array; /// Wide is casting of buffer_t to xWord for single block concurrency. /// This is not multi-block or block striping, just larger words. template = true> using wbuffer_t = aligned_array; template = true> using wstate_t = aligned_array; /// Other types. /// ----------------------------------------------------------------------- using uint = unsigned int; using idigests_t = mutable_iterable; using pad_t = std_array; /// Functions. /// ----------------------------------------------------------------------- INLINE static constexpr auto parity(auto x, auto y, auto z) NOEXCEPT; INLINE static constexpr auto choice(auto x, auto y, auto z) NOEXCEPT; INLINE static constexpr auto majority(auto x, auto y, auto z) NOEXCEPT; template INLINE static constexpr auto sigma(auto x) NOEXCEPT; INLINE static constexpr auto sigma0(auto x) NOEXCEPT; INLINE static constexpr auto sigma1(auto x) NOEXCEPT; template INLINE static constexpr auto Sigma(auto x) NOEXCEPT; INLINE static constexpr auto Sigma0(auto x) NOEXCEPT; INLINE static constexpr auto Sigma1(auto x) NOEXCEPT; /// Compression. /// ----------------------------------------------------------------------- template INLINE static constexpr auto extract(Word a) NOEXCEPT; template static consteval auto functor() NOEXCEPT; template INLINE static constexpr void round(auto a, auto& b, auto c, auto d, auto& e, auto wk) NOEXCEPT; template INLINE static constexpr void round(auto a, auto b, auto c, auto& d, auto e, auto f, auto g, auto& h, auto wk) NOEXCEPT; template INLINE static constexpr void round(auto& state, const auto& wk) NOEXCEPT; INLINE static constexpr void summarize(auto& out, const auto& in) NOEXCEPT; template static constexpr void compress_(auto& state, const auto& buffer) NOEXCEPT; template static constexpr void compress(state_t& state, const buffer_t& buffer) NOEXCEPT; /// Message scheduling. /// ----------------------------------------------------------------------- template INLINE static constexpr void prepare(auto& buffer) NOEXCEPT; template static constexpr void schedule_(auto& buffer) NOEXCEPT; static constexpr void schedule(buffer_t& buffer) NOEXCEPT; static constexpr void schedule_compress(state_t& state, buffer_t& buffer) NOEXCEPT; /// Parsing (endian sensitive). /// ----------------------------------------------------------------------- INLINE static constexpr digest_t output(const state_t& state) NOEXCEPT; INLINE static constexpr void input(buffer_t& buffer, const block_t& block) NOEXCEPT; INLINE static constexpr void input_left(auto& buffer, const half_t& half) NOEXCEPT; INLINE static constexpr void input_right(auto& buffer, const half_t& half) NOEXCEPT; INLINE static constexpr void input_left(auto& buffer, const quart_t& quarter) NOEXCEPT; INLINE static constexpr void input_right(auto& buffer, const quart_t& quarter) NOEXCEPT; /// Midstate. /// ----------------------------------------------------------------------- INLINE static constexpr void inject_left_half(auto& buffer, const auto& left) NOEXCEPT; INLINE static constexpr void inject_right_half(auto& buffer, const auto& right) NOEXCEPT; INLINE static constexpr void inject_left_quarter(auto& buffer, const auto& left) NOEXCEPT; INLINE static constexpr void inject_right_quarter(auto& buffer, const auto& right) NOEXCEPT; /// Padding. /// ----------------------------------------------------------------------- /// Scheduled padding (new and existing buffer objects). template static consteval buffer_t scheduled_pad() NOEXCEPT; template static constexpr void schedule_n(buffer_t& buffer) NOEXCEPT; static constexpr void schedule_n(buffer_t& buffer, size_t blocks) NOEXCEPT; static constexpr void schedule_1(buffer_t& buffer) NOEXCEPT; /// Unscheduled padding (new objects). template static constexpr void simple_pad(block_t& block) NOEXCEPT; template static consteval chunk_t chunk_pad() NOEXCEPT; static consteval pad_t stream_pad() NOEXCEPT; static words_t pad_block() NOEXCEPT; static words_t pad_blocks(count_t blocks) NOEXCEPT; /// Unscheduled padding (update block or buffer object). template static constexpr void pad_half(auto& buffer) NOEXCEPT; static constexpr void pad_n(auto& buffer, count_t blocks) NOEXCEPT; /// Iteration (message scheduling vectorized for multiple blocks). /// ----------------------------------------------------------------------- template INLINE static auto pack(const xblock_t& xblock) NOEXCEPT; template INLINE static void xinput(xbuffer_t& xbuffer, iblocks_t& blocks) NOEXCEPT; template = true> INLINE static Word extract(xWord a) NOEXCEPT; template INLINE static void sequential_compress(state_t& state, const xbuffer_t& xbuffer) NOEXCEPT; template = true> INLINE static void vector_schedule_sequential_compress(state_t& state, iblocks_t& blocks) NOEXCEPT; template INLINE static void iterate_vector(state_t& state, const ablocks_t& blocks) NOEXCEPT; INLINE static void iterate_vector(state_t& state, iblocks_t& blocks) NOEXCEPT; template INLINE static void iterate_native(state_t& state, const ablocks_t& blocks) NOEXCEPT; INLINE static void iterate_native(state_t& state, iblocks_t& blocks) NOEXCEPT; template INLINE static constexpr void iterate_(state_t& state, const ablocks_t& blocks) NOEXCEPT; INLINE static void iterate_(state_t& state, iblocks_t& blocks) NOEXCEPT; template INLINE static constexpr void iterate(state_t& state, const ablocks_t& blocks) NOEXCEPT; INLINE static void iterate(state_t& state, iblocks_t& blocks) NOEXCEPT; /// Merkle hashing (fully vectorized for multiple blocks). /// ----------------------------------------------------------------------- template INLINE static auto pack_pad_half() NOEXCEPT; template INLINE static auto pack_schedule_1() NOEXCEPT; template INLINE static void pad_half(xbuffer_t& xbuffer) NOEXCEPT; template INLINE static void prepare_half(xbuffer_t& xbuffer) NOEXCEPT; template INLINE static void schedule_half(xbuffer_t& xbuffer) NOEXCEPT; template INLINE static const auto& scheduled_1() NOEXCEPT; template INLINE static auto pack(const state_t& state) NOEXCEPT; template INLINE static digest_t unpack(const xstate_t& xstate) NOEXCEPT; template INLINE static void xoutput(idigests_t& digests, const xstate_t& xstate) NOEXCEPT; template = true> INLINE static void merkle_hash_vector(idigests_t& digests, iblocks_t& blocks) NOEXCEPT; INLINE static void merkle_hash_vector(digests_t& digests) NOEXCEPT; INLINE static void merkle_hash_native(idigests_t& digests, iblocks_t& blocks) NOEXCEPT; constexpr static void merkle_hash_(digests_t& digests, size_t offset=zero) NOEXCEPT; /// sigma0 vectorization (single blocks). /// ----------------------------------------------------------------------- template INLINE static void prepare_1(buffer_t& buffer, const auto& sigmas) NOEXCEPT; template INLINE static void prepare_8(buffer_t& buffer) NOEXCEPT; template INLINE static void schedule_sigma(xbuffer_t& xbuffer) NOEXCEPT; INLINE static void schedule_sigma(buffer_t& buffer) NOEXCEPT; template INLINE static void konstant_8(buffer_t& wk, const buffer_t& buffer) NOEXCEPT; template INLINE static void compress_8(state_t& state, const buffer_t& wk) NOEXCEPT; static void schedule_compress_sigma(state_t& state, buffer_t& buffer) NOEXCEPT; /// [K]onstant vectorization (single and multiple blocks). /// ----------------------------------------------------------------------- template INLINE static constexpr void konstant(auto& buffer) NOEXCEPT; template INLINE static void vector_konstant(wbuffer_t& wbuffer) NOEXCEPT; INLINE static void vector_konstant(buffer_t& buffer) NOEXCEPT; template static constexpr void konstant(xbuffer_t& xbuffer) NOEXCEPT; static constexpr void konstant(buffer_t& buffer) NOEXCEPT; static constexpr void konstant_(auto& buffer) NOEXCEPT; /// Native SHA optimizations (single blocks). /// ----------------------------------------------------------------------- template INLINE static xint128_t endian(xint128_t message) NOEXCEPT; INLINE static void shuffle(xint128_t& state0, xint128_t& state1) NOEXCEPT; INLINE static void unshuffle(xint128_t& state0, xint128_t& state1) NOEXCEPT; INLINE static void prepare(xint128_t& message0, xint128_t message1) NOEXCEPT; INLINE static void prepare(xint128_t& message0, xint128_t message1, xint128_t message2) NOEXCEPT; template INLINE static void round_4(xint128_t& state0, xint128_t& state1, xint128_t message) NOEXCEPT; template = true> INLINE static void native_rounds(xint128_t& lo, xint128_t& hi, xint128_t message0, xint128_t message1, xint128_t message2, xint128_t message3) NOEXCEPT; template = true> INLINE static void native_rounds(xint128_t& lo, xint128_t& hi, xint128_t message0, xint128_t message1, xint128_t message2, xint128_t message3) NOEXCEPT; INLINE static void native_rounds(xint128_t& lo, xint128_t& hi, const buffer_t& buffer) NOEXCEPT; template INLINE static void native_rounds(xint128_t& lo, xint128_t& hi, const block_t& block) NOEXCEPT; INLINE static void native_rounds(xint128_t& lo, xint128_t& hi, const half_t& left, const chunk_t& pad) NOEXCEPT; template = true> static void native_transform(state_t& state, const auto& block) NOEXCEPT; template = true> static void native_transform(state_t& state, const auto& block) NOEXCEPT; template = true> static void native_transform(state_t& state, const auto& block) NOEXCEPT; template = true> static void native_transform(state_t& state, iblocks_t& blocks) NOEXCEPT; template = true> static void native_transform(state_t& state, iblocks_t& blocks) NOEXCEPT; template = true> static void native_transform(state_t& state, iblocks_t& blocks) NOEXCEPT; template static digest_t native_finalize(state_t& state) NOEXCEPT; static digest_t native_finalize(state_t& state, size_t blocks) NOEXCEPT; template = true> static digest_t native_finalize(state_t& state, const words_t& pad) NOEXCEPT; template = true> static digest_t native_finalize(state_t& state, const words_t& pad) NOEXCEPT; template = true> static digest_t native_finalize(state_t& state, const words_t& pad) NOEXCEPT; static digest_t native_finalize_second(const state_t& half) NOEXCEPT; static digest_t native_finalize_double(state_t& half, size_t blocks) NOEXCEPT; static digest_t native_hash(const block_t& block) NOEXCEPT; static digest_t native_hash(const half_t& half) NOEXCEPT; static digest_t native_hash(const half_t& left, const half_t& right) NOEXCEPT; static digest_t native_hash(const quart_t& left, const quart_t& right) NOEXCEPT; static digest_t native_hash(uint8_t byte) NOEXCEPT; INLINE static void native_initialize(xint128_t& lo, xint128_t& hi) NOEXCEPT; INLINE static digest_t native_finalize_second(xint128_t lo, xint128_t hi) NOEXCEPT; static digest_t native_double_hash(const block_t& block) NOEXCEPT; static digest_t native_double_hash(const half_t& half) NOEXCEPT; static digest_t native_double_hash(const half_t& left, const half_t& right) NOEXCEPT; /// Native SHA optimizations (two blocks). /// ----------------------------------------------------------------------- INLINE static void native_rounds(xint128_t& lo0, xint128_t& hi0, xint128_t& lo1, xint128_t& hi1, xint128_t a0, xint128_t a1, xint128_t a2, xint128_t a3, xint128_t b0, xint128_t b1, xint128_t b2, xint128_t b3) NOEXCEPT; INLINE static void native_rounds(xint128_t& lo0, xint128_t& hi0, xint128_t& lo1, xint128_t& hi1, const buffer_t& buffer) NOEXCEPT; template INLINE static void native_rounds(xint128_t& lo0, xint128_t& hi0, xint128_t& lo1, xint128_t& hi1, const block_t& block0, const block_t& block1) NOEXCEPT; INLINE static void native_finalize_second(digest_t& digest0, digest_t& digest1, xint128_t lo0, xint128_t hi0, xint128_t lo1, xint128_t hi1) NOEXCEPT; static void native_double_hash(digest_t& digest0, digest_t& digest1, const block_t& block0, const block_t& block1) NOEXCEPT; /// Native SHA512 optimizations (single blocks). /// ----------------------------------------------------------------------- template INLINE static xquad_t endian(xquad_t message) NOEXCEPT; INLINE static void shuffle(xquad_t& state0, xquad_t& state1) NOEXCEPT; INLINE static void unshuffle(xquad_t& state0, xquad_t& state1) NOEXCEPT; INLINE static void prepare(xquad_t& message0, xquad_t message1) NOEXCEPT; INLINE static void prepare(xquad_t& message0, xquad_t message1, xquad_t message2) NOEXCEPT; template INLINE static void round_4(xquad_t& state0, xquad_t& state1, xquad_t message) NOEXCEPT; INLINE static void native_rounds(xquad_t& lo, xquad_t& hi, xquad_t message0, xquad_t message1, xquad_t message2, xquad_t message3) NOEXCEPT; template INLINE static void native_rounds(xquad_t& lo, xquad_t& hi, const block_t& block) NOEXCEPT; /// Native register resident double hashing (sha256). static constexpr auto native_double = use_sha && SHA::strength == 256; public: /// Summary public values. /// ----------------------------------------------------------------------- static constexpr auto caching = Cached; static constexpr auto native = (use_sha512 && (SHA::strength == 512)) || (use_sha && (SHA::strength == 256 || SHA::strength == 160)); static constexpr auto vector = (use_128 || use_256 || use_512); }; } // namespace sha } // namespace system } // namespace libbitcoin #define TEMPLATE template If> #define CLASS algorithm // Bogus warning suggests constexpr when declared consteval. BC_PUSH_WARNING(USE_CONSTEXPR_FOR_FUNCTION) BC_PUSH_WARNING(NO_UNGUARDED_POINTERS) BC_PUSH_WARNING(NO_POINTER_ARITHMETIC) BC_PUSH_WARNING(NO_ARRAY_INDEXING) #include #include #include #include #include #include #include #include #include #include #include #include #include #include BC_POP_WARNING() BC_POP_WARNING() BC_POP_WARNING() BC_POP_WARNING() #undef CLASSIF #undef CLASS #undef TEMPLATE #endif 13:["$","$L2a",null,{"project":{"id":"cmuidb72x000001s1932ifphv","owner":"libbitcoin","repo":"libbitcoin-system","displayName":"libbitcoin/libbitcoin-system","defaultBranch":"master"},"commit":{"sha":"121d29eceaf821490dfef9f329758891c584ae57","message":"Disable clang-cl warnings in system headers.","authorLogin":"evoskuil","authorName":"Eric Voskuil","date":"2026-10-30T18:12:39.000Z","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/commit/121d29eceaf821490dfef9f329758891c584ae57","isHead":false,"headSha":"876e2e139ded674b405285caa83394aac84953f0"},"gitRef":"121d29eceaf821490dfef9f329758891c584ae57","path":"include/bitcoin/system/hash/sha/algorithm.hpp","target":{"kind":"file","file":{"path":"include/bitcoin/system/hash/sha/algorithm.hpp","size":26717,"content":"$2b","tooLarge":false,"binary":false,"htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/blob/121d29eceaf821490dfef9f329758891c584ae57/include/bitcoin/system/hash/sha/algorithm.hpp","mutants":[],"mutantsAtOtherRevisions":0}},"treeCache":{"":[{"name":".github","path":".github","type":"dir","size":null},{"name":".vscode","path":".vscode","type":"dir","size":null},{"name":"builds","path":"builds","type":"dir","size":null},{"name":"doc","path":"doc","type":"dir","size":null},{"name":"include","path":"include","type":"dir","size":null},{"name":"src","path":"src","type":"dir","size":null},{"name":"test","path":"test","type":"dir","size":null},{"name":"tools","path":"tools","type":"dir","size":null},{"name":".gitignore","path":".gitignore","type":"file","size":1037},{"name":"COPYING","path":"COPYING","type":"file","size":33899},{"name":"README.md","path":"README.md","type":"file","size":9650}],"include":[{"name":"bitcoin","path":"include/bitcoin","type":"dir","size":null}],"include/bitcoin":[{"name":"system","path":"include/bitcoin/system","type":"dir","size":null},{"name":"system.hpp","path":"include/bitcoin/system.hpp","type":"file","size":18489}],"include/bitcoin/system":[{"name":"chain","path":"include/bitcoin/system/chain","type":"dir","size":null},{"name":"config","path":"include/bitcoin/system/config","type":"dir","size":null},{"name":"crypto","path":"include/bitcoin/system/crypto","type":"dir","size":null},{"name":"data","path":"include/bitcoin/system/data","type":"dir","size":null},{"name":"endian","path":"include/bitcoin/system/endian","type":"dir","size":null},{"name":"error","path":"include/bitcoin/system/error","type":"dir","size":null},{"name":"filter","path":"include/bitcoin/system/filter","type":"dir","size":null},{"name":"hash","path":"include/bitcoin/system/hash","type":"dir","size":null},{"name":"impl","path":"include/bitcoin/system/impl","type":"dir","size":null},{"name":"intrinsics","path":"include/bitcoin/system/intrinsics","type":"dir","size":null},{"name":"machine","path":"include/bitcoin/system/machine","type":"dir","size":null},{"name":"math","path":"include/bitcoin/system/math","type":"dir","size":null},{"name":"radix","path":"include/bitcoin/system/radix","type":"dir","size":null},{"name":"serial","path":"include/bitcoin/system/serial","type":"dir","size":null},{"name":"stream","path":"include/bitcoin/system/stream","type":"dir","size":null},{"name":"unicode","path":"include/bitcoin/system/unicode","type":"dir","size":null},{"name":"wallet","path":"include/bitcoin/system/wallet","type":"dir","size":null},{"name":"words","path":"include/bitcoin/system/words","type":"dir","size":null},{"name":"x509","path":"include/bitcoin/system/x509","type":"dir","size":null},{"name":"allocator.hpp","path":"include/bitcoin/system/allocator.hpp","type":"file","size":9990},{"name":"arena.hpp","path":"include/bitcoin/system/arena.hpp","type":"file","size":4397},{"name":"boost.hpp","path":"include/bitcoin/system/boost.hpp","type":"file","size":2549},{"name":"constants.hpp","path":"include/bitcoin/system/constants.hpp","type":"file","size":7217},{"name":"constraints.hpp","path":"include/bitcoin/system/constraints.hpp","type":"file","size":8213},{"name":"define.hpp","path":"include/bitcoin/system/define.hpp","type":"file","size":1861},{"name":"exceptions.hpp","path":"include/bitcoin/system/exceptions.hpp","type":"file","size":2544},{"name":"execution.hpp","path":"include/bitcoin/system/execution.hpp","type":"file","size":10757},{"name":"forks.hpp","path":"include/bitcoin/system/forks.hpp","type":"file","size":2593},{"name":"funclets.hpp","path":"include/bitcoin/system/funclets.hpp","type":"file","size":5883},{"name":"have.hpp","path":"include/bitcoin/system/have.hpp","type":"file","size":13094},{"name":"literals.hpp","path":"include/bitcoin/system/literals.hpp","type":"file","size":6680},{"name":"preprocessor.hpp","path":"include/bitcoin/system/preprocessor.hpp","type":"file","size":7292},{"name":"settings.hpp","path":"include/bitcoin/system/settings.hpp","type":"file","size":4769},{"name":"typelets.hpp","path":"include/bitcoin/system/typelets.hpp","type":"file","size":7846},{"name":"types.hpp","path":"include/bitcoin/system/types.hpp","type":"file","size":12018},{"name":"version.hpp.in","path":"include/bitcoin/system/version.hpp.in","type":"file","size":1041},{"name":"warnings.hpp","path":"include/bitcoin/system/warnings.hpp","type":"file","size":4555}],"include/bitcoin/system/hash":[{"name":"rmd","path":"include/bitcoin/system/hash/rmd","type":"dir","size":null},{"name":"sha","path":"include/bitcoin/system/hash/sha","type":"dir","size":null},{"name":"sha3","path":"include/bitcoin/system/hash/sha3","type":"dir","size":null},{"name":"accumulator.hpp","path":"include/bitcoin/system/hash/accumulator.hpp","type":"file","size":7114},{"name":"algorithm.hpp","path":"include/bitcoin/system/hash/algorithm.hpp","type":"file","size":1021},{"name":"algorithms.hpp","path":"include/bitcoin/system/hash/algorithms.hpp","type":"file","size":1987},{"name":"checksum.hpp","path":"include/bitcoin/system/hash/checksum.hpp","type":"file","size":5132},{"name":"functions.hpp","path":"include/bitcoin/system/hash/functions.hpp","type":"file","size":8311},{"name":"hash.hpp","path":"include/bitcoin/system/hash/hash.hpp","type":"file","size":1381},{"name":"hkdf.hpp","path":"include/bitcoin/system/hash/hkdf.hpp","type":"file","size":2826},{"name":"hmac.hpp","path":"include/bitcoin/system/hash/hmac.hpp","type":"file","size":2361},{"name":"muhash.hpp","path":"include/bitcoin/system/hash/muhash.hpp","type":"file","size":2659},{"name":"pbkd.hpp","path":"include/bitcoin/system/hash/pbkd.hpp","type":"file","size":2475},{"name":"scrypt.hpp","path":"include/bitcoin/system/hash/scrypt.hpp","type":"file","size":5040},{"name":"siphash.hpp","path":"include/bitcoin/system/hash/siphash.hpp","type":"file","size":2226}],"include/bitcoin/system/hash/sha":[{"name":"algorithm.hpp","path":"include/bitcoin/system/hash/sha/algorithm.hpp","type":"file","size":26717},{"name":"sha.hpp","path":"include/bitcoin/system/hash/sha/sha.hpp","type":"file","size":2603},{"name":"sha160.hpp","path":"include/bitcoin/system/hash/sha/sha160.hpp","type":"file","size":2667},{"name":"sha256.hpp","path":"include/bitcoin/system/hash/sha/sha256.hpp","type":"file","size":3060},{"name":"sha512.hpp","path":"include/bitcoin/system/hash/sha/sha512.hpp","type":"file","size":5104}]},"revisions":[{"commitSha":"c37c9b73278f1f97e6eb6421f3544f5e58edba2f","branch":null,"commitMessage":"Merge pull request #2132 from evoskuil/master","commitDate":"2026-10-29T20:40:10.000Z","mutantCount":36},{"commitSha":"9fa0f9a07f31c5cc9ebe5efa05e6d4a6d12ba183","branch":null,"commitMessage":"Test script pattern length guards and the sixteen key multisig builder boundary.","commitDate":"2026-09-29T18:05:00.000Z","mutantCount":129},{"commitSha":"98db5bfd7c7b65532e42309c7b71419d82ec5ea8","branch":null,"commitMessage":"Merge pull request #2017 from evoskuil/master","commitDate":"2026-09-28T17:24:16.000Z","mutantCount":230},{"commitSha":"827fb29d0fecbdf7a157e05b1bea59bc916787aa","branch":null,"commitMessage":"Test multisig sighash cache reset across distinct subscripts","commitDate":"2026-09-26T12:24:47.000Z","mutantCount":1},{"commitSha":"8e7a9fdcb4ca72bc5bfe9961815aaa9bc33b64a0","branch":null,"commitMessage":"Remove dead include.","commitDate":"2026-09-25T06:52:28.000Z","mutantCount":90}],"signedIn":false,"pullRequest":{"id":"cmvwrgy0h00ex01n1ycl8rckj","number":2134,"title":"Expanded CI coverage. (clang-cl, Arm, mac x64).","headSha":"121d29eceaf821490dfef9f329758891c584ae57","state":"MERGED","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/pull/2134","ranges":[[201,201],[204,204],[207,207],[212,212],[215,215]],"fileInDiff":true,"atHead":true}}]