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/2l43yyot7shmw.js","/_next/static/chunks/29v1ttach42xh.js","/_next/static/chunks/2ziic7alkvd8r.js","/_next/static/chunks/1hplpmn3-d0tx.js"],"CodeWorkspace"] 2b:T3162,/** * 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_CRYPTO_SECP256K1_ALGORITHM_GROUP_IPP #define LIBBITCOIN_SYSTEM_CRYPTO_SECP256K1_ALGORITHM_GROUP_IPP // Based on: // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html namespace libbitcoin { namespace system { namespace secp256k1 { // Group arithmetic. // ---------------------------------------------------------------------------- // protected // m = 3x^2, s = 4xy^2, x3 = m^2 - 2s, y3 = m(s - x3) - 8y^4, z3 = 2yz, which // integrally is scaled by 1/2 as l = m / 2, t = -xy^2, x3 = l^2 + 2t, // y3 = -(l(x3 + t) + y^4), z3 = yz. template constexpr void algorithm::double_(jacobian_t& r, const jacobian_t& a) NOEXCEPT { if constexpr (is_same_type) { field_t yy{}, l{}, t{}, x3{}, y3{}, z3{}; multiply(z3, a.y, a.z); square(yy, a.y); square(l, a.x); scale<3>(l, l); halve(l, l); negate(t, yy); multiply(t, t, a.x); square(x3, l); add(x3, x3, t); add(x3, x3, t); square(yy, yy); add(t, t, x3); multiply(y3, t, l); add(y3, y3, yy); negate<2>(y3, y3); r = { x3, y3, z3, a.infinity }; } else { field_t yy{}, xx{}, s{}, m{}, y4{}, x3{}, y3{}, z3{}, t{}; square(yy, a.y); square(xx, a.x); multiply(s, a.x, yy); scale<3>(m, xx); carry(m); square(x3, m); negate(t, s); scale<8>(t, t); add(x3, x3, t); carry(x3); scale<4>(s, s); subtract(t, s, x3); carry(t); multiply(y3, m, t); square(y4, yy); negate(y4, y4); scale<8>(y4, y4); add(y3, y3, y4); carry(y3); multiply(z3, a.y, a.z); scale<2>(z3, z3); carry(z3); r = { x3, y3, z3, a.infinity }; } } template constexpr Word algorithm::add(jacobian_t& r, const jacobian_t& a, const affine_t& b) NOEXCEPT { field_t h{}; return add(r, h, a, b, a.z); } // b is (x * s^2, y * s^3) for scale s, as z1 is replaced by z1 s in u2 and s2. template constexpr Word algorithm::add(jacobian_t& r, const jacobian_t& a, const affine_t& b, const field_t& scale) NOEXCEPT { field_t h{}, z{}; multiply(z, a.z, scale); return add(r, h, a, b, z); } // u1 = x1 z2^2, u2 = x2 z1^2, s1 = y1 z2^3, s2 = y2 z1^3, h = u2 - u1, // r = s2 - s1, v = u1 h^2, x3 = r^2 - h^3 - 2v, y3 = r(v - x3) - s1 h^3, // z3 = z1 z2 h. template constexpr Word algorithm::add(jacobian_t& r, const jacobian_t& a, const jacobian_t& b) NOEXCEPT { field_t z1z1{}, z2z2{}, u1{}, u2{}, s1{}, s2{}, h{}, rh{}, hh{}, hhh{}, v{}, x3{}, y3{}, z3{}, t{}; square(z1z1, a.z); square(z2z2, b.z); multiply(u1, a.x, z2z2); multiply(u2, b.x, z1z1); multiply(s1, a.y, b.z); multiply(s1, s1, z2z2); multiply(s2, b.y, a.z); multiply(s2, s2, z1z1); subtract(h, u2, u1); carry_extended(h); subtract(rh, s2, s1); carry_extended(rh); square(hh, h); multiply(hhh, h, hh); multiply(v, u1, hh); square(x3, rh); subtract(x3, x3, hhh); subtract(x3, x3, v); subtract(x3, x3, v); carry(x3); subtract(t, v, x3); carry_extended(t); multiply(y3, rh, t); multiply(t, s1, hhh); subtract(y3, y3, t); carry(y3); multiply(z3, a.z, b.z); multiply(z3, z3, h); const auto infinity = f::or_(a.infinity, b.infinity); r = { x3, y3, z3, f::broadcast(uint64_t{}) }; if constexpr (is_same_type) { return normalized_zero(h) | infinity; } else { field_t normal{ h }; normalize(normal); return f::or_(infinity, is_zero_element(normal)); } } // An uncomputed sum is of an infinite operand, or of equal x, where equal y // doubles and opposite y is infinity. constexpr void algorithm::add_complete(jacobian_t& r, const jacobian_t& a, const affine_t& b) NOEXCEPT { jacobian_t sum{}; const auto uncomputed = add(sum, a, b); declassify(uncomputed); if (!f::any(uncomputed)) { r = sum; return; } jacobian_t lifted{}; to_jacobian(lifted, b); add_complete(r, a, lifted); } constexpr void algorithm::add_complete(jacobian_t& r, const jacobian_t& a, const jacobian_t& b) NOEXCEPT { jacobian_t sum{}; const auto uncomputed = add(sum, a, b); declassify(uncomputed); if (!f::any(uncomputed)) { r = sum; return; } if (f::any(a.infinity)) { r = b; return; } if (f::any(b.infinity)) { r = a; return; } field_t z1z1{}, z2z2{}, s1{}, s2{}; square(z1z1, a.z); square(z2z2, b.z); multiply(s1, a.y, b.z); multiply(s1, s1, z2z2); multiply(s2, b.y, a.z); multiply(s2, s2, z1z1); normalize(s1); normalize(s2); if (f::any(equal(s1, s2))) { double_(r, a); return; } r = {}; r.infinity = max_uint64; } template constexpr void algorithm::negate(affine_t& r, const affine_t& a) NOEXCEPT { field_t y{}; negate<4>(y, a.y); carry(y); r = { a.x, y }; } template constexpr void algorithm::negate(jacobian_t& r, const jacobian_t& a) NOEXCEPT { field_t y{}; negate<4>(y, a.y); carry(y); r = { a.x, y, a.z, a.infinity }; } template constexpr void algorithm::endomorphism(affine_t& r, const affine_t& a) NOEXCEPT { field_t x{}; multiply(x, a.x, broadcast(beta)); r = { x, a.y }; } // Group conversion. // ---------------------------------------------------------------------------- // protected template constexpr void algorithm::to_jacobian(jacobian_t& r, const affine_t& a) NOEXCEPT { r = { a.x, a.y, broadcast({ 1 }), f::broadcast(uint64_t{}) }; } template constexpr void algorithm::to_jacobian(jacobian_t& r, const affine_t& a, const field_t& scale) NOEXCEPT { field_t ss{}, sss{}, x{}, y{}; square(ss, scale); multiply(sss, ss, scale); multiply(x, a.x, ss); multiply(y, a.y, sss); r = { x, y, broadcast({ 1 }), f::broadcast(uint64_t{}) }; } template constexpr void algorithm::to_affine(affine_t& r, const jacobian_t& a, const field_t& inverse_z) NOEXCEPT { field_t zz{}, zzz{}, x{}, y{}; square(zz, inverse_z); multiply(zzz, zz, inverse_z); multiply(x, a.x, zz); multiply(y, a.y, zzz); normalize(x); normalize(y); r = { x, y }; } template constexpr void algorithm::to_affine(affine_t& r, const jacobian_t& a) NOEXCEPT { field_t inverse_z{}; inverse(inverse_z, a.z); to_affine(r, a, inverse_z); } // Prefix products of z share one inversion, unwound from the last element. template constexpr void algorithm::to_affine(std_array, Count>& r, const std_array, Count>& a) NOEXCEPT { static_assert(is_nonzero(Count)); std_array, Count> prefix{}; prefix[zero] = a[zero].z; for (auto point = one; point < Count; ++point) multiply(prefix[point], prefix[sub1(point)], a[point].z); field_t inverted{}, inverse_z{}; inverse(inverted, prefix[sub1(Count)]); for (auto point = sub1(Count); is_nonzero(point); --point) { multiply(inverse_z, inverted, prefix[sub1(point)]); multiply(inverted, inverted, a[point].z); to_affine(r[point], a[point], inverse_z); } to_affine(r[zero], a[zero], inverted); } template constexpr Word algorithm::lift(affine_t& r, const field_t& x, Word odd) NOEXCEPT { field_t xx{}, xxx{}, yy{}, y{}, negated{}; square(xx, x); multiply(xxx, xx, x); add(yy, xxx, broadcast(curve_b)); carry(yy); const auto valid = square_root(y, yy); normalize(y); negate(negated, y); normalize(negated); select(y, f::xor_(is_odd_element(y), odd), negated, y); r = { x, y }; return valid; } template constexpr Word algorithm::is_on_curve(const affine_t& a) NOEXCEPT { field_t xx{}, xxx{}, right{}, left{}; square(xx, a.x); multiply(xxx, xx, a.x); add(right, xxx, broadcast(curve_b)); square(left, a.y); normalize(right); normalize(left); return equal(left, right); } // Group internals. // ---------------------------------------------------------------------------- // protected // u2 = x2 z^2, s2 = y2 z^3, h = u2 - x1, r = s2 - y1, v = x1 h^2, // x3 = r^2 - h^3 - 2v, y3 = r(v - x3) - y1 h^3, z3 = z1 h, which integrally // is of i = -r and negated h^2 as x3 = i^2 - h^3 - 2v, y3 = i(x3 - v) - y1 h^3. template constexpr Word algorithm::add(jacobian_t& r, field_t& h, const jacobian_t& a, const affine_t& b, const field_t& z) NOEXCEPT { if constexpr (is_same_type) { field_t zz{}, u2{}, s2{}, i{}, hh{}, hhh{}, t{}, x3{}, y3{}, z3{}; square(zz, z); multiply(u2, b.x, zz); multiply(s2, b.y, zz); multiply(s2, s2, z); negate<4>(h, a.x); add(h, h, u2); negate(i, s2); add(i, i, a.y); multiply(z3, a.z, h); square(hh, h); negate(hh, hh); multiply(hhh, hh, h); multiply(t, a.x, hh); square(x3, i); add(x3, x3, hhh); add(x3, x3, t); add(x3, x3, t); add(t, t, x3); multiply(y3, t, i); multiply(hhh, hhh, a.y); add(y3, y3, hhh); const auto uncomputed = normalized_zero(h) | a.infinity; r = { x3, y3, z3, 0_u64 }; return uncomputed; } else { field_t zz{}, u2{}, s2{}, rh{}, hh{}, hhh{}, v{}, x3{}, y3{}, z3{}, t{}; square(zz, z); multiply(u2, b.x, zz); multiply(s2, b.y, zz); multiply(s2, s2, z); subtract(h, u2, a.x); carry(h); subtract(rh, s2, a.y); carry(rh); square(hh, h); multiply(hhh, h, hh); multiply(v, a.x, hh); square(x3, rh); subtract(x3, x3, hhh); subtract(x3, x3, v); subtract(x3, x3, v); carry(x3); subtract(t, v, x3); carry(t); multiply(y3, rh, t); multiply(t, a.y, hhh); subtract(y3, y3, t); carry(y3); multiply(z3, a.z, h); field_t normal{ h }; normalize(normal); const auto uncomputed = f::or_(a.infinity, is_zero_element(normal)); r = { x3, y3, z3, f::broadcast(uint64_t{}) }; return uncomputed; } } template constexpr void algorithm::select(jacobian_t& r, Word mask, const jacobian_t& a, const jacobian_t& b) NOEXCEPT { select(r.x, mask, a.x, b.x); select(r.y, mask, a.y, b.y); select(r.z, mask, a.z, b.z); r.infinity = f::select(mask, a.infinity, b.infinity); } template constexpr void algorithm::negate(affine_t& r, const affine_t& a, Word mask) NOEXCEPT { field_t y{}; negate<4>(y, a.y); carry_extended(y); select(y, mask, y, a.y); r = { a.x, y }; } } // namespace secp256k1 } // namespace system } // namespace libbitcoin #endif 13:["$","$L2a",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":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_group.ipp","target":{"kind":"file","file":{"path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_group.ipp","size":12642,"content":"$2b","tooLarge":false,"binary":false,"htmlUrl":"https://github.com/libbitcoin/libbitcoin-system/blob/83147c18e3a80ab2949c2c8a7e3486950d7cfeff/include/bitcoin/system/impl/crypto/secp256k1/algorithm_group.ipp","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}],"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":17858}],"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":2551},{"name":"constants.hpp","path":"include/bitcoin/system/constants.hpp","type":"file","size":7135},{"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":1857},{"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":10753},{"name":"forks.hpp","path":"include/bitcoin/system/forks.hpp","type":"file","size":2519},{"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":12885},{"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":7284},{"name":"settings.hpp","path":"include/bitcoin/system/settings.hpp","type":"file","size":4730},{"name":"typelets.hpp","path":"include/bitcoin/system/typelets.hpp","type":"file","size":7716},{"name":"types.hpp","path":"include/bitcoin/system/types.hpp","type":"file","size":11068},{"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/impl":[{"name":"chain","path":"include/bitcoin/system/impl/chain","type":"dir","size":null},{"name":"config","path":"include/bitcoin/system/impl/config","type":"dir","size":null},{"name":"crypto","path":"include/bitcoin/system/impl/crypto","type":"dir","size":null},{"name":"data","path":"include/bitcoin/system/impl/data","type":"dir","size":null},{"name":"endian","path":"include/bitcoin/system/impl/endian","type":"dir","size":null},{"name":"filter","path":"include/bitcoin/system/impl/filter","type":"dir","size":null},{"name":"hash","path":"include/bitcoin/system/impl/hash","type":"dir","size":null},{"name":"machine","path":"include/bitcoin/system/impl/machine","type":"dir","size":null},{"name":"math","path":"include/bitcoin/system/impl/math","type":"dir","size":null},{"name":"radix","path":"include/bitcoin/system/impl/radix","type":"dir","size":null},{"name":"serial","path":"include/bitcoin/system/impl/serial","type":"dir","size":null},{"name":"stream","path":"include/bitcoin/system/impl/stream","type":"dir","size":null},{"name":"unicode","path":"include/bitcoin/system/impl/unicode","type":"dir","size":null},{"name":"wallet","path":"include/bitcoin/system/impl/wallet","type":"dir","size":null},{"name":"words","path":"include/bitcoin/system/impl/words","type":"dir","size":null}],"include/bitcoin/system/impl/crypto":[{"name":"aes","path":"include/bitcoin/system/impl/crypto/aes","type":"dir","size":null},{"name":"nist","path":"include/bitcoin/system/impl/crypto/nist","type":"dir","size":null},{"name":"secp256k1","path":"include/bitcoin/system/impl/crypto/secp256k1","type":"dir","size":null},{"name":"aes_gcm.ipp","path":"include/bitcoin/system/impl/crypto/aes_gcm.ipp","type":"file","size":4345}],"include/bitcoin/system/impl/crypto/secp256k1":[{"name":"algorithm_batch.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_batch.ipp","type":"file","size":22579},{"name":"algorithm_ellswift.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_ellswift.ipp","type":"file","size":6007},{"name":"algorithm_field.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_field.ipp","type":"file","size":19385},{"name":"algorithm_group.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_group.ipp","type":"file","size":12642},{"name":"algorithm_inversion.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_inversion.ipp","type":"file","size":10808},{"name":"algorithm_multiply.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_multiply.ipp","type":"file","size":20413},{"name":"algorithm_pippenger.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_pippenger.ipp","type":"file","size":8143},{"name":"algorithm_scalar.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_scalar.ipp","type":"file","size":12185},{"name":"algorithm_sign.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_sign.ipp","type":"file","size":7616},{"name":"algorithm_table.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_table.ipp","type":"file","size":3988},{"name":"algorithm_verify.ipp","path":"include/bitcoin/system/impl/crypto/secp256k1/algorithm_verify.ipp","type":"file","size":5401}]},"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}]