Bitcoin ABC 0.30.5
P2P Digital Currency
grasberg_tests.cpp
Go to the documentation of this file.
1// Copyright (c) 2015-2019 The Bitcoin Core developers
2// Distributed under the MIT/X11 software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <pow/grasberg.h>
6
7#include <chain.h>
8#include <chainparams.h>
9#include <test/lcg.h>
10
11#include <test/util/setup_common.h>
12
13#include <boost/test/unit_test.hpp>
14
15#include <cmath>
16
17using namespace grasberg;
18
19BOOST_FIXTURE_TEST_SUITE(grasberg_tests, BasicTestingSetup)
20
21BOOST_AUTO_TEST_CASE(exp2_test) {
22 BOOST_CHECK_EQUAL(deterministicExp2(0), 0);
23 BOOST_CHECK_EQUAL(deterministicExp2(1), 0);
24 BOOST_CHECK_EQUAL(deterministicExp2(42), 29);
25 BOOST_CHECK_EQUAL(deterministicExp2(0x000ff1ce), 724359);
26 BOOST_CHECK_EQUAL(deterministicExp2(0x0badf00d), 137991563);
27 BOOST_CHECK_EQUAL(deterministicExp2(0x7fffffff), 1779033703);
28 BOOST_CHECK_EQUAL(deterministicExp2(0x80000000), 1779033704);
29 BOOST_CHECK_EQUAL(deterministicExp2(0xdeadbeef), 3553907236);
30 BOOST_CHECK_EQUAL(deterministicExp2(0xfeedcafe), 4270091087);
31 BOOST_CHECK_EQUAL(deterministicExp2(0xffffffff), 4294967294);
32
33 // 100 randomly picked values.
34 BOOST_CHECK_EQUAL(deterministicExp2(0x087ae9b4), 0x05f22b96);
35 BOOST_CHECK_EQUAL(deterministicExp2(0x5425cdf3), 0x41818942);
36 BOOST_CHECK_EQUAL(deterministicExp2(0x8dbb6e9b), 0x77c0cbd7);
37 BOOST_CHECK_EQUAL(deterministicExp2(0xc72cd267), 0xb6fc25bf);
38 BOOST_CHECK_EQUAL(deterministicExp2(0x9a67c66f), 0x84ded919);
39 BOOST_CHECK_EQUAL(deterministicExp2(0x94667388), 0x7e994692);
40 BOOST_CHECK_EQUAL(deterministicExp2(0x589c28c9), 0x456a0046);
41 BOOST_CHECK_EQUAL(deterministicExp2(0x54a063f8), 0x41ec5164);
42 BOOST_CHECK_EQUAL(deterministicExp2(0xe4741ebb), 0xdb33b0e3);
43 BOOST_CHECK_EQUAL(deterministicExp2(0xed6e1573), 0xe6e49c99);
44 BOOST_CHECK_EQUAL(deterministicExp2(0xd74a77d8), 0xca907219);
45 BOOST_CHECK_EQUAL(deterministicExp2(0xe9615051), 0xe19549ff);
46 BOOST_CHECK_EQUAL(deterministicExp2(0x4b52afdf), 0x39ea41a3);
47 BOOST_CHECK_EQUAL(deterministicExp2(0x9c23c8e3), 0x86b372e0);
48 BOOST_CHECK_EQUAL(deterministicExp2(0x7e3b8bb5), 0x684f7012);
49 BOOST_CHECK_EQUAL(deterministicExp2(0x6e2a4d01), 0x58f8adc7);
50 BOOST_CHECK_EQUAL(deterministicExp2(0xf82b8d68), 0xf5427e75);
51 BOOST_CHECK_EQUAL(deterministicExp2(0x95c28f4c), 0x80028e21);
52 BOOST_CHECK_EQUAL(deterministicExp2(0x7e7814bf), 0x688a837b);
53 BOOST_CHECK_EQUAL(deterministicExp2(0x315df77b), 0x249c68ce);
54 BOOST_CHECK_EQUAL(deterministicExp2(0x64c8d384), 0x5051d61a);
55 BOOST_CHECK_EQUAL(deterministicExp2(0x7e60ec44), 0x6873e8ca);
56 BOOST_CHECK_EQUAL(deterministicExp2(0x3b8b004f), 0x2cc90282);
57 BOOST_CHECK_EQUAL(deterministicExp2(0x444c4ea5), 0x3400274f);
58 BOOST_CHECK_EQUAL(deterministicExp2(0x80759f4a), 0x6a7d4596);
59 BOOST_CHECK_EQUAL(deterministicExp2(0xe7e46027), 0xdfa5919f);
60 BOOST_CHECK_EQUAL(deterministicExp2(0x487b844b), 0x37829001);
61 BOOST_CHECK_EQUAL(deterministicExp2(0xdd45a3f4), 0xd20d0b36);
62 BOOST_CHECK_EQUAL(deterministicExp2(0x3e03f2ea), 0x2ece376f);
63 BOOST_CHECK_EQUAL(deterministicExp2(0xe69e7c49), 0xddff10d2);
64 BOOST_CHECK_EQUAL(deterministicExp2(0x2901bda5), 0x1e0fcf09);
65 BOOST_CHECK_EQUAL(deterministicExp2(0x196a8489), 0x123cc6f8);
66 BOOST_CHECK_EQUAL(deterministicExp2(0x9a19b128), 0x848caaea);
67 BOOST_CHECK_EQUAL(deterministicExp2(0x0398cca8), 0x02815e0a);
68 BOOST_CHECK_EQUAL(deterministicExp2(0xbef03f61), 0xad4da3d5);
69 BOOST_CHECK_EQUAL(deterministicExp2(0x102e1734), 0x0b76e599);
70 BOOST_CHECK_EQUAL(deterministicExp2(0xf363cf7b), 0xeed050f5);
71 BOOST_CHECK_EQUAL(deterministicExp2(0x82c00c2d), 0x6cbe9fc1);
72 BOOST_CHECK_EQUAL(deterministicExp2(0xcffbcde3), 0xc194a25a);
73 BOOST_CHECK_EQUAL(deterministicExp2(0x18d6f2fe), 0x11cf4a02);
74 BOOST_CHECK_EQUAL(deterministicExp2(0xde1ea615), 0xd31f327e);
75 BOOST_CHECK_EQUAL(deterministicExp2(0x0e96d48f), 0x0a509911);
76 BOOST_CHECK_EQUAL(deterministicExp2(0x378fa034), 0x298f481e);
77 BOOST_CHECK_EQUAL(deterministicExp2(0x857061ec), 0x6f68e4c5);
78 BOOST_CHECK_EQUAL(deterministicExp2(0xc8408fdd), 0xb8445ebf);
79 BOOST_CHECK_EQUAL(deterministicExp2(0x09c3db93), 0x06dbe12d);
80 BOOST_CHECK_EQUAL(deterministicExp2(0x128598df), 0x0d2a6e92);
81 BOOST_CHECK_EQUAL(deterministicExp2(0x7fa9d335), 0x69b57700);
82 BOOST_CHECK_EQUAL(deterministicExp2(0x1177f216), 0x0c6630f5);
83 BOOST_CHECK_EQUAL(deterministicExp2(0xa7b1dfcd), 0x931e2c0c);
84 BOOST_CHECK_EQUAL(deterministicExp2(0xb0be2271), 0x9d1d8e6c);
85 BOOST_CHECK_EQUAL(deterministicExp2(0x665c61aa), 0x51c21b91);
86 BOOST_CHECK_EQUAL(deterministicExp2(0xe4472200), 0xdaf9d24c);
87 BOOST_CHECK_EQUAL(deterministicExp2(0x9ba928c3), 0x8631cfcc);
88 BOOST_CHECK_EQUAL(deterministicExp2(0xd1464a98), 0xc327a2cc);
89 BOOST_CHECK_EQUAL(deterministicExp2(0x64a0901d), 0x502d2df6);
90 BOOST_CHECK_EQUAL(deterministicExp2(0x636df03b), 0x4f16881e);
91 BOOST_CHECK_EQUAL(deterministicExp2(0x61bf5d3f), 0x4d90c410);
92 BOOST_CHECK_EQUAL(deterministicExp2(0xa8bf3caa), 0x944498b4);
93 BOOST_CHECK_EQUAL(deterministicExp2(0x683ed475), 0x537c7131);
94 BOOST_CHECK_EQUAL(deterministicExp2(0xb375673c), 0xa02a1e57);
95 BOOST_CHECK_EQUAL(deterministicExp2(0xcd1e7fa3), 0xbe1b716f);
96 BOOST_CHECK_EQUAL(deterministicExp2(0x8d064b3f), 0x7708af2d);
97 BOOST_CHECK_EQUAL(deterministicExp2(0x83148fe1), 0x6d122064);
98 BOOST_CHECK_EQUAL(deterministicExp2(0xbee2c2b4), 0xad3df6c9);
99 BOOST_CHECK_EQUAL(deterministicExp2(0x8f39659e), 0x794630af);
100 BOOST_CHECK_EQUAL(deterministicExp2(0x0cc3e1a5), 0x0900b8f2);
101 BOOST_CHECK_EQUAL(deterministicExp2(0xc41798fb), 0xb355fb23);
102 BOOST_CHECK_EQUAL(deterministicExp2(0x4dc8ef08), 0x3c03bab6);
103 BOOST_CHECK_EQUAL(deterministicExp2(0x00171815), 0x00100270);
104 BOOST_CHECK_EQUAL(deterministicExp2(0xdb6c9075), 0xcfb99180);
105 BOOST_CHECK_EQUAL(deterministicExp2(0x13cd960c), 0x0e19e23a);
106 BOOST_CHECK_EQUAL(deterministicExp2(0x9e19dd37), 0x88c7fe4a);
107 BOOST_CHECK_EQUAL(deterministicExp2(0x3afa11d6), 0x2c53111d);
108 BOOST_CHECK_EQUAL(deterministicExp2(0x03867141), 0x0274851a);
109 BOOST_CHECK_EQUAL(deterministicExp2(0x65b991fe), 0x512d57a0);
110 BOOST_CHECK_EQUAL(deterministicExp2(0x8960fee9), 0x7359a24d);
111 BOOST_CHECK_EQUAL(deterministicExp2(0x06302a65), 0x04534f70);
112 BOOST_CHECK_EQUAL(deterministicExp2(0x9ab4e776), 0x85301748);
113 BOOST_CHECK_EQUAL(deterministicExp2(0xd5c11fed), 0xc8a9149c);
114 BOOST_CHECK_EQUAL(deterministicExp2(0xcd325145), 0xbe33626d);
115 BOOST_CHECK_EQUAL(deterministicExp2(0x45dd5919), 0x354f4f40);
116 BOOST_CHECK_EQUAL(deterministicExp2(0xa5074b00), 0x9037d404);
117 BOOST_CHECK_EQUAL(deterministicExp2(0x19139f48), 0x11fc48dc);
118 BOOST_CHECK_EQUAL(deterministicExp2(0x0ef74095), 0x0a962932);
119 BOOST_CHECK_EQUAL(deterministicExp2(0x6d1ae43b), 0x57fb888b);
120 BOOST_CHECK_EQUAL(deterministicExp2(0x021946f0), 0x017578d9);
121 BOOST_CHECK_EQUAL(deterministicExp2(0xcae745a8), 0xbb7059dd);
122 BOOST_CHECK_EQUAL(deterministicExp2(0x47572522), 0x368c57ef);
123 BOOST_CHECK_EQUAL(deterministicExp2(0x576843af), 0x445b2880);
124 BOOST_CHECK_EQUAL(deterministicExp2(0x5b5734e9), 0x47d4359b);
125 BOOST_CHECK_EQUAL(deterministicExp2(0xb504a24a), 0xa1eced3c);
126 BOOST_CHECK_EQUAL(deterministicExp2(0xa99c6f97), 0x95370102);
127 BOOST_CHECK_EQUAL(deterministicExp2(0xd63094c2), 0xc932f907);
128 BOOST_CHECK_EQUAL(deterministicExp2(0x8339e407), 0x6d370833);
129 BOOST_CHECK_EQUAL(deterministicExp2(0x79056f7b), 0x63430c57);
130 BOOST_CHECK_EQUAL(deterministicExp2(0xee327961), 0xe7e7c8fb);
131 BOOST_CHECK_EQUAL(deterministicExp2(0x89c5e1a0), 0x73bf2027);
132 BOOST_CHECK_EQUAL(deterministicExp2(0x1f28adf5), 0x1688f169);
133 BOOST_CHECK_EQUAL(deterministicExp2(0x74abd815), 0x5f1a2852);
134
135 // Check a ton of random values.
136 MMIXLinearCongruentialGenerator lcg;
137 for (int i = 0; i < 100000; i++) {
138 static constexpr int64_t POW2_32 = int64_t(1) << 32;
139
140 const uint32_t n = lcg.next();
141 const double d = double(n) / POW2_32;
142
143 const double computed = double(deterministicExp2(n)) / POW2_32;
144 const double expected = exp2(d) - 1;
145
146 BOOST_CHECK(fabs(computed - expected) < 0.0000000075);
147 }
148}
149
150BOOST_AUTO_TEST_CASE(target_block_time_test) {
151 const auto chainParams =
152 CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
153 const auto &params = chainParams->GetConsensus();
154
155 const int nHeight = 100000;
156 const int64_t expectedBlockTime =
157 nHeight * params.nPowTargetSpacing + chainParams->GenesisBlock().nTime;
158
159 CBlockIndex block;
160 block.nHeight = nHeight;
161 block.nTime = expectedBlockTime;
162
163 // When block come on schedule, the block time is what we expect.
164 BOOST_CHECK_EQUAL(computeTargetBlockTime(&block, *chainParams),
165 params.nPowTargetSpacing);
166
167 // As block come later and later, the block time we target gets shorter.
168 int64_t currentTarget = params.nPowTargetSpacing;
169 std::vector<int> downSteps = {
170 2910, 2916, 2921, 2925, 2931, 2935, 2941, 2945, 2950, 2955, 2961,
171 2965, 2970, 2976, 2980, 2986, 2991, 2995, 3001, 3007, 3011, 3016,
172 3022, 3027, 3033, 3037, 3043, 3048, 3054, 3059, 3064, 3069, 3076,
173 3080, 3086, 3091, 3097, 3103, 3107, 3114, 3119, 3124, 3131, 3135,
174 3142, 3147, 3153, 3158, 3165, 3170, 3175, 3182, 3187, 3194, 3199,
175 3205, 3210, 3217, 3223, 3228, 3235, 3241, 3246, 3253, 3259, 3265,
176 };
177
178 for (int step : downSteps) {
179 currentTarget--;
180 for (int i = 0; i < step; i++) {
181 block.nTime++;
182 BOOST_CHECK_EQUAL(computeTargetBlockTime(&block, *chainParams),
183 currentTarget);
184 }
185 }
186
187 // Now we reached saturation and the targeted block time will stay where it
188 // is.
189 currentTarget--;
190 for (int i = 0; i < 10000; i++) {
191 block.nTime++;
192 BOOST_CHECK_EQUAL(computeTargetBlockTime(&block, *chainParams),
193 currentTarget);
194 }
195
196 // As block come sooner and sooner, the block time we target gets longer.
197 block.nTime = expectedBlockTime;
198 currentTarget = params.nPowTargetSpacing;
199 std::vector<int> upSteps = {
200 2906, 2901, 2896, 2892, 2887, 2882, 2877, 2873, 2867, 2864, 2858,
201 2854, 2849, 2844, 2840, 2835, 2831, 2826, 2822, 2816, 2813, 2808,
202 2803, 2799, 2794, 2790, 2786, 2781, 2776, 2772, 2768, 2764, 2759,
203 2754, 2751, 2746, 2741, 2738, 2733, 2729, 2724, 2721, 2716, 2711,
204 2708, 2704, 2699, 2695, 2691, 2687, 2682, 2679, 2674, 2671, 2666,
205 2662, 2658, 2655, 2650, 2646, 2642, 2638, 2634, 2630, 2626, 2622,
206 2619, 2614, 2611, 2606, 2603, 2599, 2594, 2592,
207 };
208
209 for (int step : upSteps) {
210 for (int i = 0; i < step; i++) {
211 block.nTime--;
212 BOOST_CHECK_EQUAL(computeTargetBlockTime(&block, *chainParams),
213 currentTarget);
214 }
215 currentTarget++;
216 }
217
218 // Now we reached saturation and the targeted block time will stay where it
219 // is.
220 for (int i = 0; i < 10000; i++) {
221 block.nTime--;
222 BOOST_CHECK_EQUAL(computeTargetBlockTime(&block, *chainParams),
223 currentTarget);
224 }
225}
226
227static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval,
228 uint32_t nBits) {
229 CBlockIndex block;
230 block.pprev = pindexPrev;
231 block.nHeight = pindexPrev->nHeight + 1;
232 block.nTime = pindexPrev->nTime + nTimeInterval;
233 block.nBits = nBits;
234
235 block.nChainWork = pindexPrev->nChainWork + GetBlockProof(block);
236 return block;
237}
238
239BOOST_AUTO_TEST_CASE(grasberg_test) {
240 const auto chainParams =
241 CreateChainParams(*m_node.args, CBaseChainParams::MAIN);
242 const auto &params = chainParams->GetConsensus();
243
244 std::vector<CBlockIndex> blocks(3000);
245
246 const arith_uint256 powLimit = UintToArith256(params.powLimit);
247 uint32_t powLimitBits = powLimit.GetCompact();
248 arith_uint256 currentPow = powLimit >> 4;
249 uint32_t initialBits = currentPow.GetCompact();
250
251 // Genesis block.
252 blocks[0] = CBlockIndex();
253 blocks[0].nHeight = 0;
254 blocks[0].nTime = 1269211443;
255 blocks[0].nBits = initialBits;
256
257 blocks[0].nChainWork = GetBlockProof(blocks[0]);
258
259 // Check that we can use Grasberg directly from genesis.
260 CBlockHeader blkHeaderDummy;
261 uint32_t nBits =
262 GetNextGrasbergWorkRequired(&blocks[0], &blkHeaderDummy, *chainParams);
263 BOOST_CHECK_EQUAL(nBits, 0x1c100195);
264
265 // Mine several blocks and check the difficulty.
266 size_t h = 1;
267
268 // Mine regular 600s blocks.
269 std::vector<uint32_t> diffs = {
270 0x1c10032b, 0x1c1004c1, 0x1c100658, 0x1c1007ef, 0x1c100986, 0x1c100b1d,
271 0x1c100cb4, 0x1c100e4b, 0x1c100fe3, 0x1c10117b, 0x1c101313, 0x1c1014ab,
272 0x1c101643, 0x1c1017db, 0x1c101974, 0x1c101b0d, 0x1c101ca6, 0x1c101e3f,
273 0x1c101fd8, 0x1c102171, 0x1c10230a, 0x1c1024a4, 0x1c10263e, 0x1c1027d8,
274 0x1c102972, 0x1c102b0c, 0x1c102ca6, 0x1c102e41, 0x1c102fdc, 0x1c103177,
275 0x1c103312, 0x1c1034ad, 0x1c103648, 0x1c1037e4, 0x1c103980, 0x1c103b1c,
276 0x1c103cb8, 0x1c103e54, 0x1c103ff0, 0x1c10418c, 0x1c104329, 0x1c1044c6,
277 0x1c104663, 0x1c104800, 0x1c10499d, 0x1c104b3a, 0x1c104cd8, 0x1c104e76,
278 0x1c105014, 0x1c1051b2, 0x1c105350, 0x1c1054ee, 0x1c10568d, 0x1c10582c,
279 0x1c1059cb, 0x1c105b6a, 0x1c105d09, 0x1c105ea8, 0x1c106048, 0x1c1061e8,
280 0x1c106388, 0x1c106528, 0x1c1066c8, 0x1c106868, 0x1c106a09, 0x1c106baa,
281 0x1c106d4b, 0x1c106eec, 0x1c10708d, 0x1c10722e, 0x1c1073cf, 0x1c107571,
282 0x1c107713, 0x1c1078b5, 0x1c107a57, 0x1c107bf9, 0x1c107d9b, 0x1c107f3e,
283 0x1c1080e1, 0x1c108284, 0x1c108427, 0x1c1085ca, 0x1c10876d, 0x1c108911,
284 0x1c108ab5, 0x1c108c59, 0x1c108dfd, 0x1c108fa1, 0x1c109145, 0x1c1092ea,
285 0x1c10948f, 0x1c109634, 0x1c1097d9, 0x1c10997e, 0x1c109b23, 0x1c109cc9,
286 0x1c109e6f, 0x1c10a015, 0x1c10a1bb, 0x1c10a361, 0x1c10a507, 0x1c10a6ae,
287 0x1c10a855, 0x1c10a9fc, 0x1c10aba3, 0x1c10ad4a, 0x1c10aef1, 0x1c10b099,
288 0x1c10b241, 0x1c10b3e9, 0x1c10b591, 0x1c10b739, 0x1c10b8e1, 0x1c10ba8a,
289 0x1c10bc33, 0x1c10bddc, 0x1c10bf85, 0x1c10c12e, 0x1c10c2d7, 0x1c10c480,
290 0x1c10c62a, 0x1c10c7d4, 0x1c10c97e, 0x1c10cb28, 0x1c10ccd2, 0x1c10ce7c,
291 0x1c10d027, 0x1c10d1d2, 0x1c10d37d, 0x1c10d528, 0x1c10d6d3, 0x1c10d87e,
292 0x1c10da2a, 0x1c10dbd6, 0x1c10dd82, 0x1c10df2e, 0x1c10e0da, 0x1c10e286,
293 0x1c10e433, 0x1c10e5e0, 0x1c10e78d, 0x1c10e93a, 0x1c10eae7, 0x1c10ec94,
294 0x1c10ee42, 0x1c10eff0, 0x1c10f19e, 0x1c10f34c, 0x1c10f4fa, 0x1c10f6a8,
295 0x1c10f857, 0x1c10fa06, 0x1c10fbb5, 0x1c10fd64, 0x1c10ff13, 0x1c1100c2,
296 0x1c110272, 0x1c110422, 0x1c1105d2, 0x1c110782, 0x1c110932, 0x1c110ae2,
297 0x1c110c93, 0x1c110e44, 0x1c110ff5, 0x1c1111a6, 0x1c111357, 0x1c111508,
298 0x1c1116ba, 0x1c11186c, 0x1c111a1e, 0x1c111bd0, 0x1c111d82, 0x1c111f34,
299 0x1c1120e7, 0x1c11229a, 0x1c11244d, 0x1c112600, 0x1c1127b3, 0x1c112967,
300 0x1c112b1b, 0x1c112ccf, 0x1c112e83, 0x1c113037, 0x1c1131eb, 0x1c1133a0,
301 0x1c113555, 0x1c11370a, 0x1c1138bf, 0x1c113a74, 0x1c113c29, 0x1c113ddf,
302 0x1c113f95, 0x1c11414b, 0x1c114301, 0x1c1144b7, 0x1c11466d, 0x1c114824,
303 0x1c1149db, 0x1c114b92, 0x1c114d49, 0x1c114f00, 0x1c1150b7, 0x1c11526f,
304 0x1c115427, 0x1c1155df, 0x1c115797, 0x1c11594f, 0x1c115b07, 0x1c115cc0,
305 0x1c115e79, 0x1c116032, 0x1c1161eb, 0x1c1163a4, 0x1c11655d, 0x1c116717,
306 0x1c1168d1, 0x1c116a8b, 0x1c116c45, 0x1c116dff, 0x1c116fb9, 0x1c117174,
307 0x1c11732f, 0x1c1174ea, 0x1c1176a5, 0x1c117860, 0x1c117a1c, 0x1c117bd8,
308 0x1c117d94, 0x1c117f50, 0x1c11810c, 0x1c1182c8, 0x1c118485, 0x1c118642,
309 0x1c1187ff, 0x1c1189bc, 0x1c118b79, 0x1c118d36, 0x1c118ef4, 0x1c1190b2,
310 0x1c119270, 0x1c11942e, 0x1c1195ec, 0x1c1197aa, 0x1c119969, 0x1c119b28,
311 0x1c119ce7, 0x1c119ea6, 0x1c11a065, 0x1c11a224, 0x1c11a3e4, 0x1c11a5a4,
312 0x1c11a764, 0x1c11a924, 0x1c11aae4, 0x1c11aca5, 0x1c11ae66, 0x1c11b027,
313 0x1c11b1e8, 0x1c11b3a9, 0x1c11b56a, 0x1c11b72c, 0x1c11b8ee, 0x1c11bab0,
314 0x1c11bc72, 0x1c11be34, 0x1c11bff6, 0x1c11c1b9, 0x1c11c37c, 0x1c11c53f,
315 0x1c11c702, 0x1c11c8c5, 0x1c11ca88, 0x1c11cc4c, 0x1c11ce10, 0x1c11cfd4,
316 0x1c11d198, 0x1c11d35c, 0x1c11d521, 0x1c11d6e6, 0x1c11d8ab, 0x1c11da70,
317 0x1c11dc35, 0x1c11ddfa, 0x1c11dfc0, 0x1c11e186, 0x1c11e34c, 0x1c11e512,
318 0x1c11e6d8, 0x1c11e89e, 0x1c11ea65, 0x1c11ec2c, 0x1c11edf3, 0x1c11efba,
319 0x1c11f181, 0x1c11f349, 0x1c11f511, 0x1c11f6d9, 0x1c11f8a1, 0x1c11fa69,
320 };
321
322 for (uint32_t expected : diffs) {
323 blocks[h] = GetBlockIndex(&blocks[h - 1], 600, nBits);
324 nBits = GetNextGrasbergWorkRequired(&blocks[h], &blkHeaderDummy,
325 *chainParams);
326 BOOST_CHECK_EQUAL(nBits, expected);
327 h++;
328 }
329
330 // Mine faster to raise difficulty.
331 diffs = {
332 0x1c11eee4, 0x1c11e366, 0x1c11d7f0, 0x1c11cc81, 0x1c11c119, 0x1c11b5b9,
333 0x1c11aa60, 0x1c119f0e, 0x1c1193c3, 0x1c118880, 0x1c117d44, 0x1c11720f,
334 0x1c1166e1, 0x1c115bba, 0x1c11509a, 0x1c114582, 0x1c113a71, 0x1c112f67,
335 0x1c112464, 0x1c111968, 0x1c110e73, 0x1c110385, 0x1c10f89e, 0x1c10edbe,
336 0x1c10e2e5, 0x1c10d813, 0x1c10cd48, 0x1c10c284, 0x1c10b7c7, 0x1c10ad11,
337 0x1c10a261, 0x1c1097b8, 0x1c108d16, 0x1c10827b, 0x1c1077e7, 0x1c106d59,
338 0x1c1062d2, 0x1c105852, 0x1c104dd9, 0x1c104366, 0x1c1038fa, 0x1c102e95,
339 0x1c102436, 0x1c1019de, 0x1c100f8d, 0x1c100542, 0x1c0ffafe, 0x1c0ff0c0,
340 0x1c0fe689, 0x1c0fdc59, 0x1c0fd22f, 0x1c0fc80c, 0x1c0fbdef, 0x1c0fb3d9,
341 0x1c0fa9c9, 0x1c0f9fc0, 0x1c0f95bd, 0x1c0f8bc0, 0x1c0f81ca, 0x1c0f77da,
342 0x1c0f6df0, 0x1c0f640d, 0x1c0f5a30, 0x1c0f5059, 0x1c0f4689, 0x1c0f3cbf,
343 0x1c0f32fb, 0x1c0f293e, 0x1c0f1f87, 0x1c0f15d6, 0x1c0f0c2b, 0x1c0f0286,
344 0x1c0ef8e8, 0x1c0eef50, 0x1c0ee5be, 0x1c0edc32, 0x1c0ed2ac, 0x1c0ec92c,
345 0x1c0ebfb2, 0x1c0eb63e, 0x1c0eacd1, 0x1c0ea36a, 0x1c0e9a09, 0x1c0e90ae,
346 0x1c0e8759, 0x1c0e7e0a, 0x1c0e74c1, 0x1c0e6b7d, 0x1c0e623f, 0x1c0e5907,
347 0x1c0e4fd5, 0x1c0e46a9, 0x1c0e3d83, 0x1c0e3463, 0x1c0e2b49, 0x1c0e2235,
348 0x1c0e1926, 0x1c0e101d, 0x1c0e071a, 0x1c0dfe1d, 0x1c0df526, 0x1c0dec34,
349 0x1c0de348, 0x1c0dda62, 0x1c0dd181, 0x1c0dc8a6, 0x1c0dbfd1, 0x1c0db701,
350 0x1c0dae37, 0x1c0da573, 0x1c0d9cb4, 0x1c0d93fb, 0x1c0d8b47, 0x1c0d8299,
351 0x1c0d79f1, 0x1c0d714e, 0x1c0d68b1, 0x1c0d6019, 0x1c0d5787, 0x1c0d4efa,
352 0x1c0d4673, 0x1c0d3df1, 0x1c0d3575, 0x1c0d2cfe, 0x1c0d248c, 0x1c0d1c20,
353 0x1c0d13b9, 0x1c0d0b58, 0x1c0d02fc, 0x1c0cfaa5, 0x1c0cf254, 0x1c0cea08,
354 0x1c0ce1c1, 0x1c0cd980, 0x1c0cd144, 0x1c0cc90d, 0x1c0cc0dc, 0x1c0cb8b0,
355 0x1c0cb089, 0x1c0ca867, 0x1c0ca04a, 0x1c0c9833, 0x1c0c9021, 0x1c0c8814,
356 0x1c0c800c, 0x1c0c7809, 0x1c0c700b, 0x1c0c6813, 0x1c0c6020, 0x1c0c5832,
357 0x1c0c5049, 0x1c0c4865, 0x1c0c4086, 0x1c0c38ac, 0x1c0c30d7, 0x1c0c2907,
358 0x1c0c213c, 0x1c0c1976, 0x1c0c11b5, 0x1c0c09f9, 0x1c0c0242, 0x1c0bfa90,
359 0x1c0bf2e3, 0x1c0beb3b, 0x1c0be398, 0x1c0bdbfa, 0x1c0bd460, 0x1c0bcccb,
360 0x1c0bc53b, 0x1c0bbdb0, 0x1c0bb62a, 0x1c0baea9, 0x1c0ba72c, 0x1c0b9fb4,
361 0x1c0b9841, 0x1c0b90d3, 0x1c0b896a, 0x1c0b8205, 0x1c0b7aa5, 0x1c0b734a,
362 0x1c0b6bf3, 0x1c0b64a1, 0x1c0b5d54, 0x1c0b560c, 0x1c0b4ec8, 0x1c0b4789,
363 0x1c0b404f, 0x1c0b3919, 0x1c0b31e8, 0x1c0b2abb, 0x1c0b2393, 0x1c0b1c70,
364 0x1c0b1551, 0x1c0b0e37, 0x1c0b0721, 0x1c0b0010, 0x1c0af903, 0x1c0af1fb,
365 0x1c0aeaf7, 0x1c0ae3f8, 0x1c0adcfd, 0x1c0ad607, 0x1c0acf15, 0x1c0ac828,
366 0x1c0ac13f, 0x1c0aba5b, 0x1c0ab37b, 0x1c0aac9f, 0x1c0aa5c8, 0x1c0a9ef5,
367 0x1c0a9827, 0x1c0a915d, 0x1c0a8a97, 0x1c0a83d6, 0x1c0a7d19, 0x1c0a7660,
368 0x1c0a6fac, 0x1c0a68fc, 0x1c0a6250, 0x1c0a5ba8, 0x1c0a5505, 0x1c0a4e66,
369 0x1c0a47cb, 0x1c0a4134, 0x1c0a3aa2, 0x1c0a3414, 0x1c0a2d8a, 0x1c0a2704,
370 0x1c0a2082, 0x1c0a1a05, 0x1c0a138c, 0x1c0a0d17, 0x1c0a06a6, 0x1c0a0039,
371 0x1c09f9d0, 0x1c09f36b, 0x1c09ed0a, 0x1c09e6ae, 0x1c09e056, 0x1c09da02,
372 0x1c09d3b2, 0x1c09cd66, 0x1c09c71e, 0x1c09c0da, 0x1c09ba9a, 0x1c09b45e,
373 0x1c09ae26, 0x1c09a7f2, 0x1c09a1c2, 0x1c099b96, 0x1c09956e, 0x1c098f4a,
374 0x1c09892a, 0x1c09830d, 0x1c097cf4, 0x1c0976df, 0x1c0970ce, 0x1c096ac1,
375 0x1c0964b8, 0x1c095eb3, 0x1c0958b2, 0x1c0952b5, 0x1c094cbb, 0x1c0946c5,
376 0x1c0940d3, 0x1c093ae5, 0x1c0934fb, 0x1c092f14, 0x1c092931, 0x1c092352,
377 0x1c091d77, 0x1c09179f, 0x1c0911cb, 0x1c090bfb, 0x1c09062f, 0x1c090066,
378 0x1c08faa1, 0x1c08f4e0, 0x1c08ef22, 0x1c08e968, 0x1c08e3b2, 0x1c08de00,
379 0x1c08d851, 0x1c08d2a6, 0x1c08ccfe, 0x1c08c75a, 0x1c08c1ba, 0x1c08bc1d,
380 0x1c08b684, 0x1c08b0ee, 0x1c08ab5c, 0x1c08a5ce, 0x1c08a043, 0x1c089abc,
381 0x1c089538, 0x1c088fb8, 0x1c088a3b, 0x1c0884c2, 0x1c087f4c, 0x1c0879da,
382 };
383
384 for (uint32_t expected : diffs) {
385 blocks[h] = GetBlockIndex(&blocks[h - 1], 100, nBits);
386 nBits = GetNextGrasbergWorkRequired(&blocks[h], &blkHeaderDummy,
387 *chainParams);
388 BOOST_CHECK_EQUAL(nBits, expected);
389 h++;
390 }
391
392 // Mine slow blocks to lower and saturate the diffculty.
393 diffs = {
394 0x1c08a0b5, 0x1c08c842, 0x1c08f084, 0x1c09197f, 0x1c094336, 0x1c096dac,
395 0x1c0998e4, 0x1c09c4e3, 0x1c09f1ab, 0x1c0a1f41, 0x1c0a4da8, 0x1c0a7ce3,
396 0x1c0aacf7, 0x1c0adde7, 0x1c0b0fb8, 0x1c0b426d, 0x1c0b760a, 0x1c0baa94,
397 0x1c0be00f, 0x1c0c167f, 0x1c0c4de9, 0x1c0c8651, 0x1c0cbfbb, 0x1c0cfa2c,
398 0x1c0d35a9, 0x1c0d7237, 0x1c0dafdb, 0x1c0dee99, 0x1c0e2e77, 0x1c0e6f7a,
399 0x1c0eb1a7, 0x1c0ef503, 0x1c0f3994, 0x1c0f7f5f, 0x1c0fc66a, 0x1c100ebb,
400 0x1c105857, 0x1c10a345, 0x1c10ef8a, 0x1c113d2d, 0x1c118c34, 0x1c11dca5,
401 0x1c122e87, 0x1c1281e0, 0x1c12d6b7, 0x1c132d13, 0x1c1384fb, 0x1c13de76,
402 0x1c14398b, 0x1c149642, 0x1c14f4a2, 0x1c1554b3, 0x1c15b67c, 0x1c161a05,
403 0x1c167f57, 0x1c16e679, 0x1c174f74, 0x1c17ba50, 0x1c182716, 0x1c1895cf,
404 0x1c190683, 0x1c19793c, 0x1c19ee03, 0x1c1a64e1, 0x1c1adde0, 0x1c1b590a,
405 0x1c1bd668, 0x1c1c5605, 0x1c1cd7eb, 0x1c1d5c25, 0x1c1de2bd, 0x1c1e6bbe,
406 0x1c1ef733, 0x1c1f8527, 0x1c2015a6, 0x1c20a8bb, 0x1c213e73, 0x1c21d6d9,
407 0x1c2271fa, 0x1c230fe2, 0x1c23b09e, 0x1c24543a, 0x1c24fac5, 0x1c25a44b,
408 0x1c2650da, 0x1c270080, 0x1c27b34b, 0x1c28694a, 0x1c29228b, 0x1c29df1e,
409 0x1c2a9f11, 0x1c2b6274, 0x1c2c2957, 0x1c2cf3ca, 0x1c2dc1dd, 0x1c2e93a0,
410 0x1c2f6925, 0x1c30427d, 0x1c311fb9, 0x1c3200eb, 0x1c32e626, 0x1c33cf7c,
411 0x1c34bcff, 0x1c35aec3, 0x1c36a4db, 0x1c379f5c, 0x1c389e59, 0x1c39a1e7,
412 0x1c3aaa1b, 0x1c3bb70a, 0x1c3cc8ca, 0x1c3ddf71, 0x1c3efb15, 0x1c401bcd,
413 0x1c4141b1, 0x1c426cd8, 0x1c439d5b, 0x1c44d352, 0x1c460ed6, 0x1c475000,
414 0x1c4896ea, 0x1c49e3af, 0x1c4b366a, 0x1c4c8f35, 0x1c4dee2d, 0x1c4f536e,
415 0x1c50bf15, 0x1c52313f, 0x1c53aa0a, 0x1c552994, 0x1c56affc, 0x1c583d62,
416 0x1c59d1e6, 0x1c5b6da8, 0x1c5d10ca, 0x1c5ebb6d, 0x1c606db4, 0x1c6227c2,
417 0x1c63e9bb, 0x1c65b3c2, 0x1c6785fd, 0x1c696091, 0x1c6b43a5, 0x1c6d2f60,
418 0x1c6f23e9, 0x1c712169, 0x1c732808, 0x1c7537f1, 0x1c77514e, 0x1c79744a,
419 0x1c7ba112, 0x1c7dd7d2, 0x1d008018, 0x1d008263, 0x1d0084b8, 0x1d008718,
420 0x1d008983, 0x1d008bf9, 0x1d008e7a, 0x1d009107, 0x1d00939f, 0x1d009643,
421 0x1d0098f3, 0x1d009bb0, 0x1d009e79, 0x1d00a14f, 0x1d00a432, 0x1d00a722,
422 0x1d00aa20, 0x1d00ad2b, 0x1d00b044, 0x1d00b36c, 0x1d00b6a2, 0x1d00b9e7,
423 0x1d00bd3b, 0x1d00c09e, 0x1d00c411, 0x1d00c793, 0x1d00cb25, 0x1d00cec8,
424 0x1d00d27b, 0x1d00d63f, 0x1d00da15, 0x1d00ddfc, 0x1d00e1f5, 0x1d00e600,
425 0x1d00ea1e, 0x1d00ee4f, 0x1d00f293, 0x1d00f6eb, 0x1d00fb56, 0x1d00ffd6,
426 0x1d00ffff, 0x1d00ffff, 0x1d00ffff, 0x1d00ffff, 0x1d00ffff, 0x1d00ffff,
427 0x1d00ffff, 0x1d00ffff,
428 };
429
430 for (uint32_t expected : diffs) {
431 blocks[h] = GetBlockIndex(&blocks[h - 1], 3600, nBits);
432 nBits = GetNextGrasbergWorkRequired(&blocks[h], &blkHeaderDummy,
433 *chainParams);
434 BOOST_CHECK_EQUAL(nBits, expected);
435 h++;
436 }
437
438 // We floored the difficulty.
439 BOOST_CHECK_EQUAL(nBits, powLimitBits);
440
441 // Check for 0 solve time.
442 diffs = {
443 0x1d00ff35, 0x1d00fe6b, 0x1d00fda2, 0x1d00fcda, 0x1d00fc12, 0x1d00fb4b,
444 0x1d00fa84, 0x1d00f9be, 0x1d00f8f9, 0x1d00f834, 0x1d00f770, 0x1d00f6ac,
445 0x1d00f5e9, 0x1d00f527, 0x1d00f465, 0x1d00f3a4, 0x1d00f2e3, 0x1d00f223,
446 0x1d00f164, 0x1d00f0a5, 0x1d00efe7, 0x1d00ef29, 0x1d00ee6c, 0x1d00edb0,
447 0x1d00ecf4, 0x1d00ec39, 0x1d00eb7e, 0x1d00eac4, 0x1d00ea0a, 0x1d00e951,
448 0x1d00e899, 0x1d00e7e1, 0x1d00e72a, 0x1d00e673, 0x1d00e5bd, 0x1d00e507,
449 0x1d00e452, 0x1d00e39d, 0x1d00e2e9, 0x1d00e236, 0x1d00e183, 0x1d00e0d1,
450 0x1d00e01f, 0x1d00df6e, 0x1d00debd, 0x1d00de0d, 0x1d00dd5d, 0x1d00dcae,
451 0x1d00dc00, 0x1d00db52, 0x1d00daa5, 0x1d00d9f8, 0x1d00d94c, 0x1d00d8a0,
452 0x1d00d7f5, 0x1d00d74a, 0x1d00d6a0, 0x1d00d5f6, 0x1d00d54d, 0x1d00d4a4,
453 0x1d00d3fc, 0x1d00d354, 0x1d00d2ad, 0x1d00d206, 0x1d00d160, 0x1d00d0ba,
454 0x1d00d015, 0x1d00cf70, 0x1d00cecc, 0x1d00ce28, 0x1d00cd85, 0x1d00cce2,
455 0x1d00cc40, 0x1d00cb9e, 0x1d00cafd, 0x1d00ca5c, 0x1d00c9bc, 0x1d00c91c,
456 0x1d00c87d, 0x1d00c7de, 0x1d00c740, 0x1d00c6a2, 0x1d00c605, 0x1d00c568,
457 0x1d00c4cc, 0x1d00c430, 0x1d00c395, 0x1d00c2fa, 0x1d00c260, 0x1d00c1c6,
458 0x1d00c12d, 0x1d00c094, 0x1d00bffc, 0x1d00bf64, 0x1d00becd, 0x1d00be36,
459 0x1d00bda0, 0x1d00bd0a, 0x1d00bc74, 0x1d00bbdf, 0x1d00bb4a, 0x1d00bab6,
460 0x1d00ba22, 0x1d00b98f, 0x1d00b8fc, 0x1d00b86a, 0x1d00b7d8, 0x1d00b747,
461 0x1d00b6b6, 0x1d00b625, 0x1d00b595, 0x1d00b505, 0x1d00b476, 0x1d00b3e7,
462 0x1d00b359, 0x1d00b2cb, 0x1d00b23e, 0x1d00b1b1, 0x1d00b124, 0x1d00b098,
463 0x1d00b00c, 0x1d00af81, 0x1d00aef6, 0x1d00ae6c, 0x1d00ade2, 0x1d00ad58,
464 0x1d00accf, 0x1d00ac46, 0x1d00abbe, 0x1d00ab36, 0x1d00aaaf, 0x1d00aa28,
465 0x1d00a9a1, 0x1d00a91b, 0x1d00a895, 0x1d00a810, 0x1d00a78b, 0x1d00a706,
466 0x1d00a682, 0x1d00a5fe, 0x1d00a57b, 0x1d00a4f8, 0x1d00a475, 0x1d00a3f3,
467 0x1d00a371, 0x1d00a2f0, 0x1d00a26f, 0x1d00a1ee, 0x1d00a16e, 0x1d00a0ee,
468 0x1d00a06f, 0x1d009ff0, 0x1d009f71, 0x1d009ef3, 0x1d009e75, 0x1d009df8,
469 0x1d009d7b, 0x1d009cfe, 0x1d009c82, 0x1d009c06, 0x1d009b8a, 0x1d009b0f,
470 0x1d009a94, 0x1d009a1a, 0x1d0099a0, 0x1d009926, 0x1d0098ad, 0x1d009834,
471 0x1d0097bc, 0x1d009744, 0x1d0096cc, 0x1d009655, 0x1d0095de, 0x1d009567,
472 0x1d0094f1, 0x1d00947b, 0x1d009405, 0x1d009390, 0x1d00931b, 0x1d0092a7,
473 0x1d009233, 0x1d0091bf, 0x1d00914c, 0x1d0090d9, 0x1d009066, 0x1d008ff4,
474 0x1d008f82, 0x1d008f10, 0x1d008e9f, 0x1d008e2e, 0x1d008dbd, 0x1d008d4d,
475 0x1d008cdd, 0x1d008c6d, 0x1d008bfe, 0x1d008b8f, 0x1d008b20, 0x1d008ab2,
476 0x1d008a44, 0x1d0089d6, 0x1d008969, 0x1d0088fc, 0x1d00888f, 0x1d008823,
477 0x1d0087b7, 0x1d00874b, 0x1d0086e0, 0x1d008675, 0x1d00860a, 0x1d0085a0,
478 0x1d008536, 0x1d0084cc, 0x1d008463, 0x1d0083fa, 0x1d008391, 0x1d008329,
479 0x1d0082c1, 0x1d008259, 0x1d0081f2, 0x1d00818b, 0x1d008124, 0x1d0080be,
480 0x1d008058, 0x1c7ff2cf, 0x1c7f8dee, 0x1c7f295d, 0x1c7ec51b, 0x1c7e6128,
481 0x1c7dfd84, 0x1c7d9a2e, 0x1c7d3727, 0x1c7cd46e, 0x1c7c7202, 0x1c7c0fe4,
482 0x1c7bae13, 0x1c7b4c90, 0x1c7aeb59, 0x1c7a8a6f, 0x1c7a29d1, 0x1c79c980,
483 0x1c79697b, 0x1c7909c1, 0x1c78aa53, 0x1c784b30, 0x1c77ec58, 0x1c778dcb,
484 0x1c772f88, 0x1c76d190, 0x1c7673e2, 0x1c76167e, 0x1c75b963, 0x1c755c92,
485 0x1c75000a, 0x1c74a3cb, 0x1c7447d4, 0x1c73ec26, 0x1c7390c0, 0x1c7335a2,
486 0x1c72dacc, 0x1c72803e, 0x1c7225f7, 0x1c71cbf7, 0x1c71723e, 0x1c7118cc,
487 0x1c70bfa1, 0x1c7066bc, 0x1c700e1d, 0x1c6fb5c4, 0x1c6f5db1, 0x1c6f05e3,
488 0x1c6eae5a, 0x1c6e5716, 0x1c6e0017, 0x1c6da95d, 0x1c6d52e7, 0x1c6cfcb5,
489 0x1c6ca6c7, 0x1c6c511d, 0x1c6bfbb6, 0x1c6ba693, 0x1c6b51b3, 0x1c6afd16,
490 0x1c6aa8bb, 0x1c6a54a3, 0x1c6a00cd, 0x1c69ad39, 0x1c6959e7, 0x1c6906d7,
491 0x1c68b408, 0x1c68617b, 0x1c680f2f, 0x1c67bd24, 0x1c676b59, 0x1c6719cf,
492 0x1c66c885, 0x1c66777b, 0x1c6626b1, 0x1c65d627, 0x1c6585dc, 0x1c6535d1,
493 };
494
495 for (uint32_t expected : diffs) {
496 blocks[h] = GetBlockIndex(&blocks[h - 1], 0, nBits);
497 nBits = GetNextGrasbergWorkRequired(&blocks[h], &blkHeaderDummy,
498 *chainParams);
499 BOOST_CHECK_EQUAL(nBits, expected);
500 h++;
501 }
502
503 // Check for negative solve time.
504 diffs = {
505 0x1c64d713, 0x1c6478ae, 0x1c641aa1, 0x1c63bcec, 0x1c635f8f, 0x1c630289,
506 0x1c62a5da, 0x1c624982, 0x1c61ed81, 0x1c6191d6, 0x1c613681, 0x1c60db81,
507 0x1c6080d6, 0x1c602680, 0x1c5fcc7f, 0x1c5f72d2, 0x1c5f1979, 0x1c5ec073,
508 0x1c5e67c1, 0x1c5e0f62, 0x1c5db756, 0x1c5d5f9c, 0x1c5d0834, 0x1c5cb11e,
509 0x1c5c5a59, 0x1c5c03e6, 0x1c5badc4, 0x1c5b57f2, 0x1c5b0271, 0x1c5aad40,
510 0x1c5a585e, 0x1c5a03cc, 0x1c59af89, 0x1c595b95, 0x1c5907ef, 0x1c58b498,
511 0x1c58618f, 0x1c580ed3, 0x1c57bc65, 0x1c576a44, 0x1c571870, 0x1c56c6e9,
512 0x1c5675ae, 0x1c5624bf, 0x1c55d41c, 0x1c5583c4, 0x1c5533b7, 0x1c54e3f5,
513 0x1c54947e, 0x1c544551, 0x1c53f66e, 0x1c53a7d5, 0x1c535986, 0x1c530b80,
514 0x1c52bdc3, 0x1c52704f, 0x1c522323, 0x1c51d640, 0x1c5189a5, 0x1c513d51,
515 0x1c50f145, 0x1c50a580, 0x1c505a02, 0x1c500ecb, 0x1c4fc3da, 0x1c4f792f,
516 0x1c4f2eca, 0x1c4ee4ab, 0x1c4e9ad1, 0x1c4e513c, 0x1c4e07ec, 0x1c4dbee1,
517 0x1c4d761a, 0x1c4d2d97, 0x1c4ce558, 0x1c4c9d5d, 0x1c4c55a5, 0x1c4c0e30,
518 0x1c4bc6fe, 0x1c4b800f, 0x1c4b3962, 0x1c4af2f7, 0x1c4aacce, 0x1c4a66e7,
519 0x1c4a2141, 0x1c49dbdc, 0x1c4996b8, 0x1c4951d5, 0x1c490d33, 0x1c48c8d1,
520 0x1c4884af, 0x1c4840cd, 0x1c47fd2a, 0x1c47b9c7, 0x1c4776a3, 0x1c4733bd,
521 0x1c46f116, 0x1c46aead, 0x1c466c83, 0x1c462a97, 0x1c45e8e8, 0x1c45a777,
522 0x1c456643, 0x1c45254c, 0x1c44e492, 0x1c44a414, 0x1c4463d3, 0x1c4423ce,
523 0x1c43e405, 0x1c43a478, 0x1c436526, 0x1c43260f, 0x1c42e733, 0x1c42a892,
524 0x1c426a2c, 0x1c422c00, 0x1c41ee0f, 0x1c41b057, 0x1c4172d9, 0x1c413595,
525 0x1c40f88a, 0x1c40bbb8, 0x1c407f1f, 0x1c4042bf, 0x1c400697, 0x1c3fcaa8,
526 0x1c3f8ef1, 0x1c3f5372, 0x1c3f182a, 0x1c3edd1a, 0x1c3ea241, 0x1c3e679f,
527 0x1c3e2d34, 0x1c3df300, 0x1c3db902, 0x1c3d7f3b, 0x1c3d45aa, 0x1c3d0c4f,
528 0x1c3cd329, 0x1c3c9a39, 0x1c3c617e, 0x1c3c28f8, 0x1c3bf0a7, 0x1c3bb88b,
529 0x1c3b80a3, 0x1c3b48f0, 0x1c3b1171, 0x1c3ada26, 0x1c3aa30f, 0x1c3a6c2b,
530 0x1c3a357b, 0x1c39fefe, 0x1c39c8b4, 0x1c39929d, 0x1c395cb8, 0x1c392706,
531 0x1c38f186, 0x1c38bc38, 0x1c38871c, 0x1c385232, 0x1c381d79, 0x1c37e8f1,
532 0x1c37b49b, 0x1c378076, 0x1c374c81, 0x1c3718bd, 0x1c36e52a, 0x1c36b1c7,
533 0x1c367e94, 0x1c364b91, 0x1c3618be, 0x1c35e61a, 0x1c35b3a6, 0x1c358161,
534 0x1c354f4b, 0x1c351d64, 0x1c34ebab, 0x1c34ba21, 0x1c3488c5, 0x1c345798,
535 0x1c342699, 0x1c33f5c7, 0x1c33c523, 0x1c3394ad, 0x1c336464, 0x1c333448,
536 0x1c330459, 0x1c32d497, 0x1c32a502, 0x1c327599, 0x1c32465d, 0x1c32174d,
537 0x1c31e869, 0x1c31b9b1, 0x1c318b25, 0x1c315cc4, 0x1c312e8f, 0x1c310085,
538 0x1c30d2a6, 0x1c30a4f2, 0x1c307769, 0x1c304a0a, 0x1c301cd6, 0x1c2fefcc,
539 0x1c2fc2ec, 0x1c2f9636, 0x1c2f69aa, 0x1c2f3d48, 0x1c2f110f, 0x1c2ee500,
540 0x1c2eb91a, 0x1c2e8d5d, 0x1c2e61c9, 0x1c2e365e, 0x1c2e0b1b, 0x1c2de001,
541 0x1c2db50f, 0x1c2d8a46, 0x1c2d5fa5, 0x1c2d352b, 0x1c2d0ad9, 0x1c2ce0af,
542 0x1c2cb6ac, 0x1c2c8cd1, 0x1c2c631d, 0x1c2c3990, 0x1c2c102a, 0x1c2be6ea,
543 0x1c2bbdd1, 0x1c2b94df, 0x1c2b6c13, 0x1c2b436d, 0x1c2b1aed, 0x1c2af293,
544 0x1c2aca5f, 0x1c2aa250, 0x1c2a7a67, 0x1c2a52a3, 0x1c2a2b05, 0x1c2a038c,
545 0x1c29dc38, 0x1c29b508, 0x1c298dfd, 0x1c296717, 0x1c294055, 0x1c2919b7,
546 0x1c28f33d, 0x1c28cce7, 0x1c28a6b5, 0x1c2880a7, 0x1c285abd, 0x1c2834f6,
547 0x1c280f53, 0x1c27e9d3, 0x1c27c476, 0x1c279f3c, 0x1c277a25, 0x1c275530,
548 0x1c27305e, 0x1c270baf, 0x1c26e722, 0x1c26c2b7, 0x1c269e6e, 0x1c267a47,
549 0x1c265642, 0x1c26325f, 0x1c260e9d, 0x1c25eafd, 0x1c25c77e, 0x1c25a420,
550 0x1c2580e3, 0x1c255dc7, 0x1c253acc, 0x1c2517f2, 0x1c24f539, 0x1c24d2a0,
551 0x1c24b028, 0x1c248dd0, 0x1c246b98, 0x1c244980, 0x1c242788, 0x1c2405b0,
552 0x1c23e3f7, 0x1c23c25e, 0x1c23a0e4, 0x1c237f8a, 0x1c235e4f, 0x1c233d33,
553 0x1c231c36, 0x1c22fb58, 0x1c22da99, 0x1c22b9f8, 0x1c229976, 0x1c227912,
554 0x1c2258cd, 0x1c2238a6, 0x1c22189d, 0x1c21f8b2, 0x1c21d8e5, 0x1c21b936,
555 };
556
557 for (uint32_t expected : diffs) {
558 blocks[h] = GetBlockIndex(&blocks[h - 1], -100, nBits);
559 nBits = GetNextGrasbergWorkRequired(&blocks[h], &blkHeaderDummy,
560 *chainParams);
561 BOOST_CHECK_EQUAL(nBits, expected);
562 h++;
563 }
564
565 // Check for absurd solve time.
566 blocks[h] = GetBlockIndex(&blocks[h - 1], -3900000, nBits);
567 nBits = GetNextGrasbergWorkRequired(&blocks[h++], &blkHeaderDummy,
568 *chainParams);
569 BOOST_CHECK_EQUAL(nBits, 0x1821b936);
570
571 blocks[h] = GetBlockIndex(&blocks[h - 1], -5000000, nBits);
572 nBits = GetNextGrasbergWorkRequired(&blocks[h++], &blkHeaderDummy,
573 *chainParams);
574 BOOST_CHECK_EQUAL(nBits, 0x1421b936);
575
576 blocks[h] = GetBlockIndex(&blocks[h - 1], 3900000, nBits);
577 nBits = GetNextGrasbergWorkRequired(&blocks[h++], &blkHeaderDummy,
578 *chainParams);
579 BOOST_CHECK_EQUAL(nBits, 0x1821b936);
580
581 blocks[h] = GetBlockIndex(&blocks[h - 1], 5000000, nBits);
582 nBits = GetNextGrasbergWorkRequired(&blocks[h++], &blkHeaderDummy,
583 *chainParams);
584 BOOST_CHECK_EQUAL(nBits, 0x1c21b936);
585
586 blocks[h] = GetBlockIndex(&blocks[h - 1], 9000000, nBits);
587 nBits = GetNextGrasbergWorkRequired(&blocks[h++], &blkHeaderDummy,
588 *chainParams);
589 BOOST_CHECK_EQUAL(nBits, 0x1d00ffff);
590}
591
592BOOST_AUTO_TEST_CASE(testnet_difficulty_drop_test) {
593 const auto chainParams =
594 CreateChainParams(*m_node.args, CBaseChainParams::TESTNET);
595 const auto &params = chainParams->GetConsensus();
596
597 std::vector<CBlockIndex> blocks(3000);
598
599 const arith_uint256 powLimit = UintToArith256(params.powLimit);
600 uint32_t powLimitBits = powLimit.GetCompact();
601 arith_uint256 currentPow = powLimit >> 4;
602 uint32_t initialBits = currentPow.GetCompact();
603
604 // Genesis block.
605 blocks[0] = CBlockIndex();
606 blocks[0].nHeight = 0;
607 blocks[0].nTime = 1269211443;
608 blocks[0].nBits = initialBits;
609
610 blocks[0].nChainWork = GetBlockProof(blocks[0]);
611
612 // Check that we can use Grasberg directly from genesis.
613 CBlockHeader blkHeaderDummy;
614 uint32_t nBits =
615 GetNextGrasbergWorkRequired(&blocks[0], &blkHeaderDummy, *chainParams);
616 BOOST_CHECK_EQUAL(nBits, 0x1c0ffe3e);
617
618 // Up to 20 mins, difficulty is unchanged.
619 blkHeaderDummy.nTime = blocks[0].nTime + 2 * params.nPowTargetSpacing;
620 nBits =
621 GetNextGrasbergWorkRequired(&blocks[0], &blkHeaderDummy, *chainParams);
622 BOOST_CHECK_EQUAL(nBits, 0x1c0ffe3e);
623
624 // After 20 mins, difficulty drops.
625 blkHeaderDummy.nTime++;
626 nBits =
627 GetNextGrasbergWorkRequired(&blocks[0], &blkHeaderDummy, *chainParams);
628 BOOST_CHECK_EQUAL(nBits, powLimitBits);
629
630 // Mine several blocks and check the difficulty.
631 size_t h = 1;
632
633 std::vector<uint32_t> diffs = {
634 0x1c100c81, 0x1c101ad2, 0x1c10292f, 0x1c103799, 0x1c104610,
635 0x1c105494, 0x1c106325, 0x1c1071c2, 0x1c10806d, 0x1c108f25,
636 };
637
638 // Mine several blocks at minimal difficulty. Block is skipped to compute
639 // the next difficulty.
640 for (uint32_t expected : diffs) {
641 blocks[h] = GetBlockIndex(
642 &blocks[h - 1], 2 * params.nPowTargetSpacing + 1, powLimitBits);
643 nBits = GetNextGrasbergWorkRequired(&blocks[h++], &blkHeaderDummy,
644 *chainParams);
645 BOOST_CHECK_EQUAL(nBits, expected);
646 }
647
648 // Mine one block at regular difficulty, it will now be the new reference
649 // when skipping over low difficulty blocks.
650 blocks[h] = GetBlockIndex(&blocks[h - 1], 600, nBits);
651 nBits = GetNextGrasbergWorkRequired(&blocks[h++], &blkHeaderDummy,
652 *chainParams);
653 BOOST_CHECK_EQUAL(nBits, 0x1c108d54);
654
655 diffs = {
656 0x1c109c17, 0x1c10aae8, 0x1c10b9c6, 0x1c10c8b1, 0x1c10d7a9,
657 0x1c10e6af, 0x1c10f5c2, 0x1c1104e2, 0x1c111410, 0x1c11234c,
658 };
659
660 // As we mine more blocks with low difficulty, we use our new reference.
661 for (uint32_t expected : diffs) {
662 blocks[h] = GetBlockIndex(
663 &blocks[h - 1], 2 * params.nPowTargetSpacing + 1, powLimitBits);
664 nBits = GetNextGrasbergWorkRequired(&blocks[h++], &blkHeaderDummy,
665 *chainParams);
666 BOOST_CHECK_EQUAL(nBits, expected);
667 }
668}
669
670BOOST_AUTO_TEST_SUITE_END()
UintToArith256
arith_uint256 UintToArith256(const uint256 &a)
Definition: arith_uint256.cpp:268
GetBlockProof
arith_uint256 GetBlockProof(const CBlockIndex &block)
Definition: chain.cpp:74
CreateChainParams
std::unique_ptr< const CChainParams > CreateChainParams(const ArgsManager &args, const std::string &chain)
Creates and returns a std::unique_ptr<CChainParams> of the chosen chain.
Definition: chainparams.cpp:32
CBaseChainParams::TESTNET
static const std::string TESTNET
Definition: chainparamsbase.h:22
CBaseChainParams::MAIN
static const std::string MAIN
BIP70 chain name strings (main, test or regtest)
Definition: chainparamsbase.h:21
CBlockHeader
Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce value...
Definition: block.h:23
CBlockHeader::nTime
uint32_t nTime
Definition: block.h:29
CBlockIndex
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: blockindex.h:25
CBlockIndex::pprev
CBlockIndex * pprev
pointer to the index of the predecessor of this block
Definition: blockindex.h:32
CBlockIndex::nChainWork
arith_uint256 nChainWork
(memory only) Total amount of work (expected number of hashes) in the chain up to and including this ...
Definition: blockindex.h:51
CBlockIndex::nTime
uint32_t nTime
Definition: blockindex.h:92
CBlockIndex::nBits
uint32_t nBits
Definition: blockindex.h:93
CBlockIndex::nHeight
int nHeight
height of the entry in the chain. The genesis block has height 0
Definition: blockindex.h:38
arith_uint256
256-bit unsigned big integer.
Definition: arith_uint256.h:285
arith_uint256::GetCompact
uint32_t GetCompact(bool fNegative=false) const
Definition: arith_uint256.cpp:228
POW2_32
static constexpr int64_t POW2_32
Definition: grasberg.cpp:17
GetNextGrasbergWorkRequired
uint32_t GetNextGrasbergWorkRequired(const CBlockIndex *pindexPrev, const CBlockHeader *pblock, const CChainParams &chainParams)
Compute the next required proof of work using a relative target based ASERT algorithm.
Definition: grasberg.cpp:71
GetBlockIndex
static CBlockIndex GetBlockIndex(CBlockIndex *pindexPrev, int64_t nTimeInterval, uint32_t nBits)
Definition: grasberg_tests.cpp:227
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(exp2_test)
Definition: grasberg_tests.cpp:21
nHeight
unsigned int nHeight
Definition: mempool_eviction.cpp:15
grasberg::computeTargetBlockTime
int64_t computeTargetBlockTime(const CBlockIndex *pindexPrev, const CChainParams &chainParams)
Compute the block time we are aiming for.
Definition: grasberg.cpp:108
grasberg::deterministicExp2
uint32_t deterministicExp2(const uint32_t n)
Computes exp2(n) = 2^32 * (2^(n/2^32) - 1)
Definition: grasberg.cpp:140
m_node
NodeContext & m_node
Definition: interfaces.cpp:785
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
Generated on Wed Nov 20 2024 17:55:58 for Bitcoin ABC by doxygen 1.9.4