29: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"] 2a:T66dc,/** * 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_SRC_CRYPTO_SECP256K1_CUDA_CONTEXT_HPP #define LIBBITCOIN_SYSTEM_SRC_CRYPTO_SECP256K1_CUDA_CONTEXT_HPP #include #include #include #include #include #include #include #include #include #include "kernels.hpp" #include "layout.hpp" #include "library.hpp" #include "turns.hpp" namespace libbitcoin { namespace system { namespace secp256k1 { namespace cuda { BC_PUSH_WARNING(NO_REINTERPRET_CAST) BC_PUSH_WARNING(NO_ARRAY_INDEXING) BC_PUSH_WARNING(NO_POINTER_ARITHMETIC) BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT) // Context. // ---------------------------------------------------------------------------- /// The device and its resources, released with the instance. class context { public: /// Threads per block. static constexpr size_t threads = 128; /// Staging is at most a quarter of the device's free memory. static constexpr size_t memory_share = 4; /// Staging is at most this many bytes. static constexpr size_t maximum_bytes = power2(29_size); /// Rows timed to measure a kernel's rate. static constexpr size_t calibration_rows = power2(16_size); /// A chunk is at most this many rows, staged while the prior computes. static constexpr size_t chunk_rows = power2(16_size); /// A launch is sized to run about this long where the device has a limit. static constexpr auto launch_time = std::chrono::milliseconds{ 50 }; DELETE_COPY_MOVE(context); static context& instance() NOEXCEPT { static context singleton{}; return singleton; } ~context() NOEXCEPT { for (const auto stream: streams_) if (!is_null(stream)) call_.stream_destroy(stream); if (!is_zero(staging_)) call_.deallocate(staging_); if (!is_null(module_)) call_.module_unload(module_); if (retained_) call_.context_release(device_); } bool available() const NOEXCEPT { return loaded_ && !failed_.load(); } /// Results of the rows, empty if all valid or canceled, false on failure. template bool verify(const stopper& cancel, data_chunk& out, const std::span& digests, const std::span& keys, const std::span& signatures, bool urgent) NOEXCEPT { const auto count = keys.size(); const auto rows = std::min(launch_rows(), chunk_rows); out.resize(count); if (!pipeline(count, rows, urgent, cancel, [&](size_t half, size_t offset, size_t size) NOEXCEPT { return stage(half, digests.subspan(offset, size), keys.subspan(offset, size), signatures.subspan(offset, size)); }, [&](size_t half, size_t offset, size_t size) NOEXCEPT { return collect(half, std::span{ &out[offset], size }); })) return false; if (cancel || std::ranges::all_of(out, [](uint8_t value) NOEXCEPT { return is_one(value); })) out.clear(); return true; } /// Output key prefixes of the receiver for each point, false on failure. bool scan(const stopper& cancel, std::vector& prefixes, data_chunk& valid, const std::span& points, const scan::batch::receiver& keys) NOEXCEPT { scan_arguments arguments{}; if (!scan_receiver::decode(arguments, keys)) return false; const auto count = points.size(); const auto stride = add1(size_t{ arguments.label_count }); const auto fit = scan_layout::rows(half_bytes_, stride); const auto rows = std::min({ scan_rows_, chunk_rows, fit }); prefixes.resize(count * stride); valid.resize(count); return pipeline(count, rows, false, cancel, [&](size_t half, size_t offset, size_t size) NOEXCEPT { return stage(half, points.subspan(offset, size), arguments); }, [&](size_t half, size_t offset, size_t size) NOEXCEPT { const auto first = offset * stride; const std::span out{ &prefixes[first], size * stride }; return collect(half, out, std::span{ &valid[offset], size }); }); } /// Point (hash * sum) of each row, false on failure. bool compute(const stopper& cancel, const std::span& out, const std::span& valid, const std::span& sums, const std::span& hashes) NOEXCEPT { const auto count = sums.size(); const auto fit = silent_layout::rows(half_bytes_); const auto rows = std::min({ silent_rows_, chunk_rows, fit }); return pipeline(count, rows, false, cancel, [&](size_t half, size_t offset, size_t size) NOEXCEPT { return stage(half, sums.subspan(offset, size), hashes.subspan(offset, size)); }, [&](size_t half, size_t offset, size_t size) NOEXCEPT { return collect(half, out.subspan(offset, size), valid.subspan(offset, size)); }); } private: context() NOEXCEPT : loaded_(load()) { } template size_t launch_rows() const NOEXCEPT { if constexpr (is_same_type) return ecdsa_rows_; else return schnorr_rows_; } template handle_t kernel() const NOEXCEPT { if constexpr (is_same_type) return ecdsa_; else return schnorr_; } // Stage the rows in a half and queue the kernel over them on its stream. template result_t stage(size_t half, const std::span& digests, const std::span& keys, const std::span& signatures) NOEXCEPT { const auto size = keys.size(); const auto base = staging_ + half * half_bytes_; const auto stream = streams_[half]; const layout columns{ size }; typename layout::arguments arguments { reinterpret_cast(base), reinterpret_cast(base + columns.keys), reinterpret_cast(base + columns.signatures), reinterpret_cast(base + columns.results), possible_narrow_cast(size) }; void* parameters[]{ &arguments }; const auto blocks = possible_narrow_cast( ceilinged_divide(size, threads)); auto result = call_.copy_to_async(base, digests.data(), digests.size_bytes(), stream); if (result == success) result = call_.copy_to_async(base + columns.keys, keys.data(), keys.size_bytes(), stream); if (result == success) result = call_.copy_to_async(base + columns.signatures, signatures.data(), signatures.size_bytes(), stream); if (result == success) result = call_.launch(kernel(), blocks, 1, 1, possible_narrow_cast(threads), 1, 1, 0, stream, parameters, nullptr); return result; } // Return the results of the rows staged in a half, once computed. template result_t collect(size_t half, const std::span& results) NOEXCEPT { const auto base = staging_ + half * half_bytes_; const layout columns{ results.size() }; auto result = call_.copy_from_async(results.data(), base + columns.results, results.size(), streams_[half]); if (result == success) result = call_.stream_synchronize(streams_[half]); return result; } // Stage the rows, run the kernel over them, and return their results. template result_t launch(const std::span& results, const std::span& digests, const std::span& keys, const std::span& signatures) NOEXCEPT { auto result = call_.context_current(context_); if (result == success) result = stage(zero, digests, keys, signatures); if (result == success) result = collect(zero, results); return result; } // Stage each chunk in a half while the prior computes in the other, // collecting the prior before staging the next, and yielding the device // between chunks to a caller that would be served ahead. template bool pipeline(size_t count, size_t rows, bool urgent, const stopper& cancel, Stage&& stage, Collect&& collect) NOEXCEPT { turn turn{ turns_, urgent }; if (failed_.load() || is_zero(rows)) return false; auto result = call_.context_current(context_); size_t prior{}, prior_size{}, prior_half{}, chunk{}; for (size_t offset{}; result == success && offset < count; offset += rows, ++chunk) { if (cancel) break; if (turn.contended()) { if (!is_zero(prior_size)) result = collect(prior_half, prior, prior_size); prior_size = zero; if (result != success) break; turn.yield(); if (failed_.load()) return false; result = call_.context_current(context_); if (result != success) break; } const auto size = std::min(rows, count - offset); const auto half = chunk % two; result = stage(half, offset, size); if (result == success && !is_zero(prior_size)) result = collect(prior_half, prior, prior_size); prior = offset; prior_size = size; prior_half = half; } if (result == success && !cancel && !is_zero(prior_size)) result = collect(prior_half, prior, prior_size); if (result == success) result = call_.stream_synchronize(streams_.front()); if (result == success) result = call_.stream_synchronize(streams_.back()); if (result != success) { failed_.store(true); return false; } return true; } // Stage the points in a half and queue the scan over them. result_t stage(size_t half, const std::span& points, scan_arguments arguments) NOEXCEPT { const auto size = points.size(); const auto stride = add1(size_t{ arguments.label_count }); const auto base = staging_ + half * half_bytes_; const auto stream = streams_[half]; const scan_layout columns{ size, stride }; arguments.points = reinterpret_cast(base); arguments.prefixes = reinterpret_cast(base + columns.prefixes); arguments.valid = reinterpret_cast(base + columns.valid); arguments.count = possible_narrow_cast(size); void* parameters[]{ &arguments }; const auto blocks = possible_narrow_cast( ceilinged_divide(size, threads)); auto result = call_.copy_to_async(base, points.data(), points.size_bytes(), stream); if (result == success) result = call_.launch(scan_, blocks, 1, 1, possible_narrow_cast(threads), 1, 1, 0, stream, parameters, nullptr); return result; } // Stage the sums and hashes in a half and queue the points over them. result_t stage(size_t half, const std::span& sums, const std::span& hashes) NOEXCEPT { const auto size = sums.size(); const auto base = staging_ + half * half_bytes_; const auto stream = streams_[half]; const silent_layout columns{ size }; silent_arguments arguments { reinterpret_cast(base), reinterpret_cast(base + columns.hashes), reinterpret_cast(base + columns.points), reinterpret_cast(base + columns.valid), possible_narrow_cast(size) }; void* parameters[]{ &arguments }; const auto blocks = possible_narrow_cast( ceilinged_divide(size, threads)); auto result = call_.copy_to_async(base, sums.data(), sums.size_bytes(), stream); if (result == success) result = call_.copy_to_async(base + columns.hashes, hashes.data(), hashes.size_bytes(), stream); if (result == success) result = call_.launch(silent_, blocks, 1, 1, possible_narrow_cast(threads), 1, 1, 0, stream, parameters, nullptr); return result; } // Return the points and validity of the rows staged in a half. result_t collect(size_t half, const std::span& points, const std::span& valid) NOEXCEPT { const auto base = staging_ + half * half_bytes_; const silent_layout columns{ valid.size() }; auto result = call_.copy_from_async(points.data(), base + columns.points, points.size_bytes(), streams_[half]); if (result == success) result = call_.copy_from_async(valid.data(), base + columns.valid, valid.size(), streams_[half]); if (result == success) result = call_.stream_synchronize(streams_[half]); return result; } // Return the prefixes and validity of the points staged in a half. result_t collect(size_t half, const std::span& prefixes, const std::span& valid) NOEXCEPT { const auto stride = prefixes.size() / valid.size(); const auto base = staging_ + half * half_bytes_; const scan_layout columns{ valid.size(), stride }; auto result = call_.copy_from_async(prefixes.data(), base + columns.prefixes, prefixes.size_bytes(), streams_[half]); if (result == success) result = call_.copy_from_async(valid.data(), base + columns.valid, valid.size(), streams_[half]); if (result == success) result = call_.stream_synchronize(streams_[half]); return result; } bool load() NOEXCEPT { const auto library = load_library(); if (is_null(library) || !resolve(call_, library) || call_.init(0) != success) return false; int count{}; if (call_.device_count(&count) != success) return false; for (int ordinal{}; ordinal < count; ++ordinal) { int major{}, minor{}; if (call_.device_get(&device_, ordinal) == success && call_.device_attribute(&major, compute_major, device_) == success && call_.device_attribute(&minor, compute_minor, device_) == success && (major > 7 || (major == 7 && minor >= 5))) return open(); } return false; } bool open() NOEXCEPT { if (call_.context_retain(&context_, device_) != success) return false; retained_ = true; std::string ptx{}; pointer_t table{}, comb{}; size_t size{}, comb_bytes{}; if (!inflate(ptx) || call_.context_current(context_) != success || call_.context_limit(stack_limit, stack_bytes) != success || call_.module_load(&module_, ptx.c_str()) != success || call_.module_function(&ecdsa_, module_, "verify_ecdsa") != success || call_.module_function(&schnorr_, module_, "verify_schnorr") != success || call_.module_function(&scan_, module_, "scan_silent") != success || call_.module_function(&silent_, module_, "compute_silent") != success || call_.module_global(&table, &size, module_, "generator_table") != success || size != shape::table_bytes || call_.module_global(&comb, &comb_bytes, module_, "comb_table") != success || comb_bytes != shape::comb_bytes) return false; for (size_t slice{}; slice < generator_slices.size(); ++slice) if (call_.copy_to(table + slice * shape::slice_bytes, generator_slices[slice], shape::slice_bytes) != success) return false; for (size_t part{}; part < comb_parts.size(); ++part) if (call_.copy_to(comb + part * shape::part_bytes, comb_parts[part], shape::part_bytes) != success) return false; size_t free{}, total{}; if (call_.memory(&free, &total) != success) return false; const auto bytes = std::min(maximum_bytes, free / memory_share); half_bytes_ = bytes / two; if (layout::rows(half_bytes_) < calibration_rows || call_.allocate(&staging_, bytes) != success || call_.stream_create(&streams_.front(), non_blocking) != success || call_.stream_create(&streams_.back(), non_blocking) != success) return false; int limited{}; if (call_.device_attribute(&limited, execution_timeout, device_) != success) return false; return calibrate_ecdsa(half_bytes_, is_nonzero(limited)) && calibrate_schnorr(half_bytes_, is_nonzero(limited)) && calibrate_scan(half_bytes_, is_nonzero(limited)) && calibrate_silent(half_bytes_, is_nonzero(limited)); } // Launch rows from capacity, bounded by launch time where limited. template size_t calibrate(const hash_digest& digest, const hash_digest& wrong, const Key& key, const ec_signature& signature, size_t bytes, bool limited) NOEXCEPT { const std::vector digests(calibration_rows, digest); const std::vector keys(calibration_rows, key); const std::vector signatures(calibration_rows, signature); using namespace std::chrono; data_chunk results(calibration_rows); const auto start = steady_clock::now(); if (launch(results, digests, keys, signatures) != success) return zero; const auto elapsed = steady_clock::now() - start; if (!std::ranges::all_of(results, [](uint8_t value) NOEXCEPT { return is_one(value); })) return zero; uint8_t result{ 1 }; if (launch(std::span{ &result, one }, std::span{ &wrong, one }, std::span{ keys }.first(one), std::span{ signatures }.first(one)) != success || !is_zero(result)) return zero; return limit_rows(layout::rows(bytes), limited, elapsed); } // Rows of capacity, bounded by calibrated launch time where limited. static size_t limit_rows(size_t capacity, bool limited, const std::chrono::steady_clock::duration& elapsed) NOEXCEPT { using namespace std::chrono; if (!limited) return capacity; const auto count = duration_cast(elapsed).count(); const auto measured = greater(one, count); const auto target = duration_cast(launch_time).count(); const auto targeted = possible_sign_cast(target); const auto rows = calibration_rows * targeted / measured; return limit(rows, threads, capacity); } bool calibrate_ecdsa(size_t bytes, bool limited) NOEXCEPT { constexpr ec_secret secret{ 0x01 }; constexpr hash_digest digest{ 0x02 }; constexpr hash_digest wrong{ 0x03 }; ec_compressed key{}; ec_signature signature{}; if (!secret_to_public(key, secret) || !ecdsa::sign(signature, secret, digest)) return false; ecdsa_rows_ = calibrate(digest, wrong, key, signature, bytes, limited); return !is_zero(ecdsa_rows_); } bool calibrate_schnorr(size_t bytes, bool limited) NOEXCEPT { constexpr ec_secret secret{ 0x01 }; constexpr hash_digest message{ 0x02 }; constexpr hash_digest wrong{ 0x03 }; ec_compressed point{}; ec_xonly key{}; ec_signature signature{}; if (!secret_to_public(point, secret) || !schnorr::sign(signature, secret, message, null_hash)) return false; std::copy_n(std::next(point.cbegin()), key.size(), key.begin()); schnorr_rows_ = calibrate(message, wrong, key, signature, bytes, limited); return !is_zero(schnorr_rows_); } // BIP352 receiving vector "Simple send: two inputs", whose point pays // the receiver's unlabeled output key 3e9fce73d4e77a48... bool calibrate_scan(size_t bytes, bool limited) NOEXCEPT { constexpr ec_compressed point = base16_array( "024ac253c216532e961988e2a8ce266a447c894c781e52ef6cee902361db960004"); constexpr ec_secret secret = base16_array( "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3"); constexpr prefix expected = base16_array("3e9fce73d4e77a48"); scan_arguments arguments{}; scan::batch::receiver keys{}; keys.scan = base16_array( "0f694e068028a717f8af6b9411f9a133dd3565258714cc226594b34db90c1f2c"); if (!secret_to_public(keys.spend, secret) || !scan_receiver::decode(arguments, keys)) return false; using namespace std::chrono; const std::vector points(calibration_rows, point); std::vector prefixes(calibration_rows); data_chunk valid(calibration_rows); const auto start = steady_clock::now(); if (call_.context_current(context_) != success || stage(zero, points, arguments) != success || collect(zero, prefixes, valid) != success) return false; const auto elapsed = steady_clock::now() - start; if (!std::ranges::all_of(valid, [](uint8_t value) NOEXCEPT { return is_one(value); }) || !std::ranges::all_of(prefixes, [&](const prefix& value) NOEXCEPT { return value == expected; })) return false; const auto capacity = scan_layout::rows(bytes, one); scan_rows_ = limit_rows(capacity, limited, elapsed); return true; } bool calibrate_silent(size_t bytes, bool limited) NOEXCEPT { constexpr ec_secret secret{ 0x01 }; constexpr ec_secret hash = base16_array( "9d6ad855ce3417ef84e836892e5a56392bfba05fa5d97ccea30e266f540e08b3"); ec_compressed sum{}; if (!secret_to_public(sum, secret)) return false; auto expected = sum; if (!ec_multiply(expected, hash)) return false; using namespace std::chrono; const std::vector sums(calibration_rows, sum); const std::vector hashes(calibration_rows, hash); std::vector points(calibration_rows); data_chunk valid(calibration_rows); const auto start = steady_clock::now(); if (call_.context_current(context_) != success || stage(zero, sums, hashes) != success || collect(zero, points, valid) != success) return false; const auto elapsed = steady_clock::now() - start; constexpr auto rows = to_signed(calibration_rows); if (std::ranges::count(valid, one) != rows || std::ranges::count(points, expected) != rows) return false; const auto capacity = silent_layout::rows(bytes); silent_rows_ = limit_rows(capacity, limited, elapsed); return true; } functions call_{}; device_t device_{}; handle_t context_{}; handle_t module_{}; handle_t ecdsa_{}; handle_t schnorr_{}; handle_t scan_{}; handle_t silent_{}; pointer_t staging_{}; size_t half_bytes_{}; std_array streams_{}; size_t ecdsa_rows_{}; size_t schnorr_rows_{}; size_t scan_rows_{}; size_t silent_rows_{}; bool retained_{}; turns turns_{}; std::atomic_bool failed_{}; const bool loaded_; }; BC_POP_WARNING() BC_POP_WARNING() BC_POP_WARNING() BC_POP_WARNING() } // namespace cuda } // namespace secp256k1 } // namespace system } // namespace libbitcoin #endif 12:["$","$L29",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":"src/crypto/secp256k1/cuda/context.hpp","target":{"kind":"file","file":{"path":"src/crypto/secp256k1/cuda/context.hpp","size":26332,"content":"$2a","tooLarge":false,"binary":false,"htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/blob/121d29eceaf821490dfef9f329758891c584ae57/src/crypto/secp256k1/cuda/context.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}],"src":[{"name":"chain","path":"src/chain","type":"dir","size":null},{"name":"config","path":"src/config","type":"dir","size":null},{"name":"crypto","path":"src/crypto","type":"dir","size":null},{"name":"data","path":"src/data","type":"dir","size":null},{"name":"endian","path":"src/endian","type":"dir","size":null},{"name":"error","path":"src/error","type":"dir","size":null},{"name":"filter","path":"src/filter","type":"dir","size":null},{"name":"hash","path":"src/hash","type":"dir","size":null},{"name":"math","path":"src/math","type":"dir","size":null},{"name":"radix","path":"src/radix","type":"dir","size":null},{"name":"serial","path":"src/serial","type":"dir","size":null},{"name":"stream","path":"src/stream","type":"dir","size":null},{"name":"unicode","path":"src/unicode","type":"dir","size":null},{"name":"wallet","path":"src/wallet","type":"dir","size":null},{"name":"words","path":"src/words","type":"dir","size":null},{"name":"x509","path":"src/x509","type":"dir","size":null},{"name":"arena.cpp","path":"src/arena.cpp","type":"file","size":2137},{"name":"define.cpp","path":"src/define.cpp","type":"file","size":5804},{"name":"execution.cpp","path":"src/execution.cpp","type":"file","size":2110},{"name":"settings.cpp","path":"src/settings.cpp","type":"file","size":32380}],"src/crypto":[{"name":"secp256k1","path":"src/crypto/secp256k1","type":"dir","size":null},{"name":"shamir","path":"src/crypto/shamir","type":"dir","size":null},{"name":"aes_gcm.cpp","path":"src/crypto/aes_gcm.cpp","type":"file","size":1091},{"name":"chacha20_poly1305.cpp","path":"src/crypto/chacha20_poly1305.cpp","type":"file","size":4952},{"name":"chacha20.cpp","path":"src/crypto/chacha20.cpp","type":"file","size":14427},{"name":"der_parser.cpp","path":"src/crypto/der_parser.cpp","type":"file","size":5654},{"name":"fschacha20_poly1305.cpp","path":"src/crypto/fschacha20_poly1305.cpp","type":"file","size":2403},{"name":"fschacha20.cpp","path":"src/crypto/fschacha20.cpp","type":"file","size":1729},{"name":"maybe_random.cpp","path":"src/crypto/maybe_random.cpp","type":"file","size":2520},{"name":"poly1305.cpp","path":"src/crypto/poly1305.cpp","type":"file","size":18714},{"name":"salsa20.cpp","path":"src/crypto/salsa20.cpp","type":"file","size":5970},{"name":"x25519.cpp","path":"src/crypto/x25519.cpp","type":"file","size":8721},{"name":"xsalsa20_poly1305.cpp","path":"src/crypto/xsalsa20_poly1305.cpp","type":"file","size":2948}],"src/crypto/secp256k1":[{"name":"batch","path":"src/crypto/secp256k1/batch","type":"dir","size":null},{"name":"cuda","path":"src/crypto/secp256k1/cuda","type":"dir","size":null},{"name":"generator","path":"src/crypto/secp256k1/generator","type":"dir","size":null},{"name":"algorithm.cpp","path":"src/crypto/secp256k1/algorithm.cpp","type":"file","size":2256},{"name":"ec_context.cpp","path":"src/crypto/secp256k1/ec_context.cpp","type":"file","size":2234},{"name":"ec_context.hpp","path":"src/crypto/secp256k1/ec_context.hpp","type":"file","size":1854},{"name":"ecdsa.cpp","path":"src/crypto/secp256k1/ecdsa.cpp","type":"file","size":6838},{"name":"ellswift.cpp","path":"src/crypto/secp256k1/ellswift.cpp","type":"file","size":2417},{"name":"interface.cpp","path":"src/crypto/secp256k1/interface.cpp","type":"file","size":36128},{"name":"interface.hpp","path":"src/crypto/secp256k1/interface.hpp","type":"file","size":9136},{"name":"keys.cpp","path":"src/crypto/secp256k1/keys.cpp","type":"file","size":4263},{"name":"math.cpp","path":"src/crypto/secp256k1/math.cpp","type":"file","size":6451},{"name":"recover.cpp","path":"src/crypto/secp256k1/recover.cpp","type":"file","size":3462},{"name":"schnorr.cpp","path":"src/crypto/secp256k1/schnorr.cpp","type":"file","size":3384},{"name":"serialize.hpp","path":"src/crypto/secp256k1/serialize.hpp","type":"file","size":2008}],"src/crypto/secp256k1/cuda":[{"name":"context.hpp","path":"src/crypto/secp256k1/cuda/context.hpp","type":"file","size":26332},{"name":"driver.cpp","path":"src/crypto/secp256k1/cuda/driver.cpp","type":"file","size":3153},{"name":"driver.hpp","path":"src/crypto/secp256k1/cuda/driver.hpp","type":"file","size":2609},{"name":"kernels.cu","path":"src/crypto/secp256k1/cuda/kernels.cu","type":"file","size":8791},{"name":"kernels.hpp","path":"src/crypto/secp256k1/cuda/kernels.hpp","type":"file","size":2822},{"name":"layout.hpp","path":"src/crypto/secp256k1/cuda/layout.hpp","type":"file","size":5194},{"name":"library.hpp","path":"src/crypto/secp256k1/cuda/library.hpp","type":"file","size":6308},{"name":"ptx.cpp","path":"src/crypto/secp256k1/cuda/ptx.cpp","type":"file","size":1833830},{"name":"ptx.hpp","path":"src/crypto/secp256k1/cuda/ptx.hpp","type":"file","size":1331},{"name":"turns.hpp","path":"src/crypto/secp256k1/cuda/turns.hpp","type":"file","size":2945}]},"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":[],"fileInDiff":false,"atHead":true}}]