aboutsummaryrefslogtreecommitdiffstats
path: root/light/trie.go
blob: c5525358a43be75b619785924db5ece1a114ed67 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
// 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 (
    "github.com/ethereum/go-ethereum/ethdb"
    "github.com/ethereum/go-ethereum/trie"
    "golang.org/x/net/context"
)

// LightTrie is an ODR-capable wrapper around trie.SecureTrie
type LightTrie struct {
    trie *trie.SecureTrie
    id   *TrieID
    odr  OdrBackend
    db   ethdb.Database
}

// NewLightTrie creates a new LightTrie instance. It doesn't instantly try to
// access the db or network and retrieve the root node, it only initializes its
// encapsulated SecureTrie at the first actual operation.
func NewLightTrie(id *TrieID, odr OdrBackend, useFakeMap bool) *LightTrie {
    return &LightTrie{
        // SecureTrie is initialized before first request
        id:  id,
        odr: odr,
        db:  odr.Database(),
    }
}

// retrieveKey retrieves a single key, returns true and stores nodes in local
// database if successful
func (t *LightTrie) retrieveKey(ctx context.Context, key []byte) bool {
    r := &TrieRequest{Id: t.id, Key: key}
    return t.odr.Retrieve(ctx, r) == nil
}

// do tries and retries to execute a function until it returns with no error or
// an error type other than MissingNodeError
func (t *LightTrie) do(ctx context.Context, fallbackKey []byte, fn func() error) error {
    err := fn()
    for err != nil {
        mn, ok := err.(*trie.MissingNodeError)
        if !ok {
            return err
        }

        var key []byte
        if mn.PrefixLen+mn.SuffixLen > 0 {
            key = mn.Key
        } else {
            key = fallbackKey
        }
        if !t.retrieveKey(ctx, key) {
            break
        }
        err = fn()
    }
    return err
}

// Get returns the value for key stored in the trie.
// The value bytes must not be modified by the caller.
func (t *LightTrie) Get(ctx context.Context, key []byte) (res []byte, err error) {
    err = t.do(ctx, key, func() (err error) {
        if t.trie == nil {
            t.trie, err = trie.NewSecure(t.id.Root, t.db, 0)
        }
        if err == nil {
            res, err = t.trie.TryGet(key)
        }
        return
    })
    return
}

// Update associates key with value in the trie. Subsequent calls to
// Get will return value. If value has length zero, any existing value
// is deleted from the trie and calls to Get will return nil.
//
// The value bytes must not be modified by the caller while they are
// stored in the trie.
func (t *LightTrie) Update(ctx context.Context, key, value []byte) (err error) {
    err = t.do(ctx, key, func() (err error) {
        if t.trie == nil {
            t.trie, err = trie.NewSecure(t.id.Root, t.db, 0)
        }
        if err == nil {
            err = t.trie.TryUpdate(key, value)
        }
        return
    })
    return
}

// Delete removes any existing value for key from the trie.
func (t *LightTrie) Delete(ctx context.Context, key []byte) (err error) {
    err = t.do(ctx, key, func() (err error) {
        if t.trie == nil {
            t.trie, err = trie.NewSecure(t.id.Root, t.db, 0)
        }
        if err == nil {
            err = t.trie.TryDelete(key)
        }
        return
    })
    return
}