forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-20 10:52:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

remove unecessary rlp encoding/decoding cruft

Browse source
This commit is contained in:
Jared Wasinger 2023-12-19 19:27:30 +08:00
parent b883a901ed
commit 24c7314131
1 changed files with 41 additions and 102 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

143
core/state/state_witness.go
View file

@ -28,90 +28,51 @@ func (w *Witness) Root() common.Hash {
return w.root return w.root
} }
type encodedWitness struct { type rlpWitness struct {
block types.Block Block *types.Block
root common.Hash Root common.Hash
owners []common.Hash Owners []common.Hash
allPaths [][]string AllPaths [][]string
allNodes [][][]byte AllNodes [][][]byte
blockNums []uint64 BlockNums []uint64
blockHashes []common.Hash BlockHashes []common.Hash
codes []Code Codes []Code
codeHashes []common.Hash CodeHashes []common.Hash
} }
func (e *encodedWitness) ToWitness() *Witness { func (e *rlpWitness) ToWitness() *Witness {
res := NewWitness() res := NewWitness()
res.root = e.root res.root = e.Root
for i := 0; i < len(e.codes); i++ { for i := 0; i < len(e.Codes); i++ {
res.codes[e.codeHashes[i]] = e.codes[i] res.codes[e.CodeHashes[i]] = e.Codes[i]
} }
for i, owner := range e.owners { for i, owner := range e.Owners {
pathMap := make(map[string][]byte) pathMap := make(map[string][]byte)
for j := 0; j < len(e.allPaths[i]); j++ { for j := 0; j < len(e.AllPaths[i]); j++ {
pathMap[e.allPaths[i][j]] = e.allNodes[i][j] pathMap[e.AllPaths[i][j]] = e.AllNodes[i][j]
} }
res.lists[owner] = pathMap res.lists[owner] = pathMap
} }
for i, blockNum := range e.blockNums { for i, blockNum := range e.BlockNums {
res.blockHashes[blockNum] = e.blockHashes[i] res.blockHashes[blockNum] = e.BlockHashes[i]
} }
return res return res
} }
func DecodeWitnessRLP(b []byte) (*types.Block, *Witness, error) { func DecodeWitnessRLP(b []byte) (*Witness, error) {
var res encodedWitness var res Witness
stream := rlp.NewStream(bytes.NewBuffer(b), 1_000_000) if err := rlp.DecodeBytes(b, &res); err != nil {
_, err := stream.List() return nil, err
if err != nil {
panic(err)
} }
err = res.block.DecodeRLP(stream) return &res, nil
if err != nil {
panic(err)
}
if err = stream.Decode(&res.root); err != nil {
panic(err)
}
if err = stream.Decode(&res.owners); err != nil {
panic(err)
}
if err = stream.Decode(&res.allPaths); err != nil {
panic(err)
}
if err = stream.Decode(&res.allNodes); err != nil {
panic(err)
}
if err = stream.Decode(&res.blockNums); err != nil {
panic(err)
}
if err = stream.Decode(&res.blockHashes); err != nil {
panic(err)
}
if err = stream.Decode(&res.codeHashes); err != nil {
panic(err)
}
if err = stream.Decode(&res.codes); err != nil {
panic(err)
}
return &res.block, res.ToWitness(), nil
} }
func (w *Witness) EncodeRLP() []byte { func (w *Witness) EncodeRLP() ([]byte, error) {
buf := new(bytes.Buffer) var encWit rlpWitness
eb := rlp.NewEncoderBuffer(buf) encWit.Block = w.block
var root common.Hash
var owners []common.Hash
var allPaths [][]string
var allNodes [][][]byte
var blockNums []uint64
var blockHashes []common.Hash
var codes []Code
var codeHashes []common.Hash
for owner, nodeMap := range w.lists { for owner, nodeMap := range w.lists {
owners = append(owners, owner) encWit.Owners = append(encWit.Owners, owner)
var ownerPaths []string var ownerPaths []string
var ownerNodes [][]byte var ownerNodes [][]byte
@ -119,46 +80,24 @@ func (w *Witness) EncodeRLP() []byte {
ownerPaths = append(ownerPaths, path) ownerPaths = append(ownerPaths, path)
ownerNodes = append(ownerNodes, node) ownerNodes = append(ownerNodes, node)
} }
allPaths = append(allPaths, ownerPaths) encWit.AllPaths = append(encWit.AllPaths, ownerPaths)
allNodes = append(allNodes, ownerNodes) encWit.AllNodes = append(encWit.AllNodes, ownerNodes)
} }
for codeHash, code := range w.codes { for codeHash, code := range w.codes {
codeHashes = append(codeHashes, codeHash) encWit.CodeHashes = append(encWit.CodeHashes, codeHash)
codes = append(codes, code) encWit.Codes = append(encWit.Codes, code)
} }
for blockNum, blockHash := range w.blockHashes { for blockNum, blockHash := range w.blockHashes {
blockNums = append(blockNums, blockNum) encWit.BlockNums = append(encWit.BlockNums, blockNum)
blockHashes = append(blockHashes, blockHash) encWit.BlockHashes = append(encWit.BlockHashes, blockHash)
} }
l := eb.List() res, err := rlp.EncodeToBytes(&encWit)
w.block.EncodeRLP(eb) if err != nil {
eb.WriteBytes(root[:]) return nil, err
if err := rlp.Encode(eb, owners); err != nil {
panic(err)
} }
if err := rlp.Encode(eb, allPaths); err != nil { return res, nil
panic(err)
}
if err := rlp.Encode(eb, allNodes); err != nil {
panic(err)
}
if err := rlp.Encode(eb, blockNums); err != nil {
panic(err)
}
if err := rlp.Encode(eb, blockHashes); err != nil {
panic(err)
}
if err := rlp.Encode(eb, codeHashes); err != nil {
panic(err)
}
if err := rlp.Encode(eb, codes); err != nil {
panic(err)
}
eb.ListEnd(l)
eb.Flush()
return buf.Bytes()
} }
func (w *Witness) addAccessList(owner common.Hash, list map[string][]byte) { func (w *Witness) addAccessList(owner common.Hash, list map[string][]byte) {
@ -191,7 +130,7 @@ func (w Witness) Copy() Witness {
} }
func (w *Witness) LogSizeWithBlock(b *types.Block) { func (w *Witness) LogSizeWithBlock(b *types.Block) {
enc := w.EncodeRLP() enc, _ := w.EncodeRLP()
fmt.Printf("block %d witness+block size: %d\n", b.Number(), len(enc)) fmt.Printf("block %d witness+block size: %d\n", b.Number(), len(enc))
} }
@ -203,7 +142,7 @@ func (w *Witness) Summary() string {
} }
totBlock := len(xx) totBlock := len(xx)
yy := w.EncodeRLP() yy, _ := w.EncodeRLP()
totWit := len(yy) totWit := len(yy)
totCode := 0 totCode := 0
@ -262,7 +201,7 @@ func NewWitness() *Witness {
} }
func DumpBlockWitnessToFile(w *Witness, path string) error { func DumpBlockWitnessToFile(w *Witness, path string) error {
enc := w.EncodeRLP() enc, _ := w.EncodeRLP()
blockHash := w.block.Hash() blockHash := w.block.Hash()
outputFName := fmt.Sprintf("%d-%x.rlp", w.block.NumberU64(), blockHash[0:8]) outputFName := fmt.Sprintf("%d-%x.rlp", w.block.NumberU64(), blockHash[0:8])