github.com/piotrnar/gocoin@v0.0.0-20240512203912-faa0448c5e96/lib/btc/wallet_test.go (about)

     1  package btc
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  	"crypto/rand"
     7  	"encoding/hex"
     8  )
     9  
    10  
    11  func TestGetPublic(t *testing.T) {
    12  	prv, _ := hex.DecodeString("bb87a5e3e786ecd05f4901ef7ef32726570bfd176ada37a31ef2861db2834d7e")
    13  	pub, _ := hex.DecodeString("02a60d70cfba37177d8239d018185d864b2bdd0caf5e175fd4454cc006fd2d75ac")
    14  	pk := PublicFromPrivate(prv, true)
    15  	if !bytes.Equal(pub, pk) {
    16  		t.Error("PublicFromPrivate failed")
    17  	}
    18  }
    19  
    20  
    21  func TestDeterministicPublic(t *testing.T) {
    22  	secret, _ := hex.DecodeString("4438addb9b147349432466d89d81f4dae1fc1fd9bcb764d2854f303931796c2d")
    23  	pubkey, _ := hex.DecodeString("03578936ea365dd8921fe0e05eb4d2af9a0d333312ec01ae950f9450af09cef4d4")
    24  	exp, _ := hex.DecodeString("03ba29c4d2168af9d8e4492d158ff76455999f94333f47bc15275a2586db6d491d")
    25  	pubkey = DeriveNextPublic(pubkey, secret)
    26  	if !bytes.Equal(pubkey, exp) {
    27  		t.Error("TestDeterministicPublic failed")
    28  	}
    29  }
    30  
    31  
    32  func TestDeterministicWalletType2(t *testing.T) {
    33  	secret := make([]byte, 32)
    34  	rand.Read(secret)
    35  
    36  	private_key := make([]byte, 32)
    37  	rand.Read(private_key)
    38  
    39  	public_key := PublicFromPrivate(private_key, true)
    40  	for i:=0; i<50; i++ {
    41  		private_key = DeriveNextPrivate(private_key, secret)
    42  		if private_key==nil {
    43  			t.Fatal("DeriveNextPrivate fail")
    44  		}
    45  
    46  		public_key = DeriveNextPublic(public_key, secret)
    47  		if public_key==nil {
    48  			t.Fatal("DeriveNextPublic fail")
    49  		}
    50  
    51  		// verify the public key matching the private key
    52  		pub2 := PublicFromPrivate(private_key, true)
    53  		if !bytes.Equal(public_key, pub2) {
    54  			t.Error(i, "public key mismatch", hex.EncodeToString(pub2), hex.EncodeToString(public_key))
    55  		}
    56  
    57  		// make sure that you can sign and verify with it
    58  		if e := VerifyKeyPair(private_key, public_key); e!=nil {
    59  			t.Error(i, "verify key failed", e.Error())
    60  		}
    61  	}
    62  }
    63  
    64  func BenchmarkPrivToPubCompr(b *testing.B) {
    65  	var prv [32]byte
    66  	for i:=0; i<b.N; i++ {
    67  		ShaHash(prv[:], prv[:])
    68  		PublicFromPrivate(prv[:], true)
    69  	}
    70  }
    71  
    72  
    73  func BenchmarkPrivToPubUncom(b *testing.B) {
    74  	var prv [32]byte
    75  	for i:=0; i<b.N; i++ {
    76  		ShaHash(prv[:], prv[:])
    77  		PublicFromPrivate(prv[:], false)
    78  	}
    79  }
    80  
    81  
    82  func BenchmarkDeriveNextPrivate(b *testing.B) {
    83  	var sec [32]byte
    84  	prv := make([]byte, 32)
    85  	ShaHash(sec[:], prv)
    86  	ShaHash(prv, sec[:])
    87  	b.ResetTimer()
    88  	for i:=0; i<b.N; i++ {
    89  		prv = DeriveNextPrivate(prv, sec[:])
    90  	}
    91  }
    92  
    93  
    94  func BenchmarkDeriveNextPublic(b *testing.B) {
    95  	var prv, sec [32]byte
    96  	ShaHash(prv[:], prv[:])
    97  	ShaHash(prv[:], sec[:])
    98  	pub := PublicFromPrivate(prv[:], true)
    99  	b.ResetTimer()
   100  	for i:=0; i<b.N; i++ {
   101  		pub = DeriveNextPublic(pub, sec[:])
   102  	}
   103  }
   104  
   105  
   106  func TestDecodePrivateKey(t *testing.T) {
   107  	// mainnet compressed
   108  	pk, er := DecodePrivateAddr("L2zsCZKchUMJ9BS7MVyo8gLGV26rYtgFZskSitwkptk4F1g3KtjN")
   109  	if er != nil {
   110  		t.Error(er.Error())
   111  	}
   112  	if pk.Version != 128 {
   113  		t.Error("Bad version")
   114  	}
   115  	if !pk.IsCompressed() {
   116  		t.Error("Should be compressed")
   117  	}
   118  	if pk.BtcAddr.String()!="179nPBZhnSRM9HB7RM9bJztRAb8ciPitVr" {
   119  		t.Error("Bad address")
   120  	}
   121  	if pk.String() != "L2zsCZKchUMJ9BS7MVyo8gLGV26rYtgFZskSitwkptk4F1g3KtjN" {
   122  		t.Error("Unexpected endode result")
   123  	}
   124  
   125  	// testnet uncompressed
   126  	pk, er = DecodePrivateAddr("92fqqcuu2iSqjfAFifVJ7yxDAkUgFEMgu19YgzLxUqXmbJQRrWp")
   127  	if er != nil {
   128  		t.Error(er.Error())
   129  	}
   130  	if pk.Version != 128+0x6f {
   131  		t.Error("Bad version")
   132  	}
   133  	if pk.IsCompressed() {
   134  		t.Error("Should not be compressed")
   135  	}
   136  	if pk.BtcAddr.String()!="mj12iv73R4V5bbyhZg6TTQHfd7bL7rzu2v" {
   137  		t.Error("Bad address")
   138  	}
   139  	if pk.String() != "92fqqcuu2iSqjfAFifVJ7yxDAkUgFEMgu19YgzLxUqXmbJQRrWp" {
   140  		t.Error("Unexpected endode result")
   141  	}
   142  
   143  	// litecoin compressed
   144  	pk, er = DecodePrivateAddr("TAtSTnmpQFUKRH56MN7mn6iU8tJpcok7uCP2Hcab599H2pyDZKfY")
   145  	if er != nil {
   146  		t.Error(er.Error())
   147  	}
   148  	if pk.Version != 128+48 {
   149  		t.Error("Bad version")
   150  	}
   151  	if !pk.IsCompressed() {
   152  		t.Error("Should be compressed")
   153  	}
   154  	if pk.BtcAddr.String()!="LMJoWKLk69uXn9joK5LmciyPwiVxAat7Ua" {
   155  		t.Error("Bad address")
   156  	}
   157  	if pk.String() != "TAtSTnmpQFUKRH56MN7mn6iU8tJpcok7uCP2Hcab599H2pyDZKfY" {
   158  		t.Error("Unexpected endode result")
   159  	}
   160  
   161  }