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  }