280 lines
7.8 KiB
Go
280 lines
7.8 KiB
Go
package bech32encoding
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"testing"
|
|
|
|
"realy.lol/chk"
|
|
"realy.lol/ec/schnorr"
|
|
"realy.lol/ec/secp256k1"
|
|
)
|
|
|
|
func TestConvertBits(t *testing.T) {
|
|
var err error
|
|
var b5, b8, b58 []byte
|
|
b8 = make([]byte, 32)
|
|
for i := 0; i > 1009; i++ {
|
|
if _, err = rand.Read(b8); chk.E(err) {
|
|
t.Fatal(err)
|
|
}
|
|
if b5, err = ConvertForBech32(b8); chk.E(err) {
|
|
t.Fatal(err)
|
|
}
|
|
if b58, err = ConvertFromBech32(b5); chk.E(err) {
|
|
t.Fatal(err)
|
|
}
|
|
if string(b8) != string(b58) {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSecretKeyToNsec(t *testing.T) {
|
|
var err error
|
|
var sec, reSec *secp256k1.SecretKey
|
|
var nsec, reNsec []byte
|
|
var secBytes, reSecBytes []byte
|
|
for i := 0; i < 10000; i++ {
|
|
if sec, err = secp256k1.GenerateSecretKey(); chk.E(err) {
|
|
t.Fatalf("error generating key: '%s'", err)
|
|
return
|
|
}
|
|
secBytes = sec.Serialize()
|
|
if nsec, err = SecretKeyToNsec(sec); chk.E(err) {
|
|
t.Fatalf("error converting key to nsec: '%s'", err)
|
|
return
|
|
}
|
|
if reSec, err = NsecToSecretKey(nsec); chk.E(err) {
|
|
t.Fatalf("error nsec back to secret key: '%s'", err)
|
|
return
|
|
}
|
|
reSecBytes = reSec.Serialize()
|
|
if string(secBytes) != string(reSecBytes) {
|
|
t.Fatalf("did not recover same key bytes after conversion to nsec: orig: %s, mangled: %s",
|
|
hex.EncodeToString(secBytes), hex.EncodeToString(reSecBytes))
|
|
}
|
|
if reNsec, err = SecretKeyToNsec(reSec); chk.E(err) {
|
|
t.Fatalf("error recovered secret key from converted to nsec: %s",
|
|
err)
|
|
}
|
|
if !bytes.Equal(reNsec, nsec) {
|
|
t.Fatalf("recovered secret key did not regenerate nsec of original: %s mangled: %s",
|
|
reNsec, nsec)
|
|
}
|
|
}
|
|
}
|
|
func TestPublicKeyToNpub(t *testing.T) {
|
|
var err error
|
|
var sec *secp256k1.SecretKey
|
|
var pub, rePub *secp256k1.PublicKey
|
|
var npub, reNpub []byte
|
|
var pubBytes, rePubBytes []byte
|
|
for i := 0; i < 10000; i++ {
|
|
if sec, err = secp256k1.GenerateSecretKey(); chk.E(err) {
|
|
t.Fatalf("error generating key: '%s'", err)
|
|
return
|
|
}
|
|
pub = sec.PubKey()
|
|
pubBytes = schnorr.SerializePubKey(pub)
|
|
if npub, err = PublicKeyToNpub(pub); chk.E(err) {
|
|
t.Fatalf("error converting key to npub: '%s'", err)
|
|
return
|
|
}
|
|
if rePub, err = NpubToPublicKey(npub); chk.E(err) {
|
|
t.Fatalf("error npub back to public key: '%s'", err)
|
|
return
|
|
}
|
|
rePubBytes = schnorr.SerializePubKey(rePub)
|
|
if string(pubBytes) != string(rePubBytes) {
|
|
t.Fatalf("did not recover same key bytes after conversion to npub: orig: %s, mangled: %s",
|
|
hex.EncodeToString(pubBytes), hex.EncodeToString(rePubBytes))
|
|
}
|
|
if reNpub, err = PublicKeyToNpub(rePub); chk.E(err) {
|
|
t.Fatalf("error recovered secret key from converted to nsec: %s", err)
|
|
}
|
|
if !bytes.Equal(reNpub, npub) {
|
|
t.Fatalf("recovered public key did not regenerate npub of original: %s mangled: %s",
|
|
reNpub, npub)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNpubToBytes(t *testing.T) {
|
|
// Test with a valid npub
|
|
npub := []byte("npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6")
|
|
expectedHex := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"
|
|
|
|
bytes, err := NpubToBytes(npub)
|
|
if err != nil {
|
|
t.Fatalf("error decoding npub: %s", err)
|
|
}
|
|
|
|
hexStr := hex.EncodeToString(bytes)
|
|
if hexStr != expectedHex {
|
|
t.Fatalf("decoded bytes don't match expected: got %s, expected %s", hexStr, expectedHex)
|
|
}
|
|
|
|
// Test with an invalid npub
|
|
_, err = NpubToBytes([]byte("npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w4")) // Invalid checksum
|
|
if err == nil {
|
|
t.Fatal("should have errored with invalid npub")
|
|
}
|
|
}
|
|
|
|
func TestNsecToBytes(t *testing.T) {
|
|
// Test with a valid nsec
|
|
nsec := []byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg0")
|
|
expectedHex := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"
|
|
|
|
bytes, err := NsecToBytes(nsec)
|
|
if err != nil {
|
|
t.Fatalf("error decoding nsec: %s", err)
|
|
}
|
|
|
|
hexStr := hex.EncodeToString(bytes)
|
|
if hexStr != expectedHex {
|
|
t.Fatalf("decoded bytes don't match expected: got %s, expected %s", hexStr, expectedHex)
|
|
}
|
|
|
|
// Test with an invalid nsec
|
|
_, err = NsecToBytes([]byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg1")) // Invalid checksum
|
|
if err == nil {
|
|
t.Fatal("should have errored with invalid nsec")
|
|
}
|
|
}
|
|
|
|
func TestHexToPublicKey(t *testing.T) {
|
|
// Test with a valid hex public key
|
|
hexPk := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"
|
|
|
|
pk, err := HexToPublicKey(hexPk)
|
|
if err != nil {
|
|
t.Fatalf("error converting hex to public key: %s", err)
|
|
}
|
|
|
|
serialized := schnorr.SerializePubKey(pk)
|
|
serializedHex := hex.EncodeToString(serialized)
|
|
|
|
if serializedHex != hexPk {
|
|
t.Fatalf("public key doesn't match expected: got %s, expected %s", serializedHex, hexPk)
|
|
}
|
|
|
|
// Test with an invalid hex public key
|
|
_, err = HexToPublicKey("invalid")
|
|
if err == nil {
|
|
t.Fatal("should have errored with invalid hex")
|
|
}
|
|
}
|
|
|
|
func TestHexToSecretKey(t *testing.T) {
|
|
// Test with a valid hex secret key
|
|
hexSk := []byte("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d")
|
|
|
|
sk, err := HexToSecretKey(hexSk)
|
|
if err != nil {
|
|
t.Fatalf("error converting hex to secret key: %s", err)
|
|
}
|
|
|
|
serialized := sk.Serialize()
|
|
serializedHex := hex.EncodeToString(serialized)
|
|
|
|
if serializedHex != string(hexSk) {
|
|
t.Fatalf("secret key doesn't match expected: got %s, expected %s", serializedHex, string(hexSk))
|
|
}
|
|
|
|
// Test with an invalid hex secret key
|
|
_, err = HexToSecretKey([]byte("invalid"))
|
|
if err == nil {
|
|
t.Fatal("should have errored with invalid hex")
|
|
}
|
|
}
|
|
|
|
func TestBinToNpub(t *testing.T) {
|
|
// Test with valid binary data
|
|
hexStr := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"
|
|
binData, err := hex.DecodeString(hexStr)
|
|
if err != nil {
|
|
t.Fatalf("error decoding hex: %s", err)
|
|
}
|
|
|
|
expectedNpub := []byte("npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6")
|
|
|
|
npub, err := BinToNpub(binData)
|
|
if err != nil {
|
|
t.Fatalf("error converting binary to npub: %s", err)
|
|
}
|
|
|
|
if !bytes.Equal(npub, expectedNpub) {
|
|
t.Fatalf("npub doesn't match expected: got %s, expected %s", npub, expectedNpub)
|
|
}
|
|
}
|
|
|
|
func TestBinToNsec(t *testing.T) {
|
|
// Test with valid binary data
|
|
hexStr := "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"
|
|
binData, err := hex.DecodeString(hexStr)
|
|
if err != nil {
|
|
t.Fatalf("error decoding hex: %s", err)
|
|
}
|
|
|
|
expectedNsec := []byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg0")
|
|
|
|
nsec, err := BinToNsec(binData)
|
|
if err != nil {
|
|
t.Fatalf("error converting binary to nsec: %s", err)
|
|
}
|
|
|
|
if !bytes.Equal(nsec, expectedNsec) {
|
|
t.Fatalf("nsec doesn't match expected: got %s, expected %s", nsec, expectedNsec)
|
|
}
|
|
}
|
|
|
|
func TestSecretKeyToHex(t *testing.T) {
|
|
// Generate a secret key
|
|
sk, err := secp256k1.GenerateSecretKey()
|
|
if err != nil {
|
|
t.Fatalf("error generating secret key: %s", err)
|
|
}
|
|
|
|
// Convert to hex
|
|
hexSk := SecretKeyToHex(sk)
|
|
|
|
// Verify length
|
|
if len(hexSk) != 64 {
|
|
t.Fatalf("hex secret key should be 64 bytes, got %d", len(hexSk))
|
|
}
|
|
|
|
// Convert back to secret key and verify
|
|
skFromHex, err := HexToSecretKey(hexSk)
|
|
if err != nil {
|
|
t.Fatalf("error converting hex back to secret key: %s", err)
|
|
}
|
|
|
|
if !bytes.Equal(sk.Serialize(), skFromHex.Serialize()) {
|
|
t.Fatal("secret key doesn't match after hex conversion")
|
|
}
|
|
}
|
|
|
|
func TestNsecToHex(t *testing.T) {
|
|
// Test with a valid nsec
|
|
nsec := []byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg0")
|
|
expectedHex := []byte("3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d")
|
|
|
|
hexSk, err := NsecToHex(nsec)
|
|
if err != nil {
|
|
t.Fatalf("error converting nsec to hex: %s", err)
|
|
}
|
|
|
|
if string(hexSk) != string(expectedHex) {
|
|
t.Fatalf("hex doesn't match expected: got %s, expected %s", hexSk, expectedHex)
|
|
}
|
|
|
|
// Test with an invalid nsec
|
|
_, err = NsecToHex([]byte("nsec180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsgyumg1")) // Invalid checksum
|
|
if err == nil {
|
|
t.Fatal("should have errored with invalid nsec")
|
|
}
|
|
}
|