register_test.go raw
1 package chaincfg_test
2
3 import (
4 "bytes"
5 "reflect"
6 "testing"
7
8 . "github.com/p9c/p9/pkg/chaincfg"
9 )
10
11 // Define some of the required parameters for a user-registered network. This is necessary to test the registration of
12 // and lookup of encoding magics from the network.
13 var mockNetParams = Params{
14 Name: "mocknet",
15 Net: 1<<32 - 1,
16 PubKeyHashAddrID: 0x9f,
17 ScriptHashAddrID: 0xf9,
18 // Bech32HRPSegwit: "tc",
19 HDPrivateKeyID: [4]byte{0x01, 0x02, 0x03, 0x04},
20 HDPublicKeyID: [4]byte{0x05, 0x06, 0x07, 0x08},
21 }
22
23 func TestRegister(t *testing.T) {
24 type registerTest struct {
25 name string
26 params *Params
27 err error
28 }
29 type magicTest struct {
30 magic byte
31 valid bool
32 }
33 type prefixTest struct {
34 prefix string
35 valid bool
36 }
37 type hdTest struct {
38 priv []byte
39 want []byte
40 err error
41 }
42 tests := []struct {
43 name string
44 register []registerTest
45 p2pkhMagics []magicTest
46 p2shMagics []magicTest
47 segwitPrefixes []prefixTest
48 hdMagics []hdTest
49 }{
50 {
51 name: "default networks",
52 register: []registerTest{
53 {
54 name: "duplicate mainnet",
55 params: &MainNetParams,
56 err: ErrDuplicateNet,
57 },
58 {
59 name: "duplicate regtest",
60 params: &RegressionTestParams,
61 err: ErrDuplicateNet,
62 },
63 {
64 name: "duplicate testnet3",
65 params: &TestNet3Params,
66 err: ErrDuplicateNet,
67 },
68 {
69 name: "duplicate simnet",
70 params: &SimNetParams,
71 err: ErrDuplicateNet,
72 },
73 },
74 p2pkhMagics: []magicTest{
75 {
76 magic: MainNetParams.PubKeyHashAddrID,
77 valid: true,
78 },
79 {
80 magic: TestNet3Params.PubKeyHashAddrID,
81 valid: true,
82 },
83 {
84 magic: RegressionTestParams.PubKeyHashAddrID,
85 valid: true,
86 },
87 {
88 magic: SimNetParams.PubKeyHashAddrID,
89 valid: true,
90 },
91 {
92 magic: mockNetParams.PubKeyHashAddrID,
93 valid: false,
94 },
95 {
96 magic: 0xFF,
97 valid: false,
98 },
99 },
100 p2shMagics: []magicTest{
101 {
102 magic: MainNetParams.ScriptHashAddrID,
103 valid: true,
104 },
105 {
106 magic: TestNet3Params.ScriptHashAddrID,
107 valid: true,
108 },
109 {
110 magic: RegressionTestParams.ScriptHashAddrID,
111 valid: true,
112 },
113 {
114 magic: SimNetParams.ScriptHashAddrID,
115 valid: true,
116 },
117 {
118 magic: mockNetParams.ScriptHashAddrID,
119 valid: false,
120 },
121 {
122 magic: 0xFF,
123 valid: false,
124 },
125 },
126 // segwitPrefixes: []prefixTest{
127 // {
128 // prefix: MainNetParams.Bech32HRPSegwit + "1",
129 // valid: true,
130 // },
131 // {
132 // prefix: TestNet3Params.Bech32HRPSegwit + "1",
133 // valid: true,
134 // },
135 // {
136 // prefix: RegressionTestParams.Bech32HRPSegwit + "1",
137 // valid: true,
138 // },
139 // {
140 // prefix: SimNetParams.Bech32HRPSegwit + "1",
141 // valid: true,
142 // },
143 // {
144 // prefix: strings.ToUpper(MainNetParams.Bech32HRPSegwit + "1"),
145 // valid: true,
146 // },
147 // {
148 // prefix: mockNetParams.Bech32HRPSegwit + "1",
149 // valid: false,
150 // },
151 // {
152 // prefix: "abc1",
153 // valid: false,
154 // },
155 // {
156 // prefix: "1",
157 // valid: false,
158 // },
159 // {
160 // prefix: MainNetParams.Bech32HRPSegwit,
161 // valid: false,
162 // },
163 // },
164 hdMagics: []hdTest{
165 {
166 priv: MainNetParams.HDPrivateKeyID[:],
167 want: MainNetParams.HDPublicKeyID[:],
168 err: nil,
169 },
170 {
171 priv: TestNet3Params.HDPrivateKeyID[:],
172 want: TestNet3Params.HDPublicKeyID[:],
173 err: nil,
174 },
175 {
176 priv: RegressionTestParams.HDPrivateKeyID[:],
177 want: RegressionTestParams.HDPublicKeyID[:],
178 err: nil,
179 },
180 {
181 priv: SimNetParams.HDPrivateKeyID[:],
182 want: SimNetParams.HDPublicKeyID[:],
183 err: nil,
184 },
185 {
186 priv: mockNetParams.HDPrivateKeyID[:],
187 err: ErrUnknownHDKeyID,
188 },
189 {
190 priv: []byte{0xff, 0xff, 0xff, 0xff},
191 err: ErrUnknownHDKeyID,
192 },
193 {
194 priv: []byte{0xff},
195 err: ErrUnknownHDKeyID,
196 },
197 },
198 },
199 {
200 name: "register mocknet",
201 register: []registerTest{
202 {
203 name: "mocknet",
204 params: &mockNetParams,
205 err: nil,
206 },
207 },
208 p2pkhMagics: []magicTest{
209 {
210 magic: MainNetParams.PubKeyHashAddrID,
211 valid: true,
212 },
213 {
214 magic: TestNet3Params.PubKeyHashAddrID,
215 valid: true,
216 },
217 {
218 magic: RegressionTestParams.PubKeyHashAddrID,
219 valid: true,
220 },
221 {
222 magic: SimNetParams.PubKeyHashAddrID,
223 valid: true,
224 },
225 {
226 magic: mockNetParams.PubKeyHashAddrID,
227 valid: true,
228 },
229 {
230 magic: 0xFF,
231 valid: false,
232 },
233 },
234 p2shMagics: []magicTest{
235 {
236 magic: MainNetParams.ScriptHashAddrID,
237 valid: true,
238 },
239 {
240 magic: TestNet3Params.ScriptHashAddrID,
241 valid: true,
242 },
243 {
244 magic: RegressionTestParams.ScriptHashAddrID,
245 valid: true,
246 },
247 {
248 magic: SimNetParams.ScriptHashAddrID,
249 valid: true,
250 },
251 {
252 magic: mockNetParams.ScriptHashAddrID,
253 valid: true,
254 },
255 {
256 magic: 0xFF,
257 valid: false,
258 },
259 },
260 // segwitPrefixes: []prefixTest{
261 // {
262 // prefix: MainNetParams.Bech32HRPSegwit + "1",
263 // valid: true,
264 // },
265 // {
266 // prefix: TestNet3Params.Bech32HRPSegwit + "1",
267 // valid: true,
268 // },
269 // {
270 // prefix: RegressionTestParams.Bech32HRPSegwit + "1",
271 // valid: true,
272 // },
273 // {
274 // prefix: SimNetParams.Bech32HRPSegwit + "1",
275 // valid: true,
276 // },
277 // {
278 // prefix: strings.ToUpper(MainNetParams.Bech32HRPSegwit + "1"),
279 // valid: true,
280 // },
281 // {
282 // prefix: mockNetParams.Bech32HRPSegwit + "1",
283 // valid: true,
284 // },
285 // {
286 // prefix: "abc1",
287 // valid: false,
288 // },
289 // {
290 // prefix: "1",
291 // valid: false,
292 // },
293 // {
294 // prefix: MainNetParams.Bech32HRPSegwit,
295 // valid: false,
296 // },
297 // },
298 hdMagics: []hdTest{
299 {
300 priv: mockNetParams.HDPrivateKeyID[:],
301 want: mockNetParams.HDPublicKeyID[:],
302 err: nil,
303 },
304 },
305 },
306 {
307 name: "more duplicates",
308 register: []registerTest{
309 {
310 name: "duplicate mainnet",
311 params: &MainNetParams,
312 err: ErrDuplicateNet,
313 },
314 {
315 name: "duplicate regtest",
316 params: &RegressionTestParams,
317 err: ErrDuplicateNet,
318 },
319 {
320 name: "duplicate testnet3",
321 params: &TestNet3Params,
322 err: ErrDuplicateNet,
323 },
324 {
325 name: "duplicate simnet",
326 params: &SimNetParams,
327 err: ErrDuplicateNet,
328 },
329 {
330 name: "duplicate mocknet",
331 params: &mockNetParams,
332 err: ErrDuplicateNet,
333 },
334 },
335 p2pkhMagics: []magicTest{
336 {
337 magic: MainNetParams.PubKeyHashAddrID,
338 valid: true,
339 },
340 {
341 magic: TestNet3Params.PubKeyHashAddrID,
342 valid: true,
343 },
344 {
345 magic: RegressionTestParams.PubKeyHashAddrID,
346 valid: true,
347 },
348 {
349 magic: SimNetParams.PubKeyHashAddrID,
350 valid: true,
351 },
352 {
353 magic: mockNetParams.PubKeyHashAddrID,
354 valid: true,
355 },
356 {
357 magic: 0xFF,
358 valid: false,
359 },
360 },
361 p2shMagics: []magicTest{
362 {
363 magic: MainNetParams.ScriptHashAddrID,
364 valid: true,
365 },
366 {
367 magic: TestNet3Params.ScriptHashAddrID,
368 valid: true,
369 },
370 {
371 magic: RegressionTestParams.ScriptHashAddrID,
372 valid: true,
373 },
374 {
375 magic: SimNetParams.ScriptHashAddrID,
376 valid: true,
377 },
378 {
379 magic: mockNetParams.ScriptHashAddrID,
380 valid: true,
381 },
382 {
383 magic: 0xFF,
384 valid: false,
385 },
386 },
387 // segwitPrefixes: []prefixTest{
388 // {
389 // prefix: MainNetParams.Bech32HRPSegwit + "1",
390 // valid: true,
391 // },
392 // {
393 // prefix: TestNet3Params.Bech32HRPSegwit + "1",
394 // valid: true,
395 // },
396 // {
397 // prefix: RegressionTestParams.Bech32HRPSegwit + "1",
398 // valid: true,
399 // },
400 // {
401 // prefix: SimNetParams.Bech32HRPSegwit + "1",
402 // valid: true,
403 // },
404 // {
405 // prefix: strings.ToUpper(MainNetParams.Bech32HRPSegwit + "1"),
406 // valid: true,
407 // },
408 // {
409 // prefix: mockNetParams.Bech32HRPSegwit + "1",
410 // valid: true,
411 // },
412 // {
413 // prefix: "abc1",
414 // valid: false,
415 // },
416 // {
417 // prefix: "1",
418 // valid: false,
419 // },
420 // {
421 // prefix: MainNetParams.Bech32HRPSegwit,
422 // valid: false,
423 // },
424 // },
425 hdMagics: []hdTest{
426 {
427 priv: MainNetParams.HDPrivateKeyID[:],
428 want: MainNetParams.HDPublicKeyID[:],
429 err: nil,
430 },
431 {
432 priv: TestNet3Params.HDPrivateKeyID[:],
433 want: TestNet3Params.HDPublicKeyID[:],
434 err: nil,
435 },
436 {
437 priv: RegressionTestParams.HDPrivateKeyID[:],
438 want: RegressionTestParams.HDPublicKeyID[:],
439 err: nil,
440 },
441 {
442 priv: SimNetParams.HDPrivateKeyID[:],
443 want: SimNetParams.HDPublicKeyID[:],
444 err: nil,
445 },
446 {
447 priv: mockNetParams.HDPrivateKeyID[:],
448 want: mockNetParams.HDPublicKeyID[:],
449 err: nil,
450 },
451 {
452 priv: []byte{0xff, 0xff, 0xff, 0xff},
453 err: ErrUnknownHDKeyID,
454 },
455 {
456 priv: []byte{0xff},
457 err: ErrUnknownHDKeyID,
458 },
459 },
460 },
461 }
462 for _, test := range tests {
463 for _, regTest := range test.register {
464 e := Register(regTest.params)
465 if e != regTest.err {
466 t.Errorf("%s:%s: Registered network with unexpected error: got %v expected %v",
467 test.name, regTest.name, e, regTest.err,
468 )
469 }
470 }
471 for i, magTest := range test.p2pkhMagics {
472 valid := IsPubKeyHashAddrID(magTest.magic)
473 if valid != magTest.valid {
474 t.Errorf("%s: P2PKH magic %d valid mismatch: got %v expected %v",
475 test.name, i, valid, magTest.valid,
476 )
477 }
478 }
479 for i, magTest := range test.p2shMagics {
480 valid := IsScriptHashAddrID(magTest.magic)
481 if valid != magTest.valid {
482 t.Errorf("%s: P2SH magic %d valid mismatch: got %v expected %v",
483 test.name, i, valid, magTest.valid,
484 )
485 }
486 }
487 for i, prxTest := range test.segwitPrefixes {
488 valid := IsBech32SegwitPrefix(prxTest.prefix)
489 if valid != prxTest.valid {
490 t.Errorf("%s: segwit prefix %s (%d) valid mismatch: got %v expected %v",
491 test.name, prxTest.prefix, i, valid, prxTest.valid,
492 )
493 }
494 }
495 for i, magTest := range test.hdMagics {
496 pubKey, e := HDPrivateKeyToPublicKeyID(magTest.priv[:])
497 if !reflect.DeepEqual(e, magTest.err) {
498 t.Errorf("%s: HD magic %d mismatched error: got %v expected %v ",
499 test.name, i, e, magTest.err,
500 )
501 continue
502 }
503 if magTest.err == nil && !bytes.Equal(pubKey, magTest.want[:]) {
504 t.Errorf("%s: HD magic %d private and public mismatch: got %v expected %v ",
505 test.name, i, pubKey, magTest.want[:],
506 )
507 }
508 }
509 }
510 }
511