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

     1  package portxo
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/mit-dci/lit/btcutil/chaincfg/chainhash"
     6  	"github.com/mit-dci/lit/wire"
     7  	"testing"
     8  )
     9  
    10  // TestHardCoded tests serializing / deserializing a portxo
    11  func TestHardCoded(t *testing.T) {
    12  	var u1 PorTxo
    13  
    14  	b1, err := u1.Bytes()
    15  	if err != nil {
    16  		t.Fatal(err)
    17  	}
    18  
    19  	u2, err := PorTxoFromBytes(b1)
    20  	if err != nil {
    21  		t.Fatal(err)
    22  	}
    23  
    24  	//	u2.Op.Hash = chainhash.DoubleHashH([]byte("test"))
    25  	u2.Op.Hash = chainhash.DoubleHashH([]byte("test"))
    26  	u2.Op.Index = 3
    27  	u2.Value = 1234567890
    28  	u2.Mode = TxoP2PKHComp
    29  	u2.Seq = 65535
    30  	u2.KeyGen.Depth = 3
    31  	u2.KeyGen.Step[0] = 0x8000002C
    32  	u2.KeyGen.Step[1] = 1
    33  	u2.KeyGen.Step[2] = 0x80000000
    34  
    35  	//	u2.PrivKey[0] = 0x11
    36  	u2.PkScript = []byte("1234567890123456")
    37  	b2, err := u2.Bytes()
    38  	if err != nil {
    39  		t.Fatal(err)
    40  	}
    41  	u3, err := PorTxoFromBytes(b2)
    42  	if err != nil {
    43  		t.Fatal(err)
    44  	}
    45  	t.Logf("b2: %x\n", b2)
    46  
    47  	t.Logf("u2: %s", u2.String())
    48  
    49  	b3, err := u3.Bytes()
    50  	if err != nil {
    51  		t.Fatal(err)
    52  	}
    53  	t.Logf("b3: %x\n", b3)
    54  
    55  	t.Logf("u3: %s", u3.String())
    56  	if !u2.Equal(u3) {
    57  		t.Fatalf("u2, u3 should be the same")
    58  	}
    59  }
    60  
    61  // TestWithoutStuff tests serializing / deserializing a portxo without some things
    62  func TestWithoutStuff(t *testing.T) {
    63  	var u1 PorTxo
    64  
    65  	b1, err := u1.Bytes()
    66  	if err != nil {
    67  		t.Fatal(err)
    68  	}
    69  
    70  	u2, err := PorTxoFromBytes(b1)
    71  	if err != nil {
    72  		t.Fatal(err)
    73  	}
    74  
    75  	//	u2.Op.Hash = chainhash.DoubleHashH([]byte("test"))
    76  	u2.Op.Hash = chainhash.DoubleHashH([]byte("test1"))
    77  	u2.Op.Index = 0
    78  	u2.Value = 5565989
    79  	u2.Mode = TxoP2WSHComp
    80  	//	u2.Seq = 0
    81  	u2.PkScript = []byte("pub key script")
    82  	u2.KeyGen.Depth = 1
    83  	u2.KeyGen.Step[0] = 0x80000011
    84  
    85  	b2, err := u2.Bytes()
    86  	if err != nil {
    87  		t.Fatal(err)
    88  	}
    89  	u3, err := PorTxoFromBytes(b2)
    90  	if err != nil {
    91  		t.Fatal(err)
    92  	}
    93  	t.Logf("b2: %x\n", b2)
    94  
    95  	t.Logf("u2: %s", u2.String())
    96  
    97  	b3, err := u3.Bytes()
    98  	if err != nil {
    99  		t.Fatal(err)
   100  	}
   101  	t.Logf("b3: %x\n", b3)
   102  
   103  	t.Logf("u3: %s", u3.String())
   104  	if !u2.Equal(u3) {
   105  		t.Fatalf("u2, u3 should be the same")
   106  	}
   107  }
   108  
   109  // TestWithStack tests serializing / deserializing a portxo with a presig stack
   110  func TestWithStack(t *testing.T) {
   111  	var u1 PorTxo
   112  
   113  	b1, err := u1.Bytes()
   114  	if err != nil {
   115  		t.Fatal(err)
   116  	}
   117  
   118  	u2, err := PorTxoFromBytes(b1)
   119  	if err != nil {
   120  		t.Fatal(err)
   121  	}
   122  
   123  	u2.Op.Hash = chainhash.DoubleHashH([]byte("test3"))
   124  	u2.Op.Index = 3
   125  	u2.Value = 5565989
   126  	u2.Mode = TxoP2WSHComp
   127  	u2.Seq = 0
   128  	u2.KeyGen.Depth = 1
   129  	u2.KeyGen.Step[0] = 0x8000002C
   130  
   131  	//	u2.PrivKey[0] = 0x11
   132  	u2.PkScript = []byte("00112233")
   133  	u2.PreSigStack = make([][]byte, 3)
   134  	u2.PreSigStack[0] = []byte("SIGSTACK00000")
   135  	u2.PreSigStack[1] = []byte(".....STACK001")
   136  	// PreSigStack[2] is nil
   137  
   138  	b2, err := u2.Bytes()
   139  	if err != nil {
   140  		t.Fatal(err)
   141  	}
   142  	u3, err := PorTxoFromBytes(b2)
   143  	if err != nil {
   144  		t.Fatal(err)
   145  	}
   146  	t.Logf("b2: %x\n", b2)
   147  
   148  	t.Logf("u2: %s", u2.String())
   149  
   150  	b3, err := u3.Bytes()
   151  	if err != nil {
   152  		t.Fatal(err)
   153  	}
   154  	t.Logf("b3: %x\n", b3)
   155  
   156  	t.Logf("u3: %s", u3.String())
   157  	if !u2.Equal(u3) {
   158  		t.Fatalf("u2, u3 should be the same")
   159  	}
   160  }
   161  
   162  func TestPortxoSerdes(t *testing.T) {
   163  
   164  	ptxo := PorTxo{
   165  		Op: wire.OutPoint{
   166  			Hash:  chainhash.Hash([32]byte{}),
   167  			Index: 42,
   168  		},
   169  		Value:  1337,
   170  		Height: 210000,
   171  		Seq:    65536123,
   172  		Mode:   11,
   173  		KeyGen: KeyGen{
   174  			Depth:   5,
   175  			Step:    [5]uint32{19195, 28285, 37375, 46465, 13579}, // random numbers
   176  			PrivKey: [32]byte{},                                   // 0
   177  		},
   178  		PkScript:    []byte{},
   179  		PreSigStack: [][]byte{},
   180  	}
   181  
   182  	pb, err := ptxo.Bytes()
   183  	if err != nil {
   184  		fmt.Printf("error serializing: %s\n", err.Error())
   185  		t.FailNow()
   186  	}
   187  
   188  	ptxo2, err := PorTxoFromBytes(pb)
   189  	if err != nil {
   190  		fmt.Printf("error deserializing: %s\n", err.Error())
   191  		t.FailNow()
   192  	}
   193  
   194  	if ptxo.Op != ptxo2.Op ||
   195  		ptxo.Value != ptxo2.Value ||
   196  		ptxo.Height != ptxo2.Height ||
   197  		ptxo.Seq != ptxo2.Seq ||
   198  		ptxo.Mode != ptxo2.Mode ||
   199  		ptxo.KeyGen != ptxo2.KeyGen {
   200  		t.Fail()
   201  	}
   202  
   203  	if len(ptxo2.PkScript) != 0 {
   204  		t.Fail()
   205  	}
   206  
   207  	if len(ptxo2.PreSigStack) != 0 {
   208  		t.Fail()
   209  	}
   210  
   211  }