did:key Identifiers

Encode a public key as a self-describing did:key string, parse it back, and derive verification material — plus a frank assessment of the keys/parsers package.

github.com/sonr-io/crypto/keys turns a public key into a stable, self-describing string and back again. A did:key identifier needs no registry and no network lookup: the key material is the identifier, so resolving one is a pure decode. The package wraps libp2p’s github.com/libp2p/go-libp2p/core/crypto.PubKey interface, which gives it RSA, Ed25519, and secp256k1 support for free, and adds a secp256k1-specific path for public keys that arrive as raw bytes from an MPC enclave.

Reach for this when you need a canonical identifier for a key you already hold — a UCAN issuer, a log line, a database column, a delegation audience.

Do not reach for this when you need a DID with mutable state (rotation, service endpoints, multiple verification methods). did:key is immutable by construction: change the key, change the identifier. The DIDMethod enum in this package names other methods, but only did:key is implemented here.

Encoding

DID.String() builds the identifier in three steps:

1. id.Raw() — the raw public key bytes from libp2p (33 or 65 bytes for secp256k1, 32 for Ed25519, DER PKIX for RSA).
2. An unsigned-varint multicodec prefix identifying the key type is prepended.
3. The whole buffer is multibase-encoded with base58btc, which yields the leading z.

So every identifier this package produces looks like did:key:z…. Parse reverses exactly those steps and rejects any multibase encoding other than base58btc.

KeyPrefix is the string constant "did:key". GetMulticodecType(keyType int) maps an int(crypto.RSA) / int(crypto.Ed25519) / int(crypto.Secp256k1) to the values above and errors on anything else.

Constructors

The DID type

DID embeds crypto.PubKey, so every libp2p method (Raw, Type, Equals, Verify, Bytes) is promoted onto it. On top of that:

Round trip

Grounded in TestDIDStringFormat and TestMPCIntegration in keys/didkey_test.go:

package main

import (
	"crypto/rand"
	"fmt"

	p2pcrypto "github.com/libp2p/go-libp2p/core/crypto"
	"github.com/sonr-io/crypto/keys"
)

func main() {
	priv, _, err := p2pcrypto.GenerateSecp256k1Key(rand.Reader)
	if err != nil {
		panic(err)
	}

	did, err := keys.NewDID(priv.GetPublic())
	if err != nil {
		panic(err)
	}

	s := did.String() // "did:key:z..."
	fmt.Println(s)

	parsed, err := keys.Parse(s)
	if err != nil {
		panic(err)
	}

	// The encoding is canonical for a given input: re-stringifying is identical.
	fmt.Println("stable:", parsed.String() == s)
	fmt.Println("same type:", parsed.Type() == did.Type())

	// Cheap validity check on an untrusted string.
	fmt.Println("valid:", keys.ValidateFormat(s) == nil)

	compressed, err := parsed.CompressedPubKey()
	fmt.Println("compressed len:", len(compressed), err) // 33
}

For a key that arrives from an enclave rather than a libp2p keypair, swap the constructor:

did, err := keys.NewFromMPCPubKey(enclave.PubKeyBytes())

DIDMethod

A plain string enum, verbatim from keys/methods.go. It carries no behaviour beyond String(), and nothing else in the package consumes it — it exists for callers that need to tag which method a DID string belongs to.

const (
	DIDMethodKey      DIDMethod = "key"
	DIDMethodSonr     DIDMethod = "sonr"
	DIDMehthodBitcoin DIDMethod = "btcr"
	DIDMethodEthereum DIDMethod = "ethr"
	DIDMethodCbor     DIDMethod = "cbor"
	DIDMethodCID      DIDMethod = "cid"
	DIDMethodIPFS     DIDMethod = "ipfs"
)

The PubKey interface

Separate from libp2p’s type, keys.PubKey adapts a curves.Point into something DID can embed. NewPubKey(pk curves.Point) PubKey is the only constructor.

The 66-byte signature layout

PubKey.Verify does not accept a standard 64-byte r || s signature. Reading keys/pubkey.go and keys/utils.go, it:

1. Requires the signature to be exactly 66 bytes, rejecting anything else with "malformed signature: not the correct size".
2. Parses it as V || R || S, where V is a single recovery-id byte at offset 0, R is sig[1:33], and S is sig[33:66].
3. Hashes the message with SHA3-256 (not SHA-256) and calls ecdsa.Verify on that digest, ignoring V entirely.
4. Reconstructs the ECDSA public key by slicing the compressed point as x = bytes[1:33], y = bytes[33:] on curves.K256().

Address() does not do what its comment says

The doc comment promises “a blockchain-compatible address” and an inline comment claims “first 20 bytes of Keccak-256 hash (Ethereum-style)”. The code does neither:

// keys/didkey.go, secp256k1 branch, verbatim:
return fmt.Sprintf("sonr1%x", rawPubBytes[:8]), nil

Avoid keys/parsers

keys/parsers looks like a set of per-chain address parsers. It is not. Verified by reading every file in the directory:

Caveats

Next