2015-11-30 12:34:19 +00:00
|
|
|
// Copyright 2015 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 light
|
|
|
|
|
|
|
|
import (
|
2017-03-22 17:20:33 +00:00
|
|
|
"context"
|
2018-02-05 16:40:32 +00:00
|
|
|
"errors"
|
2017-06-27 13:57:06 +00:00
|
|
|
"fmt"
|
2017-03-22 17:20:33 +00:00
|
|
|
|
2017-06-27 13:57:06 +00:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2020-08-21 12:10:40 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core/rawdb"
|
2017-06-27 13:57:06 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
2017-04-18 11:08:17 +00:00
|
|
|
"github.com/ethereum/go-ethereum/crypto"
|
2018-02-05 16:40:32 +00:00
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
2021-09-28 08:48:07 +00:00
|
|
|
"github.com/ethereum/go-ethereum/rlp"
|
2015-11-30 12:34:19 +00:00
|
|
|
"github.com/ethereum/go-ethereum/trie"
|
2023-05-09 07:11:04 +00:00
|
|
|
"github.com/ethereum/go-ethereum/trie/trienode"
|
2015-11-30 12:34:19 +00:00
|
|
|
)
|
|
|
|
|
2020-12-10 13:33:52 +00:00
|
|
|
var (
|
|
|
|
sha3Nil = crypto.Keccak256Hash(nil)
|
|
|
|
)
|
|
|
|
|
2017-06-27 13:57:06 +00:00
|
|
|
func NewState(ctx context.Context, head *types.Header, odr OdrBackend) *state.StateDB {
|
2019-08-06 10:40:28 +00:00
|
|
|
state, _ := state.New(head.Root, NewStateDatabase(ctx, head, odr), nil)
|
2017-06-27 13:57:06 +00:00
|
|
|
return state
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewStateDatabase(ctx context.Context, head *types.Header, odr OdrBackend) state.Database {
|
|
|
|
return &odrDatabase{ctx, StateTrieID(head), odr}
|
|
|
|
}
|
|
|
|
|
|
|
|
type odrDatabase struct {
|
|
|
|
ctx context.Context
|
|
|
|
id *TrieID
|
|
|
|
backend OdrBackend
|
|
|
|
}
|
|
|
|
|
|
|
|
func (db *odrDatabase) OpenTrie(root common.Hash) (state.Trie, error) {
|
|
|
|
return &odrTrie{db: db, id: db.id}, nil
|
|
|
|
}
|
|
|
|
|
core/state, light, les: make signature of ContractCode hash-independent (#27209)
* core/state, light, les: make signature of ContractCode hash-independent
* push current state for feedback
* les: fix unit test
* core, les, light: fix les unittests
* core/state, trie, les, light: fix state iterator
* core, les: address comments
* les: fix lint
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
2023-06-28 09:11:02 +00:00
|
|
|
func (db *odrDatabase) OpenStorageTrie(stateRoot common.Hash, address common.Address, root common.Hash) (state.Trie, error) {
|
|
|
|
return &odrTrie{db: db, id: StorageTrieID(db.id, address, root)}, nil
|
2017-06-27 13:57:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (db *odrDatabase) CopyTrie(t state.Trie) state.Trie {
|
|
|
|
switch t := t.(type) {
|
|
|
|
case *odrTrie:
|
|
|
|
cpy := &odrTrie{db: t.db, id: t.id}
|
|
|
|
if t.trie != nil {
|
cmd, core, eth, les, light: track deleted nodes (#25757)
* cmd, core, eth, les, light: track deleted nodes
* trie: add docs
* trie: address comments
* cmd, core, eth, les, light, trie: trie id
* trie: add tests
* trie, core: updates
* trie: fix imports
* trie: add utility print-method for nodeset
* trie: import err
* trie: fix go vet warnings
Co-authored-by: Martin Holst Swende <martin@swende.se>
2022-09-27 08:01:02 +00:00
|
|
|
cpy.trie = t.trie.Copy()
|
2017-06-27 13:57:06 +00:00
|
|
|
}
|
|
|
|
return cpy
|
|
|
|
default:
|
|
|
|
panic(fmt.Errorf("unknown trie type %T", t))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
core/state, light, les: make signature of ContractCode hash-independent (#27209)
* core/state, light, les: make signature of ContractCode hash-independent
* push current state for feedback
* les: fix unit test
* core, les, light: fix les unittests
* core/state, trie, les, light: fix state iterator
* core, les: address comments
* les: fix lint
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
2023-06-28 09:11:02 +00:00
|
|
|
func (db *odrDatabase) ContractCode(addr common.Address, codeHash common.Hash) ([]byte, error) {
|
2019-02-14 15:18:32 +00:00
|
|
|
if codeHash == sha3Nil {
|
2017-06-27 13:57:06 +00:00
|
|
|
return nil, nil
|
|
|
|
}
|
2020-08-21 12:10:40 +00:00
|
|
|
code := rawdb.ReadCode(db.backend.Database(), codeHash)
|
|
|
|
if len(code) != 0 {
|
2017-06-27 13:57:06 +00:00
|
|
|
return code, nil
|
|
|
|
}
|
|
|
|
id := *db.id
|
core/state, light, les: make signature of ContractCode hash-independent (#27209)
* core/state, light, les: make signature of ContractCode hash-independent
* push current state for feedback
* les: fix unit test
* core, les, light: fix les unittests
* core/state, trie, les, light: fix state iterator
* core, les: address comments
* les: fix lint
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
2023-06-28 09:11:02 +00:00
|
|
|
id.AccountAddress = addr[:]
|
2017-06-27 13:57:06 +00:00
|
|
|
req := &CodeRequest{Id: &id, Hash: codeHash}
|
|
|
|
err := db.backend.Retrieve(db.ctx, req)
|
|
|
|
return req.Data, err
|
|
|
|
}
|
|
|
|
|
core/state, light, les: make signature of ContractCode hash-independent (#27209)
* core/state, light, les: make signature of ContractCode hash-independent
* push current state for feedback
* les: fix unit test
* core, les, light: fix les unittests
* core/state, trie, les, light: fix state iterator
* core, les: address comments
* les: fix lint
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
2023-06-28 09:11:02 +00:00
|
|
|
func (db *odrDatabase) ContractCodeSize(addr common.Address, codeHash common.Hash) (int, error) {
|
|
|
|
code, err := db.ContractCode(addr, codeHash)
|
2017-06-27 13:57:06 +00:00
|
|
|
return len(code), err
|
|
|
|
}
|
|
|
|
|
2018-02-05 16:40:32 +00:00
|
|
|
func (db *odrDatabase) TrieDB() *trie.Database {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-09-07 07:08:56 +00:00
|
|
|
func (db *odrDatabase) DiskDB() ethdb.KeyValueStore {
|
|
|
|
panic("not implemented")
|
|
|
|
}
|
|
|
|
|
2017-06-27 13:57:06 +00:00
|
|
|
type odrTrie struct {
|
|
|
|
db *odrDatabase
|
2016-10-14 03:47:09 +00:00
|
|
|
id *TrieID
|
2017-06-27 13:57:06 +00:00
|
|
|
trie *trie.Trie
|
|
|
|
}
|
|
|
|
|
2023-03-27 08:48:46 +00:00
|
|
|
func (t *odrTrie) GetStorage(_ common.Address, key []byte) ([]byte, error) {
|
2017-06-27 13:57:06 +00:00
|
|
|
key = crypto.Keccak256(key)
|
2023-06-01 08:29:41 +00:00
|
|
|
var enc []byte
|
2017-06-27 13:57:06 +00:00
|
|
|
err := t.do(key, func() (err error) {
|
2023-06-01 08:29:41 +00:00
|
|
|
enc, err = t.trie.Get(key)
|
2017-06-27 13:57:06 +00:00
|
|
|
return err
|
|
|
|
})
|
2023-06-01 08:29:41 +00:00
|
|
|
if err != nil || len(enc) == 0 {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
_, content, _, err := rlp.Split(enc)
|
|
|
|
return content, err
|
2017-06-27 13:57:06 +00:00
|
|
|
}
|
|
|
|
|
2023-03-27 08:48:46 +00:00
|
|
|
func (t *odrTrie) GetAccount(address common.Address) (*types.StateAccount, error) {
|
2022-08-04 14:13:18 +00:00
|
|
|
var res types.StateAccount
|
2023-01-03 13:41:40 +00:00
|
|
|
key := crypto.Keccak256(address.Bytes())
|
2022-08-04 14:13:18 +00:00
|
|
|
err := t.do(key, func() (err error) {
|
2023-04-20 10:57:24 +00:00
|
|
|
value, err := t.trie.Get(key)
|
2022-08-04 14:13:18 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if value == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return rlp.DecodeBytes(value, &res)
|
|
|
|
})
|
|
|
|
return &res, err
|
|
|
|
}
|
|
|
|
|
2023-03-27 08:48:46 +00:00
|
|
|
func (t *odrTrie) UpdateAccount(address common.Address, acc *types.StateAccount) error {
|
2023-01-03 13:41:40 +00:00
|
|
|
key := crypto.Keccak256(address.Bytes())
|
2021-09-28 08:48:07 +00:00
|
|
|
value, err := rlp.EncodeToBytes(acc)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("decoding error in account update: %w", err)
|
|
|
|
}
|
|
|
|
return t.do(key, func() error {
|
2023-04-20 10:57:24 +00:00
|
|
|
return t.trie.Update(key, value)
|
2021-09-28 08:48:07 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-06-22 12:52:52 +00:00
|
|
|
func (t *odrTrie) UpdateContractCode(_ common.Address, _ common.Hash, _ []byte) error {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-03-27 08:48:46 +00:00
|
|
|
func (t *odrTrie) UpdateStorage(_ common.Address, key, value []byte) error {
|
2017-06-27 13:57:06 +00:00
|
|
|
key = crypto.Keccak256(key)
|
2023-06-01 08:29:41 +00:00
|
|
|
v, _ := rlp.EncodeToBytes(value)
|
2017-06-27 13:57:06 +00:00
|
|
|
return t.do(key, func() error {
|
2023-06-01 08:29:41 +00:00
|
|
|
return t.trie.Update(key, v)
|
2017-06-27 13:57:06 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-03-27 08:48:46 +00:00
|
|
|
func (t *odrTrie) DeleteStorage(_ common.Address, key []byte) error {
|
2017-06-27 13:57:06 +00:00
|
|
|
key = crypto.Keccak256(key)
|
|
|
|
return t.do(key, func() error {
|
2023-04-20 10:57:24 +00:00
|
|
|
return t.trie.Delete(key)
|
2017-06-27 13:57:06 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-05-09 07:11:04 +00:00
|
|
|
// DeleteAccount abstracts an account deletion from the trie.
|
2023-03-27 08:48:46 +00:00
|
|
|
func (t *odrTrie) DeleteAccount(address common.Address) error {
|
2023-01-03 13:41:40 +00:00
|
|
|
key := crypto.Keccak256(address.Bytes())
|
2022-08-17 11:14:49 +00:00
|
|
|
return t.do(key, func() error {
|
2023-04-20 10:57:24 +00:00
|
|
|
return t.trie.Delete(key)
|
2022-08-17 11:14:49 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-06-27 12:36:38 +00:00
|
|
|
func (t *odrTrie) Commit(collectLeaf bool) (common.Hash, *trienode.NodeSet, error) {
|
2017-06-27 13:57:06 +00:00
|
|
|
if t.trie == nil {
|
2023-06-27 12:36:38 +00:00
|
|
|
return t.id.Root, nil, nil
|
2017-06-27 13:57:06 +00:00
|
|
|
}
|
2022-08-04 08:03:20 +00:00
|
|
|
return t.trie.Commit(collectLeaf)
|
2017-06-27 13:57:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (t *odrTrie) Hash() common.Hash {
|
|
|
|
if t.trie == nil {
|
|
|
|
return t.id.Root
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|
2017-06-27 13:57:06 +00:00
|
|
|
return t.trie.Hash()
|
|
|
|
}
|
|
|
|
|
cmd, core/state, eth, tests, trie: improve state reader (#27428)
The state availability is checked during the creation of a state reader.
- In hash-based database, if the specified root node does not exist on disk disk, then
the state reader won't be created and an error will be returned.
- In path-based database, if the specified state layer is not available, then the
state reader won't be created and an error will be returned.
This change also contains a stricter semantics regarding the `Commit` operation: once it has been performed, the trie is no longer usable, and certain operations will return an error.
2023-06-20 19:31:45 +00:00
|
|
|
func (t *odrTrie) NodeIterator(startkey []byte) (trie.NodeIterator, error) {
|
|
|
|
return newNodeIterator(t, startkey), nil
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|
|
|
|
|
2017-06-27 13:57:06 +00:00
|
|
|
func (t *odrTrie) GetKey(sha []byte) []byte {
|
|
|
|
return nil
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|
|
|
|
|
2023-06-19 14:28:40 +00:00
|
|
|
func (t *odrTrie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error {
|
2018-02-05 16:40:32 +00:00
|
|
|
return errors.New("not implemented, needs client/server interface split")
|
|
|
|
}
|
|
|
|
|
2015-11-30 12:34:19 +00:00
|
|
|
// do tries and retries to execute a function until it returns with no error or
|
|
|
|
// an error type other than MissingNodeError
|
2017-06-27 13:57:06 +00:00
|
|
|
func (t *odrTrie) do(key []byte, fn func() error) error {
|
|
|
|
for {
|
|
|
|
var err error
|
|
|
|
if t.trie == nil {
|
cmd, core, eth, les, light: track deleted nodes (#25757)
* cmd, core, eth, les, light: track deleted nodes
* trie: add docs
* trie: address comments
* cmd, core, eth, les, light, trie: trie id
* trie: add tests
* trie, core: updates
* trie: fix imports
* trie: add utility print-method for nodeset
* trie: import err
* trie: fix go vet warnings
Co-authored-by: Martin Holst Swende <martin@swende.se>
2022-09-27 08:01:02 +00:00
|
|
|
var id *trie.ID
|
core/state, light, les: make signature of ContractCode hash-independent (#27209)
* core/state, light, les: make signature of ContractCode hash-independent
* push current state for feedback
* les: fix unit test
* core, les, light: fix les unittests
* core/state, trie, les, light: fix state iterator
* core, les: address comments
* les: fix lint
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
2023-06-28 09:11:02 +00:00
|
|
|
if len(t.id.AccountAddress) > 0 {
|
|
|
|
id = trie.StorageTrieID(t.id.StateRoot, crypto.Keccak256Hash(t.id.AccountAddress), t.id.Root)
|
cmd, core, eth, les, light: track deleted nodes (#25757)
* cmd, core, eth, les, light: track deleted nodes
* trie: add docs
* trie: address comments
* cmd, core, eth, les, light, trie: trie id
* trie: add tests
* trie, core: updates
* trie: fix imports
* trie: add utility print-method for nodeset
* trie: import err
* trie: fix go vet warnings
Co-authored-by: Martin Holst Swende <martin@swende.se>
2022-09-27 08:01:02 +00:00
|
|
|
} else {
|
|
|
|
id = trie.StateTrieID(t.id.StateRoot)
|
2022-06-06 15:14:55 +00:00
|
|
|
}
|
cmd, core, eth, les, light: track deleted nodes (#25757)
* cmd, core, eth, les, light: track deleted nodes
* trie: add docs
* trie: address comments
* cmd, core, eth, les, light, trie: trie id
* trie: add tests
* trie, core: updates
* trie: fix imports
* trie: add utility print-method for nodeset
* trie: import err
* trie: fix go vet warnings
Co-authored-by: Martin Holst Swende <martin@swende.se>
2022-09-27 08:01:02 +00:00
|
|
|
t.trie, err = trie.New(id, trie.NewDatabase(t.db.backend.Database()))
|
2017-06-27 13:57:06 +00:00
|
|
|
}
|
|
|
|
if err == nil {
|
|
|
|
err = fn()
|
|
|
|
}
|
2017-04-18 11:08:17 +00:00
|
|
|
if _, ok := err.(*trie.MissingNodeError); !ok {
|
2015-11-30 12:34:19 +00:00
|
|
|
return err
|
|
|
|
}
|
2017-06-27 13:57:06 +00:00
|
|
|
r := &TrieRequest{Id: t.id, Key: key}
|
|
|
|
if err := t.db.backend.Retrieve(t.db.ctx, r); err != nil {
|
2017-12-17 21:40:39 +00:00
|
|
|
return err
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-27 13:57:06 +00:00
|
|
|
type nodeIterator struct {
|
|
|
|
trie.NodeIterator
|
|
|
|
t *odrTrie
|
|
|
|
err error
|
|
|
|
}
|
|
|
|
|
|
|
|
func newNodeIterator(t *odrTrie, startkey []byte) trie.NodeIterator {
|
|
|
|
it := &nodeIterator{t: t}
|
|
|
|
// Open the actual non-ODR trie if that hasn't happened yet.
|
|
|
|
if t.trie == nil {
|
|
|
|
it.do(func() error {
|
cmd, core, eth, les, light: track deleted nodes (#25757)
* cmd, core, eth, les, light: track deleted nodes
* trie: add docs
* trie: address comments
* cmd, core, eth, les, light, trie: trie id
* trie: add tests
* trie, core: updates
* trie: fix imports
* trie: add utility print-method for nodeset
* trie: import err
* trie: fix go vet warnings
Co-authored-by: Martin Holst Swende <martin@swende.se>
2022-09-27 08:01:02 +00:00
|
|
|
var id *trie.ID
|
core/state, light, les: make signature of ContractCode hash-independent (#27209)
* core/state, light, les: make signature of ContractCode hash-independent
* push current state for feedback
* les: fix unit test
* core, les, light: fix les unittests
* core/state, trie, les, light: fix state iterator
* core, les: address comments
* les: fix lint
---------
Co-authored-by: Gary Rong <garyrong0905@gmail.com>
2023-06-28 09:11:02 +00:00
|
|
|
if len(t.id.AccountAddress) > 0 {
|
|
|
|
id = trie.StorageTrieID(t.id.StateRoot, crypto.Keccak256Hash(t.id.AccountAddress), t.id.Root)
|
cmd, core, eth, les, light: track deleted nodes (#25757)
* cmd, core, eth, les, light: track deleted nodes
* trie: add docs
* trie: address comments
* cmd, core, eth, les, light, trie: trie id
* trie: add tests
* trie, core: updates
* trie: fix imports
* trie: add utility print-method for nodeset
* trie: import err
* trie: fix go vet warnings
Co-authored-by: Martin Holst Swende <martin@swende.se>
2022-09-27 08:01:02 +00:00
|
|
|
} else {
|
|
|
|
id = trie.StateTrieID(t.id.StateRoot)
|
2022-06-06 15:14:55 +00:00
|
|
|
}
|
cmd, core, eth, les, light: track deleted nodes (#25757)
* cmd, core, eth, les, light: track deleted nodes
* trie: add docs
* trie: address comments
* cmd, core, eth, les, light, trie: trie id
* trie: add tests
* trie, core: updates
* trie: fix imports
* trie: add utility print-method for nodeset
* trie: import err
* trie: fix go vet warnings
Co-authored-by: Martin Holst Swende <martin@swende.se>
2022-09-27 08:01:02 +00:00
|
|
|
t, err := trie.New(id, trie.NewDatabase(t.db.backend.Database()))
|
2017-06-27 13:57:06 +00:00
|
|
|
if err == nil {
|
|
|
|
it.t.trie = t
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
})
|
|
|
|
}
|
|
|
|
it.do(func() error {
|
cmd, core/state, eth, tests, trie: improve state reader (#27428)
The state availability is checked during the creation of a state reader.
- In hash-based database, if the specified root node does not exist on disk disk, then
the state reader won't be created and an error will be returned.
- In path-based database, if the specified state layer is not available, then the
state reader won't be created and an error will be returned.
This change also contains a stricter semantics regarding the `Commit` operation: once it has been performed, the trie is no longer usable, and certain operations will return an error.
2023-06-20 19:31:45 +00:00
|
|
|
var err error
|
|
|
|
it.NodeIterator, err = it.t.trie.NodeIterator(startkey)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-06-27 13:57:06 +00:00
|
|
|
return it.NodeIterator.Error()
|
2015-11-30 12:34:19 +00:00
|
|
|
})
|
2017-06-27 13:57:06 +00:00
|
|
|
return it
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|
|
|
|
|
2017-06-27 13:57:06 +00:00
|
|
|
func (it *nodeIterator) Next(descend bool) bool {
|
|
|
|
var ok bool
|
|
|
|
it.do(func() error {
|
|
|
|
ok = it.NodeIterator.Next(descend)
|
|
|
|
return it.NodeIterator.Error()
|
2015-11-30 12:34:19 +00:00
|
|
|
})
|
2017-06-27 13:57:06 +00:00
|
|
|
return ok
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|
|
|
|
|
2017-06-27 13:57:06 +00:00
|
|
|
// do runs fn and attempts to fill in missing nodes by retrieving.
|
|
|
|
func (it *nodeIterator) do(fn func() error) {
|
|
|
|
var lasthash common.Hash
|
|
|
|
for {
|
|
|
|
it.err = fn()
|
|
|
|
missing, ok := it.err.(*trie.MissingNodeError)
|
|
|
|
if !ok {
|
|
|
|
return
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|
2017-06-27 13:57:06 +00:00
|
|
|
if missing.NodeHash == lasthash {
|
|
|
|
it.err = fmt.Errorf("retrieve loop for trie node %x", missing.NodeHash)
|
|
|
|
return
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|
2017-06-27 13:57:06 +00:00
|
|
|
lasthash = missing.NodeHash
|
|
|
|
r := &TrieRequest{Id: it.t.id, Key: nibblesToKey(missing.Path)}
|
|
|
|
if it.err = it.t.db.backend.Retrieve(it.t.db.ctx, r); it.err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (it *nodeIterator) Error() error {
|
|
|
|
if it.err != nil {
|
|
|
|
return it.err
|
|
|
|
}
|
|
|
|
return it.NodeIterator.Error()
|
|
|
|
}
|
|
|
|
|
|
|
|
func nibblesToKey(nib []byte) []byte {
|
|
|
|
if len(nib) > 0 && nib[len(nib)-1] == 0x10 {
|
|
|
|
nib = nib[:len(nib)-1] // drop terminator
|
|
|
|
}
|
|
|
|
if len(nib)&1 == 1 {
|
|
|
|
nib = append(nib, 0) // make even
|
|
|
|
}
|
|
|
|
key := make([]byte, len(nib)/2)
|
|
|
|
for bi, ni := 0, 0; ni < len(nib); bi, ni = bi+1, ni+2 {
|
|
|
|
key[bi] = nib[ni]<<4 | nib[ni+1]
|
|
|
|
}
|
|
|
|
return key
|
2015-11-30 12:34:19 +00:00
|
|
|
}
|