forked from bitcoin/bitcoin
/
spork.h
287 lines (244 loc) · 9.65 KB
/
spork.h
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
// Copyright (c) 2014-2017 The Dash Core developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef SPORK_H
#define SPORK_H
#include "hash.h"
#include "net.h"
#include "utilstrencodings.h"
#include "key.h"
class CSporkMessage;
class CSporkManager;
/*
Don't ever reuse these IDs for other sporks
- This would result in old clients getting confused about which spork is for what
*/
static const int SPORK_2_INSTANTSEND_ENABLED = 10001;
static const int SPORK_3_INSTANTSEND_BLOCK_FILTERING = 10002;
static const int SPORK_5_INSTANTSEND_MAX_VALUE = 10004;
static const int SPORK_6_NEW_SIGS = 10005;
static const int SPORK_8_MASTERNODE_PAYMENT_ENFORCEMENT = 10007;
static const int SPORK_9_SUPERBLOCKS_ENABLED = 10008;
static const int SPORK_10_MASTERNODE_PAY_UPDATED_NODES = 10009;
static const int SPORK_12_RECONSIDER_BLOCKS = 10011;
static const int SPORK_14_REQUIRE_SENTINEL_FLAG = 10013;
static const int SPORK_15_DETERMINISTIC_MNS_ENABLED = 10014;
static const int SPORK_16_INSTANTSEND_AUTOLOCKS = 10015;
static const int SPORK_START = SPORK_2_INSTANTSEND_ENABLED;
static const int SPORK_END = SPORK_16_INSTANTSEND_AUTOLOCKS;
extern std::map<int, int64_t> mapSporkDefaults;
extern CSporkManager sporkManager;
/**
* Sporks are network parameters used primarily to prevent forking and turn
* on/off certain features. They are a soft consensus mechanism.
*
* We use 2 main classes to manage the spork system.
*
* SporkMessages - low-level constructs which contain the sporkID, value,
* signature and a signature timestamp
* SporkManager - a higher-level construct which manages the naming, use of
* sporks, signatures and verification, and which sporks are active according
* to this node
*/
/**
* CSporkMessage is a low-level class used to encapsulate Spork messages and
* serialize them for transmission to other peers. This includes the internal
* spork ID, value, spork signature and timestamp for the signature.
*/
class CSporkMessage
{
private:
std::vector<unsigned char> vchSig;
public:
int nSporkID;
int64_t nValue;
int64_t nTimeSigned;
CSporkMessage(int nSporkID, int64_t nValue, int64_t nTimeSigned) :
nSporkID(nSporkID),
nValue(nValue),
nTimeSigned(nTimeSigned)
{}
CSporkMessage() :
nSporkID(0),
nValue(0),
nTimeSigned(0)
{}
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action) {
READWRITE(nSporkID);
READWRITE(nValue);
READWRITE(nTimeSigned);
READWRITE(vchSig);
}
/**
* GetHash returns the double-sha256 hash of the serialized spork message.
*/
uint256 GetHash() const;
/**
* GetSignatureHash returns the hash of the serialized spork message
* without the signature included. The intent of this method is to get the
* hash to be signed.
*/
uint256 GetSignatureHash() const;
/**
* Sign will sign the spork message with the given key.
*/
bool Sign(const CKey& key, bool fSporkSixActive);
/**
* CheckSignature will ensure the spork signature matches the provided public
* key hash.
*/
bool CheckSignature(const CKeyID& pubKeyId, bool fSporkSixActive) const;
/**
* GetSignerKeyID is used to recover the spork address of the key used to
* sign this spork message.
*
* This method was introduced along with the multi-signer sporks feature,
* in order to identify which spork key signed this message.
*/
bool GetSignerKeyID(CKeyID& retKeyidSporkSigner, bool fSporkSixActive);
/**
* Relay is used to send this spork message to other peers.
*/
void Relay(CConnman& connman);
};
/**
* CSporkManager is a higher-level class which manages the node's spork
* messages, rules for which sporks should be considered active/inactive, and
* processing for certain sporks (e.g. spork 12).
*/
class CSporkManager
{
private:
static const std::string SERIALIZATION_VERSION_STRING;
mutable CCriticalSection cs;
std::map<uint256, CSporkMessage> mapSporksByHash;
std::map<int, std::map<CKeyID, CSporkMessage> > mapSporksActive;
std::set<CKeyID> setSporkPubKeyIDs;
int nMinSporkKeys;
CKey sporkPrivKey;
/**
* SporkValueIsActive is used to get the value agreed upon by the majority
* of signed spork messages for a given Spork ID.
*/
bool SporkValueIsActive(int nSporkID, int64_t& nActiveValueRet) const;
public:
CSporkManager() {}
ADD_SERIALIZE_METHODS;
template <typename Stream, typename Operation>
inline void SerializationOp(Stream& s, Operation ser_action) {
std::string strVersion;
if(ser_action.ForRead()) {
READWRITE(strVersion);
if (strVersion != SERIALIZATION_VERSION_STRING) {
return;
}
} else {
strVersion = SERIALIZATION_VERSION_STRING;
READWRITE(strVersion);
}
// we don't serialize pubkey ids because pubkeys should be
// hardcoded or be setted with cmdline or options, should
// not reuse pubkeys from previous dashd run
READWRITE(mapSporksByHash);
READWRITE(mapSporksActive);
// we don't serialize private key to prevent its leakage
}
/**
* Clear is used to clear all in-memory active spork messages. Since spork
* public and private keys are set in init.cpp, we do not clear them here.
*
* This method was introduced along with the spork cache.
*/
void Clear();
/**
* CheckAndRemove is defined to fulfill an interface as part of the on-disk
* cache used to cache sporks between runs. If sporks that are restored
* from cache do not have valid signatures when compared against the
* current spork private keys, they are removed from in-memory storage.
*
* This method was introduced along with the spork cache.
*/
void CheckAndRemove();
/**
* ProcessSpork is used to handle the 'getsporks' and 'spork' p2p messages.
*
* For 'getsporks', it sends active sporks to the requesting peer. For 'spork',
* it validates the spork and adds it to the internal spork storage and
* performs any necessary processing.
*/
void ProcessSpork(CNode* pfrom, const std::string& strCommand, CDataStream& vRecv, CConnman& connman);
/**
* ExecuteSpork is used to perform certain actions based on the spork value.
*
* Currently only used with Spork 12.
*/
void ExecuteSpork(int nSporkID, int nValue);
/**
* UpdateSpork is used by the spork RPC command to set a new spork value, sign
* and broadcast the spork message.
*/
bool UpdateSpork(int nSporkID, int64_t nValue, CConnman& connman);
/**
* IsSporkActive returns a bool for time-based sporks, and should be used
* to determine whether the spork can be considered active or not.
*
* For value-based sporks such as SPORK_5_INSTANTSEND_MAX_VALUE, the spork
* value should not be considered a timestamp, but an integer value
* instead, and therefore this method doesn't make sense and should not be
* used.
*/
bool IsSporkActive(int nSporkID);
/**
* GetSporkValue returns the spork value given a Spork ID. If no active spork
* message has yet been received by the node, it returns the default value.
*/
int64_t GetSporkValue(int nSporkID);
/**
* GetSporkIDByName returns the internal Spork ID given the spork name.
*/
int GetSporkIDByName(const std::string& strName);
/**
* GetSporkNameByID returns the spork name as a string, given a Spork ID.
*/
std::string GetSporkNameByID(int nSporkID);
/**
* GetSporkByHash returns a spork message given a hash of the spork message.
*
* This is used when a requesting peer sends a MSG_SPORK inventory message with
* the hash, to quickly lookup and return the full spork message. We maintain a
* hash-based index of sporks for this reason, and this function is the access
* point into that index.
*/
bool GetSporkByHash(const uint256& hash, CSporkMessage &sporkRet);
/**
* SetSporkAddress is used to set a public key ID which will be used to
* verify spork signatures.
*
* This can be called multiple times to add multiple keys to the set of
* valid spork signers.
*/
bool SetSporkAddress(const std::string& strAddress);
/**
* SetMinSporkKeys is used to set the required spork signer threshold, for
* a spork to be considered active.
*
* This value must be at least a majority of the total number of spork
* keys, and for obvious resons cannot be larger than that number.
*/
bool SetMinSporkKeys(int minSporkKeys);
/**
* SetPrivKey is used to set a spork key to enable setting / signing of
* spork values.
*
* This will return false if the private key does not match any spork
* address in the set of valid spork signers (see SetSporkAddress).
*/
bool SetPrivKey(const std::string& strPrivKey);
/**
* ToString returns the string representation of the SporkManager.
*/
std::string ToString() const;
};
#endif