aboutsummaryrefslogtreecommitdiffstats
path: root/light/odr_util.go
blob: 97ba440ace1355cb815a0919526ab3db1f0c30a6 (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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
// Copyright 2016 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 (
    "bytes"
    "context"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/rlp"
)

var sha3_nil = crypto.Keccak256Hash(nil)

func GetHeaderByNumber(ctx context.Context, odr OdrBackend, number uint64) (*types.Header, error) {
    db := odr.Database()
    hash := core.GetCanonicalHash(db, number)
    if (hash != common.Hash{}) {
        // if there is a canonical hash, there is a header too
        header := core.GetHeader(db, hash, number)
        if header == nil {
            panic("Canonical hash present but header not found")
        }
        return header, nil
    }

    var (
        chtCount, sectionHeadNum uint64
        sectionHead              common.Hash
    )
    if odr.ChtIndexer() != nil {
        chtCount, sectionHeadNum, sectionHead = odr.ChtIndexer().Sections()
        canonicalHash := core.GetCanonicalHash(db, sectionHeadNum)
        // if the CHT was injected as a trusted checkpoint, we have no canonical hash yet so we accept zero hash too
        for chtCount > 0 && canonicalHash != sectionHead && canonicalHash != (common.Hash{}) {
            chtCount--
            if chtCount > 0 {
                sectionHeadNum = chtCount*CHTFrequencyClient - 1
                sectionHead = odr.ChtIndexer().SectionHead(chtCount - 1)
                canonicalHash = core.GetCanonicalHash(db, sectionHeadNum)
            }
        }
    }
    if number >= chtCount*CHTFrequencyClient {
        return nil, ErrNoTrustedCht
    }
    r := &ChtRequest{ChtRoot: GetChtRoot(db, chtCount-1, sectionHead), ChtNum: chtCount - 1, BlockNum: number}
    if err := odr.Retrieve(ctx, r); err != nil {
        return nil, err
    }
    return r.Header, nil
}

func GetCanonicalHash(ctx context.Context, odr OdrBackend, number uint64) (common.Hash, error) {
    hash := core.GetCanonicalHash(odr.Database(), number)
    if (hash != common.Hash{}) {
        return hash, nil
    }
    header, err := GetHeaderByNumber(ctx, odr, number)
    if header != nil {
        return header.Hash(), nil
    }
    return common.Hash{}, err
}

// GetBodyRLP retrieves the block body (transactions and uncles) in RLP encoding.
func GetBodyRLP(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (rlp.RawValue, error) {
    if data := core.GetBodyRLP(odr.Database(), hash, number); data != nil {
        return data, nil
    }
    r := &BlockRequest{Hash: hash, Number: number}
    if err := odr.Retrieve(ctx, r); err != nil {
        return nil, err
    } else {
        return r.Rlp, nil
    }
}

// GetBody retrieves the block body (transactons, uncles) corresponding to the
// hash.
func GetBody(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (*types.Body, error) {
    data, err := GetBodyRLP(ctx, odr, hash, number)
    if err != nil {
        return nil, err
    }
    body := new(types.Body)
    if err := rlp.Decode(bytes.NewReader(data), body); err != nil {
        return nil, err
    }
    return body, nil
}

// GetBlock retrieves an entire block corresponding to the hash, assembling it
// back from the stored header and body.
func GetBlock(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (*types.Block, error) {
    // Retrieve the block header and body contents
    header := core.GetHeader(odr.Database(), hash, number)
    if header == nil {
        return nil, ErrNoHeader
    }
    body, err := GetBody(ctx, odr, hash, number)
    if err != nil {
        return nil, err
    }
    // Reassemble the block and return
    return types.NewBlockWithHeader(header).WithBody(body.Transactions, body.Uncles), nil
}

// GetBlockReceipts retrieves the receipts generated by the transactions included
// in a block given by its hash.
func GetBlockReceipts(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (types.Receipts, error) {
    // Retrieve the potentially incomplete receipts from disk or network
    receipts := core.GetBlockReceipts(odr.Database(), hash, number)
    if receipts == nil {
        r := &ReceiptsRequest{Hash: hash, Number: number}
        if err := odr.Retrieve(ctx, r); err != nil {
            return nil, err
        }
        receipts = r.Receipts
    }
    // If the receipts are incomplete, fill the derived fields
    if len(receipts) > 0 && receipts[0].TxHash == (common.Hash{}) {
        block, err := GetBlock(ctx, odr, hash, number)
        if err != nil {
            return nil, err
        }
        genesis := core.GetCanonicalHash(odr.Database(), 0)
        config, _ := core.GetChainConfig(odr.Database(), genesis)

        core.SetReceiptsData(config, block, receipts)
        core.WriteBlockReceipts(odr.Database(), hash, number, receipts)
    }
    return receipts, nil
}

// GetBlockLogs retrieves the logs generated by the transactions included in a
// block given by its hash.
func GetBlockLogs(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) ([][]*types.Log, error) {
    // Retrieve the potentially incomplete receipts from disk or network
    receipts := core.GetBlockReceipts(odr.Database(), hash, number)
    if receipts == nil {
        r := &ReceiptsRequest{Hash: hash, Number: number}
        if err := odr.Retrieve(ctx, r); err != nil {
            return nil, err
        }
        receipts = r.Receipts
    }
    // Return the logs without deriving any computed fields on the receipts
    logs := make([][]*types.Log, len(receipts))
    for i, receipt := range receipts {
        logs[i] = receipt.Logs
    }
    return logs, nil
}

// GetBloomBits retrieves a batch of compressed bloomBits vectors belonging to the given bit index and section indexes
func GetBloomBits(ctx context.Context, odr OdrBackend, bitIdx uint, sectionIdxList []uint64) ([][]byte, error) {
    db := odr.Database()
    result := make([][]byte, len(sectionIdxList))
    var (
        reqList []uint64
        reqIdx  []int
    )

    var (
        bloomTrieCount, sectionHeadNum uint64
        sectionHead                    common.Hash
    )
    if odr.BloomTrieIndexer() != nil {
        bloomTrieCount, sectionHeadNum, sectionHead = odr.BloomTrieIndexer().Sections()
        canonicalHash := core.GetCanonicalHash(db, sectionHeadNum)
        // if the BloomTrie was injected as a trusted checkpoint, we have no canonical hash yet so we accept zero hash too
        for bloomTrieCount > 0 && canonicalHash != sectionHead && canonicalHash != (common.Hash{}) {
            bloomTrieCount--
            if bloomTrieCount > 0 {
                sectionHeadNum = bloomTrieCount*BloomTrieFrequency - 1
                sectionHead = odr.BloomTrieIndexer().SectionHead(bloomTrieCount - 1)
                canonicalHash = core.GetCanonicalHash(db, sectionHeadNum)
            }
        }
    }

    for i, sectionIdx := range sectionIdxList {
        sectionHead := core.GetCanonicalHash(db, (sectionIdx+1)*BloomTrieFrequency-1)
        // if we don't have the canonical hash stored for this section head number, we'll still look for
        // an entry with a zero sectionHead (we store it with zero section head too if we don't know it
        // at the time of the retrieval)
        bloomBits, err := core.GetBloomBits(db, bitIdx, sectionIdx, sectionHead)
        if err == nil {
            result[i] = bloomBits
        } else {
            if sectionIdx >= bloomTrieCount {
                return nil, ErrNoTrustedBloomTrie
            }
            reqList = append(reqList, sectionIdx)
            reqIdx = append(reqIdx, i)
        }
    }
    if reqList == nil {
        return result, nil
    }

    r := &BloomRequest{BloomTrieRoot: GetBloomTrieRoot(db, bloomTrieCount-1, sectionHead), BloomTrieNum: bloomTrieCount - 1, BitIdx: bitIdx, SectionIdxList: reqList}
    if err := odr.Retrieve(ctx, r); err != nil {
        return nil, err
    } else {
        for i, idx := range reqIdx {
            result[idx] = r.BloomBits[i]
        }
        return result, nil
    }
}