github.com/mit-dci/lit@v0.0.0-20221102210550-8c3d3b49f2ce/lnutil/msglib_test.go (about)

     1  package lnutil
     2  
     3  import (
     4  	"math/rand"
     5  	"testing"
     6  
     7  	"github.com/mit-dci/lit/btcutil/chaincfg/chainhash"
     8  )
     9  
    10  func TestChatMsg(t *testing.T) {
    11  	peerid := rand.Uint32()
    12  	text := "hello"
    13  
    14  	msg := NewChatMsg(peerid, text)
    15  	b := msg.Bytes()
    16  
    17  	msg2, err := NewChatMsgFromBytes(b, peerid)
    18  
    19  	if err != nil {
    20  		t.Fatal(err)
    21  	}
    22  
    23  	if !LitMsgEqual(msg, msg2) {
    24  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
    25  	}
    26  
    27  	msg3, err := LitMsgFromBytes(b, peerid)
    28  
    29  	if err != nil {
    30  		t.Fatal(err)
    31  	}
    32  
    33  	if !LitMsgEqual(msg2, msg3) {
    34  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
    35  	}
    36  
    37  	_, err = LitMsgFromBytes(b[:1], peerid) //purposely error to check working
    38  
    39  	if err == nil {
    40  		t.Fatalf("Should have errored Chat Msg, but didn't")
    41  	}
    42  }
    43  
    44  func TestPointReqMsg(t *testing.T) {
    45  	peerid := rand.Uint32()
    46  	cointype := rand.Uint32()
    47  
    48  	msg := NewPointReqMsg(peerid, cointype)
    49  	b := msg.Bytes()
    50  
    51  	msg2, err := NewPointReqMsgFromBytes(b, peerid)
    52  
    53  	if err != nil {
    54  		t.Fatal(err)
    55  	}
    56  
    57  	if !LitMsgEqual(msg, msg2) {
    58  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
    59  	}
    60  
    61  	msg3, err := LitMsgFromBytes(b, peerid)
    62  
    63  	if err != nil {
    64  		t.Fatal(err)
    65  	}
    66  
    67  	if !LitMsgEqual(msg2, msg3) {
    68  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
    69  	}
    70  
    71  	_, err = LitMsgFromBytes(b[:3], peerid) //purposely error to check working
    72  
    73  	if err == nil {
    74  		t.Fatalf("Should have errored, but didn't")
    75  	}
    76  }
    77  
    78  func TestPointRespMsg(t *testing.T) {
    79  	peerid := rand.Uint32()
    80  	channelPub := make([]byte, 33)
    81  	refundPub := make([]byte, 33)
    82  	HAKDbase := make([]byte, 33)
    83  	NHTLCBase := make([]byte, 33)
    84  	N2HTLCBase := make([]byte, 33)
    85  	_, _ = rand.Read(channelPub)
    86  	_, _ = rand.Read(refundPub)
    87  	_, _ = rand.Read(HAKDbase)
    88  	_, _ = rand.Read(NHTLCBase)
    89  	_, _ = rand.Read(N2HTLCBase)
    90  
    91  	var cp [33]byte
    92  	copy(cp[:], channelPub[:])
    93  	var rp [33]byte
    94  	copy(rp[:], refundPub[:])
    95  	var hb [33]byte
    96  	copy(hb[:], HAKDbase[:])
    97  	var nhtb [33]byte
    98  	copy(nhtb[:], NHTLCBase[:])
    99  	var n2htb [33]byte
   100  	copy(n2htb[:], N2HTLCBase[:])
   101  
   102  	msg := NewPointRespMsg(peerid, cp, rp, hb, nhtb, n2htb)
   103  	b := msg.Bytes()
   104  
   105  	msg2, err := NewPointRespMsgFromBytes(b, peerid)
   106  
   107  	if err != nil {
   108  		t.Fatal(err)
   109  	}
   110  
   111  	if !LitMsgEqual(msg, msg2) {
   112  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   113  	}
   114  
   115  	msg3, err := LitMsgFromBytes(b, peerid)
   116  
   117  	if err != nil {
   118  		t.Fatal(err)
   119  	}
   120  
   121  	if !LitMsgEqual(msg2, msg3) {
   122  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   123  	}
   124  
   125  	_, err = LitMsgFromBytes(b[:98], peerid) //purposely error to check working
   126  
   127  	if err == nil {
   128  		t.Fatalf("Should have errored, but didn't")
   129  	}
   130  }
   131  
   132  func TestChanDescMsg(t *testing.T) {
   133  	peerid := rand.Uint32()
   134  	var outPoint [36]byte
   135  	var pubKey [33]byte
   136  	var refundPub [33]byte
   137  	var hakd [33]byte
   138  	var nhtlc [33]byte
   139  	var n2htlc [33]byte
   140  	cointype := uint32(rand.Int31())
   141  	capacity := rand.Int63()
   142  	payment := rand.Int63()
   143  	var elkZero [33]byte
   144  	var elkOne [33]byte
   145  	var elkTwo [33]byte
   146  
   147  	_, _ = rand.Read(outPoint[:])
   148  	_, _ = rand.Read(pubKey[:])
   149  	_, _ = rand.Read(refundPub[:])
   150  	_, _ = rand.Read(hakd[:])
   151  	_, _ = rand.Read(nhtlc[:])
   152  	_, _ = rand.Read(n2htlc[:])
   153  	_, _ = rand.Read(elkZero[:])
   154  	_, _ = rand.Read(elkOne[:])
   155  	_, _ = rand.Read(elkTwo[:])
   156  
   157  	op := *OutPointFromBytes(outPoint)
   158  
   159  	var data [32]byte
   160  
   161  	msg := NewChanDescMsg(peerid, op,
   162  		pubKey, refundPub, hakd,
   163  		nhtlc, n2htlc,
   164  		cointype, capacity, payment, elkZero, elkOne, elkTwo, data)
   165  	b := msg.Bytes()
   166  
   167  	msg2, err := NewChanDescMsgFromBytes(b, peerid)
   168  
   169  	if err != nil {
   170  		t.Fatal(err)
   171  	}
   172  
   173  	if !LitMsgEqual(msg, msg2) {
   174  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   175  	}
   176  
   177  	msg3, err := LitMsgFromBytes(b, peerid)
   178  
   179  	if err != nil {
   180  		t.Fatal(err)
   181  	}
   182  
   183  	if !LitMsgEqual(msg2, msg3) {
   184  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   185  	}
   186  
   187  	_, err = LitMsgFromBytes(b[:250], peerid) //purposely error to check working
   188  
   189  	if err == nil {
   190  		t.Fatalf("Should have errored, but didn't")
   191  	}
   192  
   193  }
   194  
   195  func TestChanAckMsg(t *testing.T) {
   196  	peerid := rand.Uint32()
   197  	var outPoint [36]byte
   198  	var elkZero [33]byte
   199  	var elkOne [33]byte
   200  	var elkTwo [33]byte
   201  	var sig [64]byte
   202  
   203  	_, _ = rand.Read(outPoint[:])
   204  	_, _ = rand.Read(sig[:])
   205  	_, _ = rand.Read(elkZero[:])
   206  	_, _ = rand.Read(elkOne[:])
   207  	_, _ = rand.Read(elkTwo[:])
   208  
   209  	op := *OutPointFromBytes(outPoint)
   210  
   211  	msg := NewChanAckMsg(peerid, op, elkZero, elkOne, elkTwo, sig)
   212  	b := msg.Bytes()
   213  
   214  	msg2, err := NewChanAckMsgFromBytes(b, peerid)
   215  
   216  	if err != nil {
   217  		t.Fatal(err)
   218  	}
   219  
   220  	if !LitMsgEqual(msg, msg2) {
   221  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   222  	}
   223  
   224  	msg3, err := LitMsgFromBytes(b, peerid)
   225  
   226  	if err != nil {
   227  		t.Fatal(err)
   228  	}
   229  
   230  	if !LitMsgEqual(msg2, msg3) {
   231  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   232  	}
   233  
   234  	_, err = LitMsgFromBytes(b[:98], peerid) //purposely error to check working by not sending enough bytes
   235  
   236  	if err == nil {
   237  		t.Fatalf("Should have errored, but didn't")
   238  	}
   239  }
   240  
   241  func TestSigProofMsg(t *testing.T) {
   242  	peerid := rand.Uint32()
   243  	var outPoint [36]byte
   244  	var sig [64]byte
   245  
   246  	_, _ = rand.Read(outPoint[:])
   247  	_, _ = rand.Read(sig[:])
   248  
   249  	op := *OutPointFromBytes(outPoint)
   250  
   251  	msg := NewSigProofMsg(peerid, op, sig)
   252  	b := msg.Bytes()
   253  
   254  	msg2, err := NewSigProofMsgFromBytes(b, peerid)
   255  
   256  	if err != nil {
   257  		t.Fatal(err)
   258  	}
   259  
   260  	if !LitMsgEqual(msg, msg2) {
   261  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   262  	}
   263  
   264  	msg3, err := LitMsgFromBytes(b, peerid)
   265  
   266  	if err != nil {
   267  		t.Fatal(err)
   268  	}
   269  
   270  	if !LitMsgEqual(msg2, msg3) {
   271  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   272  	}
   273  
   274  	_, err = LitMsgFromBytes(b[:99], peerid) //purposely error to check working by not sending enough bytes
   275  
   276  	if err == nil {
   277  		t.Fatalf("Should have errored, but didn't")
   278  	}
   279  }
   280  
   281  func TestCloseReqMsg(t *testing.T) {
   282  	peerid := rand.Uint32()
   283  	var outPoint [36]byte
   284  	var sig [64]byte
   285  
   286  	_, _ = rand.Read(outPoint[:])
   287  	_, _ = rand.Read(sig[:])
   288  
   289  	op := *OutPointFromBytes(outPoint)
   290  
   291  	msg := NewCloseReqMsg(peerid, op, sig)
   292  	b := msg.Bytes()
   293  
   294  	msg2, err := NewCloseReqMsgFromBytes(b, peerid)
   295  
   296  	if err != nil {
   297  		t.Fatal(err)
   298  	}
   299  
   300  	if !LitMsgEqual(msg, msg2) {
   301  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   302  	}
   303  
   304  	msg3, err := LitMsgFromBytes(b, peerid)
   305  
   306  	if err != nil {
   307  		t.Fatal(err)
   308  	}
   309  
   310  	if !LitMsgEqual(msg2, msg3) {
   311  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   312  	}
   313  
   314  	_, err = LitMsgFromBytes(b[:99], peerid) //purposely error to check working by not sending enough bytes
   315  
   316  	if err == nil {
   317  		t.Fatalf("Should have errored, but didn't")
   318  	}
   319  }
   320  
   321  func TestDeltaSigMsg(t *testing.T) {
   322  	peerid := rand.Uint32()
   323  	var outPoint [36]byte
   324  	var empty [32]byte
   325  	delta := rand.Int31()
   326  	var sig [64]byte
   327  	htlcsigs := make([][64]byte, 1)
   328  	htlcsigs[0] = [64]byte{}
   329  
   330  	_, _ = rand.Read(outPoint[:])
   331  	_, _ = rand.Read(sig[:])
   332  	_, _ = rand.Read(htlcsigs[0][:])
   333  
   334  	op := *OutPointFromBytes(outPoint)
   335  
   336  	msg := NewDeltaSigMsg(peerid, op, delta, sig, htlcsigs, empty)
   337  	b := msg.Bytes()
   338  
   339  	msg2, err := NewDeltaSigMsgFromBytes(b, peerid)
   340  
   341  	if err != nil {
   342  		t.Fatal(err)
   343  	}
   344  
   345  	if !LitMsgEqual(msg, msg2) {
   346  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   347  	}
   348  
   349  	msg3, err := LitMsgFromBytes(b, peerid)
   350  
   351  	if err != nil {
   352  		t.Fatal(err)
   353  	}
   354  
   355  	if !LitMsgEqual(msg2, msg3) {
   356  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   357  	}
   358  
   359  	_, err = LitMsgFromBytes(b[:99], peerid) //purposely error to check working by not sending enough bytes
   360  
   361  	if err == nil {
   362  		t.Fatalf("Should have errored, but didn't")
   363  	}
   364  }
   365  
   366  func TestSigRevMsg(t *testing.T) {
   367  	peerid := rand.Uint32()
   368  	var outPoint [36]byte
   369  	var sig [64]byte
   370  	var elk [32]byte
   371  	var n2elk [33]byte
   372  	var n2htlc [33]byte
   373  
   374  	htlcsigs := make([][64]byte, 1)
   375  	htlcsigs[0] = [64]byte{}
   376  
   377  	_, _ = rand.Read(outPoint[:])
   378  	_, _ = rand.Read(sig[:])
   379  	_, _ = rand.Read(elk[:])
   380  	_, _ = rand.Read(n2elk[:])
   381  	_, _ = rand.Read(n2htlc[:])
   382  	_, _ = rand.Read(htlcsigs[0][:])
   383  
   384  	op := *OutPointFromBytes(outPoint)
   385  	Elk, _ := chainhash.NewHash(elk[:])
   386  
   387  	msg := NewSigRev(peerid, op, sig, *Elk, n2elk, htlcsigs, n2htlc)
   388  	b := msg.Bytes()
   389  
   390  	msg2, err := NewSigRevFromBytes(b, peerid)
   391  
   392  	if err != nil {
   393  		t.Fatal(err)
   394  	}
   395  
   396  	if !LitMsgEqual(msg, msg2) {
   397  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   398  	}
   399  
   400  	msg3, err := LitMsgFromBytes(b, peerid)
   401  
   402  	if err != nil {
   403  		t.Fatal(err)
   404  	}
   405  
   406  	if !LitMsgEqual(msg2, msg3) {
   407  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   408  	}
   409  
   410  	_, err = LitMsgFromBytes(b[:99], peerid) //purposely error to check working by not sending enough bytes
   411  
   412  	if err == nil {
   413  		t.Fatalf("Should have errored, but didn't")
   414  	}
   415  }
   416  
   417  func TestGapSigRevMsg(t *testing.T) {
   418  	peerid := rand.Uint32()
   419  	var outPoint [36]byte
   420  	var sig [64]byte
   421  	var elk [32]byte
   422  	var n2elk [33]byte
   423  	var n2htlc [33]byte
   424  	htlcsigs := make([][64]byte, 1)
   425  	htlcsigs[0] = [64]byte{}
   426  
   427  	_, _ = rand.Read(htlcsigs[0][:])
   428  	_, _ = rand.Read(outPoint[:])
   429  	_, _ = rand.Read(sig[:])
   430  	_, _ = rand.Read(elk[:])
   431  	_, _ = rand.Read(n2elk[:])
   432  	_, _ = rand.Read(n2htlc[:])
   433  
   434  	op := *OutPointFromBytes(outPoint)
   435  	Elk, _ := chainhash.NewHash(elk[:])
   436  
   437  	msg := NewGapSigRev(peerid, op, sig, *Elk, n2elk, htlcsigs, n2htlc)
   438  	b := msg.Bytes()
   439  
   440  	msg2, err := NewGapSigRevFromBytes(b, peerid)
   441  
   442  	if err != nil {
   443  		t.Fatal(err)
   444  	}
   445  
   446  	if !LitMsgEqual(msg, msg2) {
   447  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   448  	}
   449  
   450  	msg3, err := LitMsgFromBytes(b, peerid)
   451  
   452  	if err != nil {
   453  		t.Fatal(err)
   454  	}
   455  
   456  	if !LitMsgEqual(msg2, msg3) {
   457  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   458  	}
   459  
   460  	_, err = LitMsgFromBytes(b[:99], peerid) //purposely error to check working by not sending enough bytes
   461  
   462  	if err == nil {
   463  		t.Fatalf("Should have errored, but didn't")
   464  	}
   465  }
   466  
   467  func TestRevMsg(t *testing.T) {
   468  	peerid := rand.Uint32()
   469  	var outPoint [36]byte
   470  	var elk [32]byte
   471  	var n2elk [33]byte
   472  	var n2htlc [33]byte
   473  
   474  	_, _ = rand.Read(outPoint[:])
   475  	_, _ = rand.Read(elk[:])
   476  	_, _ = rand.Read(n2elk[:])
   477  	_, _ = rand.Read(n2htlc[:])
   478  
   479  	op := *OutPointFromBytes(outPoint)
   480  	Elk, _ := chainhash.NewHash(elk[:])
   481  
   482  	msg := NewRevMsg(peerid, op, *Elk, n2elk, n2htlc)
   483  	b := msg.Bytes()
   484  
   485  	msg2, err := NewRevMsgFromBytes(b, peerid)
   486  
   487  	if err != nil {
   488  		t.Fatal(err)
   489  	}
   490  
   491  	if !LitMsgEqual(msg, msg2) {
   492  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   493  	}
   494  
   495  	msg3, err := LitMsgFromBytes(b, peerid)
   496  
   497  	if err != nil {
   498  		t.Fatal(err)
   499  	}
   500  
   501  	if !LitMsgEqual(msg2, msg3) {
   502  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   503  	}
   504  
   505  	_, err = LitMsgFromBytes(b[:99], peerid) //purposely error to check working by not sending enough bytes
   506  
   507  	if err == nil {
   508  		t.Fatalf("Should have errored, but didn't")
   509  	}
   510  }
   511  
   512  func TestWatchDescMsg(t *testing.T) {
   513  	peerid := rand.Uint32()
   514  	cointype := rand.Uint32()
   515  	var pkh [20]byte
   516  	delay := uint16(rand.Int())
   517  	fee := rand.Int63()
   518  	var customerBP [33]byte
   519  	var adBP [33]byte
   520  
   521  	_, _ = rand.Read(pkh[:])
   522  	_, _ = rand.Read(customerBP[:])
   523  	_, _ = rand.Read(adBP[:])
   524  
   525  	msg := NewWatchDescMsg(peerid, cointype, pkh, delay, fee, customerBP, adBP)
   526  	b := msg.Bytes()
   527  
   528  	msg2, err := NewWatchDescMsgFromBytes(b, peerid)
   529  
   530  	if err != nil {
   531  		t.Fatal(err)
   532  	}
   533  
   534  	if !LitMsgEqual(msg, msg2) {
   535  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   536  	}
   537  
   538  	msg3, err := LitMsgFromBytes(b, peerid)
   539  
   540  	if err != nil {
   541  		t.Fatal(err)
   542  	}
   543  
   544  	if !LitMsgEqual(msg2, msg3) {
   545  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   546  	}
   547  
   548  	_, err = LitMsgFromBytes(b[:95], peerid) //purposely error to check working by not sending enough bytes
   549  
   550  	if err == nil {
   551  		t.Fatalf("Should have errored, but didn't")
   552  	}
   553  }
   554  
   555  func TestComMsg(t *testing.T) {
   556  	peerid := rand.Uint32()
   557  	var parTxid [16]byte
   558  	var pkh [20]byte
   559  	var elk [32]byte
   560  	var sig [64]byte
   561  
   562  	_, _ = rand.Read(parTxid[:])
   563  	_, _ = rand.Read(elk[:])
   564  	_, _ = rand.Read(pkh[:])
   565  	_, _ = rand.Read(sig[:])
   566  	cointype := rand.Uint32()
   567  	Elk, _ := chainhash.NewHash(elk[:])
   568  
   569  	msg := NewComMsg(peerid, cointype, pkh, *Elk, parTxid, sig)
   570  	b := msg.Bytes()
   571  
   572  	msg2, err := NewWatchStateMsgFromBytes(b, peerid)
   573  
   574  	if err != nil {
   575  		t.Fatal(err)
   576  	}
   577  
   578  	if !LitMsgEqual(msg, msg2) {
   579  		t.Fatalf("from bytes mismatch:\n%x\n%x\n", msg.Bytes(), msg2.Bytes())
   580  	}
   581  
   582  	msg3, err := LitMsgFromBytes(b, peerid)
   583  
   584  	if err != nil {
   585  		t.Fatal(err)
   586  	}
   587  
   588  	if !LitMsgEqual(msg2, msg3) {
   589  		t.Fatalf("interface mismatch:\n%x\n%x\n", msg2.Bytes(), msg3.Bytes())
   590  	}
   591  
   592  	_, err = LitMsgFromBytes(b[:99], peerid) //purposely error to check working by not sending enough bytes
   593  
   594  	if err == nil {
   595  		t.Fatalf("Should have errored, but didn't")
   596  	}
   597  }