diff --git a/did/doc/assertion_method.go b/did/doc/assertion_method.go
index 8c595e4..3f2f96b 100644
--- a/did/doc/assertion_method.go
+++ b/did/doc/assertion_method.go
@@ -5,8 +5,8 @@ import (
 
 	"crypto/ed25519"
 
-	"github.com/bahner/go-ma/key"
 	"github.com/bahner/go-ma/multi"
+	"github.com/multiformats/go-multicodec"
 )
 
 func (d *Document) AssertionMethodPublicKey() (ed25519.PublicKey, error) {
@@ -20,7 +20,7 @@ func (d *Document) AssertionMethodPublicKey() (ed25519.PublicKey, error) {
 		return nil, ErrPublicKeyMultibaseInvalid
 	}
 
-	if codec != key.ASSERTION_METHOD_KEY_MULTICODEC_STRING {
+	if codec != multicodec.Ed25519Pub {
 		return nil, ErrMultiCodecInvalid
 	}
 
diff --git a/did/doc/errors.go b/did/doc/errors.go
index 3e293b1..9ae856a 100644
--- a/did/doc/errors.go
+++ b/did/doc/errors.go
@@ -21,7 +21,7 @@ var (
 	ErrPublicKeyMultibaseInvalid  = errors.New("failed to decode public key multibase")
 	ErrPublicKeyMultibaseEmpty    = errors.New("public key multibase is empty")
 	ErrPublicKeyMultibaseMismatch = errors.New("public key multibase mismatch")
-	ErrMultiCodecInvalid          = fmt.Errorf("codec must be %s", key.ASSERTION_METHOD_KEY_MULTICODEC_STRING)
+	ErrMultiCodecInvalid          = fmt.Errorf("codec must be %s", key.KEY_AGREEMENT_MULTICODEC.String())
 
 	ErrPublicKeyLengthInvalid = fmt.Errorf("public keysize must be %d", ed25519.PublicKeySize)
 
diff --git a/did/doc/key_agreement.go b/did/doc/key_agreement.go
index 1b2eef5..b279180 100644
--- a/did/doc/key_agreement.go
+++ b/did/doc/key_agreement.go
@@ -20,7 +20,7 @@ func (d *Document) KeyAgreementPublicKeyBytes() ([]byte, error) {
 		return nil, fmt.Errorf("doc/key_agreement_public_key: Error decoding publicKeyMultibase: %w", err)
 	}
 
-	if codec != key.KEY_AGREEMENT_MULTICODEC_STRING {
+	if codec != key.KEY_AGREEMENT_MULTICODEC {
 		return nil, ErrMultiCodecInvalid
 	}
 
diff --git a/did/doc/payload.go b/did/doc/payload.go
index 329ebc3..d797809 100644
--- a/did/doc/payload.go
+++ b/did/doc/payload.go
@@ -3,6 +3,7 @@ package doc
 import (
 	"github.com/bahner/go-ma/multi"
 	cbor "github.com/fxamacker/cbor/v2"
+	"github.com/multiformats/go-multicodec"
 	"lukechampine.com/blake3"
 )
 
@@ -35,8 +36,7 @@ func (d *Document) PayloadHash() ([]byte, error) {
 
 	// Hash the payload
 	hashed := blake3.Sum256(p)
-	multicodecHashed, err := multi.MulticodecEncode(hashed[:])
-	// multicodecHashed, err := multi.MulticodecEncode(ma.HASH_ALGORITHM_MULTICODEC_STRING, hashed[:])
+	multicodecHashed, err := multi.MulticodecEncode(multicodec.Blake3, hashed[:])
 	if err != nil {
 		return nil, ErrPayloadMultiencode
 	}
diff --git a/key/encryption.go b/key/encryption.go
index 2d3ad6b..9daed67 100644
--- a/key/encryption.go
+++ b/key/encryption.go
@@ -14,8 +14,9 @@ import (
 )
 
 const (
-	KEY_AGREEMENT_MULTICODEC_STRING = "x25519-pub"
-	KEY_AGREEMENT_KEY_TYPE          = "MultiKey"
+	// KEY_AGREEMENT_MULTICODEC_STRING = "x25519-pub"
+	KEY_AGREEMENT_MULTICODEC = mc.X25519Pub
+	KEY_AGREEMENT_KEY_TYPE   = "MultiKey"
 )
 
 type EncryptionKey struct {
@@ -54,7 +55,7 @@ func NewEncryptionKey(identifier string) (EncryptionKey, error) {
 	curve25519.ScalarBaseMult(&pubKey, &privKey)
 
 	// Encode the public key to multibase
-	publicKeyMultibase, err := multi.PublicKeyMultibaseEncode(pubKey[:], KEY_AGREEMENT_MULTICODEC_STRING)
+	publicKeyMultibase, err := multi.PublicKeyMultibaseEncode(KEY_AGREEMENT_MULTICODEC, pubKey[:])
 	if err != nil {
 		return EncryptionKey{}, fmt.Errorf("NewEncryptionKey: %w", err)
 	}
diff --git a/key/set/packer.go b/key/set/packer.go
index ed9e17c..b680b03 100644
--- a/key/set/packer.go
+++ b/key/set/packer.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/bahner/go-ma/multi"
 	cbor "github.com/fxamacker/cbor/v2"
+	log "github.com/sirupsen/logrus"
 )
 
 func (k Keyset) MarshalToCBOR() ([]byte, error) {
@@ -17,6 +18,8 @@ func UnmarshalFromCBOR(data []byte) (Keyset, error) {
 		return Keyset{}, fmt.Errorf("KeysetUnmarshalFromCBOR: %w", err)
 	}
 
+	log.Debugf("Unmarshaled keyset: %v", k)
+
 	return k, nil
 }
 
@@ -37,5 +40,8 @@ func Unpack(data string) (Keyset, error) {
 		return Keyset{}, fmt.Errorf("KeysetUnpack: %w", err)
 	}
 
-	return UnmarshalFromCBOR(decoded)
+	keyset, err := UnmarshalFromCBOR(decoded)
+	log.Debugf("Unpacked keyset: %v", keyset)
+
+	return keyset, err
 }
diff --git a/key/signing.go b/key/signing.go
index a5b0a78..d3317b1 100644
--- a/key/signing.go
+++ b/key/signing.go
@@ -15,8 +15,8 @@ import (
 )
 
 const (
-	ASSERTION_METHOD_KEY_MULTICODEC_STRING = "ed25519-pub"
-	ASSERTION_METHOD_KEY_TYPE              = "MultiKey"
+	ASSERTION_METHOD_KEY_TYPE   = "MultiKey"
+	ASSERTION_METHOD_MULTICODEC = mc.Ed25519Pub
 )
 
 type SigningKey struct {
@@ -53,7 +53,7 @@ func NewSigningKey(identifier string) (SigningKey, error) {
 		return SigningKey{}, fmt.Errorf("NewSigningKey: %w", err)
 	}
 
-	publicKeyMultibase, err := multi.PublicKeyMultibaseEncode(publicKey, ASSERTION_METHOD_KEY_MULTICODEC_STRING)
+	publicKeyMultibase, err := multi.PublicKeyMultibaseEncode(ASSERTION_METHOD_MULTICODEC, publicKey)
 	if err != nil {
 		return SigningKey{}, fmt.Errorf("NewSigningKey: %w", err)
 	}
@@ -99,7 +99,7 @@ func (s SigningKey) Verify() error {
 		return fmt.Errorf("SigningKeyVerify: %w", err)
 	}
 
-	if key[0] != byte(mc.Ed25519Pub) {
+	if key[0] != byte(ASSERTION_METHOD_MULTICODEC) {
 		return ErrInvalidMulticodec
 	}
 
diff --git a/multi/errors.go b/multi/errors.go
new file mode 100644
index 0000000..29efddf
--- /dev/null
+++ b/multi/errors.go
@@ -0,0 +1,9 @@
+package multi
+
+import "fmt"
+
+var (
+	ErrNoInput      = fmt.Errorf("error decoding: insufficient data")
+	ErrInvalidSize  = fmt.Errorf("error decoding: invalid varint size")
+	ErrUnknownCodec = fmt.Errorf("error obtaining codec name: unknown codec")
+)
diff --git a/multi/multicodec.go b/multi/multicodec.go
index b36427e..03979c9 100644
--- a/multi/multicodec.go
+++ b/multi/multicodec.go
@@ -7,36 +7,38 @@ import (
 	"github.com/multiformats/go-varint"
 )
 
-func MulticodecEncode(payload []byte) ([]byte, error) {
+func MulticodecEncode(codec multicodec.Code, payload []byte) ([]byte, error) {
 
-	codec := uint64(multicodec.Blake3)
+	c := uint64(codec)
 
-	codecBytes := varint.ToUvarint(codec)
+	codecBytes := varint.ToUvarint(c)
 	encoded := append(codecBytes, payload...)
 	return encoded, nil
 }
 
-// Returns the codec name, payload and error of a multicodec encoded byte array
-func MulticodecDecode(encoded []byte) (string, []byte, error) {
+// Returns the codec, payload and error of a multicodec encoded byte array
+func MulticodecDecode(encoded []byte) (multicodec.Code, []byte, error) {
+
+	var codec multicodec.Code
+
 	if len(encoded) < 1 {
-		return "", nil, fmt.Errorf("error decoding: insufficient data")
+		return codec, nil, ErrNoInput
 	}
 
 	// log.Debugf("mutlticodecdecode: encoded: %x", encoded)
 
 	code, n, err := varint.FromUvarint(encoded)
 	if err != nil {
-		return "", nil, fmt.Errorf("error decoding varint: %w", err)
+		return codec, nil, fmt.Errorf("error decoding varint: %w", err)
 	}
 	if n < 1 || n >= len(encoded) {
-		return "", nil, fmt.Errorf("error decoding: invalid varint size")
+		return codec, nil, ErrInvalidSize
 	}
 
-	codecName := multicodec.Code(code).String()
-	if codecName == "" {
-		return "", nil, fmt.Errorf("error obtaining codec name: unknown codec")
+	codec = multicodec.Code(code)
+	if codec == 0 {
+		return codec, nil, ErrUnknownCodec
 	}
 
-	// log.Debugf("mutlticodecdecode: codecName: %s", codecName)
-	return codecName, encoded[n:], nil
+	return codec, encoded[n:], nil
 }
diff --git a/multi/public_key_multibase.go b/multi/public_key_multibase.go
index 4e72e0c..bf2a657 100644
--- a/multi/public_key_multibase.go
+++ b/multi/public_key_multibase.go
@@ -1,10 +1,14 @@
 package multi
 
-import "fmt"
+import (
+	"fmt"
 
-func PublicKeyMultibaseEncode(publicKey []byte, codecName string) (string, error) {
+	"github.com/multiformats/go-multicodec"
+)
 
-	multicodecedKey, err := MulticodecEncode(publicKey)
+func PublicKeyMultibaseEncode(codec multicodec.Code, publicKey []byte) (string, error) {
+
+	multicodecedKey, err := MulticodecEncode(codec, publicKey)
 	if err != nil {
 		return "", fmt.Errorf("key/codec: error multicodec encoding public key: %s", err)
 	}
@@ -18,18 +22,20 @@ func PublicKeyMultibaseEncode(publicKey []byte, codecName string) (string, error
 
 }
 
-func PublicKeyMultibaseDecode(publicKey string) (string, []byte, error) {
+func PublicKeyMultibaseDecode(publicKey string) (multicodec.Code, []byte, error) {
+
+	var codec multicodec.Code
 
 	decodedPublicKeyMultibase, err := MultibaseDecode(publicKey)
 	if err != nil {
-		return "", nil, fmt.Errorf("key/codec: error multibase decoding public key: %s", err)
+		return codec, nil, err
 	}
 
-	codecName, decodedPublicKey, err := MulticodecDecode(decodedPublicKeyMultibase)
+	codec, decodedPublicKey, err := MulticodecDecode(decodedPublicKeyMultibase)
 	if err != nil {
-		return "", nil, fmt.Errorf("key/codec: error multicodec decoding public key: %s", err)
+		return codec, nil, err
 	}
 
-	return codecName, decodedPublicKey, nil
+	return codec, decodedPublicKey, nil
 
 }