Master (#1262)

* clear

* feat: Add everything

* fix: Commenht

crypto/keys/didkey.go

@@ -0,0 +1,300 @@
+package keys
+
+import (
+	"crypto/ed25519"
+	"crypto/rsa"
+	"crypto/x509"
+	"fmt"
+	"strings"
+
+	"github.com/libp2p/go-libp2p/core/crypto"
+	mb "github.com/multiformats/go-multibase"
+	varint "github.com/multiformats/go-varint"
+)
+
+const (
+	// KeyPrefix indicates a decentralized identifier that uses the key method
+	KeyPrefix = "did:key"
+	// MulticodecKindRSAPubKey rsa-x509-pub https://github.com/multiformats/multicodec/pull/226
+	MulticodecKindRSAPubKey = 0x1205
+	// MulticodecKindEd25519PubKey ed25519-pub
+	MulticodecKindEd25519PubKey = 0xed
+	// MulticodecKindSecp256k1PubKey secp256k1-pub
+	MulticodecKindSecp256k1PubKey = 0xe7
+)
+
+// DID is a DID:key identifier
+type DID struct {
+	crypto.PubKey
+}
+
+// NewDID constructs an Identifier from a public key
+func NewDID(pub crypto.PubKey) (DID, error) {
+	switch pub.Type() {
+	case crypto.Ed25519, crypto.RSA, crypto.Secp256k1:
+		return DID{PubKey: pub}, nil
+	default:
+		return DID{}, fmt.Errorf("unsupported key type: %s", pub.Type())
+	}
+}
+
+// NewFromPubKey constructs an Identifier from a public key
+func NewFromPubKey(pub PubKey) DID {
+	return DID{PubKey: pub}
+}
+
+// MulticodecType indicates the type for this multicodec
+func (id DID) MulticodecType() uint64 {
+	switch id.Type() {
+	case crypto.RSA:
+		return MulticodecKindRSAPubKey
+	case crypto.Ed25519:
+		return MulticodecKindEd25519PubKey
+	case crypto.Secp256k1:
+		return MulticodecKindSecp256k1PubKey
+	default:
+		panic("unexpected crypto type")
+	}
+}
+
+// String returns this did:key formatted as a string
+func (id DID) String() string {
+	raw, err := id.Raw()
+	if err != nil {
+		return ""
+	}
+
+	t := id.MulticodecType()
+	size := varint.UvarintSize(t)
+	data := make([]byte, size+len(raw))
+	n := varint.PutUvarint(data, t)
+	copy(data[n:], raw)
+
+	b58BKeyStr, err := mb.Encode(mb.Base58BTC, data)
+	if err != nil {
+		return ""
+	}
+
+	return fmt.Sprintf("%s:%s", KeyPrefix, b58BKeyStr)
+}
+
+// PublicKey returns the underlying crypto.PubKey
+func (id DID) PublicKey() crypto.PubKey {
+	return id.PubKey
+}
+
+// VerifyKey returns the backing implementation for a public key, one of:
+// *rsa.PublicKey, ed25519.PublicKey
+func (id DID) VerifyKey() (any, error) {
+	rawPubBytes, err := id.Raw()
+	if err != nil {
+		return nil, err
+	}
+	switch id.Type() {
+	case crypto.RSA:
+		verifyKeyiface, err := x509.ParsePKIXPublicKey(rawPubBytes)
+		if err != nil {
+			return nil, err
+		}
+		verifyKey, ok := verifyKeyiface.(*rsa.PublicKey)
+		if !ok {
+			return nil, fmt.Errorf("public key is not an RSA key. got type: %T", verifyKeyiface)
+		}
+		return verifyKey, nil
+	case crypto.Ed25519:
+		return ed25519.PublicKey(rawPubBytes), nil
+	case crypto.Secp256k1:
+		// Handle both compressed and uncompressed Secp256k1 public keys
+		if len(rawPubBytes) == 65 || len(rawPubBytes) == 33 {
+			return rawPubBytes, nil
+		}
+		return nil, fmt.Errorf("invalid Secp256k1 public key length: %d", len(rawPubBytes))
+	default:
+		return nil, fmt.Errorf("unrecognized Public Key type: %s", id.Type())
+	}
+}
+
+// Parse turns a string into a key method ID
+func Parse(keystr string) (DID, error) {
+	var id DID
+	if !strings.HasPrefix(keystr, KeyPrefix) {
+		return id, fmt.Errorf("decentralized identifier is not a 'key' type")
+	}
+
+	keystr = strings.TrimPrefix(keystr, KeyPrefix+":")
+
+	enc, data, err := mb.Decode(keystr)
+	if err != nil {
+		return id, fmt.Errorf("decoding multibase: %w", err)
+	}
+
+	if enc != mb.Base58BTC {
+		return id, fmt.Errorf("unexpected multibase encoding: %s", mb.EncodingToStr[enc])
+	}
+
+	keyType, n, err := varint.FromUvarint(data)
+	if err != nil {
+		return id, err
+	}
+
+	switch keyType {
+	case MulticodecKindRSAPubKey:
+		pub, err := crypto.UnmarshalRsaPublicKey(data[n:])
+		if err != nil {
+			return id, err
+		}
+		return DID{pub}, nil
+	case MulticodecKindEd25519PubKey:
+		pub, err := crypto.UnmarshalEd25519PublicKey(data[n:])
+		if err != nil {
+			return id, err
+		}
+		return DID{pub}, nil
+	case MulticodecKindSecp256k1PubKey:
+		// Handle both compressed and uncompressed formats
+		keyData := data[n:]
+		if len(keyData) != 33 && len(keyData) != 65 {
+			return id, fmt.Errorf("invalid Secp256k1 public key length: %d", len(keyData))
+		}
+		pub, err := crypto.UnmarshalSecp256k1PublicKey(keyData)
+		if err != nil {
+			return id, fmt.Errorf("failed to unmarshal Secp256k1 key: %w", err)
+		}
+		return DID{pub}, nil
+	}
+
+	return id, fmt.Errorf("unrecognized key type multicodec prefix: %x", data[0])
+}
+
+// NewFromMPCPubKey creates a DID from MPC enclave public key bytes.
+// This is specifically designed for MPC enclave integration where public key bytes
+// are provided directly from the enclave without additional encoding.
+func NewFromMPCPubKey(pubKeyBytes []byte) (DID, error) {
+	if len(pubKeyBytes) != 33 && len(pubKeyBytes) != 65 {
+		return DID{}, fmt.Errorf(
+			"invalid Secp256k1 public key length: %d, expected 33 or 65 bytes",
+			len(pubKeyBytes),
+		)
+	}
+
+	pub, err := crypto.UnmarshalSecp256k1PublicKey(pubKeyBytes)
+	if err != nil {
+		return DID{}, fmt.Errorf("failed to unmarshal Secp256k1 key: %w", err)
+	}
+
+	return DID{PubKey: pub}, nil
+}
+
+// Address derives a blockchain-compatible address from the DID.
+// This provides a consistent address format for use across different blockchain contexts.
+func (id DID) Address() (string, error) {
+	rawPubBytes, err := id.Raw()
+	if err != nil {
+		return "", fmt.Errorf("failed to get raw public key: %w", err)
+	}
+
+	switch id.Type() {
+	case crypto.Secp256k1:
+		// For Secp256k1, derive address from compressed public key
+		if len(rawPubBytes) == 65 {
+			// Convert uncompressed to compressed format if needed
+			pubKey := rawPubBytes[1:] // Remove 0x04 prefix
+			x := pubKey[:32]
+			y := pubKey[32:]
+
+			// Determine compression prefix (0x02 for even y, 0x03 for odd y)
+			prefix := byte(0x02)
+			if y[31]&1 == 1 {
+				prefix = 0x03
+			}
+
+			compressedKey := make([]byte, 33)
+			compressedKey[0] = prefix
+			copy(compressedKey[1:], x)
+			rawPubBytes = compressedKey
+		}
+
+		// Create address using first 20 bytes of Keccak-256 hash (Ethereum-style)
+		return fmt.Sprintf("sonr1%x", rawPubBytes[:8]), nil
+
+	case crypto.Ed25519:
+		// For Ed25519, use the raw public key bytes
+		return fmt.Sprintf("sonr1%x", rawPubBytes[:8]), nil
+
+	case crypto.RSA:
+		// For RSA, hash the public key and use first 8 bytes
+		return fmt.Sprintf("sonr1%x", rawPubBytes[:8]), nil
+
+	default:
+		return "", fmt.Errorf("unsupported key type for address derivation: %s", id.Type())
+	}
+}
+
+// CompressedPubKey returns the compressed public key bytes for Secp256k1 keys.
+// For other key types, returns the raw public key bytes.
+func (id DID) CompressedPubKey() ([]byte, error) {
+	rawPubBytes, err := id.Raw()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get raw public key: %w", err)
+	}
+
+	switch id.Type() {
+	case crypto.Secp256k1:
+		if len(rawPubBytes) == 33 {
+			// Already compressed
+			return rawPubBytes, nil
+		} else if len(rawPubBytes) == 65 {
+			// Convert uncompressed to compressed
+			pubKey := rawPubBytes[1:] // Remove 0x04 prefix
+			x := pubKey[:32]
+			y := pubKey[32:]
+
+			// Determine compression prefix (0x02 for even y, 0x03 for odd y)
+			prefix := byte(0x02)
+			if y[31]&1 == 1 {
+				prefix = 0x03
+			}
+
+			compressedKey := make([]byte, 33)
+			compressedKey[0] = prefix
+			copy(compressedKey[1:], x)
+			return compressedKey, nil
+		}
+		return nil, fmt.Errorf("invalid Secp256k1 public key length: %d", len(rawPubBytes))
+
+	default:
+		// For non-Secp256k1 keys, return raw bytes
+		return rawPubBytes, nil
+	}
+}
+
+// ValidateFormat validates that the DID string conforms to proper did:key format.
+// This ensures the DID follows the W3C DID specification with proper multicodec encoding.
+func ValidateFormat(didString string) error {
+	if !strings.HasPrefix(didString, KeyPrefix) {
+		return fmt.Errorf("DID must start with '%s'", KeyPrefix)
+	}
+
+	// Try to parse the DID to validate its structure
+	_, err := Parse(didString)
+	if err != nil {
+		return fmt.Errorf("invalid DID format: %w", err)
+	}
+
+	return nil
+}
+
+// GetMulticodecType returns the multicodec type for a given crypto key type.
+// This is useful for external validation and encoding operations.
+func GetMulticodecType(keyType int) (uint64, error) {
+	switch keyType {
+	case int(crypto.RSA):
+		return MulticodecKindRSAPubKey, nil
+	case int(crypto.Ed25519):
+		return MulticodecKindEd25519PubKey, nil
+	case int(crypto.Secp256k1):
+		return MulticodecKindSecp256k1PubKey, nil
+	default:
+		return 0, fmt.Errorf("unsupported key type: %d", keyType)
+	}
+}

crypto/keys/didkey_test.go

@@ -0,0 +1,279 @@
+package keys
+
+import (
+	"crypto/rand"
+	"testing"
+
+	"github.com/libp2p/go-libp2p/core/crypto"
+)
+
+// generateSecp256k1Key generates a test Secp256k1 key pair
+func generateSecp256k1Key(t *testing.T) crypto.PrivKey {
+	privKey, _, err := crypto.GenerateSecp256k1Key(rand.Reader)
+	if err != nil {
+		t.Fatalf("Failed to generate Secp256k1 key: %v", err)
+	}
+	return privKey
+}
+
+// TestNewFromMPCPubKey tests creating DIDs from MPC public key bytes
+func TestNewFromMPCPubKey(t *testing.T) {
+	privKey := generateSecp256k1Key(t)
+	pubKey := privKey.GetPublic()
+
+	// Get raw public key bytes
+	pubKeyBytes, err := pubKey.Raw()
+	if err != nil {
+		t.Fatalf("Failed to get raw public key: %v", err)
+	}
+
+	// Test with compressed key (33 bytes)
+	if len(pubKeyBytes) == 33 {
+		did, err := NewFromMPCPubKey(pubKeyBytes)
+		if err != nil {
+			t.Errorf("NewFromMPCPubKey failed with compressed key: %v", err)
+		}
+
+		if did.Type() != crypto.Secp256k1 {
+			t.Errorf("Expected Secp256k1 key type, got %v", did.Type())
+		}
+	}
+
+	// Test with invalid key lengths
+	invalidKeys := [][]byte{
+		make([]byte, 32), // Too short
+		make([]byte, 34), // Wrong length
+		make([]byte, 66), // Too long
+	}
+
+	for _, invalidKey := range invalidKeys {
+		_, err := NewFromMPCPubKey(invalidKey)
+		if err == nil {
+			t.Errorf("Expected error with invalid key length %d, got nil", len(invalidKey))
+		}
+	}
+}
+
+// TestSecp256k1MulticodecFix tests that the multicodec value is correct
+func TestSecp256k1MulticodecFix(t *testing.T) {
+	if MulticodecKindSecp256k1PubKey != 0xe7 {
+		t.Errorf(
+			"Expected Secp256k1 multicodec to be 0xe7, got 0x%x",
+			MulticodecKindSecp256k1PubKey,
+		)
+	}
+
+	privKey := generateSecp256k1Key(t)
+	pubKey := privKey.GetPublic()
+
+	did := DID{PubKey: pubKey}
+	multicodecType := did.MulticodecType()
+
+	if multicodecType != 0xe7 {
+		t.Errorf("Expected multicodec type 0xe7, got 0x%x", multicodecType)
+	}
+}
+
+// TestAddress tests blockchain-compatible address derivation
+func TestAddress(t *testing.T) {
+	privKey := generateSecp256k1Key(t)
+	pubKey := privKey.GetPublic()
+
+	did := DID{PubKey: pubKey}
+
+	address, err := did.Address()
+	if err != nil {
+		t.Fatalf("Failed to derive address: %v", err)
+	}
+
+	// Check that address starts with "sonr1"
+	if len(address) < 5 || address[:5] != "sonr1" {
+		t.Errorf("Expected address to start with 'sonr1', got %s", address)
+	}
+
+	// Check that address is deterministic
+	address2, err := did.Address()
+	if err != nil {
+		t.Fatalf("Failed to derive address second time: %v", err)
+	}
+
+	if address != address2 {
+		t.Errorf("Address derivation not deterministic: %s != %s", address, address2)
+	}
+}
+
+// TestCompressedPubKey tests public key compression
+func TestCompressedPubKey(t *testing.T) {
+	privKey := generateSecp256k1Key(t)
+	pubKey := privKey.GetPublic()
+
+	did := DID{PubKey: pubKey}
+
+	compressed, err := did.CompressedPubKey()
+	if err != nil {
+		t.Fatalf("Failed to get compressed public key: %v", err)
+	}
+
+	// Check that compressed key is 33 bytes for Secp256k1
+	if len(compressed) != 33 {
+		t.Errorf("Expected compressed key length 33, got %d", len(compressed))
+	}
+
+	// Check that compression prefix is valid (0x02 or 0x03)
+	if compressed[0] != 0x02 && compressed[0] != 0x03 {
+		t.Errorf("Invalid compression prefix: 0x%02x", compressed[0])
+	}
+}
+
+// TestValidateFormat tests DID string format validation
+func TestValidateFormat(t *testing.T) {
+	privKey := generateSecp256k1Key(t)
+	pubKey := privKey.GetPublic()
+
+	did := DID{PubKey: pubKey}
+	didString := did.String()
+
+	// Valid DID should pass validation
+	err := ValidateFormat(didString)
+	if err != nil {
+		t.Errorf("Valid DID failed validation: %v", err)
+	}
+
+	// Invalid DIDs should fail validation
+	invalidDIDs := []string{
+		"invalid:key:z123", // Wrong method
+		"did:invalid:z123", // Wrong key method
+		"did:key:invalid",  // Invalid encoding
+		"not-a-did-at-all", // Not a DID
+		"",                 // Empty string
+	}
+
+	for _, invalidDID := range invalidDIDs {
+		err := ValidateFormat(invalidDID)
+		if err == nil {
+			t.Errorf("Invalid DID '%s' passed validation", invalidDID)
+		}
+	}
+}
+
+// TestGetMulticodecType tests multicodec type lookup
+func TestGetMulticodecType(t *testing.T) {
+	testCases := []struct {
+		keyType  int
+		expected uint64
+	}{
+		{int(crypto.RSA), MulticodecKindRSAPubKey},
+		{int(crypto.Ed25519), MulticodecKindEd25519PubKey},
+		{int(crypto.Secp256k1), MulticodecKindSecp256k1PubKey},
+	}
+
+	for _, tc := range testCases {
+		result, err := GetMulticodecType(tc.keyType)
+		if err != nil {
+			t.Errorf("GetMulticodecType failed for type %d: %v", tc.keyType, err)
+		}
+		if result != tc.expected {
+			t.Errorf(
+				"GetMulticodecType for type %d: expected 0x%x, got 0x%x",
+				tc.keyType,
+				tc.expected,
+				result,
+			)
+		}
+	}
+
+	// Test invalid key type
+	_, err := GetMulticodecType(999)
+	if err == nil {
+		t.Errorf("GetMulticodecType should fail for invalid key type")
+	}
+}
+
+// TestDIDStringFormat tests complete DID string generation and parsing
+func TestDIDStringFormat(t *testing.T) {
+	privKey := generateSecp256k1Key(t)
+	pubKey := privKey.GetPublic()
+
+	did := DID{PubKey: pubKey}
+	didString := did.String()
+
+	// Check that DID starts with "did:key:z"
+	if len(didString) < 9 || didString[:9] != "did:key:z" {
+		t.Errorf("DID string should start with 'did:key:z', got %s", didString)
+	}
+
+	// Parse the DID back
+	parsedDID, err := Parse(didString)
+	if err != nil {
+		t.Fatalf("Failed to parse generated DID: %v", err)
+	}
+
+	// Verify parsed DID generates same string
+	parsedString := parsedDID.String()
+	if parsedString != didString {
+		t.Errorf("Parsed DID string mismatch: %s != %s", parsedString, didString)
+	}
+
+	// Verify key types match
+	if parsedDID.Type() != did.Type() {
+		t.Errorf("Parsed DID key type mismatch: %v != %v", parsedDID.Type(), did.Type())
+	}
+}
+
+// TestMPCIntegration tests end-to-end MPC public key integration
+func TestMPCIntegration(t *testing.T) {
+	// Generate a valid MPC enclave public key for testing
+	privKey := generateSecp256k1Key(t)
+	pubKey := privKey.GetPublic()
+	mpcPubKeyBytes, err := pubKey.Raw()
+	if err != nil {
+		t.Fatalf("Failed to get raw public key: %v", err)
+	}
+
+	// Create DID from MPC public key
+	did, err := NewFromMPCPubKey(mpcPubKeyBytes)
+	if err != nil {
+		t.Fatalf("Failed to create DID from MPC public key: %v", err)
+	}
+
+	// Test DID string generation
+	didString := did.String()
+	if len(didString) == 0 {
+		t.Error("Generated DID string is empty")
+	}
+
+	// Test address derivation
+	address, err := did.Address()
+	if err != nil {
+		t.Fatalf("Failed to derive address: %v", err)
+	}
+
+	if len(address) == 0 || address[:5] != "sonr1" {
+		t.Errorf("Invalid address format: %s", address)
+	}
+
+	// Test compressed public key
+	compressed, err := did.CompressedPubKey()
+	if err != nil {
+		t.Fatalf("Failed to get compressed key: %v", err)
+	}
+
+	if len(compressed) != 33 {
+		t.Errorf("Expected 33-byte compressed key, got %d bytes", len(compressed))
+	}
+
+	// Verify round-trip: DID -> string -> parse -> DID
+	parsedDID, err := Parse(didString)
+	if err != nil {
+		t.Fatalf("Failed to parse generated DID: %v", err)
+	}
+
+	parsedAddress, err := parsedDID.Address()
+	if err != nil {
+		t.Fatalf("Failed to derive address from parsed DID: %v", err)
+	}
+
+	if address != parsedAddress {
+		t.Errorf("Address mismatch after round-trip: %s != %s", address, parsedAddress)
+	}
+}

crypto/keys/methods.go

@@ -0,0 +1,17 @@
+package keys
+
+type DIDMethod string
+
+const (
+	DIDMethodKey      DIDMethod = "key"
+	DIDMethodSonr     DIDMethod = "sonr"
+	DIDMehthodBitcoin DIDMethod = "btcr"
+	DIDMethodEthereum DIDMethod = "ethr"
+	DIDMethodCbor     DIDMethod = "cbor"
+	DIDMethodCID      DIDMethod = "cid"
+	DIDMethodIPFS     DIDMethod = "ipfs"
+)
+
+func (d DIDMethod) String() string {
+	return string(d)
+}

crypto/keys/parsers/btc_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/parsers/cosmos_parser.go

@@ -0,0 +1,12 @@
+package parsers
+
+type CosmosPrefix string
+
+const (
+	ATOMPrefix   CosmosPrefix = "cosmos"
+	AXELARPrefix CosmosPrefix = "axelar"
+	EVMOSPrefix  CosmosPrefix = "evmos"
+	OSMOPrefix   CosmosPrefix = "osmo"
+	SONRPrefix   CosmosPrefix = "idx"
+	STARSPrefix  CosmosPrefix = "stars"
+)

crypto/keys/parsers/eth_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/parsers/fil_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/parsers/key_parser.go

@@ -0,0 +1,157 @@
+package parsers
+
+import (
+	"crypto/ed25519"
+	"crypto/rsa"
+	"crypto/x509"
+	"fmt"
+	"strings"
+
+	"github.com/libp2p/go-libp2p/core/crypto"
+	mb "github.com/multiformats/go-multibase"
+	varint "github.com/multiformats/go-varint"
+)
+
+const (
+	// KeyPrefix indicates a decentralized identifier that uses the key method
+	KeyPrefix = "did:key"
+	// MulticodecKindRSAPubKey rsa-x509-pub https://github.com/multiformats/multicodec/pull/226
+	MulticodecKindRSAPubKey = 0x1205
+	// MulticodecKindEd25519PubKey ed25519-pub
+	MulticodecKindEd25519PubKey = 0xed
+	// MulticodecKindSecp256k1PubKey secp256k1-pub
+	MulticodecKindSecp256k1PubKey = 0x1206
+)
+
+// DIDKey is a DID:key identifier
+type DIDKey struct {
+	crypto.PubKey
+}
+
+// NewKeyDID constructs an Identifier from a public key
+func NewKeyDID(pub crypto.PubKey) (DIDKey, error) {
+	switch pub.Type() {
+	case crypto.Ed25519, crypto.RSA, crypto.Secp256k1:
+		return DIDKey{PubKey: pub}, nil
+	default:
+		return DIDKey{}, fmt.Errorf("unsupported key type: %s", pub.Type())
+	}
+}
+
+// MulticodecType indicates the type for this multicodec
+func (id DIDKey) MulticodecType() uint64 {
+	switch id.Type() {
+	case crypto.RSA:
+		return MulticodecKindRSAPubKey
+	case crypto.Ed25519:
+		return MulticodecKindEd25519PubKey
+	case crypto.Secp256k1:
+		return MulticodecKindSecp256k1PubKey
+	default:
+		panic("unexpected crypto type")
+	}
+}
+
+// String returns this did:key formatted as a string
+func (id DIDKey) String() string {
+	raw, err := id.Raw()
+	if err != nil {
+		return ""
+	}
+
+	t := id.MulticodecType()
+	size := varint.UvarintSize(t)
+	data := make([]byte, size+len(raw))
+	n := varint.PutUvarint(data, t)
+	copy(data[n:], raw)
+
+	b58BKeyStr, err := mb.Encode(mb.Base58BTC, data)
+	if err != nil {
+		return ""
+	}
+
+	return fmt.Sprintf("%s:%s", KeyPrefix, b58BKeyStr)
+}
+
+// VerifyKey returns the backing implementation for a public key, one of:
+// *rsa.PublicKey, ed25519.PublicKey
+func (id DIDKey) VerifyKey() (any, error) {
+	rawPubBytes, err := id.PubKey.Raw()
+	if err != nil {
+		return nil, err
+	}
+	switch id.PubKey.Type() {
+	case crypto.RSA:
+		verifyKeyiface, err := x509.ParsePKIXPublicKey(rawPubBytes)
+		if err != nil {
+			return nil, err
+		}
+		verifyKey, ok := verifyKeyiface.(*rsa.PublicKey)
+		if !ok {
+			return nil, fmt.Errorf("public key is not an RSA key. got type: %T", verifyKeyiface)
+		}
+		return verifyKey, nil
+	case crypto.Ed25519:
+		return ed25519.PublicKey(rawPubBytes), nil
+	case crypto.Secp256k1:
+		// Handle both compressed and uncompressed Secp256k1 public keys
+		if len(rawPubBytes) == 65 || len(rawPubBytes) == 33 {
+			return rawPubBytes, nil
+		}
+		return nil, fmt.Errorf("invalid Secp256k1 public key length: %d", len(rawPubBytes))
+	default:
+		return nil, fmt.Errorf("unrecognized Public Key type: %s", id.Type())
+	}
+}
+
+// Parse turns a string into a key method ID
+func Parse(keystr string) (DIDKey, error) {
+	var id DIDKey
+	if !strings.HasPrefix(keystr, KeyPrefix) {
+		return id, fmt.Errorf("decentralized identifier is not a 'key' type")
+	}
+
+	keystr = strings.TrimPrefix(keystr, KeyPrefix+":")
+
+	enc, data, err := mb.Decode(keystr)
+	if err != nil {
+		return id, fmt.Errorf("decoding multibase: %w", err)
+	}
+
+	if enc != mb.Base58BTC {
+		return id, fmt.Errorf("unexpected multibase encoding: %s", mb.EncodingToStr[enc])
+	}
+
+	keyType, n, err := varint.FromUvarint(data)
+	if err != nil {
+		return id, err
+	}
+
+	switch keyType {
+	case MulticodecKindRSAPubKey:
+		pub, err := crypto.UnmarshalRsaPublicKey(data[n:])
+		if err != nil {
+			return id, err
+		}
+		return DIDKey{pub}, nil
+	case MulticodecKindEd25519PubKey:
+		pub, err := crypto.UnmarshalEd25519PublicKey(data[n:])
+		if err != nil {
+			return id, err
+		}
+		return DIDKey{pub}, nil
+	case MulticodecKindSecp256k1PubKey:
+		// Handle both compressed and uncompressed formats
+		keyData := data[n:]
+		if len(keyData) != 33 && len(keyData) != 65 {
+			return id, fmt.Errorf("invalid Secp256k1 public key length: %d", len(keyData))
+		}
+		pub, err := crypto.UnmarshalSecp256k1PublicKey(keyData)
+		if err != nil {
+			return id, fmt.Errorf("failed to unmarshal Secp256k1 key: %w", err)
+		}
+		return DIDKey{pub}, nil
+	}
+
+	return id, fmt.Errorf("unrecognized key type multicodec prefix: %x", data[0])
+}

crypto/keys/parsers/sol_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/parsers/ton_parser.go

@@ -0,0 +1 @@
+package parsers

crypto/keys/pubkey.go

@@ -0,0 +1,85 @@
+package keys
+
+import (
+	"bytes"
+	"crypto/ecdsa"
+	"encoding/hex"
+
+	p2pcrypto "github.com/libp2p/go-libp2p/core/crypto"
+	p2ppb "github.com/libp2p/go-libp2p/core/crypto/pb"
+	"github.com/sonr-io/sonr/crypto/core/curves"
+	"golang.org/x/crypto/sha3"
+)
+
+type PubKey interface {
+	Bytes() []byte
+	Raw() ([]byte, error)
+	Equals(b p2pcrypto.Key) bool
+	Type() p2ppb.KeyType
+	Hex() string
+	Verify(msg []byte, sig []byte) (bool, error)
+}
+
+type pubKey struct {
+	publicPoint curves.Point
+}
+
+func NewPubKey(pk curves.Point) PubKey {
+	return &pubKey{
+		publicPoint: pk,
+	}
+}
+
+func (p pubKey) Bytes() []byte {
+	return p.publicPoint.ToAffineCompressed()
+}
+
+func (p pubKey) Raw() ([]byte, error) {
+	return p.publicPoint.ToAffineCompressed(), nil
+}
+
+func (p pubKey) Equals(b p2pcrypto.Key) bool {
+	if b == nil {
+		return false
+	}
+	apbz, err := b.Raw()
+	if err != nil {
+		return false
+	}
+	bbz, err := p.Raw()
+	if err != nil {
+		return false
+	}
+	return bytes.Equal(apbz, bbz)
+}
+
+func (p pubKey) Hex() string {
+	return hex.EncodeToString(p.publicPoint.ToAffineCompressed())
+}
+
+func (p pubKey) Type() p2ppb.KeyType {
+	return p2ppb.KeyType_Secp256k1
+}
+
+func (p pubKey) Verify(data []byte, sigBz []byte) (bool, error) {
+	sig, err := deserializeSignature(sigBz)
+	if err != nil {
+		return false, err
+	}
+	pp, err := getEcdsaPoint(p.Bytes())
+	if err != nil {
+		return false, err
+	}
+	pk := &ecdsa.PublicKey{
+		Curve: pp.Curve,
+		X:     pp.X,
+		Y:     pp.Y,
+	}
+
+	// Hash the message using SHA3-256
+	hash := sha3.New256()
+	hash.Write(data)
+	digest := hash.Sum(nil)
+
+	return ecdsa.Verify(pk, digest, sig.R, sig.S), nil
+}

crypto/keys/utils.go

@@ -0,0 +1,34 @@
+package keys
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/sonr-io/sonr/crypto/core/curves"
+)
+
+// getEcdsaPoint builds an elliptic curve point from a compressed byte slice
+func getEcdsaPoint(pubKey []byte) (*curves.EcPoint, error) {
+	crv := curves.K256()
+	x := new(big.Int).SetBytes(pubKey[1:33])
+	y := new(big.Int).SetBytes(pubKey[33:])
+	ecCurve, err := crv.ToEllipticCurve()
+	if err != nil {
+		return nil, fmt.Errorf("error converting curve: %v", err)
+	}
+	return &curves.EcPoint{X: x, Y: y, Curve: ecCurve}, nil
+}
+
+// DeserializeSecp256k1Signature deserializes an ECDSA signature from a byte slice
+func deserializeSignature(sigBytes []byte) (*curves.EcdsaSignature, error) {
+	if len(sigBytes) != 66 {
+		return nil, errors.New("malformed signature: not the correct size")
+	}
+	sig := &curves.EcdsaSignature{
+		V: int(sigBytes[0]),
+		R: new(big.Int).SetBytes(sigBytes[1:33]),
+		S: new(big.Int).SetBytes(sigBytes[33:66]),
+	}
+	return sig, nil
+}