plugeth/les/odr_requests.go

357 lines
11 KiB
Go
Raw Normal View History

2016-11-09 01:01:56 +00:00
// Copyright 2016 The go-ethereum Authors
2016-10-14 03:51:29 +00:00
// 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 (
"encoding/binary"
"errors"
"fmt"
2016-10-14 03:51:29 +00:00
"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/log"
2016-10-14 03:51:29 +00:00
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/trie"
)
var (
errInvalidMessageType = errors.New("invalid message type")
errMultipleEntries = errors.New("multiple response entries")
errHeaderUnavailable = errors.New("header unavailable")
errTxHashMismatch = errors.New("transaction hash mismatch")
errUncleHashMismatch = errors.New("uncle hash mismatch")
errReceiptHashMismatch = errors.New("receipt hash mismatch")
errDataHashMismatch = errors.New("data hash mismatch")
errCHTHashMismatch = errors.New("cht hash mismatch")
)
2016-10-14 03:51:29 +00:00
type LesOdrRequest interface {
GetCost(*peer) uint64
CanSend(*peer) bool
2016-10-14 03:51:29 +00:00
Request(uint64, *peer) error
Validate(ethdb.Database, *Msg) error
2016-10-14 03:51:29 +00:00
}
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 (r *BlockRequest) GetCost(peer *peer) uint64 {
2016-10-14 03:51:29 +00:00
return peer.GetRequestCost(GetBlockBodiesMsg, 1)
}
// CanSend tells if a certain peer is suitable for serving the given request
func (r *BlockRequest) CanSend(peer *peer) bool {
return peer.HasBlock(r.Hash, r.Number)
}
2016-10-14 03:51:29 +00:00
// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (r *BlockRequest) Request(reqID uint64, peer *peer) error {
peer.Log().Debug("Requesting block body", "hash", r.Hash)
return peer.RequestBodies(reqID, r.GetCost(peer), []common.Hash{r.Hash})
2016-10-14 03:51:29 +00:00
}
// 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 (r *BlockRequest) Validate(db ethdb.Database, msg *Msg) error {
log.Debug("Validating block body", "hash", r.Hash)
// Ensure we have a correct message with a single block body
2016-10-14 03:51:29 +00:00
if msg.MsgType != MsgBlockBodies {
return errInvalidMessageType
2016-10-14 03:51:29 +00:00
}
bodies := msg.Obj.([]*types.Body)
if len(bodies) != 1 {
return errMultipleEntries
2016-10-14 03:51:29 +00:00
}
body := bodies[0]
// Retrieve our stored header and validate block content against it
header := core.GetHeader(db, r.Hash, r.Number)
2016-10-14 03:51:29 +00:00
if header == nil {
return errHeaderUnavailable
2016-10-14 03:51:29 +00:00
}
if header.TxHash != types.DeriveSha(types.Transactions(body.Transactions)) {
return errTxHashMismatch
2016-10-14 03:51:29 +00:00
}
if header.UncleHash != types.CalcUncleHash(body.Uncles) {
return errUncleHashMismatch
2016-10-14 03:51:29 +00:00
}
// Validations passed, encode and store RLP
2016-10-14 03:51:29 +00:00
data, err := rlp.EncodeToBytes(body)
if err != nil {
return err
2016-10-14 03:51:29 +00:00
}
r.Rlp = data
return nil
2016-10-14 03:51:29 +00:00
}
// 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 (r *ReceiptsRequest) GetCost(peer *peer) uint64 {
2016-10-14 03:51:29 +00:00
return peer.GetRequestCost(GetReceiptsMsg, 1)
}
// CanSend tells if a certain peer is suitable for serving the given request
func (r *ReceiptsRequest) CanSend(peer *peer) bool {
return peer.HasBlock(r.Hash, r.Number)
}
2016-10-14 03:51:29 +00:00
// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (r *ReceiptsRequest) Request(reqID uint64, peer *peer) error {
peer.Log().Debug("Requesting block receipts", "hash", r.Hash)
return peer.RequestReceipts(reqID, r.GetCost(peer), []common.Hash{r.Hash})
2016-10-14 03:51:29 +00:00
}
// 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 (r *ReceiptsRequest) Validate(db ethdb.Database, msg *Msg) error {
log.Debug("Validating block receipts", "hash", r.Hash)
// Ensure we have a correct message with a single block receipt
2016-10-14 03:51:29 +00:00
if msg.MsgType != MsgReceipts {
return errInvalidMessageType
2016-10-14 03:51:29 +00:00
}
receipts := msg.Obj.([]types.Receipts)
if len(receipts) != 1 {
return errMultipleEntries
2016-10-14 03:51:29 +00:00
}
receipt := receipts[0]
// Retrieve our stored header and validate receipt content against it
header := core.GetHeader(db, r.Hash, r.Number)
2016-10-14 03:51:29 +00:00
if header == nil {
return errHeaderUnavailable
2016-10-14 03:51:29 +00:00
}
if header.ReceiptHash != types.DeriveSha(receipt) {
return errReceiptHashMismatch
2016-10-14 03:51:29 +00:00
}
// Validations passed, store and return
r.Receipts = receipt
return nil
2016-10-14 03:51:29 +00:00
}
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 (r *TrieRequest) GetCost(peer *peer) uint64 {
2016-10-14 03:51:29 +00:00
return peer.GetRequestCost(GetProofsMsg, 1)
}
// CanSend tells if a certain peer is suitable for serving the given request
func (r *TrieRequest) CanSend(peer *peer) bool {
return peer.HasBlock(r.Id.BlockHash, r.Id.BlockNumber)
}
2016-10-14 03:51:29 +00:00
// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (r *TrieRequest) Request(reqID uint64, peer *peer) error {
peer.Log().Debug("Requesting trie proof", "root", r.Id.Root, "key", r.Key)
2016-10-14 03:51:29 +00:00
req := &ProofReq{
BHash: r.Id.BlockHash,
AccKey: r.Id.AccKey,
Key: r.Key,
2016-10-14 03:51:29 +00:00
}
return peer.RequestProofs(reqID, r.GetCost(peer), []*ProofReq{req})
2016-10-14 03:51:29 +00:00
}
// 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 (r *TrieRequest) Validate(db ethdb.Database, msg *Msg) error {
log.Debug("Validating trie proof", "root", r.Id.Root, "key", r.Key)
2016-10-14 03:51:29 +00:00
// Ensure we have a correct message with a single proof
2016-10-14 03:51:29 +00:00
if msg.MsgType != MsgProofs {
return errInvalidMessageType
2016-10-14 03:51:29 +00:00
}
proofs := msg.Obj.([][]rlp.RawValue)
if len(proofs) != 1 {
return errMultipleEntries
2016-10-14 03:51:29 +00:00
}
// Verify the proof and store if checks out
if _, err := trie.VerifyProof(r.Id.Root, r.Key, proofs[0]); err != nil {
return fmt.Errorf("merkle proof verification failed: %v", err)
2016-10-14 03:51:29 +00:00
}
r.Proof = proofs[0]
return nil
2016-10-14 03:51:29 +00:00
}
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 (r *CodeRequest) GetCost(peer *peer) uint64 {
2016-10-14 03:51:29 +00:00
return peer.GetRequestCost(GetCodeMsg, 1)
}
// CanSend tells if a certain peer is suitable for serving the given request
func (r *CodeRequest) CanSend(peer *peer) bool {
return peer.HasBlock(r.Id.BlockHash, r.Id.BlockNumber)
}
2016-10-14 03:51:29 +00:00
// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (r *CodeRequest) Request(reqID uint64, peer *peer) error {
peer.Log().Debug("Requesting code data", "hash", r.Hash)
2016-10-14 03:51:29 +00:00
req := &CodeReq{
BHash: r.Id.BlockHash,
AccKey: r.Id.AccKey,
2016-10-14 03:51:29 +00:00
}
return peer.RequestCode(reqID, r.GetCost(peer), []*CodeReq{req})
2016-10-14 03:51:29 +00:00
}
// 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 (r *CodeRequest) Validate(db ethdb.Database, msg *Msg) error {
log.Debug("Validating code data", "hash", r.Hash)
// Ensure we have a correct message with a single code element
2016-10-14 03:51:29 +00:00
if msg.MsgType != MsgCode {
return errInvalidMessageType
2016-10-14 03:51:29 +00:00
}
reply := msg.Obj.([][]byte)
if len(reply) != 1 {
return errMultipleEntries
2016-10-14 03:51:29 +00:00
}
data := reply[0]
// Verify the data and store if checks out
if hash := crypto.Keccak256Hash(data); r.Hash != hash {
return errDataHashMismatch
2016-10-14 03:51:29 +00:00
}
r.Data = data
return nil
2016-10-14 03:51:29 +00:00
}
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 (r *ChtRequest) GetCost(peer *peer) uint64 {
2016-10-14 03:51:29 +00:00
return peer.GetRequestCost(GetHeaderProofsMsg, 1)
}
// CanSend tells if a certain peer is suitable for serving the given request
func (r *ChtRequest) CanSend(peer *peer) bool {
peer.lock.RLock()
defer peer.lock.RUnlock()
return r.ChtNum <= (peer.headInfo.Number-light.ChtConfirmations)/light.ChtFrequency
}
2016-10-14 03:51:29 +00:00
// Request sends an ODR request to the LES network (implementation of LesOdrRequest)
func (r *ChtRequest) Request(reqID uint64, peer *peer) error {
peer.Log().Debug("Requesting CHT", "cht", r.ChtNum, "block", r.BlockNum)
2016-10-14 03:51:29 +00:00
req := &ChtReq{
ChtNum: r.ChtNum,
BlockNum: r.BlockNum,
2016-10-14 03:51:29 +00:00
}
return peer.RequestHeaderProofs(reqID, r.GetCost(peer), []*ChtReq{req})
2016-10-14 03:51:29 +00:00
}
// 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 (r *ChtRequest) Validate(db ethdb.Database, msg *Msg) error {
log.Debug("Validating CHT", "cht", r.ChtNum, "block", r.BlockNum)
2016-10-14 03:51:29 +00:00
// Ensure we have a correct message with a single proof element
2016-10-14 03:51:29 +00:00
if msg.MsgType != MsgHeaderProofs {
return errInvalidMessageType
2016-10-14 03:51:29 +00:00
}
proofs := msg.Obj.([]ChtResp)
if len(proofs) != 1 {
return errMultipleEntries
2016-10-14 03:51:29 +00:00
}
proof := proofs[0]
// Verify the CHT
2016-10-14 03:51:29 +00:00
var encNumber [8]byte
binary.BigEndian.PutUint64(encNumber[:], r.BlockNum)
value, err := trie.VerifyProof(r.ChtRoot, encNumber[:], proof.Proof)
2016-10-14 03:51:29 +00:00
if err != nil {
return err
2016-10-14 03:51:29 +00:00
}
var node light.ChtNode
if err := rlp.DecodeBytes(value, &node); err != nil {
return err
2016-10-14 03:51:29 +00:00
}
if node.Hash != proof.Header.Hash() {
return errCHTHashMismatch
2016-10-14 03:51:29 +00:00
}
// Verifications passed, store and return
r.Header = proof.Header
r.Proof = proof.Proof
r.Td = node.Td
2016-10-14 03:51:29 +00:00
return nil
2016-10-14 03:51:29 +00:00
}