Refactor signer implementation to use p8k package

- Replaced all instances of p256k1signer with the new p8k.Signer across various modules, including event creation, policy handling, and database interactions.
- Updated related test cases and benchmarks to ensure compatibility with the new signer interface.
- Bumped version to v0.25.0 to reflect these significant changes and improvements in cryptographic operations.

pkg/crypto/p8k/recovery.go

@@ -0,0 +1,108 @@
+package secp
+
+import (
+	"fmt"
+)
+
+// SignRecoverable creates a recoverable ECDSA signature
+func (c *Context) SignRecoverable(msg32 []byte, seckey []byte) (sig []byte, err error) {
+	if ecdsaSignRecoverable == nil {
+		err = fmt.Errorf("recovery module not available")
+		return
+	}
+
+	if len(msg32) != 32 {
+		err = fmt.Errorf("message must be 32 bytes")
+		return
+	}
+
+	if len(seckey) != PrivateKeySize {
+		err = fmt.Errorf("private key must be %d bytes", PrivateKeySize)
+		return
+	}
+
+	sig = make([]byte, RecoverableSignatureSize)
+	ret := ecdsaSignRecoverable(c.ctx, &sig[0], &msg32[0], &seckey[0], 0, 0)
+	if ret != 1 {
+		err = fmt.Errorf("failed to create recoverable signature")
+		return
+	}
+
+	return
+}
+
+// SerializeRecoverableSignatureCompact serializes a recoverable signature
+func (c *Context) SerializeRecoverableSignatureCompact(sig []byte) (output64 []byte, recid int32, err error) {
+	if ecdsaRecoverableSignatureSerializeCompact == nil {
+		err = fmt.Errorf("recovery module not available")
+		return
+	}
+
+	if len(sig) != RecoverableSignatureSize {
+		err = fmt.Errorf("recoverable signature must be %d bytes", RecoverableSignatureSize)
+		return
+	}
+
+	output64 = make([]byte, 64)
+	ret := ecdsaRecoverableSignatureSerializeCompact(c.ctx, &output64[0], &recid, &sig[0])
+	if ret != 1 {
+		err = fmt.Errorf("failed to serialize recoverable signature")
+		return
+	}
+
+	return
+}
+
+// ParseRecoverableSignatureCompact parses a compact recoverable signature
+func (c *Context) ParseRecoverableSignatureCompact(input64 []byte, recid int32) (sig []byte, err error) {
+	if ecdsaRecoverableSignatureParseCompact == nil {
+		err = fmt.Errorf("recovery module not available")
+		return
+	}
+
+	if len(input64) != 64 {
+		err = fmt.Errorf("compact signature must be 64 bytes")
+		return
+	}
+
+	if recid < 0 || recid > 3 {
+		err = fmt.Errorf("recovery id must be 0-3")
+		return
+	}
+
+	sig = make([]byte, RecoverableSignatureSize)
+	ret := ecdsaRecoverableSignatureParseCompact(c.ctx, &sig[0], &input64[0], recid)
+	if ret != 1 {
+		err = fmt.Errorf("failed to parse recoverable signature")
+		return
+	}
+
+	return
+}
+
+// Recover recovers a public key from a recoverable signature
+func (c *Context) Recover(sig []byte, msg32 []byte) (pubkey []byte, err error) {
+	if ecdsaRecover == nil {
+		err = fmt.Errorf("recovery module not available")
+		return
+	}
+
+	if len(sig) != RecoverableSignatureSize {
+		err = fmt.Errorf("recoverable signature must be %d bytes", RecoverableSignatureSize)
+		return
+	}
+
+	if len(msg32) != 32 {
+		err = fmt.Errorf("message must be 32 bytes")
+		return
+	}
+
+	pubkey = make([]byte, PublicKeySize)
+	ret := ecdsaRecover(c.ctx, &pubkey[0], &sig[0], &msg32[0])
+	if ret != 1 {
+		err = fmt.Errorf("failed to recover public key")
+		return
+	}
+
+	return
+}