99f81d2724
In this PR, all TryXXX(e.g. TryGet) APIs of trie are renamed to XXX(e.g. Get) with an error returned. The original XXX(e.g. Get) APIs are renamed to MustXXX(e.g. MustGet) and does not return any error -- they print a log output. A future PR will change the behaviour to panic on errorrs.
117 lines
3.7 KiB
Go
117 lines
3.7 KiB
Go
// Copyright 2021 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library 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 Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package types
|
|
|
|
import (
|
|
"bytes"
|
|
"sync"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"golang.org/x/crypto/sha3"
|
|
)
|
|
|
|
// hasherPool holds LegacyKeccak256 hashers for rlpHash.
|
|
var hasherPool = sync.Pool{
|
|
New: func() interface{} { return sha3.NewLegacyKeccak256() },
|
|
}
|
|
|
|
// encodeBufferPool holds temporary encoder buffers for DeriveSha and TX encoding.
|
|
var encodeBufferPool = sync.Pool{
|
|
New: func() interface{} { return new(bytes.Buffer) },
|
|
}
|
|
|
|
// rlpHash encodes x and hashes the encoded bytes.
|
|
func rlpHash(x interface{}) (h common.Hash) {
|
|
sha := hasherPool.Get().(crypto.KeccakState)
|
|
defer hasherPool.Put(sha)
|
|
sha.Reset()
|
|
rlp.Encode(sha, x)
|
|
sha.Read(h[:])
|
|
return h
|
|
}
|
|
|
|
// prefixedRlpHash writes the prefix into the hasher before rlp-encoding x.
|
|
// It's used for typed transactions.
|
|
func prefixedRlpHash(prefix byte, x interface{}) (h common.Hash) {
|
|
sha := hasherPool.Get().(crypto.KeccakState)
|
|
defer hasherPool.Put(sha)
|
|
sha.Reset()
|
|
sha.Write([]byte{prefix})
|
|
rlp.Encode(sha, x)
|
|
sha.Read(h[:])
|
|
return h
|
|
}
|
|
|
|
// TrieHasher is the tool used to calculate the hash of derivable list.
|
|
// This is internal, do not use.
|
|
type TrieHasher interface {
|
|
Reset()
|
|
Update([]byte, []byte) error
|
|
Hash() common.Hash
|
|
}
|
|
|
|
// DerivableList is the input to DeriveSha.
|
|
// It is implemented by the 'Transactions' and 'Receipts' types.
|
|
// This is internal, do not use these methods.
|
|
type DerivableList interface {
|
|
Len() int
|
|
EncodeIndex(int, *bytes.Buffer)
|
|
}
|
|
|
|
func encodeForDerive(list DerivableList, i int, buf *bytes.Buffer) []byte {
|
|
buf.Reset()
|
|
list.EncodeIndex(i, buf)
|
|
// It's really unfortunate that we need to do perform this copy.
|
|
// StackTrie holds onto the values until Hash is called, so the values
|
|
// written to it must not alias.
|
|
return common.CopyBytes(buf.Bytes())
|
|
}
|
|
|
|
// DeriveSha creates the tree hashes of transactions, receipts, and withdrawals in a block header.
|
|
func DeriveSha(list DerivableList, hasher TrieHasher) common.Hash {
|
|
hasher.Reset()
|
|
|
|
valueBuf := encodeBufferPool.Get().(*bytes.Buffer)
|
|
defer encodeBufferPool.Put(valueBuf)
|
|
|
|
// StackTrie requires values to be inserted in increasing hash order, which is not the
|
|
// order that `list` provides hashes in. This insertion sequence ensures that the
|
|
// order is correct.
|
|
//
|
|
// The error returned by hasher is omitted because hasher will produce an incorrect
|
|
// hash in case any error occurs.
|
|
var indexBuf []byte
|
|
for i := 1; i < list.Len() && i <= 0x7f; i++ {
|
|
indexBuf = rlp.AppendUint64(indexBuf[:0], uint64(i))
|
|
value := encodeForDerive(list, i, valueBuf)
|
|
hasher.Update(indexBuf, value)
|
|
}
|
|
if list.Len() > 0 {
|
|
indexBuf = rlp.AppendUint64(indexBuf[:0], 0)
|
|
value := encodeForDerive(list, 0, valueBuf)
|
|
hasher.Update(indexBuf, value)
|
|
}
|
|
for i := 0x80; i < list.Len(); i++ {
|
|
indexBuf = rlp.AppendUint64(indexBuf[:0], uint64(i))
|
|
value := encodeForDerive(list, i, valueBuf)
|
|
hasher.Update(indexBuf, value)
|
|
}
|
|
return hasher.Hash()
|
|
}
|