feat: implement Phase 1 Axon protocol core package

Adds the foundational Go package implementing the full Axon protocol
signing and crypto spec per PROTOCOL.md:

- Event/Tag structs and all kind constants (KindProfile through KindJobFeedback)
- Byte-exact canonical_payload construction per the PROTOCOL.md layout table
- Tag sorting and canonical_tags SHA256 hash (duplicate detection included)
- Ed25519 sign/verify, challenge sign/verify
- X25519 key conversion from Ed25519 keypair (RFC 8032 §5.1.5 clamping +
  birational Edwards→Montgomery map for pubkeys)
- ChaCha20-Poly1305 encrypt/decrypt for DMs (nonce prepended)
- MessagePack encode/decode for events and wire messages

Test vectors written first in testdata/vectors.json covering canonical_tags,
canonical_payload, event_id, and signature verification — all deterministic
known-input → known-output pairs for cross-language validation in Phase 4.

13 tests, all passing.

1 files changed, 54 insertions, 0 deletions

diff --git a/encoding.go b/encoding.go
new file mode 100644
index 0000000..4ed9da6
--- /dev/null
+++ b/encoding.go
@@ -0,0 +1,54 @@
+package axon
+
+import (
+        "fmt"
+
+        "github.com/vmihailenco/msgpack/v5"
+)
+
+// MarshalEvent encodes an Event to MessagePack. Fields are encoded in the
+// canonical struct order using the msgpack struct tags. Binary fields (id,
+// pubkey, sig, content) are encoded as msgpack bin type ([]byte).
+func MarshalEvent(e *Event) ([]byte, error) {
+        b, err := msgpack.Marshal(e)
+        if err != nil {
+                return nil, fmt.Errorf("axon: marshal event: %w", err)
+        }
+        return b, nil
+}
+
+// UnmarshalEvent decodes a MessagePack blob into an Event.
+func UnmarshalEvent(data []byte) (*Event, error) {
+        var e Event
+        if err := msgpack.Unmarshal(data, &e); err != nil {
+                return nil, fmt.Errorf("axon: unmarshal event: %w", err)
+        }
+        return &e, nil
+}
+
+// MarshalMessage encodes a wire message as a msgpack array: [type, payload].
+// messageType is a uint16; payload is any msgpack-serializable value.
+func MarshalMessage(messageType uint16, payload interface{}) ([]byte, error) {
+        b, err := msgpack.Marshal([]interface{}{messageType, payload})
+        if err != nil {
+                return nil, fmt.Errorf("axon: marshal message: %w", err)
+        }
+        return b, nil
+}
+
+// UnmarshalMessageType reads only the first element of a [type, payload]
+// msgpack array, returning the message type without decoding the payload.
+func UnmarshalMessageType(data []byte) (uint16, error) {
+        var arr []msgpack.RawMessage
+        if err := msgpack.Unmarshal(data, &arr); err != nil {
+                return 0, fmt.Errorf("axon: unmarshal message: %w", err)
+        }
+        if len(arr) < 1 {
+                return 0, fmt.Errorf("axon: message array is empty")
+        }
+        var t uint16
+        if err := msgpack.Unmarshal(arr[0], &t); err != nil {
+                return 0, fmt.Errorf("axon: unmarshal message type: %w", err)
+        }
+        return t, nil
+}