perf: eliminate allocations in verify path and add pubkey cache
Add in-place ScalarN operations (mulTo, addTo, negTo) that write to caller-provided output arrays instead of allocating. Add Glv.splitScalarInto that uses pre-allocated scratch buffers from PointScratch, eliminating ~26 LongArray allocations per call (called 2x per verify = ~52 allocs saved). Both mul and mulDoubleG now use the allocation-free split path. Pool all LongArray and MutablePoint allocations in verifySchnorr into thread-local PointScratch (verifyPx/Py/R/S/E/Rx/Ry, verifyPPoint, verifyResult). Add U256.fromBytesInto for decoding into pre-allocated arrays. Total: ~14 object allocations eliminated per verify call. Add pubkey decompression cache (256-entry direct-mapped) that skips the liftX square root (~280 field ops) for repeated pubkeys. In Nostr, the same authors are verified repeatedly, so cache hit rate is high. This saves ~13% of verify cost per cache hit. Increase benchmark warmup/iterations for more stable measurements (e.g., verifySchnorr: 200/500 -> 2000/5000). JVM benchmark result: verify ratio improved from 3.0x to 2.0x vs native C (with 100% cache hit rate on the benchmark's single pubkey). https://claude.ai/code/session_017UbWduFi1sLUsgVUMUH2nx
This commit is contained in:
Claude
@@ -71,6 +71,58 @@ internal object Glv {
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocation-free splitScalar using pre-allocated scratch from PointScratch.
|
||||
* Eliminates ~26 LongArray allocations per call (called 2× per verify = ~52 allocs saved).
|
||||
*/
|
||||
fun splitScalarInto(
|
||||
outK1: LongArray,
|
||||
outK2: LongArray,
|
||||
k: LongArray,
|
||||
w: LongArray,
|
||||
t1: LongArray,
|
||||
t2: LongArray,
|
||||
): Split {
|
||||
// c1 = mulShift384(k, G1)
|
||||
mulShift384Into(t1, k, G1, w)
|
||||
// c2 = mulShift384(k, G2)
|
||||
mulShift384Into(t2, k, G2, w)
|
||||
|
||||
// r2 = add(mul(c1, MINUS_B1), mul(c2, MINUS_B2))
|
||||
// Use outK1 as temp for mul(c1, MINUS_B1), outK2 as temp for mul(c2, MINUS_B2)
|
||||
ScalarN.mulTo(outK1, t1, MINUS_B1, w)
|
||||
ScalarN.mulTo(outK2, t2, MINUS_B2, w)
|
||||
ScalarN.addTo(outK2, outK1, outK2) // outK2 = r2
|
||||
|
||||
// r1 = add(mul(r2, MINUS_LAMBDA), k)
|
||||
ScalarN.mulTo(outK1, outK2, MINUS_LAMBDA, w)
|
||||
ScalarN.addTo(outK1, outK1, k) // outK1 = r1
|
||||
|
||||
val neg1 = U256.cmp(outK1, N_HALF) > 0
|
||||
val neg2 = U256.cmp(outK2, N_HALF) > 0
|
||||
if (neg1) ScalarN.negTo(outK1, outK1)
|
||||
if (neg2) ScalarN.negTo(outK2, outK2)
|
||||
return Split(outK1, outK2, neg1, neg2)
|
||||
}
|
||||
|
||||
/** Allocation-free mulShift384. */
|
||||
private fun mulShift384Into(
|
||||
out: LongArray,
|
||||
k: LongArray,
|
||||
g: LongArray,
|
||||
w: LongArray,
|
||||
) {
|
||||
U256.mulWide(w, k, g)
|
||||
out[0] = w[6]
|
||||
out[1] = w[7]
|
||||
out[2] = 0L
|
||||
out[3] = 0L
|
||||
if (w[5] < 0) { // bit 63 of w[5] = bit 383 (rounding)
|
||||
out[0]++
|
||||
if (out[0] == 0L) out[1]++
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== wNAF Encoding ====================
|
||||
|
||||
/**
|
||||
|
||||
@@ -346,6 +346,24 @@ internal object ECPoint {
|
||||
val batchZInv = LongArray(4)
|
||||
val batchZInv2 = LongArray(4)
|
||||
val batchZInv3 = LongArray(4)
|
||||
|
||||
// Pre-allocated scratch for Glv.splitScalar (avoids ~26 LongArray allocs per call)
|
||||
val splitWide = LongArray(8) // mulShift384 and ScalarN.mulTo scratch
|
||||
val splitT1 = LongArray(4) // temporary for mul results
|
||||
val splitT2 = LongArray(4) // temporary for mul results
|
||||
val splitK1 = LongArray(4) // output k1
|
||||
val splitK2 = LongArray(4) // output k2
|
||||
|
||||
// Pre-allocated scratch for verifySchnorr (avoids per-call allocations)
|
||||
val verifyPx = LongArray(4)
|
||||
val verifyPy = LongArray(4)
|
||||
val verifyR = LongArray(4)
|
||||
val verifyS = LongArray(4)
|
||||
val verifyE = LongArray(4)
|
||||
val verifyRx = LongArray(4)
|
||||
val verifyRy = LongArray(4)
|
||||
val verifyPPoint = MutablePoint()
|
||||
val verifyResult = MutablePoint()
|
||||
}
|
||||
|
||||
private val scratch = ScratchLocal { PointScratch() }
|
||||
@@ -563,8 +581,8 @@ internal object ECPoint {
|
||||
val wnd = 5
|
||||
val tableSize = 1 shl (wnd - 2) // 8 entries
|
||||
|
||||
// Split scalar via GLV: scalar = k₁ + k₂·λ
|
||||
val split = Glv.splitScalar(scalar)
|
||||
// Split scalar via GLV: scalar = k₁ + k₂·λ (allocation-free)
|
||||
val split = Glv.splitScalarInto(s.splitK1, s.splitK2, scalar, s.splitWide, s.splitT1, s.splitT2)
|
||||
Glv.wnafInto(s.wnaf1, s.wnafTmp, split.k1, wnd, 129)
|
||||
Glv.wnafInto(s.wnaf2, s.wnafTmp, split.k2, wnd, 129)
|
||||
val wnaf1 = s.wnaf1
|
||||
@@ -701,13 +719,14 @@ internal object ECPoint {
|
||||
val wP = 5 // Window for P-side (table built per-call, keep small)
|
||||
val pTableSize = 1 shl (wP - 2) // 8 entries for P
|
||||
|
||||
// Split scalars via GLV decomposition
|
||||
val sSplit = Glv.splitScalar(s)
|
||||
val eSplit = Glv.splitScalar(e)
|
||||
|
||||
// Build wNAF: G-side uses wider window (cached table), P-side uses w=5
|
||||
// Split scalars via GLV decomposition (allocation-free).
|
||||
// sSplit writes into splitK1/K2, then wNAF encodes them immediately
|
||||
// before eSplit overwrites the same scratch buffers.
|
||||
val sSplit = Glv.splitScalarInto(sc.splitK1, sc.splitK2, s, sc.splitWide, sc.splitT1, sc.splitT2)
|
||||
Glv.wnafInto(sc.wnaf1, sc.wnafTmp, sSplit.k1, WINDOW_G, 129)
|
||||
Glv.wnafInto(sc.wnaf2, sc.wnafTmp, sSplit.k2, WINDOW_G, 129)
|
||||
// Now safe to reuse splitK1/K2 for the e scalar
|
||||
val eSplit = Glv.splitScalarInto(sc.splitK1, sc.splitK2, e, sc.splitWide, sc.splitT1, sc.splitT2)
|
||||
Glv.wnafInto(sc.wnaf3, sc.wnafTmp, eSplit.k1, wP, 129)
|
||||
Glv.wnafInto(sc.wnaf4, sc.wnafTmp, eSplit.k2, wP, 129)
|
||||
val wnafS1 = sc.wnaf1
|
||||
|
||||
@@ -22,6 +22,10 @@ package com.vitorpamplona.quartz.utils.secp256k1
|
||||
|
||||
/**
|
||||
* Arithmetic modulo the secp256k1 group order n using LongArray(4) limbs.
|
||||
*
|
||||
* Provides both allocating (convenience) and in-place (hot-path) variants.
|
||||
* The in-place variants write results to caller-provided output arrays, avoiding
|
||||
* allocation in the inner loops of scalar multiplication and GLV decomposition.
|
||||
*/
|
||||
internal object ScalarN {
|
||||
val N =
|
||||
@@ -64,12 +68,21 @@ internal object ScalarN {
|
||||
b: LongArray,
|
||||
): LongArray {
|
||||
val r = LongArray(4)
|
||||
val carry = U256.addTo(r, a, b)
|
||||
if (carry != 0) U256.addTo(r, r, N_COMPLEMENT)
|
||||
reduceSelf(r)
|
||||
addTo(r, a, b)
|
||||
return r
|
||||
}
|
||||
|
||||
/** In-place add: out = (a + b) mod n. */
|
||||
fun addTo(
|
||||
out: LongArray,
|
||||
a: LongArray,
|
||||
b: LongArray,
|
||||
) {
|
||||
val carry = U256.addTo(out, a, b)
|
||||
if (carry != 0) U256.addTo(out, out, N_COMPLEMENT)
|
||||
reduceSelf(out)
|
||||
}
|
||||
|
||||
fun sub(
|
||||
a: LongArray,
|
||||
b: LongArray,
|
||||
@@ -89,6 +102,17 @@ internal object ScalarN {
|
||||
return reduceWide(w)
|
||||
}
|
||||
|
||||
/** In-place multiply: out = (a * b) mod n. Uses caller-provided wide buffer. */
|
||||
fun mulTo(
|
||||
out: LongArray,
|
||||
a: LongArray,
|
||||
b: LongArray,
|
||||
w: LongArray,
|
||||
) {
|
||||
U256.mulWide(w, a, b)
|
||||
reduceWideTo(out, w)
|
||||
}
|
||||
|
||||
fun neg(a: LongArray): LongArray {
|
||||
if (U256.isZero(a)) return LongArray(4)
|
||||
val r = LongArray(4)
|
||||
@@ -96,6 +120,18 @@ internal object ScalarN {
|
||||
return r
|
||||
}
|
||||
|
||||
/** In-place negate: out = (-a) mod n. Safe for out === a. */
|
||||
fun negTo(
|
||||
out: LongArray,
|
||||
a: LongArray,
|
||||
) {
|
||||
if (U256.isZero(a)) {
|
||||
for (i in 0 until 4) out[i] = 0L
|
||||
} else {
|
||||
U256.subTo(out, N, a)
|
||||
}
|
||||
}
|
||||
|
||||
fun inv(a: LongArray): LongArray {
|
||||
require(!U256.isZero(a))
|
||||
return powModN(a, N_MINUS_2)
|
||||
@@ -106,87 +142,125 @@ internal object ScalarN {
|
||||
}
|
||||
|
||||
/**
|
||||
* Reduce 512-bit product mod n.
|
||||
* Reduce 512-bit product mod n (allocating version).
|
||||
* Uses hi × 2^256 ≡ hi × N_COMPLEMENT (mod n). N_COMPLEMENT is ~129 bits.
|
||||
*/
|
||||
private fun reduceWide(w: LongArray): LongArray {
|
||||
val lo = LongArray(4)
|
||||
val hi = LongArray(4)
|
||||
for (i in 0 until 4) {
|
||||
lo[i] = w[i]
|
||||
hi[i] = w[i + 4]
|
||||
}
|
||||
if (U256.isZero(hi)) {
|
||||
reduceSelf(lo)
|
||||
return lo
|
||||
val result = LongArray(4)
|
||||
reduceWideTo(result, w)
|
||||
return result
|
||||
}
|
||||
|
||||
/**
|
||||
* Reduce 512-bit product mod n into caller-provided output.
|
||||
* Reuses the wide buffer w as scratch (caller must not need it after this call).
|
||||
*/
|
||||
private fun reduceWideTo(
|
||||
out: LongArray,
|
||||
w: LongArray,
|
||||
) {
|
||||
// Split into lo (w[0..3]) and hi (w[4..7])
|
||||
val hasHi = w[4] != 0L || w[5] != 0L || w[6] != 0L || w[7] != 0L
|
||||
if (!hasHi) {
|
||||
for (i in 0 until 4) out[i] = w[i]
|
||||
reduceSelf(out)
|
||||
return
|
||||
}
|
||||
|
||||
// Round 1: lo + hi × N_COMPLEMENT
|
||||
val hiTimesNC = LongArray(8)
|
||||
U256.mulWide(hiTimesNC, hi, N_COMPLEMENT)
|
||||
val sum = LongArray(8)
|
||||
// We reuse w[0..7] as scratch for hiTimesNC by saving lo first
|
||||
val lo0 = w[0]
|
||||
val lo1 = w[1]
|
||||
val lo2 = w[2]
|
||||
val lo3 = w[3]
|
||||
val hi0 = w[4]
|
||||
val hi1 = w[5]
|
||||
val hi2 = w[6]
|
||||
val hi3 = w[7]
|
||||
val hiArr = longArrayOf(hi0, hi1, hi2, hi3)
|
||||
|
||||
val hiTimesNC = w // reuse w as scratch
|
||||
U256.mulWide(hiTimesNC, hiArr, N_COMPLEMENT)
|
||||
|
||||
// sum = hiTimesNC + lo
|
||||
var carry = 0L
|
||||
for (i in 0 until 8) {
|
||||
val s1 = hiTimesNC[i] + if (i < 4) lo[i] else 0L
|
||||
val loVal =
|
||||
if (i == 0) {
|
||||
lo0
|
||||
} else if (i == 1) {
|
||||
lo1
|
||||
} else if (i == 2) {
|
||||
lo2
|
||||
} else if (i == 3) {
|
||||
lo3
|
||||
} else {
|
||||
0L
|
||||
}
|
||||
val s1 = hiTimesNC[i] + loVal
|
||||
val c1 = if (s1.toULong() < hiTimesNC[i].toULong()) 1L else 0L
|
||||
val s2 = s1 + carry
|
||||
val c2 = if (s2.toULong() < s1.toULong()) 1L else 0L
|
||||
sum[i] = s2
|
||||
w[i] = s2
|
||||
carry = c1 + c2
|
||||
}
|
||||
|
||||
// Round 2 if still > 256 bits
|
||||
val lo2 = LongArray(4)
|
||||
val hi2 = LongArray(4)
|
||||
for (i in 0 until 4) {
|
||||
lo2[i] = sum[i]
|
||||
hi2[i] = sum[i + 4]
|
||||
}
|
||||
if (U256.isZero(hi2)) {
|
||||
reduceSelf(lo2)
|
||||
return lo2
|
||||
// Check if round 2 needed
|
||||
val hasHi2 = w[4] != 0L || w[5] != 0L || w[6] != 0L || w[7] != 0L
|
||||
if (!hasHi2) {
|
||||
for (i in 0 until 4) out[i] = w[i]
|
||||
reduceSelf(out)
|
||||
return
|
||||
}
|
||||
|
||||
val hi2NC = LongArray(8)
|
||||
U256.mulWide(hi2NC, hi2, N_COMPLEMENT)
|
||||
// Round 2
|
||||
val hi2Arr = longArrayOf(w[4], w[5], w[6], w[7])
|
||||
val saved0 = w[0]
|
||||
val saved1 = w[1]
|
||||
val saved2 = w[2]
|
||||
val saved3 = w[3]
|
||||
val hi2NC = w
|
||||
U256.mulWide(hi2NC, hi2Arr, N_COMPLEMENT)
|
||||
|
||||
var c2 = 0L
|
||||
val result = LongArray(4)
|
||||
for (i in 0 until 4) {
|
||||
val s1 = lo2[i] + hi2NC[i]
|
||||
val c1 = if (s1.toULong() < lo2[i].toULong()) 1L else 0L
|
||||
val loVal =
|
||||
if (i == 0) {
|
||||
saved0
|
||||
} else if (i == 1) {
|
||||
saved1
|
||||
} else if (i == 2) {
|
||||
saved2
|
||||
} else {
|
||||
saved3
|
||||
}
|
||||
val s1 = loVal + hi2NC[i]
|
||||
val c1 = if (s1.toULong() < loVal.toULong()) 1L else 0L
|
||||
val s2 = s1 + c2
|
||||
val cc = if (s2.toULong() < s1.toULong()) 1L else 0L
|
||||
result[i] = s2
|
||||
out[i] = s2
|
||||
c2 = c1 + cc
|
||||
}
|
||||
// Handle remaining overflow from hi2NC[4..7] + carry
|
||||
// hi2NC[4..7] should be small (hi2 is ~129 bits, NC is ~129 bits → product ≤ 258 bits)
|
||||
// So hi2NC[4] might be non-zero but hi2NC[5..7] should be zero.
|
||||
// Fold: overflow * N_COMPLEMENT into result
|
||||
var ov = c2 + hi2NC[4]
|
||||
for (i in 5 until 8) ov += hi2NC[i]
|
||||
if (ov != 0L) {
|
||||
// ov × NC[0]
|
||||
val c0lo = ov * N_COMPLEMENT[0]
|
||||
val c0hi = unsignedMultiplyHigh(ov, N_COMPLEMENT[0])
|
||||
// ov × NC[1]
|
||||
val c1lo = ov * N_COMPLEMENT[1]
|
||||
val c1hi = unsignedMultiplyHigh(ov, N_COMPLEMENT[1])
|
||||
// ov × NC[2] = ov × 1 = ov
|
||||
val s0 = result[0] + c0lo
|
||||
val carry0 = if (s0.toULong() < result[0].toULong()) 1L else 0L
|
||||
result[0] = s0
|
||||
val s1 = result[1] + c0hi + c1lo + carry0
|
||||
val carry1 = if (s1.toULong() < result[1].toULong()) 1L else 0L
|
||||
result[1] = s1
|
||||
val s2 = result[2] + c1hi + ov + carry1
|
||||
val carry2 = if (s2.toULong() < result[2].toULong()) 1L else 0L
|
||||
result[2] = s2
|
||||
result[3] += carry2
|
||||
val s0 = out[0] + c0lo
|
||||
val carry0 = if (s0.toULong() < out[0].toULong()) 1L else 0L
|
||||
out[0] = s0
|
||||
val s1 = out[1] + c0hi + c1lo + carry0
|
||||
val carry1 = if (s1.toULong() < out[1].toULong()) 1L else 0L
|
||||
out[1] = s1
|
||||
val s2 = out[2] + c1hi + ov + carry1
|
||||
val carry2 = if (s2.toULong() < out[2].toULong()) 1L else 0L
|
||||
out[2] = s2
|
||||
out[3] += carry2
|
||||
}
|
||||
|
||||
while (U256.cmp(result, N) >= 0) U256.subTo(result, result, N)
|
||||
return result
|
||||
while (U256.cmp(out, N) >= 0) U256.subTo(out, out, N)
|
||||
}
|
||||
|
||||
private fun powModN(
|
||||
|
||||
+71
-12
@@ -99,6 +99,58 @@ object Secp256k1 {
|
||||
h + h
|
||||
}
|
||||
|
||||
// ==================== Pubkey decompression cache ====================
|
||||
//
|
||||
// liftX (square root on secp256k1) costs ~280 field ops per call. In Nostr,
|
||||
// the same pubkeys are verified repeatedly (every event from the same author).
|
||||
// This cache maps x-only pubkey bytes → decompressed (x, y) coordinates,
|
||||
// saving the sqrt for repeated pubkeys (~13% of verify cost per cache hit).
|
||||
//
|
||||
// Simple fixed-size direct-mapped cache (no LRU overhead). Size must be power of 2.
|
||||
// 256 entries × (32 + 32 + 32) bytes = ~24KB. Cache collisions just evict silently.
|
||||
private const val PUBKEY_CACHE_SIZE = 256 // power of 2
|
||||
private const val PUBKEY_CACHE_MASK = PUBKEY_CACHE_SIZE - 1
|
||||
|
||||
private class CachedPubkey(
|
||||
val keyBytes: ByteArray, // 32-byte x-only pubkey (for equality check)
|
||||
val px: LongArray, // decompressed x (4 limbs)
|
||||
val py: LongArray, // decompressed y (4 limbs)
|
||||
)
|
||||
|
||||
private val pubkeyCache = arrayOfNulls<CachedPubkey>(PUBKEY_CACHE_SIZE)
|
||||
|
||||
/**
|
||||
* liftX with caching. Returns true and fills outX/outY if the pubkey is valid.
|
||||
* On cache hit, copies the cached coordinates (2 array copies, ~trivial).
|
||||
* On cache miss, computes sqrt and stores the result.
|
||||
*/
|
||||
private fun liftXCached(
|
||||
outX: LongArray,
|
||||
outY: LongArray,
|
||||
pub: ByteArray,
|
||||
): Boolean {
|
||||
// Hash the pubkey bytes to a cache slot (use first 4 bytes as index)
|
||||
val slot =
|
||||
(
|
||||
(pub[0].toInt() and 0xFF) or
|
||||
((pub[1].toInt() and 0xFF) shl 8)
|
||||
) and PUBKEY_CACHE_MASK
|
||||
|
||||
val cached = pubkeyCache[slot]
|
||||
if (cached != null && cached.keyBytes.contentEquals(pub)) {
|
||||
// Cache hit — copy pre-computed coordinates
|
||||
cached.px.copyInto(outX)
|
||||
cached.py.copyInto(outY)
|
||||
return true
|
||||
}
|
||||
|
||||
// Cache miss — compute sqrt and store
|
||||
if (!ECPoint.liftX(outX, outY, U256.fromBytes(pub))) return false
|
||||
|
||||
pubkeyCache[slot] = CachedPubkey(pub.copyOf(), outX.copyOf(), outY.copyOf())
|
||||
return true
|
||||
}
|
||||
|
||||
// ==================== Key operations ====================
|
||||
|
||||
/** Create a 65-byte uncompressed public key (04 || x || y) from a 32-byte secret key. */
|
||||
@@ -338,13 +390,18 @@ object Secp256k1 {
|
||||
): Boolean {
|
||||
if (signature.size != 64 || pub.size != 32) return false
|
||||
|
||||
val px = LongArray(4)
|
||||
val py = LongArray(4)
|
||||
if (!ECPoint.liftX(px, py, U256.fromBytes(pub))) return false
|
||||
// Use thread-local scratch to avoid per-verify allocations.
|
||||
// Saves ~10 LongArray(4) + 2 MutablePoint = ~14 object allocations per call.
|
||||
val sc = ECPoint.getScratch()
|
||||
val px = sc.verifyPx
|
||||
val py = sc.verifyPy
|
||||
if (!liftXCached(px, py, pub)) return false
|
||||
|
||||
val r = U256.fromBytes(signature, 0)
|
||||
val r = sc.verifyR
|
||||
U256.fromBytesInto(r, signature, 0)
|
||||
if (U256.cmp(r, FieldP.P) >= 0) return false
|
||||
val s = U256.fromBytes(signature, 32)
|
||||
val s = sc.verifyS
|
||||
U256.fromBytesInto(s, signature, 32)
|
||||
if (U256.cmp(s, ScalarN.N) >= 0) return false
|
||||
|
||||
// Build challenge hash input in a single array: prefix(64) + r(32) + pub(32) + data(N)
|
||||
@@ -354,18 +411,20 @@ object Secp256k1 {
|
||||
pub.copyInto(hashInput, 96)
|
||||
data.copyInto(hashInput, 128)
|
||||
val eHash = sha256(hashInput)
|
||||
val e = ScalarN.reduce(U256.fromBytes(eHash))
|
||||
val e = sc.verifyE
|
||||
U256.fromBytesInto(e, eHash, 0)
|
||||
if (U256.cmp(e, ScalarN.N) >= 0) U256.subTo(e, e, ScalarN.N) // inline reduce
|
||||
|
||||
// R = s·G + (-e)·P via Shamir's trick
|
||||
val negE = ScalarN.neg(e)
|
||||
val pPoint = MutablePoint()
|
||||
ScalarN.negTo(e, e) // negate in-place
|
||||
val pPoint = sc.verifyPPoint
|
||||
pPoint.setAffine(px, py)
|
||||
val result = MutablePoint()
|
||||
ECPoint.mulDoubleG(result, s, pPoint, negE)
|
||||
val result = sc.verifyResult
|
||||
ECPoint.mulDoubleG(result, s, pPoint, e)
|
||||
|
||||
if (result.isInfinity()) return false
|
||||
val rx = LongArray(4)
|
||||
val ry = LongArray(4)
|
||||
val rx = sc.verifyRx
|
||||
val ry = sc.verifyRy
|
||||
if (!ECPoint.toAffine(result, rx, ry)) return false
|
||||
if (!ECPoint.hasEvenY(ry)) return false
|
||||
return U256.cmp(rx, r) == 0
|
||||
|
||||
@@ -477,9 +477,19 @@ internal object U256 {
|
||||
offset: Int,
|
||||
): LongArray {
|
||||
val r = LongArray(4)
|
||||
fromBytesInto(r, bytes, offset)
|
||||
return r
|
||||
}
|
||||
|
||||
/** Decode big-endian 32 bytes into a pre-allocated LongArray(4). */
|
||||
fun fromBytesInto(
|
||||
out: LongArray,
|
||||
bytes: ByteArray,
|
||||
offset: Int,
|
||||
) {
|
||||
for (i in 0 until 4) {
|
||||
val o = offset + 24 - i * 8
|
||||
r[i] = ((bytes[o].toLong() and 0xFF) shl 56) or
|
||||
out[i] = ((bytes[o].toLong() and 0xFF) shl 56) or
|
||||
((bytes[o + 1].toLong() and 0xFF) shl 48) or
|
||||
((bytes[o + 2].toLong() and 0xFF) shl 40) or
|
||||
((bytes[o + 3].toLong() and 0xFF) shl 32) or
|
||||
@@ -488,7 +498,6 @@ internal object U256 {
|
||||
((bytes[o + 6].toLong() and 0xFF) shl 8) or
|
||||
(bytes[o + 7].toLong() and 0xFF)
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
fun toBytes(a: LongArray): ByteArray {
|
||||
|
||||
Reference in New Issue
Block a user