Sign worked. updated sign example. Testing reshare

Author: tuananhk13bk

examples/generate/main.go

@@ -104,13 +104,15 @@ func main() {
 
 	// STEP 3: Create wallets
 	for _, walletID := range walletIDs {
+		wg.Add(1) // Add to WaitGroup BEFORE attempting to create wallet
+
 		if err := mpcClient.CreateWallet(walletID); err != nil {
 			logger.Error("CreateWallet failed", err)
 			walletStartTimes.Delete(walletID)
-			wg.Done()
+			wg.Done() // Now this is safe since we added 1 above
 			continue
 		}
-		wg.Add(1)
+
 		logger.Info("CreateWallet sent, awaiting result...", "walletID", walletID)
 	}
 

examples/sign/main.go

@@ -21,6 +21,18 @@ func main() {
 	config.InitViperConfig()
 	logger.Init(environment, true)
 
+	algorithm := viper.GetString("event_initiator_algorithm")
+	if algorithm == "" {
+		algorithm = "ed25519"
+	}
+
+	// Validate algorithm
+	if algorithm != "ed25519" && algorithm != "p256" {
+		logger.Fatal(
+			"Invalid event_initiator_algorithm in config. Must be 'ed25519' or 'p256'",
+			nil,
+		)
+	}
 	natsURL := viper.GetString("nats.url")
 	natsConn, err := nats.Connect(natsURL)
 	if err != nil {
@@ -30,17 +42,29 @@ func main() {
 	defer natsConn.Close()
 
 	mpcClient := client.NewMPCClient(client.Options{
-		NatsConn: natsConn,
-		KeyPath:  "./event_initiator.key",
+		Algorithm: algorithm,
+		NatsConn:  natsConn,
+		KeyPath:   "./event_initiator.key",
 	})
 
 	// 2) Once wallet exists, immediately fire a SignTransaction
 	txID := uuid.New().String()
 	dummyTx := []byte("deadbeef") // replace with real transaction bytes
 
+	// Determine key type based on algorithm
+	var keyType types.KeyType
+	switch algorithm {
+	case "ed25519":
+		keyType = types.KeyTypeEd25519
+	case "p256":
+		keyType = types.KeyTypeP256
+	default:
+		logger.Fatal("Unsupported algorithm", nil)
+	}
+
 	txMsg := &types.SignTxMessage{
-		KeyType:             types.KeyTypeEd25519,
-		WalletID:            "c47cd6f4-8ef4-4d77-9d2b-37f9d062e615",
+		KeyType:             keyType,
+		WalletID:            "ad24f678-b04b-4149-bcf6-bf9c90df8e63", // Use the generated wallet ID
 		NetworkInternalCode: "solana-devnet",
 		TxID:                txID,
 		Tx:                  dummyTx,

pkg/encryption/p256.go

@@ -6,6 +6,7 @@ import (
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/x509"
+	"encoding/base64"
 	"encoding/hex"
 	"fmt"
 	"strings"
@@ -55,16 +56,18 @@ func ParseP256PrivateKey(keyData []byte) (*ecdsa.PrivateKey, error) {
 	return nil, fmt.Errorf("failed to parse P256 private key from DER or hex format")
 }
 
-// SignWithP256 signs data using the P256 private key
+// SignWithP256 signs data using a P256 private key
 func SignWithP256(privateKey *ecdsa.PrivateKey, data []byte) ([]byte, error) {
+	if privateKey == nil {
+		return nil, fmt.Errorf("invalid private key: private key is nil")
+	}
+
 	if privateKey.Curve == nil {
 		return nil, fmt.Errorf("invalid private key: curve is nil")
 	}
 
 	hash := sha256.Sum256(data)
 
-	// Use crypto/ecdsa.Sign to create a proper P256 signature
-	// The signature will be in ASN.1 DER format
 	signature, err := ecdsa.SignASN1(rand.Reader, privateKey, hash[:])
 	if err != nil {
 		return nil, fmt.Errorf("failed to sign data: %w", err)
@@ -117,3 +120,65 @@ func VerifyP256Signature(publicKey *ecdsa.PublicKey, data []byte, signature []by
 
 	return nil
 }
+func ParseP256PublicKeyFromBytes(keyBytes []byte) (*ecdsa.PublicKey, error) {
+	// Try to parse as DER first
+	if key, err := x509.ParsePKIXPublicKey(keyBytes); err == nil {
+		if ecdsaKey, ok := key.(*ecdsa.PublicKey); ok {
+			if ecdsaKey.Curve == elliptic.P256() {
+				return ecdsaKey, nil
+			}
+		}
+	}
+
+	// Try to parse as EC public key
+	if key, err := x509.ParsePKIXPublicKey(keyBytes); err == nil {
+		if ecdsaKey, ok := key.(*ecdsa.PublicKey); ok {
+			if ecdsaKey.Curve == elliptic.P256() {
+				return ecdsaKey, nil
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("failed to parse P-256 public key from bytes")
+}
+
+// ParseP256PublicKeyFromHex parses a P-256 public key from hex string
+func ParseP256PublicKeyFromHex(hexString string) (*ecdsa.PublicKey, error) {
+	// Remove 0x prefix if present
+	if strings.HasPrefix(hexString, "0x") {
+		hexString = hexString[2:]
+	}
+
+	// Decode hex
+	keyBytes, err := hex.DecodeString(hexString)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode hex string: %w", err)
+	}
+
+	return ParseP256PublicKeyFromBytes(keyBytes)
+}
+
+// ParseP256PublicKeyFromBase64 parses a P-256 public key from base64 string
+func ParseP256PublicKeyFromBase64(base64String string) (*ecdsa.PublicKey, error) {
+	// Decode base64
+	keyBytes, err := base64.StdEncoding.DecodeString(base64String)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode base64 string: %w", err)
+	}
+
+	return ParseP256PublicKeyFromBytes(keyBytes)
+}
+
+// ValidateP256PublicKey validates that a public key is P-256
+func ValidateP256PublicKey(publicKey *ecdsa.PublicKey) error {
+	if publicKey == nil {
+		return fmt.Errorf("public key is nil")
+	}
+	if publicKey.Curve == nil {
+		return fmt.Errorf("public key curve is nil")
+	}
+	if publicKey.Curve != elliptic.P256() {
+		return fmt.Errorf("public key is not P-256 curve (got: %s)", publicKey.Curve.Params().Name)
+	}
+	return nil
+}