Electroneum
chain_split_1.cpp
Go to the documentation of this file.
1 // Copyrights(c) 2017-2021, The Electroneum Project
2 // Copyrights(c) 2014-2019, The Monero Project
3 //
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without modification, are
7 // permitted provided that the following conditions are met:
8 //
9 // 1. Redistributions of source code must retain the above copyright notice, this list of
10 // conditions and the following disclaimer.
11 //
12 // 2. Redistributions in binary form must reproduce the above copyright notice, this list
13 // of conditions and the following disclaimer in the documentation and/or other
14 // materials provided with the distribution.
15 //
16 // 3. Neither the name of the copyright holder nor the names of its contributors may be
17 // used to endorse or promote products derived from this software without specific
18 // prior written permission.
19 //
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
21 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
23 // THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
27 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28 // THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
31 
32 #include "chaingen.h"
33 #include "chain_split_1.h"
34 
35 using namespace std;
36 
37 using namespace epee;
38 using namespace cryptonote;
39 
40 
42 {
51  //REGISTER_CALLBACK("check_orphaned_chain_1", gen_simple_chain_split_1::check_orphaned_chain_1);
52  //REGISTER_CALLBACK("check_orphaned_switched_to_alternative", gen_simple_chain_split_1::check_orphaned_switched_to_alternative);
53  //REGISTER_CALLBACK("check_orphaned_chain_2", gen_simple_chain_split_1::check_orphaned_chain_2);
54  //REGISTER_CALLBACK("check_orphaned_switched_to_main", gen_simple_chain_split_1::check_orphaned_switched_to_main);
55  //REGISTER_CALLBACK("check_orphaned_chain_38", gen_simple_chain_split_1::check_orphaned_chain_38);
56  //REGISTER_CALLBACK("check_orphaned_chain_39", gen_simple_chain_split_1::check_orphaned_chain_39);
57  //REGISTER_CALLBACK("check_orphaned_chain_40", gen_simple_chain_split_1::check_orphaned_chain_40);
58  //REGISTER_CALLBACK("check_orphaned_chain_41", gen_simple_chain_split_1::check_orphaned_chain_41);
59 }
60 //-----------------------------------------------------------------------------------------------------
61 bool gen_simple_chain_split_1::generate(std::vector<test_event_entry> &events) const
62 {
63  uint64_t ts_start = 1338224400;
64  /*
65  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 <-- main blockchain height
66  (0 )-(1 )-(2 )-(3 )-(4 )-(5 ) -(6 ) -(7 ) -(8 )|-(17) -(18) -(19) -(20) -(21)|-(22)|-(23)|-(24)|
67  \ -(9 ) -(10)|-(11)|-(12)|-(13) -(14) -(15) -(16)
68  -(25) -(26)|
69  -(27)| #check switching to alternative
70  ----------------------------------------------------------------------------------
71  -(28) -(29) -(30) -(31)|
72  -(32)| #check switching orphans to main
73  ----------------------------------------------------------------------------------
74  -(33) -(34) -(35) -(36) -(37) -(38)|
75  -(39)| #<--this part becomes alternative chain connected to main
76  -(40)| #still marked as orphaned
77  -(41)|
78  #check orphaned with block in the middle of the orphaned chain
79  */
80 
81  GENERATE_ACCOUNT(first_miner_account);
82  // events index
83  MAKE_GENESIS_BLOCK(events, blk_0, first_miner_account, ts_start); // 0
84  MAKE_NEXT_BLOCK(events, blk_1, blk_0, first_miner_account); // 1
85  MAKE_NEXT_BLOCK(events, blk_2, blk_1, first_miner_account); // 2
86  MAKE_NEXT_BLOCK(events, blk_3, blk_2, first_miner_account); // 3
87  MAKE_NEXT_BLOCK(events, blk_4, blk_3, first_miner_account); // 4
88  MAKE_NEXT_BLOCK(events, blk_5, blk_4, first_miner_account); // 5
89  MAKE_NEXT_BLOCK(events, blk_6, blk_5, first_miner_account); // 6
90  MAKE_NEXT_BLOCK(events, blk_7, blk_6, first_miner_account); // 7
91  MAKE_NEXT_BLOCK(events, blk_8, blk_7, first_miner_account); // 8
92  //split
93  MAKE_NEXT_BLOCK(events, blk_9, blk_5, first_miner_account); // 9
94  MAKE_NEXT_BLOCK(events, blk_10, blk_9, first_miner_account); // 10
95  DO_CALLBACK(events, "check_split_not_switched"); // 11
96  MAKE_NEXT_BLOCK(events, blk_11, blk_10, first_miner_account); // 12
97  DO_CALLBACK(events, "check_split_not_switched2"); // 13
98  MAKE_NEXT_BLOCK(events, blk_12, blk_11, first_miner_account); // 14
99  DO_CALLBACK(events, "check_split_switched"); // 15
100  MAKE_NEXT_BLOCK(events, blk_13, blk_12, first_miner_account); // 16
101  MAKE_NEXT_BLOCK(events, blk_14, blk_13, first_miner_account); // 17
102  MAKE_NEXT_BLOCK(events, blk_15, blk_14, first_miner_account); // 18
103  MAKE_NEXT_BLOCK(events, blk_16, blk_15, first_miner_account); // 19
104  //split again and check back switching
105  MAKE_NEXT_BLOCK(events, blk_17, blk_8, first_miner_account); // 20
106  MAKE_NEXT_BLOCK(events, blk_18, blk_17, first_miner_account); // 21
107  MAKE_NEXT_BLOCK(events, blk_19, blk_18, first_miner_account); // 22
108  MAKE_NEXT_BLOCK(events, blk_20, blk_19, first_miner_account); // 23
109  MAKE_NEXT_BLOCK(events, blk_21, blk_20, first_miner_account); // 24
110  DO_CALLBACK(events, "check_split_not_switched_back"); // 25
111  MAKE_NEXT_BLOCK(events, blk_22, blk_21, first_miner_account); // 26
112  DO_CALLBACK(events, "check_split_switched_back_1"); // 27
113  MAKE_NEXT_BLOCK(events, blk_23, blk_22, first_miner_account); // 28
114  DO_CALLBACK(events, "check_split_switched_back_2"); // 29
115 
116  REWIND_BLOCKS(events, blk_23r, blk_23, first_miner_account); // 30...N1
117  GENERATE_ACCOUNT(alice);
118  MAKE_TX(events, tx_0, first_miner_account, alice, MK_COINS(10), blk_23); // N1+1
119  MAKE_TX(events, tx_1, first_miner_account, alice, MK_COINS(20), blk_23); // N1+2
120  MAKE_TX(events, tx_2, first_miner_account, alice, MK_COINS(30), blk_23); // N1+3
121  DO_CALLBACK(events, "check_mempool_1"); // N1+4
122  MAKE_NEXT_BLOCK_TX1(events, blk_24, blk_23r, first_miner_account, tx_0); // N1+5
123  DO_CALLBACK(events, "check_mempool_2"); // N1+6
124  /*
125  //check orphaned blocks
126  MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_27, blk_16, get_test_target(), first_miner_account);
127  MAKE_NEXT_BLOCK(events, blk_25, blk_orph_27, get_test_target(), first_miner_account); // 36
128  MAKE_NEXT_BLOCK(events, blk_26, blk_25, get_test_target(), first_miner_account); // 37
129  DO_CALLBACK(events, "check_orphaned_chain_1"); // 38
130  ADD_BLOCK(events, blk_orph_27); // 39
131  DO_CALLBACK(events, "check_orphaned_switched_to_alternative"); // 40
132 
133  //check orphaned check to main chain
134  MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_32, blk_16, get_test_target(), first_miner_account);
135  MAKE_NEXT_BLOCK(events, blk_28, blk_orph_32, get_test_target(), first_miner_account); // 41
136  MAKE_NEXT_BLOCK(events, blk_29, blk_28, get_test_target(), first_miner_account); // 42
137  MAKE_NEXT_BLOCK(events, blk_30, blk_29, get_test_target(), first_miner_account); // 43
138  MAKE_NEXT_BLOCK(events, blk_31, blk_30, get_test_target(), first_miner_account); // 44
139  DO_CALLBACK(events, "check_orphaned_chain_2"); // 45
140  ADD_BLOCK(events, blk_orph_32); // 46
141  DO_CALLBACK(events, "check_orphaned_switched_to_main"); // 47
142 
143  //check orphaned check to main chain
144  MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_39, blk_16, get_test_target(), first_miner_account);
145  MAKE_NEXT_BLOCK(events, blk_33, blk_orph_39, get_test_target(), first_miner_account); // 48
146  MAKE_NEXT_BLOCK(events, blk_34, blk_33, get_test_target(), first_miner_account); // 49
147  MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_41, blk_34, get_test_target(), first_miner_account);
148  MAKE_NEXT_BLOCK(events, blk_35, blk_orph_41, get_test_target(), first_miner_account); // 50
149  MAKE_NEXT_BLOCK(events, blk_36, blk_35, get_test_target(), first_miner_account); // 51
150  MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_40, blk_36, get_test_target(), first_miner_account);
151  MAKE_NEXT_BLOCK(events, blk_37, blk_orph_40, get_test_target(), first_miner_account); // 52
152  MAKE_NEXT_BLOCK(events, blk_38, blk_37, get_test_target(), first_miner_account); // 53
153  DO_CALLBACK(events, "check_orphaned_chain_38"); // 54
154  ADD_BLOCK(events, blk_orph_39); // 55
155  DO_CALLBACK(events, "check_orphaned_chain_39"); // 56
156  ADD_BLOCK(events, blk_orph_40); // 57
157  DO_CALLBACK(events, "check_orphaned_chain_40"); // 58
158  ADD_BLOCK(events, blk_orph_41); // 59
159  DO_CALLBACK(events, "check_orphaned_chain_41"); // 60
160  */
161  return true;
162 }
163 //-----------------------------------------------------------------------------------------------------
164 bool gen_simple_chain_split_1::check_mempool_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
165 {
166  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_mempool_2");
168  return true;
169 }
170 //-----------------------------------------------------------------------------------------------------
171 bool gen_simple_chain_split_1::check_mempool_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
172 {
173  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_mempool_1");
175  return true;
176 }
177 //-----------------------------------------------------------------------------------------------------
178 bool gen_simple_chain_split_1::check_split_not_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
179 {
180  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_not_switched");
181  //check height
184  CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[8])));
186  return true;
187 }
188 //-----------------------------------------------------------------------------------------------------
189 bool gen_simple_chain_split_1::check_split_not_switched2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
190 {
191  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_not_switched2");
192  //check height
195  CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[8])));
197  return true;
198 }
199 //-----------------------------------------------------------------------------------------------------
200 bool gen_simple_chain_split_1::check_split_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
201 {
202  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_switched");
203 
204  //check height
207  CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[14])));
209  return true;
210 }
211 //-----------------------------------------------------------------------------------------------------
212 bool gen_simple_chain_split_1::check_split_not_switched_back(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
213 {
214  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_not_switched_back");
215  //check height
218  CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[19])));
220 
221  return true;
222 }
223 //-----------------------------------------------------------------------------------------------------
224 bool gen_simple_chain_split_1::check_split_switched_back_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
225 {
226  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_switched_back_1");
227 
228  //check height
231  CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[26])));
233 
234  return true;
235 }//-----------------------------------------------------------------------------------------------------
236 bool gen_simple_chain_split_1::check_split_switched_back_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
237 {
238  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_switched_back_2");
239 
240  //check height
243  CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[28])));
245  return true;
246 }
247 //-----------------------------------------------------------------------------------------------------
248 /*
249 bool gen_simple_chain_split_1::check_orphaned_chain_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
250 {
251  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_1");
252  CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 2);
253  return true;
254 }
255 //-----------------------------------------------------------------------------------------------------
256 bool gen_simple_chain_split_1::check_orphaned_switched_to_alternative(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
257 {
258  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_switched_to_alternative");
259  CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 0);
260  CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 17);
261  CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 11);
262  return true;
263 }
264 //-----------------------------------------------------------------------------------------------------
265 bool gen_simple_chain_split_1::check_orphaned_chain_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
266 {
267  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_2");
268  CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 4);
269  return true;
270 }
271 //-----------------------------------------------------------------------------------------------------
272 bool gen_simple_chain_split_1::check_orphaned_switched_to_main(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
273 {
274  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_switched_to_main");
275  CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 0);
276  CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 19);
277  CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 14);
278  return true;
279 }
280 //-----------------------------------------------------------------------------------------------------
281 bool gen_simple_chain_split_1::check_orphaned_chain_38(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
282 {
283  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_38");
284  CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 6);
285  CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 14);
286  CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 19);
287  return true;
288 }
289 //-----------------------------------------------------------------------------------------------------
290 bool gen_simple_chain_split_1::check_orphaned_chain_39(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
291 {
292  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_39");
293  CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 4);
294  CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 17);
295  CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 19);
296  return true;
297 }
298 //-----------------------------------------------------------------------------------------------------
299 bool gen_simple_chain_split_1::check_orphaned_chain_40(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
300 {
301  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_40");
302  CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 5);
303  CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 17);
304  CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 19);
305  return true;
306 }
307 //-----------------------------------------------------------------------------------------------------
308 bool gen_simple_chain_split_1::check_orphaned_chain_41(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)
309 {
310  DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_41");
311  CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 0);
312  CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 19);
313  CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 23);
314 
315  return true;
316 }*/
317 //-----------------------------------------------------------------------------------------------------
318 
319 
320 
#define MAKE_NEXT_BLOCK_TX1(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, TX1)
Definition: chaingen.h:849
bool check_split_switched(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
crypto::hash get_tail_id() const
get the hash of the most recent block on the blockchain
bool check_split_not_switched_back(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
bool check_mempool_1(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
STL namespace.
#define MAKE_NEXT_BLOCK(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC)
Definition: chaingen.h:839
#define CHECK_TEST_CONDITION(cond)
Definition: chaingen.h:1057
Holds cryptonote related classes and helpers.
Definition: ban.cpp:40
uint64_t get_current_blockchain_height() const
get the current height of the blockchain
bool check_split_switched_back_2(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
handles core cryptonote functionality
#define MAKE_GENESIS_BLOCK(VEC_EVENTS, BLK_NAME, MINER_ACC, TS)
Definition: chaingen.h:833
#define REGISTER_CALLBACK(CB_NAME, CLBACK)
Definition: chaingen.h:827
unsigned __int64 uint64_t
Definition: stdint.h:136
bool generate(std::vector< test_event_entry > &events) const
bool check_split_switched_back_1(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
size_t get_pool_transactions_count() const
get the total number of transactions in the pool
bool check_split_not_switched2(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
#define REWIND_BLOCKS(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC)
Definition: chaingen.h:890
size_t get_alternative_blocks_count() const
returns the number of alternative blocks stored
bool check_mempool_2(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
#define MAKE_TX(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, HEAD)
Definition: chaingen.h:903
bool check_split_not_switched(cryptonote::core &c, size_t ev_index, const std::vector< test_event_entry > &events)
crypto::hash get_block_hash(uint64_t height)
#define MK_COINS(amount)
Definition: chaingen.h:1060
#define GENERATE_ACCOUNT(account)
Definition: chaingen.h:801
#define DEFINE_TESTS_ERROR_CONTEXT(text)
Definition: chaingen.h:1056
#define DO_CALLBACK(VEC_EVENTS, CB_NAME)
Definition: chaingen.h:820
size_t get_blockchain_total_transactions() const
gets the total number of transactions on the main chain