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