Performance: use NEON accelerated keccak (#19092)

Switch to https://github.com/erigontech/fastkeccak

---------

Co-authored-by: Alex Sharov <AskAlexSharov@gmail.com>
Co-authored-by: yperbasis <andrey.ashikhmin@gmail.com>
Co-authored-by: Andrew Ashikhmin <34320705+yperbasis@users.noreply.github.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: SharovBot <sharovbot@erigon.tech>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: 6 people

common/address.go

@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"math/big"
 
-	"golang.org/x/crypto/sha3"
+	keccak "github.com/erigontech/fastkeccak"
 
 	"github.com/erigontech/erigon/common/hexutil"
 	"github.com/erigontech/erigon/common/length"
@@ -77,7 +77,7 @@ func (a *Address) checksumHex() []byte {
 	buf := a.hex()
 
 	// compute checksum
-	sha := sha3.NewLegacyKeccak256()
+	sha := keccak.NewFastKeccak()
 	//nolint:errcheck
 	sha.Write(buf[2:])
 	hash := sha.Sum(nil)

common/crypto/crypto.go

@@ -27,12 +27,12 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"hash"
 	"io"
 	"math/big"
 	"os"
 	"sync"
 
+	keccak "github.com/erigontech/fastkeccak"
 	"github.com/holiman/uint256"
 	"golang.org/x/crypto/sha3"
 
@@ -67,16 +67,8 @@ type EllipticCurve interface {
 	Unmarshal(data []byte) (x, y *big.Int)
 }
 
-// KeccakState wraps sha3.state. In addition to the usual hash methods, it also supports
-// Read to get a variable amount of data from the hash state. Read is faster than Sum
-// because it doesn't copy the internal state, but also modifies the internal state.
-type KeccakState interface {
-	hash.Hash
-	Read([]byte) (int, error)
-}
-
 // HashData hashes the provided data using the KeccakState and returns a 32 byte hash
-func HashData(kh KeccakState, data []byte) (h common.Hash) {
+func HashData(kh keccak.KeccakState, data []byte) (h common.Hash) {
 	kh.Reset()
 	//nolint:errcheck
 	kh.Write(data)
@@ -325,14 +317,14 @@ func PubkeyToAddress(p ecdsa.PublicKey) common.Address {
 // hasherPool holds LegacyKeccak hashers.
 var hasherPool = sync.Pool{
 	New: func() any {
-		return sha3.NewLegacyKeccak256()
+		return keccak.NewFastKeccak()
 	},
 }
 
 // NewKeccakState creates a new KeccakState
-func NewKeccakState() KeccakState {
-	h := hasherPool.Get().(KeccakState)
+func NewKeccakState() keccak.KeccakState {
+	h := hasherPool.Get().(keccak.KeccakState)
 	h.Reset()
 	return h
 }
-func ReturnToPool(h KeccakState) { hasherPool.Put(h) }
+func ReturnToPool(h keccak.KeccakState) { hasherPool.Put(h) }

common/hasher.go

@@ -17,27 +17,18 @@
 package common
 
 import (
-	"hash"
 	"sync"
 
-	"golang.org/x/crypto/sha3"
+	keccak "github.com/erigontech/fastkeccak"
 )
 
-// keccakState wraps sha3.state. In addition to the usual hash methods, it also supports
-// Read to get a variable amount of data from the hash state. Read is faster than Sum
-// because it doesn't copy the internal state, but also modifies the internal state.
-type keccakState interface {
-	hash.Hash
-	Read([]byte) (int, error)
-}
-
 type Hasher struct {
-	Sha keccakState
+	Sha keccak.KeccakState
 }
 
 var hashersPool = sync.Pool{
 	New: func() any {
-		return &Hasher{Sha: sha3.NewLegacyKeccak256().(keccakState)}
+		return &Hasher{Sha: keccak.NewFastKeccak()}
 	},
 }
 

db/kv/kvcache/cache.go

@@ -29,8 +29,8 @@ import (
 	"time"
 
 	"github.com/c2h5oh/datasize"
+	keccak "github.com/erigontech/fastkeccak"
 	btree2 "github.com/tidwall/btree"
-	"golang.org/x/crypto/sha3"
 
 	"github.com/erigontech/erigon/common"
 	"github.com/erigontech/erigon/db/kv"
@@ -198,7 +198,7 @@ func New(cfg CoherentConfig) *Coherent {
 		roots:        map[uint64]*CoherentRoot{},
 		stateEvict:   &ThreadSafeEvictionList{l: NewList()},
 		codeEvict:    &ThreadSafeEvictionList{l: NewList()},
-		hasher:       sha3.NewLegacyKeccak256(),
+		hasher:       keccak.NewFastKeccak(),
 		cfg:          cfg,
 		miss:         metrics.GetOrCreateCounter(fmt.Sprintf(`cache_total{result="miss",name="%s"}`, cfg.MetricsLabel)),
 		hits:         metrics.GetOrCreateCounter(fmt.Sprintf(`cache_total{result="hit",name="%s"}`, cfg.MetricsLabel)),

db/kv/kvcache/cache_test.go

@@ -25,9 +25,9 @@ import (
 	"testing"
 	"time"
 
+	keccak "github.com/erigontech/fastkeccak"
 	"github.com/holiman/uint256"
 	"github.com/stretchr/testify/require"
-	"golang.org/x/crypto/sha3"
 
 	"github.com/erigontech/erigon/common"
 	"github.com/erigontech/erigon/common/log/v3"
@@ -509,7 +509,7 @@ func TestOnNewBlockCodeHashKey(t *testing.T) {
 
 	require.Len(elems, 1)
 
-	h := sha3.NewLegacyKeccak256()
+	h := keccak.NewFastKeccak()
 	h.Write(code)
 	expectedKey := h.Sum(nil)
 

db/rawdb/accessors_chain_test.go

@@ -25,9 +25,9 @@ import (
 	"math/big"
 	"testing"
 
+	keccak "github.com/erigontech/fastkeccak"
 	"github.com/holiman/uint256"
 	"github.com/stretchr/testify/require"
-	"golang.org/x/crypto/sha3"
 
 	"github.com/erigontech/erigon/common"
 	"github.com/erigontech/erigon/common/crypto"
@@ -349,7 +349,7 @@ func TestHeaderStorage(t *testing.T) {
 	if entry := rawdb.ReadHeaderRLP(tx, header.Hash(), header.Number.Uint64()); entry == nil {
 		t.Fatalf("Stored header RLP not found")
 	} else {
-		hasher := sha3.NewLegacyKeccak256()
+		hasher := keccak.NewFastKeccak()
 		hasher.Write(entry)
 
 		if hash := common.BytesToHash(hasher.Sum(nil)); hash != header.Hash() {
@@ -397,7 +397,7 @@ func TestBodyStorage(t *testing.T) {
 	}
 
 	// Create a test body to move around the database and make sure it's really new
-	hasher := sha3.NewLegacyKeccak256()
+	hasher := keccak.NewFastKeccak()
 	_ = rlp.Encode(hasher, body)
 	hash := common.BytesToHash(hasher.Sum(nil))
 	header := &types.Header{Number: *common.Num1}
@@ -421,7 +421,7 @@ func TestBodyStorage(t *testing.T) {
 		if err != nil {
 			log.Error("ReadBodyRLP failed", "err", err)
 		}
-		hasher := sha3.NewLegacyKeccak256()
+		hasher := keccak.NewFastKeccak()
 		hasher.Write(bodyRlp)
 
 		if calc := common.BytesToHash(hasher.Sum(nil)); calc != hash {

db/snaptype2/headers_freezer.go

@@ -7,6 +7,8 @@ import (
 	"runtime"
 	"time"
 
+	keccak "github.com/erigontech/fastkeccak"
+
 	"github.com/erigontech/erigon/common"
 	"github.com/erigontech/erigon/common/crypto"
 	"github.com/erigontech/erigon/common/dbg"
@@ -90,7 +92,7 @@ func (f *HeaderFreezer) Freeze(ctx context.Context, blockFrom, blockTo state.Roo
 var _ state.IndexKeyFactory = (*HeaderAccessorIndexKeyFactory)(nil)
 
 type HeaderAccessorIndexKeyFactory struct {
-	s crypto.KeccakState
+	s keccak.KeccakState
 	h common.Hash
 }
 

execution/commitment/bin_patricia_hashed.go

@@ -99,8 +99,8 @@ package commitment
 //
 //func NewBinPatriciaHashed(accountKeyLen int, ctx PatriciaContext, tmpdir string) *BinPatriciaHashed {
 //	bph := &BinPatriciaHashed{
-//		keccak:        sha3.NewLegacyKeccak256().(keccakState),
-//		keccak2:       sha3.NewLegacyKeccak256().(keccakState),
+//		keccak:        keccak.NewFastKeccak(),
+//		keccak2:       keccak.NewFastKeccak(),
 //		accountKeyLen: accountKeyLen,
 //		accountFn:     wrapAccountStorageFn(ctx.GetAccount),
 //		storageFn:     wrapAccountStorageFn(ctx.GetStorage),

execution/commitment/commitment.go

@@ -30,9 +30,9 @@ import (
 	"sync/atomic"
 	"unsafe"
 
+	keccak "github.com/erigontech/fastkeccak"
 	"github.com/google/btree"
 	"github.com/holiman/uint256"
-	"golang.org/x/crypto/sha3"
 
 	"github.com/erigontech/erigon/common"
 	"github.com/erigontech/erigon/common/crypto"
@@ -1106,7 +1106,7 @@ func (branchData BranchData) Validate(branchKey []byte) error {
 	if err = validateAfterMap(afterMap, row); err != nil {
 		return err
 	}
-	if err = validatePlainKeys(branchKey, row, sha3.NewLegacyKeccak256().(keccakState)); err != nil {
+	if err = validatePlainKeys(branchKey, row, keccak.NewFastKeccak()); err != nil {
 		return err
 	}
 	return nil
@@ -1126,7 +1126,7 @@ func validateAfterMap(afterMap uint16, row [16]*cell) error {
 	return nil
 }
 
-func validatePlainKeys(branchKey []byte, row [16]*cell, keccak keccakState) error {
+func validatePlainKeys(branchKey []byte, row [16]*cell, keccak keccak.KeccakState) error {
 	uncompactedBranchKey := uncompactNibbles(branchKey)
 	if HasTerm(uncompactedBranchKey) {
 		uncompactedBranchKey = uncompactedBranchKey[:len(uncompactedBranchKey)-1]

execution/commitment/hex_patricia_hashed.go

@@ -23,7 +23,6 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"hash"
 	"io"
 	"math/bits"
 	"runtime"
@@ -32,7 +31,7 @@ import (
 	"sync/atomic"
 	"time"
 
-	"golang.org/x/crypto/sha3"
+	keccak "github.com/erigontech/fastkeccak"
 
 	"github.com/erigontech/erigon/common"
 	"github.com/erigontech/erigon/common/crypto"
@@ -48,14 +47,6 @@ import (
 	"github.com/erigontech/erigon/execution/types/accounts"
 )
 
-// keccakState wraps sha3.state. In addition to the usual hash methods, it also supports
-// Read to get a variable amount of data from the hash state. Read is faster than Sum
-// because it doesn't copy the internal state, but also modifies the internal state.
-type keccakState interface {
-	hash.Hash
-	Read([]byte) (int, error)
-}
-
 // DomainPutter is an interface for putting data into domains.
 // Used by commitment to write branch data.
 type DomainPutter = stateifs.DomainPutter
@@ -82,8 +73,8 @@ type HexPatriciaHashed struct {
 	branchBefore  [128]bool     // For each row, whether there was a branch node in the database loaded in unfold
 	touchMap      [128]uint16   // For each row, bitmap of cells that were either present before modification, or modified or deleted
 	afterMap      [128]uint16   // For each row, bitmap of cells that were present after modification
-	keccak        keccakState
-	keccak2       keccakState
+	keccak        keccak.KeccakState
+	keccak2       keccak.KeccakState
 	rootChecked   bool // Set to false if it is not known whether the root is empty, set to true if it is checked
 	rootTouched   bool
 	rootPresent   bool
@@ -133,8 +124,8 @@ func (hph *HexPatriciaHashed) SpawnSubTrie(ctx PatriciaContext, forNibble int) *
 func NewHexPatriciaHashed(accountKeyLen int16, ctx PatriciaContext) *HexPatriciaHashed {
 	hph := &HexPatriciaHashed{
 		ctx:           ctx,
-		keccak:        sha3.NewLegacyKeccak256().(keccakState),
-		keccak2:       sha3.NewLegacyKeccak256().(keccakState),
+		keccak:        keccak.NewFastKeccak(),
+		keccak2:       keccak.NewFastKeccak(),
 		accountKeyLen: accountKeyLen,
 		auxBuffer:     bytes.NewBuffer(make([]byte, 8192)),
 		hadToLoadL:    make(map[uint64]skipStat),
@@ -207,11 +198,11 @@ var (
 	emptyRootHashBytes = empty.RootHash.Bytes()
 )
 
-func (cell *cell) hashAccKey(keccak keccakState, depth int16, hashBuf []byte) error {
+func (cell *cell) hashAccKey(keccak keccak.KeccakState, depth int16, hashBuf []byte) error {
 	return hashKey(keccak, cell.accountAddr[:cell.accountAddrLen], cell.hashedExtension[:], depth, hashBuf)
 }
 
-func (cell *cell) hashStorageKey(keccak keccakState, accountKeyLen, downOffset int16, hashedKeyOffset int16, hashBuf []byte) error {
+func (cell *cell) hashStorageKey(keccak keccak.KeccakState, accountKeyLen, downOffset int16, hashedKeyOffset int16, hashBuf []byte) error {
 	return hashKey(keccak, cell.storageAddr[accountKeyLen:cell.storageAddrLen], cell.hashedExtension[downOffset:], hashedKeyOffset, hashBuf)
 }
 
@@ -376,7 +367,7 @@ func (cell *cell) fillFromLowerCell(lowCell *cell, lowDepth int16, preExtension
 	cell.loaded = lowCell.loaded
 }
 
-func (cell *cell) deriveHashedKeys(depth int16, keccak keccakState, accountKeyLen int16, hashBuf []byte) error {
+func (cell *cell) deriveHashedKeys(depth int16, keccak keccak.KeccakState, accountKeyLen int16, hashBuf []byte) error {
 	extraLen := int16(0)
 	if cell.accountAddrLen > 0 {
 		if depth > 64 {