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/2l43yyot7shmw.js","/_next/static/chunks/29v1ttach42xh.js","/_next/static/chunks/2ziic7alkvd8r.js","/_next/static/chunks/1hplpmn3-d0tx.js"],"CodeWorkspace"] 2a:T4906,/** * 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_GENERATOR_GENERATOR_HPP #define LIBBITCOIN_SYSTEM_SRC_CRYPTO_SECP256K1_GENERATOR_GENERATOR_HPP // The generator table is computed at compile time in slices, one translation // unit each, as compiler memory grows with the arithmetic evaluated in a unit. // This header includes no library headers, as each unit otherwise pays for // parsing them. #include #include #include #include namespace libbitcoin { namespace system { namespace secp256k1 { namespace precompute { using word = std::uint64_t; using size = std::size_t; /// Table shape, matching the algorithm class. constexpr size slice_size = 512; constexpr size block_size = 16; constexpr size limbs = 5; constexpr size slice_blocks = slice_size / block_size; constexpr size block_words = 2 * limbs * block_size; constexpr size table_words = slice_blocks * block_words; constexpr size slice_words = table_words; /// Field element, four 64 bit words (normal). struct element { word value[4]{}; }; struct affine { element x{}; element y{}; }; struct jacobian { element x{}; element y{}; element z{}; }; constexpr element prime { { 0xfffffffefffffc2f, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff } }; constexpr word fold = 0x00000001000003d1; constexpr affine generator { { { 0x59f2815b16f81798, 0x029bfcdb2dce28d9, 0x55a06295ce870b07, 0x79be667ef9dcbbac } }, { { 0x9c47d08ffb10d4b8, 0xfd17b448a6855419, 0x5da4fbfc0e1108a8, 0x483ada7726a3c465 } } }; constexpr affine twice { { { 0xabac09b95c709ee5, 0x5c778e4b8cef3ca7, 0x3045406e95c07cd8, 0xc6047f9441ed7d6d } }, { { 0x236431a950cfe52a, 0xf7f632653266d0e1, 0xa3c58419466ceaee, 0x1ae168fea63dc339 } } }; // Field arithmetic. // ---------------------------------------------------------------------------- // high:low = a * b. constexpr void multiply(word& high, word& low, word a, word b) noexcept { constexpr word half = 0xffffffff; const auto al = a & half, ah = a >> 32; const auto bl = b & half, bh = b >> 32; const auto ll = al * bl, lh = al * bh, hl = ah * bl, hh = ah * bh; const auto middle = (ll >> 32) + (lh & half) + (hl & half); low = (middle << 32) | (ll & half); high = hh + (lh >> 32) + (hl >> 32) + (middle >> 32); } constexpr bool below_prime(const element& a) noexcept { for (size i = 4; i-- > 0;) if (a.value[i] != prime.value[i]) return a.value[i] < prime.value[i]; return false; } // r = a - p, for a not below p. constexpr element reduce(const element& a) noexcept { element r{}; word borrow{}; for (size i = 0; i < 4; ++i) { const auto subtrahend = prime.value[i] + borrow; borrow = (a.value[i] < subtrahend || subtrahend < borrow) ? 1 : 0; r.value[i] = a.value[i] - subtrahend; } return r; } // r = a + carry * 2^256, reduced. constexpr element fold_carry(element r, word carry) noexcept { while (carry != 0) { word high{}, low{}; multiply(high, low, carry, fold); word next{}; for (size i = 0; i < 4; ++i) { const auto addend = i == 0 ? low : (i == 1 ? high : 0); const auto sum = r.value[i] + addend; const word over = sum < addend ? 1 : 0; r.value[i] = sum + next; next = over + (r.value[i] < sum ? 1 : 0); } carry = next; } return below_prime(r) ? r : reduce(r); } constexpr element add(const element& a, const element& b) noexcept { element r{}; word carry{}; for (size i = 0; i < 4; ++i) { const auto sum = a.value[i] + b.value[i]; const word over = sum < a.value[i] ? 1 : 0; r.value[i] = sum + carry; carry = over + (r.value[i] < sum ? 1 : 0); } return fold_carry(r, carry); } constexpr element negate(const element& a) noexcept { element r{}; word borrow{}; auto zero = true; for (size i = 0; i < 4; ++i) { zero = zero && a.value[i] == 0; const auto subtrahend = a.value[i] + borrow; borrow = (prime.value[i] < subtrahend || subtrahend < borrow) ? 1 : 0; r.value[i] = prime.value[i] - subtrahend; } return zero ? a : r; } constexpr element subtract(const element& a, const element& b) noexcept { return add(a, negate(b)); } constexpr element multiply(const element& a, const element& b) noexcept { word product[8]{}; for (size i = 0; i < 4; ++i) { word carry{}; for (size j = 0; j < 4; ++j) { word high{}, low{}; multiply(high, low, a.value[i], b.value[j]); low += carry; high += low < carry ? 1 : 0; product[i + j] += low; high += product[i + j] < low ? 1 : 0; carry = high; } product[i + 4] = carry; } // Words above 2^256 fold by 2^256 mod p. element r{}; word carry{}; for (size i = 0; i < 4; ++i) { word high{}, low{}; multiply(high, low, product[i + 4], fold); low += carry; high += low < carry ? 1 : 0; r.value[i] = product[i] + low; high += r.value[i] < low ? 1 : 0; carry = high; } return fold_carry(r, carry); } constexpr element square(const element& a) noexcept { return multiply(a, a); } // a^(p - 2). constexpr element inverse(const element& a) noexcept { constexpr element exponent { { 0xfffffffefffffc2d, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff } }; element r{ { 1 } }; for (size i = 4; i-- > 0;) for (size bit = 64; bit-- > 0;) { r = square(r); if (((exponent.value[i] >> bit) & 1) != 0) r = multiply(r, a); } return r; } // Group arithmetic. // ---------------------------------------------------------------------------- constexpr jacobian twofold(const jacobian& a) noexcept { const auto yy = square(a.y); const auto xy = multiply(a.x, yy); const auto s = add(add(xy, xy), add(xy, xy)); const auto xx = square(a.x); const auto m = add(add(xx, xx), xx); const auto x3 = subtract(square(m), add(s, s)); auto y4 = square(yy); y4 = add(y4, y4); y4 = add(y4, y4); y4 = add(y4, y4); const auto y3 = subtract(multiply(m, subtract(s, x3)), y4); const auto z3 = multiply(add(a.y, a.y), a.z); return { x3, y3, z3 }; } // a + b, for a not b or -b. constexpr jacobian sum(const jacobian& a, const affine& b) noexcept { const auto zz = square(a.z); const auto u2 = multiply(b.x, zz); const auto s2 = multiply(b.y, multiply(zz, a.z)); const auto h = subtract(u2, a.x); const auto r = subtract(s2, a.y); const auto hh = square(h); const auto hhh = multiply(h, hh); const auto v = multiply(a.x, hh); const auto x3 = subtract(subtract(square(r), hhh), add(v, v)); const auto y3 = subtract(multiply(r, subtract(v, x3)), multiply(a.y, hhh)); const auto z3 = multiply(a.z, h); return { x3, y3, z3 }; } // Table computation. // ---------------------------------------------------------------------------- /// Odd multiples of a block and running products of their z in the slice. struct forward { jacobian points[block_size]{}; element products[block_size]{}; }; /// Affine odd multiples of a block, and inverse of the product before the /// block. struct backward { affine points[block_size]{}; element inverse{}; }; // (2 * Slice * slice_size + 1)G, the first multiple of the slice. template constexpr jacobian first() noexcept { constexpr word multiple = 2 * Slice * slice_size + 1; jacobian r{ generator.x, generator.y, { { 1 } } }; auto bit = size{ 63 }; while (((multiple >> bit) & 1) == 0) --bit; while (bit-- > 0) { r = twofold(r); if (((multiple >> bit) & 1) != 0) r = sum(r, generator); } return r; } template constexpr forward forwarded() noexcept; template constexpr backward backwarded() noexcept; template constexpr forward forwards = forwarded(); template constexpr backward backwards = backwarded(); template constexpr forward forwarded() noexcept { forward out{}; if constexpr (Block == 0) { out.points[0] = first(); out.products[0] = out.points[0].z; } else { const auto& prior = forwards; out.points[0] = sum(prior.points[block_size - 1], twice); out.products[0] = multiply(prior.products[block_size - 1], out.points[0].z); } for (size point = 1; point < block_size; ++point) { out.points[point] = sum(out.points[point - 1], twice); out.products[point] = multiply(out.products[point - 1], out.points[point].z); } return out; } // The block after the last holds only the inverse of the slice product, and // each block unwinds its prefix products into affine points. template constexpr backward backwarded() noexcept { backward out{}; if constexpr (Block == slice_blocks) { const auto& last = forwards; out.inverse = inverse(last.products[block_size - 1]); } else { const auto& chunk = forwards; out.inverse = backwards.inverse; for (size point = block_size; point-- > 0;) { element inverse_z{}; if (point != 0) inverse_z = multiply(out.inverse, chunk.products[point - 1]); else if constexpr (Block != 0) inverse_z = multiply(out.inverse, forwards.products[block_size - 1]); else inverse_z = out.inverse; out.inverse = multiply(out.inverse, chunk.points[point].z); const auto zz = square(inverse_z); out.points[point] = { multiply(chunk.points[point].x, zz), multiply(chunk.points[point].y, multiply(zz, inverse_z)) }; } } return out; } // Five 52 bit limbs of a normal element. constexpr void limbs52(word* out, size stride, const element& a) noexcept { constexpr word mask = 0x000fffffffffffff; out[0 * stride] = a.value[0] & mask; out[1 * stride] = ((a.value[0] >> 52) | (a.value[1] << 12)) & mask; out[2 * stride] = ((a.value[1] >> 40) | (a.value[2] << 24)) & mask; out[3 * stride] = ((a.value[2] >> 28) | (a.value[3] << 36)) & mask; out[4 * stride] = a.value[3] >> 16; } // Block b of a table holds x limbs then y limbs, each as a column of the block // size. template constexpr void emit(std::array& out) noexcept { const auto& chunk = backwards; const auto base = Block * block_words; for (size point = 0; point < block_size; ++point) { const auto& entry = chunk.points[point]; const auto at = base + point; limbs52(&out[at], block_size, entry.x); limbs52(&out[at + limbs * block_size], block_size, entry.y); } } template constexpr std::array slice( std::index_sequence) noexcept { std::array out{}; (emit(out), ...); return out; } template constexpr std::array slice() noexcept { return slice(std::make_index_sequence{}); } // Comb table computation. // ---------------------------------------------------------------------------- /// Comb shape, matching the algorithm class. constexpr size comb_bits = 6; constexpr size comb_size = size{ 1 } << (comb_bits - 1); constexpr size comb_windows = (256 + comb_bits) / comb_bits; constexpr size comb_part_windows = 15; constexpr size comb_words = 2 * limbs; constexpr size comb_part_words = comb_part_windows * comb_size * comb_words; constexpr affine normal(const jacobian& a) noexcept { const auto inverse_z = inverse(a.z); const auto zz = square(inverse_z); return { multiply(a.x, zz), multiply(a.y, multiply(zz, inverse_z)) }; } constexpr size comb_blocks = comb_size / block_size; template constexpr affine based() noexcept; template constexpr affine bases = based(); // 2^(comb_bits * Window) * G. template constexpr affine based() noexcept { if constexpr (Window == 0) { return generator; } else { const auto& prior = bases; jacobian r{ prior.x, prior.y, { { 1 } } }; for (size bit = 0; bit < comb_bits; ++bit) r = twofold(r); return normal(r); } } template constexpr forward comb_forwarded() noexcept; template constexpr backward comb_backwarded() noexcept; template constexpr forward comb_forwards = comb_forwarded(); template constexpr backward comb_backwards = comb_backwarded(); // Multiples 16 * Block + 1 through 16 * Block + 16 of the window base. template constexpr forward comb_forwarded() noexcept { const auto& base = bases; forward out{}; size point{}; if constexpr (Block == 0) { out.points[0] = { base.x, base.y, { { 1 } } }; out.products[0] = out.points[0].z; out.points[1] = twofold(out.points[0]); out.products[1] = multiply(out.products[0], out.points[1].z); point = 2; } else { const auto& prior = comb_forwards; out.points[0] = sum(prior.points[block_size - 1], base); out.products[0] = multiply(prior.products[block_size - 1], out.points[0].z); point = 1; } for (; point < block_size; ++point) { out.points[point] = sum(out.points[point - 1], base); out.products[point] = multiply(out.products[point - 1], out.points[point].z); } return out; } // The block after the last holds only the inverse of the window product, and // each block unwinds its prefix products into affine points. template constexpr backward comb_backwarded() noexcept { backward out{}; if constexpr (Block == comb_blocks) { const auto& last = comb_forwards; out.inverse = inverse(last.products[block_size - 1]); } else { const auto& chunk = comb_forwards; out.inverse = comb_backwards.inverse; for (size point = block_size; point-- > 0;) { element inverse_z{}; if (point != 0) inverse_z = multiply(out.inverse, chunk.products[point - 1]); else if constexpr (Block != 0) inverse_z = multiply(out.inverse, comb_forwards.products[block_size - 1]); else inverse_z = out.inverse; out.inverse = multiply(out.inverse, chunk.points[point].z); const auto zz = square(inverse_z); out.points[point] = { multiply(chunk.points[point].x, zz), multiply(chunk.points[point].y, multiply(zz, inverse_z)) }; } } return out; } // Window entry j is (j + 1) * base, x limbs then y limbs. template constexpr void comb_emit(std::array& out, size offset, std::index_sequence) noexcept { const auto emit_block = [&](const backward& chunk, size block) noexcept { for (size point = 0; point < block_size; ++point) { const auto at = offset + (block * block_size + point) * comb_words; limbs52(&out[at], 1, chunk.points[point].x); limbs52(&out[at + limbs], 1, chunk.points[point].y); } }; (emit_block(comb_backwards, Blocks), ...); } template constexpr void comb_emit(std::array& out, size offset) noexcept { if constexpr (Window < comb_windows) comb_emit(out, offset, std::make_index_sequence{}); } template constexpr std::array comb( std::index_sequence) noexcept { std::array out{}; (comb_emit(out, Windows * comb_size * comb_words), ...); return out; } template constexpr std::array comb() noexcept { return comb(std::make_index_sequence{}); } } // namespace precompute /// Generator table slices, each defined in its own translation unit. extern const std::array generator_slice_00, generator_slice_01, generator_slice_02, generator_slice_03, generator_slice_04, generator_slice_05, generator_slice_06, generator_slice_07, generator_slice_08, generator_slice_09, generator_slice_10, generator_slice_11, generator_slice_12, generator_slice_13, generator_slice_14, generator_slice_15; /// Comb table parts, each defined in its own translation unit. extern const std::array comb_part_00, comb_part_01, comb_part_02; } // 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":"83147c18e3a80ab2949c2c8a7e3486950d7cfeff","message":"Merge pull request #2109 from evoskuil/master\n\nPerf/chain parse allocations (cherry-picked from PR2090)","authorLogin":"evoskuil","authorName":"Eric Voskuil","date":"2026-10-22T16:03:52.000Z","htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/commit/83147c18e3a80ab2949c2c8a7e3486950d7cfeff","isHead":true,"headSha":"83147c18e3a80ab2949c2c8a7e3486950d7cfeff"},"gitRef":"master","path":"src/crypto/secp256k1/generator/generator.hpp","target":{"kind":"file","file":{"path":"src/crypto/secp256k1/generator/generator.hpp","size":18694,"content":"$2a","tooLarge":false,"binary":false,"htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/blob/83147c18e3a80ab2949c2c8a7e3486950d7cfeff/src/crypto/secp256k1/generator/generator.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":"examples","path":"examples","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":9727}],"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":5690},{"name":"execution.cpp","path":"src/execution.cpp","type":"file","size":2110},{"name":"settings.cpp","path":"src/settings.cpp","type":"file","size":26844}],"src/crypto":[{"name":"secp256k1","path":"src/crypto/secp256k1","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":14408},{"name":"der_parser.cpp","path":"src/crypto/der_parser.cpp","type":"file","size":7018},{"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":2517},{"name":"poly1305.cpp","path":"src/crypto/poly1305.cpp","type":"file","size":18744},{"name":"salsa20.cpp","path":"src/crypto/salsa20.cpp","type":"file","size":6080},{"name":"x25519.cpp","path":"src/crypto/x25519.cpp","type":"file","size":8765},{"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":35523},{"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":6449},{"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/generator":[{"name":"comb_00.cpp","path":"src/crypto/secp256k1/generator/comb_00.cpp","type":"file","size":1119},{"name":"comb_01.cpp","path":"src/crypto/secp256k1/generator/comb_01.cpp","type":"file","size":1119},{"name":"comb_02.cpp","path":"src/crypto/secp256k1/generator/comb_02.cpp","type":"file","size":1119},{"name":"generator.hpp","path":"src/crypto/secp256k1/generator/generator.hpp","type":"file","size":18694},{"name":"slice_00.cpp","path":"src/crypto/secp256k1/generator/slice_00.cpp","type":"file","size":1122},{"name":"slice_01.cpp","path":"src/crypto/secp256k1/generator/slice_01.cpp","type":"file","size":1122},{"name":"slice_02.cpp","path":"src/crypto/secp256k1/generator/slice_02.cpp","type":"file","size":1122},{"name":"slice_03.cpp","path":"src/crypto/secp256k1/generator/slice_03.cpp","type":"file","size":1122},{"name":"slice_04.cpp","path":"src/crypto/secp256k1/generator/slice_04.cpp","type":"file","size":1122},{"name":"slice_05.cpp","path":"src/crypto/secp256k1/generator/slice_05.cpp","type":"file","size":1122},{"name":"slice_06.cpp","path":"src/crypto/secp256k1/generator/slice_06.cpp","type":"file","size":1122},{"name":"slice_07.cpp","path":"src/crypto/secp256k1/generator/slice_07.cpp","type":"file","size":1122},{"name":"slice_08.cpp","path":"src/crypto/secp256k1/generator/slice_08.cpp","type":"file","size":1122},{"name":"slice_09.cpp","path":"src/crypto/secp256k1/generator/slice_09.cpp","type":"file","size":1122},{"name":"slice_10.cpp","path":"src/crypto/secp256k1/generator/slice_10.cpp","type":"file","size":1123},{"name":"slice_11.cpp","path":"src/crypto/secp256k1/generator/slice_11.cpp","type":"file","size":1123},{"name":"slice_12.cpp","path":"src/crypto/secp256k1/generator/slice_12.cpp","type":"file","size":1123},{"name":"slice_13.cpp","path":"src/crypto/secp256k1/generator/slice_13.cpp","type":"file","size":1123},{"name":"slice_14.cpp","path":"src/crypto/secp256k1/generator/slice_14.cpp","type":"file","size":1123},{"name":"slice_15.cpp","path":"src/crypto/secp256k1/generator/slice_15.cpp","type":"file","size":1123}]},"revisions":[{"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":null}]