extrakeys_test.go raw

   1  package p256k1
   2  
   3  import (
   4  	"testing"
   5  )
   6  
   7  func TestXOnlyPubkeyParse(t *testing.T) {
   8  	// Generate a keypair and get its x-only pubkey
   9  	kp, err := KeyPairGenerate()
  10  	if err != nil {
  11  		t.Fatalf("failed to generate keypair: %v", err)
  12  	}
  13  
  14  	xonly, err := kp.XOnlyPubkey()
  15  	if err != nil {
  16  		t.Fatalf("failed to get x-only pubkey: %v", err)
  17  	}
  18  
  19  	// Serialize and parse back
  20  	serialized := xonly.Serialize()
  21  	parsed, err := XOnlyPubkeyParse(serialized[:])
  22  	if err != nil {
  23  		t.Fatalf("failed to parse x-only pubkey: %v", err)
  24  	}
  25  
  26  	// Should match
  27  	if XOnlyPubkeyCmp(xonly, parsed) != 0 {
  28  		t.Error("parsed x-only pubkey does not match original")
  29  	}
  30  }
  31  
  32  func TestXOnlyPubkeyFromPubkey(t *testing.T) {
  33  	// Generate keypair
  34  	kp, err := KeyPairGenerate()
  35  	if err != nil {
  36  		t.Fatalf("failed to generate keypair: %v", err)
  37  	}
  38  
  39  	// Convert to x-only
  40  	xonly, parity, err := XOnlyPubkeyFromPubkey(kp.Pubkey())
  41  	if err != nil {
  42  		t.Fatalf("failed to convert to x-only: %v", err)
  43  	}
  44  
  45  	// Parity should be 0 or 1
  46  	if parity != 0 && parity != 1 {
  47  		t.Errorf("invalid parity: %d", parity)
  48  	}
  49  
  50  	// X coordinate should match
  51  	var pkX [32]byte
  52  	var pt GroupElementAffine
  53  	pt.fromBytes(kp.Pubkey().data[:])
  54  	if parity == 1 {
  55  		pt.negate(&pt)
  56  	}
  57  	pt.x.normalize()
  58  	pt.x.getB32(pkX[:])
  59  
  60  	xonlySerialized := xonly.Serialize()
  61  	for i := 0; i < 32; i++ {
  62  		if pkX[i] != xonlySerialized[i] {
  63  			t.Errorf("X coordinate mismatch at byte %d", i)
  64  		}
  65  	}
  66  }
  67  
  68  func TestKeyPairCreate(t *testing.T) {
  69  	// Generate a secret key
  70  	seckey, err := ECSeckeyGenerate()
  71  	if err != nil {
  72  		t.Fatalf("failed to generate secret key: %v", err)
  73  	}
  74  
  75  	// Create keypair
  76  	kp, err := KeyPairCreate(seckey)
  77  	if err != nil {
  78  		t.Fatalf("failed to create keypair: %v", err)
  79  	}
  80  
  81  	// Verify secret key matches
  82  	kpSeckey := kp.Seckey()
  83  	for i := 0; i < 32; i++ {
  84  		if kpSeckey[i] != seckey[i] {
  85  			t.Errorf("secret key mismatch at byte %d", i)
  86  		}
  87  	}
  88  
  89  	// Verify public key matches
  90  	var expectedPubkey PublicKey
  91  	if err := ECPubkeyCreate(&expectedPubkey, seckey); err != nil {
  92  		t.Fatalf("failed to create expected pubkey: %v", err)
  93  	}
  94  
  95  	if ECPubkeyCmp(kp.Pubkey(), &expectedPubkey) != 0 {
  96  		t.Error("public key does not match")
  97  	}
  98  }
  99  
 100  func TestKeyPairGenerate(t *testing.T) {
 101  	kp, err := KeyPairGenerate()
 102  	if err != nil {
 103  		t.Fatalf("failed to generate keypair: %v", err)
 104  	}
 105  
 106  	// Verify secret key is valid
 107  	if !ECSeckeyVerify(kp.Seckey()) {
 108  		t.Error("generated secret key is invalid")
 109  	}
 110  
 111  	// Verify public key matches secret key
 112  	var expectedPubkey PublicKey
 113  	if err := ECPubkeyCreate(&expectedPubkey, kp.Seckey()); err != nil {
 114  		t.Fatalf("failed to create expected pubkey: %v", err)
 115  	}
 116  
 117  	if ECPubkeyCmp(kp.Pubkey(), &expectedPubkey) != 0 {
 118  		t.Error("public key does not match secret key")
 119  	}
 120  }
 121  
 122  func TestXOnlyPubkeyCmp(t *testing.T) {
 123  	kp1, err := KeyPairGenerate()
 124  	if err != nil {
 125  		t.Fatalf("failed to generate keypair 1: %v", err)
 126  	}
 127  
 128  	kp2, err := KeyPairGenerate()
 129  	if err != nil {
 130  		t.Fatalf("failed to generate keypair 2: %v", err)
 131  	}
 132  
 133  	xonly1, err := kp1.XOnlyPubkey()
 134  	if err != nil {
 135  		t.Fatalf("failed to get x-only pubkey 1: %v", err)
 136  	}
 137  
 138  	xonly2, err := kp2.XOnlyPubkey()
 139  	if err != nil {
 140  		t.Fatalf("failed to get x-only pubkey 2: %v", err)
 141  	}
 142  
 143  	// Compare with itself should return 0
 144  	if XOnlyPubkeyCmp(xonly1, xonly1) != 0 {
 145  		t.Error("x-only pubkey should equal itself")
 146  	}
 147  
 148  	// Compare with different key should return non-zero
 149  	cmp := XOnlyPubkeyCmp(xonly1, xonly2)
 150  	if cmp == 0 {
 151  		t.Error("different x-only pubkeys should not compare equal")
 152  	}
 153  }
 154