keys_test.go raw

   1  package bech32encoding
   2  
   3  import (
   4  	"crypto/rand"
   5  	"encoding/hex"
   6  	"testing"
   7  
   8  	"next.orly.dev/pkg/nostr/crypto/ec/schnorr"
   9  	"next.orly.dev/pkg/nostr/crypto/ec/secp256k1"
  10  	"next.orly.dev/pkg/nostr/utils"
  11  	"next.orly.dev/pkg/lol/chk"
  12  )
  13  
  14  func TestConvertBits(t *testing.T) {
  15  	var err error
  16  	var b5, b8, b58 []byte
  17  	b8 = make([]byte, 32)
  18  	for i := 0; i > 1009; i++ {
  19  		if _, err = rand.Read(b8); chk.E(err) {
  20  			t.Fatal(err)
  21  		}
  22  		if b5, err = ConvertForBech32(b8); chk.E(err) {
  23  			t.Fatal(err)
  24  		}
  25  		if b58, err = ConvertFromBech32(b5); chk.E(err) {
  26  			t.Fatal(err)
  27  		}
  28  		if string(b8) != string(b58) {
  29  			t.Fatal(err)
  30  		}
  31  	}
  32  }
  33  
  34  func TestSecretKeyToNsec(t *testing.T) {
  35  	var err error
  36  	var sec, reSec *secp256k1.SecretKey
  37  	var nsec, reNsec []byte
  38  	var secBytes, reSecBytes []byte
  39  	for i := 0; i < 10000; i++ {
  40  		if sec, err = secp256k1.GenerateSecretKey(); chk.E(err) {
  41  			t.Fatalf("error generating key: '%s'", err)
  42  			return
  43  		}
  44  		secBytes = sec.Serialize()
  45  		if nsec, err = SecretKeyToNsec(sec); chk.E(err) {
  46  			t.Fatalf("error converting key to nsec: '%s'", err)
  47  			return
  48  		}
  49  		if reSec, err = NsecToSecretKey(nsec); chk.E(err) {
  50  			t.Fatalf("error nsec back to secret key: '%s'", err)
  51  			return
  52  		}
  53  		reSecBytes = reSec.Serialize()
  54  		if string(secBytes) != string(reSecBytes) {
  55  			t.Fatalf(
  56  				"did not recover same key bytes after conversion to nsec: orig: %s, mangled: %s",
  57  				hex.EncodeToString(secBytes), hex.EncodeToString(reSecBytes),
  58  			)
  59  		}
  60  		if reNsec, err = SecretKeyToNsec(reSec); chk.E(err) {
  61  			t.Fatalf(
  62  				"error recovered secret key from converted to nsec: %s",
  63  				err,
  64  			)
  65  		}
  66  		if !utils.FastEqual(reNsec, nsec) {
  67  			t.Fatalf(
  68  				"recovered secret key did not regenerate nsec of original: %s mangled: %s",
  69  				reNsec, nsec,
  70  			)
  71  		}
  72  	}
  73  }
  74  func TestPublicKeyToNpub(t *testing.T) {
  75  	var err error
  76  	var sec *secp256k1.SecretKey
  77  	var pub, rePub *secp256k1.PublicKey
  78  	var npub, reNpub []byte
  79  	var pubBytes, rePubBytes []byte
  80  	for i := 0; i < 10000; i++ {
  81  		if sec, err = secp256k1.GenerateSecretKey(); chk.E(err) {
  82  			t.Fatalf("error generating key: '%s'", err)
  83  			return
  84  		}
  85  		pub = sec.PubKey()
  86  		pubBytes = schnorr.SerializePubKey(pub)
  87  		if npub, err = PublicKeyToNpub(pub); chk.E(err) {
  88  			t.Fatalf("error converting key to npub: '%s'", err)
  89  			return
  90  		}
  91  		if rePub, err = NpubToPublicKey(npub); chk.E(err) {
  92  			t.Fatalf("error npub back to public key: '%s'", err)
  93  			return
  94  		}
  95  		rePubBytes = schnorr.SerializePubKey(rePub)
  96  		if string(pubBytes) != string(rePubBytes) {
  97  			t.Fatalf(
  98  				"did not recover same key bytes after conversion to npub: orig: %s, mangled: %s",
  99  				hex.EncodeToString(pubBytes), hex.EncodeToString(rePubBytes),
 100  			)
 101  		}
 102  		if reNpub, err = PublicKeyToNpub(rePub); chk.E(err) {
 103  			t.Fatalf(
 104  				"error recovered secret key from converted to nsec: %s", err,
 105  			)
 106  		}
 107  		if !utils.FastEqual(reNpub, npub) {
 108  			t.Fatalf(
 109  				"recovered public key did not regenerate npub of original: %s mangled: %s",
 110  				reNpub, npub,
 111  			)
 112  		}
 113  	}
 114  }
 115