aboutsummaryrefslogtreecommitdiffstats
path: root/les/odr_requests.go
blob: a4fbd79f654763a3c6e64b3559a8aefa1b86a3c4 (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
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
// 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 implements on-demand retrieval capable state and chain objects
// for the Ethereum Light Client.
package les

import (
    "bytes"
    "encoding/binary"

    "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/ethdb"
    "github.com/ethereum/go-ethereum/light"
    "github.com/ethereum/go-ethereum/logger"
    "github.com/ethereum/go-ethereum/logger/glog"
    "github.com/ethereum/go-ethereum/rlp"
    "github.com/ethereum/go-ethereum/trie"
)

type LesOdrRequest interface {
    GetCost(*peer) uint64
    CanSend(*peer) bool
    Request(uint64, *peer) error
    Valid(ethdb.Database, *Msg) bool // if true, keeps the retrieved object
}

func LesRequest(req light.OdrRequest) LesOdrRequest {
    switch r := req.(type) {
    case *light.BlockRequest:
        return (*BlockRequest)(r)
    case *light.ReceiptsRequest:
        return (*ReceiptsRequest)(r)
    case *light.TrieRequest:
        return (*TrieRequest)(r)
    case *light.CodeRequest:
        return (*CodeRequest)(r)
    case *light.ChtRequest:
        return (*ChtRequest)(r)
    default:
        return nil
    }
}

// BlockRequest is the ODR request type for block bodies
type BlockRequest light.BlockRequest

// GetCost returns the cost of the given ODR request according to the serving
// peer's cost table (implementation of LesOdrRequest)
func (self *BlockRequest) GetCost(peer *peer) uint64 {
    return peer.GetRequestCost(GetBlockBodiesMsg, 1)
}

// CanSend tells if a certain peer is suitable for serving the given request
func (self *BlockRequest) CanSend(peer *peer) bool {
    return peer.HasBlock(self.Hash, self.Number)
}

// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (self *BlockRequest) Request(reqID uint64, peer *peer) error {
    glog.V(logger.Debug).Infof("ODR: requesting body of block %08x from peer %v", self.Hash[:4], peer.id)
    return peer.RequestBodies(reqID, self.GetCost(peer), []common.Hash{self.Hash})
}

// Valid processes an ODR request reply message from the LES network
// returns true and stores results in memory if the message was a valid reply
// to the request (implementation of LesOdrRequest)
func (self *BlockRequest) Valid(db ethdb.Database, msg *Msg) bool {
    glog.V(logger.Debug).Infof("ODR: validating body of block %08x", self.Hash[:4])
    if msg.MsgType != MsgBlockBodies {
        glog.V(logger.Debug).Infof("ODR: invalid message type")
        return false
    }
    bodies := msg.Obj.([]*types.Body)
    if len(bodies) != 1 {
        glog.V(logger.Debug).Infof("ODR: invalid number of entries: %d", len(bodies))
        return false
    }
    body := bodies[0]
    header := core.GetHeader(db, self.Hash, self.Number)
    if header == nil {
        glog.V(logger.Debug).Infof("ODR: header not found for block %08x", self.Hash[:4])
        return false
    }
    txHash := types.DeriveSha(types.Transactions(body.Transactions))
    if header.TxHash != txHash {
        glog.V(logger.Debug).Infof("ODR: header.TxHash %08x does not match received txHash %08x", header.TxHash[:4], txHash[:4])
        return false
    }
    uncleHash := types.CalcUncleHash(body.Uncles)
    if header.UncleHash != uncleHash {
        glog.V(logger.Debug).Infof("ODR: header.UncleHash %08x does not match received uncleHash %08x", header.UncleHash[:4], uncleHash[:4])
        return false
    }
    data, err := rlp.EncodeToBytes(body)
    if err != nil {
        glog.V(logger.Debug).Infof("ODR: body RLP encode error: %v", err)
        return false
    }
    self.Rlp = data
    glog.V(logger.Debug).Infof("ODR: validation successful")
    return true
}

// ReceiptsRequest is the ODR request type for block receipts by block hash
type ReceiptsRequest light.ReceiptsRequest

// GetCost returns the cost of the given ODR request according to the serving
// peer's cost table (implementation of LesOdrRequest)
func (self *ReceiptsRequest) GetCost(peer *peer) uint64 {
    return peer.GetRequestCost(GetReceiptsMsg, 1)
}

// CanSend tells if a certain peer is suitable for serving the given request
func (self *ReceiptsRequest) CanSend(peer *peer) bool {
    return peer.HasBlock(self.Hash, self.Number)
}

// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (self *ReceiptsRequest) Request(reqID uint64, peer *peer) error {
    glog.V(logger.Debug).Infof("ODR: requesting receipts for block %08x from peer %v", self.Hash[:4], peer.id)
    return peer.RequestReceipts(reqID, self.GetCost(peer), []common.Hash{self.Hash})
}

// Valid processes an ODR request reply message from the LES network
// returns true and stores results in memory if the message was a valid reply
// to the request (implementation of LesOdrRequest)
func (self *ReceiptsRequest) Valid(db ethdb.Database, msg *Msg) bool {
    glog.V(logger.Debug).Infof("ODR: validating receipts for block %08x", self.Hash[:4])
    if msg.MsgType != MsgReceipts {
        glog.V(logger.Debug).Infof("ODR: invalid message type")
        return false
    }
    receipts := msg.Obj.([]types.Receipts)
    if len(receipts) != 1 {
        glog.V(logger.Debug).Infof("ODR: invalid number of entries: %d", len(receipts))
        return false
    }
    hash := types.DeriveSha(receipts[0])
    header := core.GetHeader(db, self.Hash, self.Number)
    if header == nil {
        glog.V(logger.Debug).Infof("ODR: header not found for block %08x", self.Hash[:4])
        return false
    }
    if !bytes.Equal(header.ReceiptHash[:], hash[:]) {
        glog.V(logger.Debug).Infof("ODR: header receipts hash %08x does not match calculated RLP hash %08x", header.ReceiptHash[:4], hash[:4])
        return false
    }
    self.Receipts = receipts[0]
    glog.V(logger.Debug).Infof("ODR: validation successful")
    return true
}

type ProofReq struct {
    BHash       common.Hash
    AccKey, Key []byte
    FromLevel   uint
}

// ODR request type for state/storage trie entries, see LesOdrRequest interface
type TrieRequest light.TrieRequest

// GetCost returns the cost of the given ODR request according to the serving
// peer's cost table (implementation of LesOdrRequest)
func (self *TrieRequest) GetCost(peer *peer) uint64 {
    return peer.GetRequestCost(GetProofsMsg, 1)
}

// CanSend tells if a certain peer is suitable for serving the given request
func (self *TrieRequest) CanSend(peer *peer) bool {
    return peer.HasBlock(self.Id.BlockHash, self.Id.BlockNumber)
}

// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (self *TrieRequest) Request(reqID uint64, peer *peer) error {
    glog.V(logger.Debug).Infof("ODR: requesting trie root %08x key %08x from peer %v", self.Id.Root[:4], self.Key[:4], peer.id)
    req := &ProofReq{
        BHash:  self.Id.BlockHash,
        AccKey: self.Id.AccKey,
        Key:    self.Key,
    }
    return peer.RequestProofs(reqID, self.GetCost(peer), []*ProofReq{req})
}

// Valid processes an ODR request reply message from the LES network
// returns true and stores results in memory if the message was a valid reply
// to the request (implementation of LesOdrRequest)
func (self *TrieRequest) Valid(db ethdb.Database, msg *Msg) bool {
    glog.V(logger.Debug).Infof("ODR: validating trie root %08x key %08x", self.Id.Root[:4], self.Key[:4])

    if msg.MsgType != MsgProofs {
        glog.V(logger.Debug).Infof("ODR: invalid message type")
        return false
    }
    proofs := msg.Obj.([][]rlp.RawValue)
    if len(proofs) != 1 {
        glog.V(logger.Debug).Infof("ODR: invalid number of entries: %d", len(proofs))
        return false
    }
    _, err := trie.VerifyProof(self.Id.Root, self.Key, proofs[0])
    if err != nil {
        glog.V(logger.Debug).Infof("ODR: merkle proof verification error: %v", err)
        return false
    }
    self.Proof = proofs[0]
    glog.V(logger.Debug).Infof("ODR: validation successful")
    return true
}

type CodeReq struct {
    BHash  common.Hash
    AccKey []byte
}

// ODR request type for node data (used for retrieving contract code), see LesOdrRequest interface
type CodeRequest light.CodeRequest

// GetCost returns the cost of the given ODR request according to the serving
// peer's cost table (implementation of LesOdrRequest)
func (self *CodeRequest) GetCost(peer *peer) uint64 {
    return peer.GetRequestCost(GetCodeMsg, 1)
}

// CanSend tells if a certain peer is suitable for serving the given request
func (self *CodeRequest) CanSend(peer *peer) bool {
    return peer.HasBlock(self.Id.BlockHash, self.Id.BlockNumber)
}

// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (self *CodeRequest) Request(reqID uint64, peer *peer) error {
    glog.V(logger.Debug).Infof("ODR: requesting node data for hash %08x from peer %v", self.Hash[:4], peer.id)
    req := &CodeReq{
        BHash:  self.Id.BlockHash,
        AccKey: self.Id.AccKey,
    }
    return peer.RequestCode(reqID, self.GetCost(peer), []*CodeReq{req})
}

// Valid processes an ODR request reply message from the LES network
// returns true and stores results in memory if the message was a valid reply
// to the request (implementation of LesOdrRequest)
func (self *CodeRequest) Valid(db ethdb.Database, msg *Msg) bool {
    glog.V(logger.Debug).Infof("ODR: validating node data for hash %08x", self.Hash[:4])
    if msg.MsgType != MsgCode {
        glog.V(logger.Debug).Infof("ODR: invalid message type")
        return false
    }
    reply := msg.Obj.([][]byte)
    if len(reply) != 1 {
        glog.V(logger.Debug).Infof("ODR: invalid number of entries: %d", len(reply))
        return false
    }
    data := reply[0]
    hash := crypto.Sha3Hash(data)
    if !bytes.Equal(self.Hash[:], hash[:]) {
        glog.V(logger.Debug).Infof("ODR: requested hash %08x does not match received data hash %08x", self.Hash[:4], hash[:4])
        return false
    }
    self.Data = data
    glog.V(logger.Debug).Infof("ODR: validation successful")
    return true
}

type ChtReq struct {
    ChtNum, BlockNum, FromLevel uint64
}

type ChtResp struct {
    Header *types.Header
    Proof  []rlp.RawValue
}

// ODR request type for requesting headers by Canonical Hash Trie, see LesOdrRequest interface
type ChtRequest light.ChtRequest

// GetCost returns the cost of the given ODR request according to the serving
// peer's cost table (implementation of LesOdrRequest)
func (self *ChtRequest) GetCost(peer *peer) uint64 {
    return peer.GetRequestCost(GetHeaderProofsMsg, 1)
}

// CanSend tells if a certain peer is suitable for serving the given request
func (self *ChtRequest) CanSend(peer *peer) bool {
    peer.lock.RLock()
    defer peer.lock.RUnlock()

    return self.ChtNum <= (peer.headInfo.Number-light.ChtConfirmations)/light.ChtFrequency
}

// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (self *ChtRequest) Request(reqID uint64, peer *peer) error {
    glog.V(logger.Debug).Infof("ODR: requesting CHT #%d block #%d from peer %v", self.ChtNum, self.BlockNum, peer.id)
    req := &ChtReq{
        ChtNum:   self.ChtNum,
        BlockNum: self.BlockNum,
    }
    return peer.RequestHeaderProofs(reqID, self.GetCost(peer), []*ChtReq{req})
}

// Valid processes an ODR request reply message from the LES network
// returns true and stores results in memory if the message was a valid reply
// to the request (implementation of LesOdrRequest)
func (self *ChtRequest) Valid(db ethdb.Database, msg *Msg) bool {
    glog.V(logger.Debug).Infof("ODR: validating CHT #%d block #%d", self.ChtNum, self.BlockNum)

    if msg.MsgType != MsgHeaderProofs {
        glog.V(logger.Debug).Infof("ODR: invalid message type")
        return false
    }
    proofs := msg.Obj.([]ChtResp)
    if len(proofs) != 1 {
        glog.V(logger.Debug).Infof("ODR: invalid number of entries: %d", len(proofs))
        return false
    }
    proof := proofs[0]
    var encNumber [8]byte
    binary.BigEndian.PutUint64(encNumber[:], self.BlockNum)
    value, err := trie.VerifyProof(self.ChtRoot, encNumber[:], proof.Proof)
    if err != nil {
        glog.V(logger.Debug).Infof("ODR: CHT merkle proof verification error: %v", err)
        return false
    }
    var node light.ChtNode
    if err := rlp.DecodeBytes(value, &node); err != nil {
        glog.V(logger.Debug).Infof("ODR: error decoding CHT node: %v", err)
        return false
    }
    if node.Hash != proof.Header.Hash() {
        glog.V(logger.Debug).Infof("ODR: CHT header hash does not match")
        return false
    }

    self.Proof = proof.Proof
    self.Header = proof.Header
    self.Td = node.Td
    glog.V(logger.Debug).Infof("ODR: validation successful")
    return true
}