From 79c0aff8355ae5a41890a1939d30c5a66995843a Mon Sep 17 00:00:00 2001 From: Dave Collins Date: Tue, 23 Jun 2026 06:44:16 -0500 Subject: [PATCH 1/5] secp256k1: Reorder field64 benchmarks. This moves some of the FieldVal64 benchmarks to match the order definition in the 10x26 field for consistency. --- dcrec/secp256k1/field64_bench_test.go | 76 +++++++++++++-------------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/dcrec/secp256k1/field64_bench_test.go b/dcrec/secp256k1/field64_bench_test.go index 1668e74139..327c487cca 100644 --- a/dcrec/secp256k1/field64_bench_test.go +++ b/dcrec/secp256k1/field64_bench_test.go @@ -6,40 +6,35 @@ package secp256k1 import "testing" -// BenchmarkField64Sqrt benchmarks calculating the square root of an unsigned -// 256-bit big-endian integer modulo the field prime with the FieldVal64 type. -func BenchmarkField64Sqrt(b *testing.B) { - // The function is constant time so any value is fine. - valHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" - f := mustFieldVal64(valHex) +// BenchmarkField64Add benchmarks adding two field values. +func BenchmarkField64Add(b *testing.B) { + a := mustFieldVal64("d2e670a19c6d753d1a6d8b20bd045df8a08fb162cf508956c31268c6d81ffdab") + c := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - var result FieldVal64 - _ = result.SquareRootVal(f) + var sum FieldVal64 + sum.Add2(a, c) } } -// BenchmarkField64Inverse benchmarks calculating the multiplicative inverse of -// an unsigned 256-bit big-endian integer modulo the field prime with the -// FieldVal64 type. -func BenchmarkField64Inverse(b *testing.B) { - // The function is constant time so any value is fine. - valHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" - f := mustFieldVal64(valHex) +// BenchmarkField64Mul benchmarks multiplying two field values. +func BenchmarkField64Mul(b *testing.B) { + a := mustFieldVal64("d2e670a19c6d753d1a6d8b20bd045df8a08fb162cf508956c31268c6d81ffdab") + c := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - f.Inverse() + var prod FieldVal64 + prod.Mul2(a, c) } } -// BenchmarkField64IsGtOrEqPrimeMinusOrder benchmarks determining whether a value -// is greater than or equal to the field prime minus the group order with the -// FieldVal64 type. -func BenchmarkField64IsGtOrEqPrimeMinusOrder(b *testing.B) { +// BenchmarkField64Sqrt benchmarks calculating the square root of an unsigned +// 256-bit big-endian integer modulo the field prime with the FieldVal64 type. +func BenchmarkField64Sqrt(b *testing.B) { // The function is constant time so any value is fine. valHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" f := mustFieldVal64(valHex) @@ -47,44 +42,49 @@ func BenchmarkField64IsGtOrEqPrimeMinusOrder(b *testing.B) { b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - _ = f.IsGtOrEqPrimeMinusOrder() + var result FieldVal64 + _ = result.SquareRootVal(f) } } -// BenchmarkField64Add benchmarks adding two field values. -func BenchmarkField64Add(b *testing.B) { - a := mustFieldVal64("d2e670a19c6d753d1a6d8b20bd045df8a08fb162cf508956c31268c6d81ffdab") - c := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") +// BenchmarkField64Square benchmarks squaring a field value. +func BenchmarkField64Square(b *testing.B) { + a := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - var sum FieldVal64 - sum.Add2(a, c) + var sq FieldVal64 + sq.SquareVal(a) } } -// BenchmarkField64Mul benchmarks multiplying two field values. -func BenchmarkField64Mul(b *testing.B) { - a := mustFieldVal64("d2e670a19c6d753d1a6d8b20bd045df8a08fb162cf508956c31268c6d81ffdab") - c := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") +// BenchmarkField64Inverse benchmarks calculating the multiplicative inverse of +// an unsigned 256-bit big-endian integer modulo the field prime with the +// FieldVal64 type. +func BenchmarkField64Inverse(b *testing.B) { + // The function is constant time so any value is fine. + valHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" + f := mustFieldVal64(valHex) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - var prod FieldVal64 - prod.Mul2(a, c) + f.Inverse() } } -// BenchmarkField64Square benchmarks squaring a field value. -func BenchmarkField64Square(b *testing.B) { - a := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") +// BenchmarkField64IsGtOrEqPrimeMinusOrder benchmarks determining whether a value +// is greater than or equal to the field prime minus the group order with the +// FieldVal64 type. +func BenchmarkField64IsGtOrEqPrimeMinusOrder(b *testing.B) { + // The function is constant time so any value is fine. + valHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" + f := mustFieldVal64(valHex) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - var sq FieldVal64 - sq.SquareVal(a) + _ = f.IsGtOrEqPrimeMinusOrder() } } From feb05ab18579c160d02149c549b9feaac0393eff Mon Sep 17 00:00:00 2001 From: Dave Collins Date: Tue, 23 Jun 2026 06:50:24 -0500 Subject: [PATCH 2/5] secp256k1: Consistent field64 benchmark comments. --- dcrec/secp256k1/field64_bench_test.go | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/dcrec/secp256k1/field64_bench_test.go b/dcrec/secp256k1/field64_bench_test.go index 327c487cca..ddd2aa0c9e 100644 --- a/dcrec/secp256k1/field64_bench_test.go +++ b/dcrec/secp256k1/field64_bench_test.go @@ -6,7 +6,8 @@ package secp256k1 import "testing" -// BenchmarkField64Add benchmarks adding two field values. +// BenchmarkField64Add benchmarks adding two unsigned 256-bit big-endian +// integers modulo the field prime with [FieldVal64]. func BenchmarkField64Add(b *testing.B) { a := mustFieldVal64("d2e670a19c6d753d1a6d8b20bd045df8a08fb162cf508956c31268c6d81ffdab") c := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") @@ -19,7 +20,8 @@ func BenchmarkField64Add(b *testing.B) { } } -// BenchmarkField64Mul benchmarks multiplying two field values. +// BenchmarkField64Mul benchmarks multiplying two unsigned 256-bit big-endian +// integers modulo the field prime with [FieldVal64]. func BenchmarkField64Mul(b *testing.B) { a := mustFieldVal64("d2e670a19c6d753d1a6d8b20bd045df8a08fb162cf508956c31268c6d81ffdab") c := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") @@ -47,7 +49,8 @@ func BenchmarkField64Sqrt(b *testing.B) { } } -// BenchmarkField64Square benchmarks squaring a field value. +// BenchmarkField64Square benchmarks squaring a 256-bit big-endian integer +// modulo the field prime with [FieldVal64]. func BenchmarkField64Square(b *testing.B) { a := mustFieldVal64("16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca") @@ -60,8 +63,8 @@ func BenchmarkField64Square(b *testing.B) { } // BenchmarkField64Inverse benchmarks calculating the multiplicative inverse of -// an unsigned 256-bit big-endian integer modulo the field prime with the -// FieldVal64 type. +// an unsigned 256-bit big-endian integer modulo the field prime with +// [FieldVal64]. func BenchmarkField64Inverse(b *testing.B) { // The function is constant time so any value is fine. valHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" @@ -74,9 +77,9 @@ func BenchmarkField64Inverse(b *testing.B) { } } -// BenchmarkField64IsGtOrEqPrimeMinusOrder benchmarks determining whether a value -// is greater than or equal to the field prime minus the group order with the -// FieldVal64 type. +// BenchmarkField64IsGtOrEqPrimeMinusOrder benchmarks determining whether a +// value is greater than or equal to the field prime minus the group order with +// [FieldVal64]. func BenchmarkField64IsGtOrEqPrimeMinusOrder(b *testing.B) { // The function is constant time so any value is fine. valHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" From 37afa07733fa347d71d610565acb6b4316921f75 Mon Sep 17 00:00:00 2001 From: Dave Collins Date: Tue, 23 Jun 2026 06:51:10 -0500 Subject: [PATCH 3/5] secp256k1: Add field64 negate benchmark. --- dcrec/secp256k1/field64_bench_test.go | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/dcrec/secp256k1/field64_bench_test.go b/dcrec/secp256k1/field64_bench_test.go index ddd2aa0c9e..813e210bb1 100644 --- a/dcrec/secp256k1/field64_bench_test.go +++ b/dcrec/secp256k1/field64_bench_test.go @@ -6,6 +6,21 @@ package secp256k1 import "testing" +// BenchmarkField64Negate benchmarks calculating the additive inverse of an +// unsigned 256-bit big-endian integer modulo the field prime with [FieldVal64]. +func BenchmarkField64Negate(b *testing.B) { + // The function is constant time so any value is fine. + valHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" + f := mustFieldVal64(valHex) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var result FieldVal64 + _ = result.NegateVal(f) + } +} + // BenchmarkField64Add benchmarks adding two unsigned 256-bit big-endian // integers modulo the field prime with [FieldVal64]. func BenchmarkField64Add(b *testing.B) { From 9aa4ebfd2465ad9eff21ef24d4dbf30b83f7b0bd Mon Sep 17 00:00:00 2001 From: Dave Collins Date: Tue, 30 Jun 2026 19:24:54 -0500 Subject: [PATCH 4/5] secp256k1: Add field64 mulint benchmark. --- dcrec/secp256k1/field64_bench_test.go | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/dcrec/secp256k1/field64_bench_test.go b/dcrec/secp256k1/field64_bench_test.go index 813e210bb1..e26d24bbfe 100644 --- a/dcrec/secp256k1/field64_bench_test.go +++ b/dcrec/secp256k1/field64_bench_test.go @@ -35,6 +35,19 @@ func BenchmarkField64Add(b *testing.B) { } } +// BenchmarkFieldMulInt benchmarks multiplying an unsigned 256-bit big-endian +// integer by small integers with [FieldVal64.MulInt]. +func BenchmarkField64MulInt(b *testing.B) { + fHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" + f := mustFieldVal64(fHex) + + b.ResetTimer() + b.ReportAllocs() + for i := 0; i < b.N; i++ { + f.MulInt(2) + } +} + // BenchmarkField64Mul benchmarks multiplying two unsigned 256-bit big-endian // integers modulo the field prime with [FieldVal64]. func BenchmarkField64Mul(b *testing.B) { From 46b523adcbdc5d86ebc3a67ed70071037d53fbd7 Mon Sep 17 00:00:00 2001 From: Dave Collins Date: Tue, 23 Jun 2026 06:56:43 -0500 Subject: [PATCH 5/5] secp256k1: Add field64 mulbyx benchmarks. --- dcrec/secp256k1/field64_bench_test.go | 56 ++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/dcrec/secp256k1/field64_bench_test.go b/dcrec/secp256k1/field64_bench_test.go index e26d24bbfe..e35e4e5e75 100644 --- a/dcrec/secp256k1/field64_bench_test.go +++ b/dcrec/secp256k1/field64_bench_test.go @@ -4,7 +4,9 @@ package secp256k1 -import "testing" +import ( + "testing" +) // BenchmarkField64Negate benchmarks calculating the additive inverse of an // unsigned 256-bit big-endian integer modulo the field prime with [FieldVal64]. @@ -35,6 +37,58 @@ func BenchmarkField64Add(b *testing.B) { } } +// BenchmarkField64MulBy2 benchmarks multiplying an unsigned 256-bit big-endian +// integer by 2 with [FieldVal64.MulBy2]. +func BenchmarkField64MulBy2(b *testing.B) { + fHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" + f := mustFieldVal64(fHex) + + b.ResetTimer() + b.ReportAllocs() + for i := 0; i < b.N; i++ { + f.MulBy2() + } +} + +// BenchmarkField64MulBy3 benchmarks multiplying an unsigned 256-bit big-endian +// integer by 3 with [FieldVal64.MulBy3]. +func BenchmarkField64MulBy3(b *testing.B) { + fHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" + f := mustFieldVal64(fHex) + + b.ResetTimer() + b.ReportAllocs() + for i := 0; i < b.N; i++ { + f.MulBy3() + } +} + +// BenchmarkField64MulBy4 benchmarks multiplying an unsigned 256-bit big-endian +// integer by 4 with [FieldVal64.MulBy4]. +func BenchmarkField64MulBy4(b *testing.B) { + fHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" + f := mustFieldVal64(fHex) + + b.ResetTimer() + b.ReportAllocs() + for i := 0; i < b.N; i++ { + f.MulBy4() + } +} + +// BenchmarkField64MulBy8 benchmarks multiplying an unsigned 256-bit big-endian +// integer by 8 with [FieldVal64.MulBy8]. +func BenchmarkField64MulBy8(b *testing.B) { + fHex := "16fb970147a9acc73654d4be233cc48b875ce20a2122d24f073d29bd28805aca" + f := mustFieldVal64(fHex) + + b.ResetTimer() + b.ReportAllocs() + for i := 0; i < b.N; i++ { + f.MulBy8() + } +} + // BenchmarkFieldMulInt benchmarks multiplying an unsigned 256-bit big-endian // integer by small integers with [FieldVal64.MulInt]. func BenchmarkField64MulInt(b *testing.B) {