This repository has been archived by the owner on Aug 19, 2024. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 189
/
protocol.go
237 lines (206 loc) · 8.1 KB
/
protocol.go
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
// Modifications Copyright 2018 The klaytn Authors
// Copyright 2014 The go-ethereum Authors
// This file is part of go-ethereum.
//
// 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/>.
//
// This file is derived from eth/protocol.go (2018/06/04).
// Modified and improved for the klaytn development.
package cn
import (
"fmt"
"io"
"math/big"
"time"
"github.com/klaytn/klaytn"
"github.com/klaytn/klaytn/blockchain/types"
"github.com/klaytn/klaytn/common"
"github.com/klaytn/klaytn/datasync/downloader"
"github.com/klaytn/klaytn/datasync/fetcher"
"github.com/klaytn/klaytn/node/cn/snap"
"github.com/klaytn/klaytn/reward"
"github.com/klaytn/klaytn/rlp"
)
// Constants to match up protocol versions and messages
const (
klay62 = 62
klay63 = 63
klay64 = 64
klay65 = 65
)
// ProtocolName is the official short name of the protocol used during capability negotiation.
var ProtocolName = "klay"
// ProtocolVersions are the upported versions of the klay protocol (first is primary).
var ProtocolVersions = []uint{klay65, klay64, klay63, klay62}
// ProtocolLengths are the number of implemented message corresponding to different protocol versions.
var ProtocolLengths = []uint64{21, 19, 17, 8}
const ProtocolMaxMsgSize = 12 * 1024 * 1024 // Maximum cap on the size of a protocol message
// Klaytn protocol message codes
// TODO-Klaytn-Issue751 Protocol message should be refactored. Present code is not used.
const (
// Protocol messages belonging to klay/62
StatusMsg = 0x00
NewBlockHashesMsg = 0x01
BlockHeaderFetchRequestMsg = 0x02
BlockHeaderFetchResponseMsg = 0x03
BlockBodiesFetchRequestMsg = 0x04
BlockBodiesFetchResponseMsg = 0x05
TxMsg = 0x06
BlockHeadersRequestMsg = 0x07
BlockHeadersMsg = 0x08
BlockBodiesRequestMsg = 0x09
BlockBodiesMsg = 0x0a
NewBlockMsg = 0x0b
// Protocol messages belonging to klay/63
NodeDataRequestMsg = 0x0c
NodeDataMsg = 0x0d
ReceiptsRequestMsg = 0x0e
ReceiptsMsg = 0x0f
// Protocol messages belonging to klay/64
Unused10 = 0x10 // Skipped a number because 0x11 is already taken
Unused11 = 0x11 // Already used by consensus (IstanbulMsg)
// Protocol messages belonging to klay/65
StakingInfoRequestMsg = 0x12
StakingInfoMsg = 0x13
MsgCodeEnd = 0x14
)
type errCode int
const (
ErrMsgTooLarge = iota
ErrDecode
ErrInvalidMsgCode
ErrProtocolVersionMismatch
ErrNetworkIdMismatch
ErrGenesisBlockMismatch
ErrChainIDMismatch
ErrNoStatusMsg
ErrExtraStatusMsg
ErrSuspendedPeer
ErrUnexpectedTxType
ErrFailedToGetStateDB
ErrUnsupportedEnginePolicy
)
func (e errCode) String() string {
return errorToString[int(e)]
}
// XXX change once legacy code is out
var errorToString = map[int]string{
ErrMsgTooLarge: "Message too long",
ErrDecode: "Invalid message",
ErrInvalidMsgCode: "Invalid message code",
ErrProtocolVersionMismatch: "Protocol version mismatch",
ErrNetworkIdMismatch: "NetworkId mismatch",
ErrGenesisBlockMismatch: "Genesis block mismatch",
ErrChainIDMismatch: "ChainID mismatch",
ErrNoStatusMsg: "No status message",
ErrExtraStatusMsg: "Extra status message",
ErrSuspendedPeer: "Suspended peer",
ErrUnexpectedTxType: "Unexpected tx type",
ErrFailedToGetStateDB: "Failed to get stateDB",
ErrUnsupportedEnginePolicy: "Unsupported engine or policy",
}
//go:generate mockgen -destination=node/cn/mocks/downloader_mock.go -package=mocks github.com/klaytn/klaytn/node/cn ProtocolManagerDownloader
// ProtocolManagerDownloader is an interface of downloader.Downloader used by ProtocolManager.
type ProtocolManagerDownloader interface {
RegisterPeer(id string, version int, peer downloader.Peer) error
UnregisterPeer(id string) error
DeliverBodies(id string, transactions [][]*types.Transaction) error
DeliverHeaders(id string, headers []*types.Header) error
DeliverNodeData(id string, data [][]byte) error
DeliverReceipts(id string, receipts [][]*types.Receipt) error
DeliverStakingInfos(id string, stakingInfos []*reward.StakingInfo) error
DeliverSnapPacket(peer *snap.Peer, packet snap.Packet) error
Terminate()
Synchronise(id string, head common.Hash, td *big.Int, mode downloader.SyncMode) error
Progress() klaytn.SyncProgress
Cancel()
GetSnapSyncer() *snap.Syncer
SyncStakingInfo(id string, from, to uint64) error
SyncStakingInfoStatus() *downloader.SyncingStatus
}
//go:generate mockgen -destination=node/cn/mocks/fetcher_mock.go -package=mocks github.com/klaytn/klaytn/node/cn ProtocolManagerFetcher
// ProtocolManagerFetcher is an interface of fetcher.Fetcher used by ProtocolManager.
type ProtocolManagerFetcher interface {
Enqueue(peer string, block *types.Block) error
FilterBodies(peer string, transactions [][]*types.Transaction, time time.Time) [][]*types.Transaction
FilterHeaders(peer string, headers []*types.Header, time time.Time) []*types.Header
Notify(peer string, hash common.Hash, number uint64, time time.Time, headerFetcher fetcher.HeaderRequesterFn, bodyFetcher fetcher.BodyRequesterFn) error
Start()
Stop()
}
// statusData is the network packet for the status message.
type statusData struct {
ProtocolVersion uint32
NetworkId uint64
TD *big.Int
CurrentBlock common.Hash
GenesisBlock common.Hash
ChainID *big.Int // ChainID to sign a transaction.
}
// newBlockHashesData is the network packet for the block announcements.
type newBlockHashesData []struct {
Hash common.Hash // Hash of one particular block being announced
Number uint64 // Number of one particular block being announced
}
// getBlockHeadersData represents a block header query.
type getBlockHeadersData struct {
Origin hashOrNumber // Block from which to retrieve headers
Amount uint64 // Maximum number of headers to retrieve
Skip uint64 // Blocks to skip between consecutive headers
Reverse bool // Query direction (false = rising towards latest, true = falling towards genesis)
}
// hashOrNumber is a combined field for specifying an origin block.
type hashOrNumber struct {
Hash common.Hash // Block hash from which to retrieve headers (excludes Number)
Number uint64 // Block hash from which to retrieve headers (excludes Hash)
}
// EncodeRLP is a specialized encoder for hashOrNumber to encode only one of the
// two contained union fields.
func (hn *hashOrNumber) EncodeRLP(w io.Writer) error {
if hn.Hash == (common.Hash{}) {
return rlp.Encode(w, hn.Number)
}
if hn.Number != 0 {
return fmt.Errorf("both origin hash (%x) and number (%d) provided", hn.Hash, hn.Number)
}
return rlp.Encode(w, hn.Hash)
}
// DecodeRLP is a specialized decoder for hashOrNumber to decode the contents
// into either a block hash or a block number.
func (hn *hashOrNumber) DecodeRLP(s *rlp.Stream) error {
_, size, _ := s.Kind()
origin, err := s.Raw()
if err == nil {
switch {
case size == 32:
err = rlp.DecodeBytes(origin, &hn.Hash)
case size <= 8:
err = rlp.DecodeBytes(origin, &hn.Number)
default:
err = fmt.Errorf("invalid input size %d for origin", size)
}
}
return err
}
// newBlockData is the network packet for the block propagation message.
type newBlockData struct {
Block *types.Block
TD *big.Int
}
// blockBody represents the data content of a single block.
type blockBody struct {
Transactions []*types.Transaction // Transactions contained within a block
}
// blockBodiesData is the network packet for block content distribution.
type blockBodiesData []*blockBody