You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
114 lines
2.8 KiB
114 lines
2.8 KiB
package bech32encoding |
|
|
|
import ( |
|
"crypto/rand" |
|
"encoding/hex" |
|
"testing" |
|
|
|
"crypto.orly/ec/schnorr" |
|
"crypto.orly/ec/secp256k1" |
|
"lol.mleku.dev/chk" |
|
"utils.orly" |
|
) |
|
|
|
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 !utils.FastEqual(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 !utils.FastEqual(reNpub, npub) { |
|
t.Fatalf( |
|
"recovered public key did not regenerate npub of original: %s mangled: %s", |
|
reNpub, npub, |
|
) |
|
} |
|
} |
|
}
|
|
|