chore: sync dependencies and format code

bls/bls_test.go

@@ -322,7 +322,7 @@ func TestVerifyRejectsIdentityKey(t *testing.T) {
 	// Create a zero/identity public key by constructing all-zero bytes
 	// This represents the identity point (point at infinity) in G1
 	zeroKeyBytes := make([]byte, PublicKeyLen)
-	
+
 	// Attempt to parse the zero key
 	zeroPk, err := PublicKeyFromCompressedBytes(zeroKeyBytes)
 	// If parsing fails (which is expected for identity point), the test passes

hash/blake3/blake3_c.go

@@ -1,7 +1,7 @@
 // Copyright (C) 2025, Lux Industries, Inc. All rights reserved.
 // See the file LICENSE for licensing terms.
 
-//go:build cgo && darwin
+//go:build cgo && darwin && luxcpp
 
 // Package blake3 provides Blake3 hash functions via luxcpp/crypto.
 // This CGO version provides optimized hashing with automatic CPU/GPU selection.

hash/blake3/blake3_purego.go

@@ -0,0 +1,161 @@
+// Copyright (C) 2025, Lux Industries, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+//go:build !cgo || !darwin || !luxcpp
+
+// Package blake3 provides pure Go Blake3 hash functions.
+// This is the fallback when the CGO-accelerated version is unavailable.
+package blake3
+
+import (
+	"encoding/binary"
+)
+
+const (
+	// Size256 is the standard Blake3 output size
+	Size256 = 32
+	// Size512 is extended Blake3 output size
+	Size512 = 64
+)
+
+// GPUAvailable returns false for pure Go implementation.
+func GPUAvailable() bool {
+	return false
+}
+
+// Backend returns "Go" for pure Go implementation.
+func Backend() string {
+	return "Go"
+}
+
+// Sum256 computes a 32-byte Blake3 hash using zeebo/blake3.
+func Sum256(data []byte) [Size256]byte {
+	h := New()
+	h.Write(data)
+	var out [Size256]byte
+	h.Reader().Read(out[:])
+	return out
+}
+
+// Sum512 computes a 64-byte Blake3 hash using XOF mode.
+func Sum512(data []byte) [Size512]byte {
+	h := New()
+	h.Write(data)
+	var out [Size512]byte
+	h.Reader().Read(out[:])
+	return out
+}
+
+// SumXOF computes an extendable output hash of arbitrary length.
+func SumXOF(data []byte, outLen int) []byte {
+	if outLen <= 0 {
+		return nil
+	}
+	h := New()
+	h.Write(data)
+	out := make([]byte, outLen)
+	h.Reader().Read(out)
+	return out
+}
+
+// BatchSum256 computes Blake3 hashes for multiple inputs.
+// Pure Go version processes sequentially.
+func BatchSum256(inputs [][]byte) [][Size256]byte {
+	n := len(inputs)
+	if n == 0 {
+		return nil
+	}
+	results := make([][Size256]byte, n)
+	for i, data := range inputs {
+		results[i] = Sum256(data)
+	}
+	return results
+}
+
+// MerkleRoot computes the Merkle root of leaves using Blake3.
+func MerkleRoot(leaves [][]byte) [Size256]byte {
+	var out [Size256]byte
+	n := len(leaves)
+	if n == 0 {
+		return out
+	}
+
+	// Hash each leaf first
+	hashes := make([][Size256]byte, n)
+	for i, leaf := range leaves {
+		hashes[i] = Sum256(leaf)
+	}
+
+	// Build tree bottom-up
+	for len(hashes) > 1 {
+		nextLevel := make([][Size256]byte, (len(hashes)+1)/2)
+		for i := 0; i < len(hashes); i += 2 {
+			if i+1 < len(hashes) {
+				// Hash pair
+				combined := make([]byte, Size256*2)
+				copy(combined[:Size256], hashes[i][:])
+				copy(combined[Size256:], hashes[i+1][:])
+				nextLevel[i/2] = Sum256(combined)
+			} else {
+				// Odd node, promote to next level
+				nextLevel[i/2] = hashes[i]
+			}
+		}
+		hashes = nextLevel
+	}
+
+	if len(hashes) > 0 {
+		out = hashes[0]
+	}
+	return out
+}
+
+// DeriveKey derives a key from context and key material using Blake3 KDF.
+func DeriveKey(context string, keyMaterial []byte) [Size256]byte {
+	// Use proper Blake3 KDF: derive_key(context, key_material)
+	// Combine context and key material with domain separation
+	h := NewWithDomain("BLAKE3 KDF: " + context)
+	h.Write(keyMaterial)
+	var out [Size256]byte
+	h.Reader().Read(out[:])
+	return out
+}
+
+// sumXOF implements XOF by chaining hash outputs with counter.
+// This matches the CGO implementation for compatibility.
+func sumXOF(data []byte, outLen int) []byte {
+	if outLen <= Size256 {
+		hash := Sum256(data)
+		return hash[:outLen]
+	}
+
+	out := make([]byte, outLen)
+	// First block: hash the data directly
+	first := Sum256(data)
+	copy(out[:Size256], first[:])
+
+	// Subsequent blocks: hash(data || counter)
+	remaining := outLen - Size256
+	counter := uint64(1)
+	offset := Size256
+
+	for remaining > 0 {
+		// Create input: data || counter (little-endian)
+		counterBytes := make([]byte, 8)
+		binary.LittleEndian.PutUint64(counterBytes, counter)
+		input := append(data, counterBytes...)
+
+		block := Sum256(input)
+		toCopy := Size256
+		if remaining < Size256 {
+			toCopy = remaining
+		}
+		copy(out[offset:offset+toCopy], block[:toCopy])
+
+		offset += toCopy
+		remaining -= toCopy
+		counter++
+	}
+
+	return out
+}

precompile/bls.go

@@ -404,7 +404,7 @@ func computeLagrangeCoeff(indices []uint64, i, t int) fr.Element {
 		xi.SetUint64(indices[i] + 1) // 1-indexed for proper interpolation
 		xj.SetUint64(indices[j] + 1)
 
-		num.Neg(&xj)       // -x_j
+		num.Neg(&xj)        // -x_j
 		denom.Sub(&xi, &xj) // x_i - x_j
 		denom.Inverse(&denom)