Actually lookup identities and write records!

Major milestone! We're writing ping records to the network, and using
the target's public key to do it!

api/api.go

···
 // https://github.com/bluesky-social/indigo/pull/716
 
 package api
+
+const (
+	ActorProfileNSID = "app.atyo.actor.profile"
+	PingNSID         = "app.atyo.ping"
+
+	SelfActorProfile = "self"
+)

api/atyo/actorprofile.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package atyo
+
+// schema: app.atyo.actor.profile
+
+import (
+	"github.com/bluesky-social/indigo/lex/util"
+)
+
+func init() {
+	util.RegisterType("app.atyo.actor.profile", &ActorProfile{})
+} //
+// RECORDTYPE: ActorProfile
+type ActorProfile struct {
+	LexiconTypeID string                          `json:"$type,const=app.atyo.actor.profile" cborgen:"$type,const=app.atyo.actor.profile"`
+	PublicKeys    []*ActorProfile_PublicKeys_Elem `json:"publicKeys" cborgen:"publicKeys"`
+}
+
+type ActorProfile_PublicKeys_Elem struct {
+	CreatedAt string        `json:"createdAt" cborgen:"createdAt"`
+	ExpiresAt *string       `json:"expiresAt,omitempty" cborgen:"expiresAt,omitempty"`
+	Key       util.LexBytes `json:"key,omitempty" cborgen:"key,omitempty"`
+}

api/atyo/cbor_gen.go

···
 
 	return nil
 }
+func (t *ActorProfile_PublicKeys_Elem) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 3
+
+	if t.ExpiresAt == nil {
+		fieldCount--
+	}
+
+	if t.Key == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+		return err
+	}
+
+	// t.Key (util.LexBytes) (slice)
+	if t.Key != nil {
+
+		if len("key") > 1000000 {
+			return xerrors.Errorf("Value in field \"key\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("key")); err != nil {
+			return err
+		}
+
+		if len(t.Key) > 2097152 {
+			return xerrors.Errorf("Byte array in field t.Key was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Key))); err != nil {
+			return err
+		}
+
+		if _, err := cw.Write(t.Key); err != nil {
+			return err
+		}
+
+	}
+
+	// t.CreatedAt (string) (string)
+	if len("createdAt") > 1000000 {
+		return xerrors.Errorf("Value in field \"createdAt\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("createdAt")); err != nil {
+		return err
+	}
+
+	if len(t.CreatedAt) > 1000000 {
+		return xerrors.Errorf("Value in field t.CreatedAt was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
+		return err
+	}
+
+	// t.ExpiresAt (string) (string)
+	if t.ExpiresAt != nil {
+
+		if len("expiresAt") > 1000000 {
+			return xerrors.Errorf("Value in field \"expiresAt\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("expiresAt"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("expiresAt")); err != nil {
+			return err
+		}
+
+		if t.ExpiresAt == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.ExpiresAt) > 1000000 {
+				return xerrors.Errorf("Value in field t.ExpiresAt was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.ExpiresAt))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.ExpiresAt)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (t *ActorProfile_PublicKeys_Elem) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = ActorProfile_PublicKeys_Elem{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("ActorProfile_PublicKeys_Elem: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 9)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.Key (util.LexBytes) (slice)
+		case "key":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 2097152 {
+				return fmt.Errorf("t.Key: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.Key = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(cr, t.Key); err != nil {
+				return err
+			}
+
+			// t.CreatedAt (string) (string)
+		case "createdAt":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.CreatedAt = string(sval)
+			}
+			// t.ExpiresAt (string) (string)
+		case "expiresAt":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.ExpiresAt = (*string)(&sval)
+				}
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+func (t *ActorProfile) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+
+	if _, err := cw.Write([]byte{162}); err != nil {
+		return err
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if len("$type") > 1000000 {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.atyo.actor.profile"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("app.atyo.actor.profile")); err != nil {
+		return err
+	}
+
+	// t.PublicKeys ([]*atyo.ActorProfile_PublicKeys_Elem) (slice)
+	if len("publicKeys") > 1000000 {
+		return xerrors.Errorf("Value in field \"publicKeys\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("publicKeys"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("publicKeys")); err != nil {
+		return err
+	}
+
+	if len(t.PublicKeys) > 8192 {
+		return xerrors.Errorf("Slice value in field t.PublicKeys was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PublicKeys))); err != nil {
+		return err
+	}
+	for _, v := range t.PublicKeys {
+		if err := v.MarshalCBOR(cw); err != nil {
+			return err
+		}
+
+	}
+	return nil
+}
+
+func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = ActorProfile{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
+	}
+
+	n := extra
+
+	nameBuf := make([]byte, 10)
+	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
+
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
+				return err
+			}
+			continue
+		}
+
+		switch string(nameBuf[:nameLen]) {
+		// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.PublicKeys ([]*atyo.ActorProfile_PublicKeys_Elem) (slice)
+		case "publicKeys":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 8192 {
+				return fmt.Errorf("t.PublicKeys: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.PublicKeys = make([]*ActorProfile_PublicKeys_Elem, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+
+						b, err := cr.ReadByte()
+						if err != nil {
+							return err
+						}
+						if b != cbg.CborNull[0] {
+							if err := cr.UnreadByte(); err != nil {
+								return err
+							}
+							t.PublicKeys[i] = new(ActorProfile_PublicKeys_Elem)
+							if err := t.PublicKeys[i].UnmarshalCBOR(cr); err != nil {
+								return xerrors.Errorf("unmarshaling t.PublicKeys[i] pointer: %w", err)
+							}
+						}
+
+					}
+
+				}
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

appview/keys.go

···
 package appview
 
 import (
-	"net/http"
+	"context"
+	"crypto/rand"
+	"fmt"
+	"os"
 
+	"atyo.app/api"
+	"atyo.app/api/atyo"
+	"github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/bluesky-social/indigo/lex/util"
+	"github.com/bluesky-social/indigo/xrpc"
+	"golang.org/x/crypto/nacl/box"
 )
 
-func (*Server) addPublicKey(w http.ResponseWriter, req *http.Request) {
-	// TODO
+type KeyManager struct {
+	client         *xrpc.Client
+	selfPrivateKey *[32]byte
+	cache          map[string]*[32]byte
 }
 
-func (*Server) removePublicKey(w http.ResponseWriter, req *http.Request) {
-	// TODO
+// TODO: get pubkey from atproto profile; probably needs a new lexicon
+// also maybe if there are multiple records we should do one for each?
+func (k *KeyManager) fetchUserPubKey(ctx context.Context, id *identity.Identity) (key *[32]byte, err error) {
+	record, profile, err := k.fetchProfile(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	key = new([32]byte)
+
+	if len(profile.PublicKeys) < 1 ||
+		profile.PublicKeys[0] == nil ||
+		copy(key[:], profile.PublicKeys[0].Key) != 32 {
+		return nil, fmt.Errorf(
+			"record %s/%s has invalid format",
+			id.DID.String(), record.Cid,
+		)
+	}
+
+	return key, nil
 }
 
-type KeyManager struct{}
+func (k *KeyManager) fetchProfile(ctx context.Context, id *identity.Identity) (*atproto.RepoGetRecord_Output, *atyo.ActorProfile, error) {
+	record, err := atproto.RepoGetRecord(
+		ctx,
+		// hmm should this be a relay instance or something? Need to check this
+		// when fetching a record for someone with a different PDS (ugh which means
+		// I need an account that uses a different PDS which maybe means selfhosting)
+		k.client,
+		"",
+		api.ActorProfileNSID,
+		id.DID.String(),
+		api.SelfActorProfile,
+	)
+	if err != nil {
+		return nil, nil, err
+	}
 
-// TODO: get pubkey from atproto profile; probably needs a new lexicon
-// also maybe if there are multiple records we should do one for each?
-func (*KeyManager) fetchUserPubKey(id *identity.Identity) (key [32]byte, err error) {
-	return
+	profile, ok := record.Value.Val.(*atyo.ActorProfile)
+	if !ok {
+		b, err := record.Value.MarshalJSON()
+		return nil, nil, fmt.Errorf(
+			"failed to deserialize record: %w, JSON repr: `%s`",
+			err, b,
+		)
+	}
+	return record, profile, nil
 }
 
 // TODO: load from local DB or something like that...
 // There should probably be expiration dates associated with these too
-func (*KeyManager) fetchPrivKey() (key [32]byte, err error) {
-	return
+func (k *KeyManager) fetchPrivKey() (key *[32]byte, err error) {
+	if k.selfPrivateKey != nil {
+		return k.selfPrivateKey, nil
+	}
+
+	return nil, fmt.Errorf("no private key set, maybe login required?")
+}
+
+func (k *KeyManager) genAndPublishKeyPair(ctx context.Context, did string) error {
+	selfPubKey, selfPrivKey, err := box.GenerateKey(rand.Reader)
+	if err != nil {
+		panic(err)
+	}
+
+	// ugh, generated API type doesn't work for swapping because it needs an
+	// `omitempty` on the SwapRecord field. Two approaches here; manually impl
+	// the XRPC or fetch a CID and pass it along if found. the latter seems easier
+	// for now (and is also what tangled.sh appears to do).
+
+	var swapRecord *string
+	existing, _ := atproto.RepoGetRecord(ctx, k.client, "", api.ActorProfileNSID, did, api.SelfActorProfile)
+	if existing != nil {
+		swapRecord = existing.Cid
+	}
+
+	_, err = atproto.RepoPutRecord(
+		ctx,
+		k.client,
+		&atproto.RepoPutRecord_Input{
+			Collection: api.ActorProfileNSID,
+			Repo:       did,
+			Rkey:       api.SelfActorProfile,
+			SwapRecord: swapRecord,
+			Record: &util.LexiconTypeDecoder{
+				Val: &atyo.ActorProfile{
+					PublicKeys: []*atyo.ActorProfile_PublicKeys_Elem{
+						{
+							CreatedAt: syntax.DatetimeNow().String(),
+							Key:       util.LexBytes(selfPubKey[:]),
+							// TODO reasonable expiration, idk like 1mo?
+						},
+					},
+				},
+			},
+		},
+	)
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintln(os.Stderr, "created pubkey record")
+
+	k.selfPrivateKey = selfPrivKey
+	return nil
 }

appview/login.go

···
 
 	fmt.Fprintln(os.Stderr, "sending login request to "+s.client.Host)
 
-	result, err := atproto.ServerCreateSession(
+	loginResult, err := atproto.ServerCreateSession(
 		req.Context(),
 		s.client,
 		&atproto.ServerCreateSession_Input{
···
 	}
 
 	s.client.Auth = &xrpc.AuthInfo{
-		AccessJwt:  result.AccessJwt,
-		RefreshJwt: result.RefreshJwt, // TODO persist in db or something?
-		Handle:     result.Handle,
-		Did:        result.Did,
+		AccessJwt:  loginResult.AccessJwt,
+		RefreshJwt: loginResult.RefreshJwt, // TODO persist in db or something?
+		Handle:     loginResult.Handle,
+		Did:        loginResult.Did,
 	}
 
-	fmt.Fprintln(os.Stderr, "logged into account: ")
+	// for now, just create a key and publish it on every login. In the future
+	// this private key should live in sqlite db instead or something,
+	// so we don't need to republish it every time lmao. Also we should in theory
+	// make this more of an update than a replace but it's fine for now
 
-	resp, err := json.Marshal(result)
+	if err = s.keys.genAndPublishKeyPair(req.Context(), loginResult.Did); err != nil {
+		http.Error(
+			w,
+			"Failed to create profile record: "+err.Error(),
+			http.StatusInternalServerError,
+		)
+
+	}
+
+	resp, err := json.Marshal(loginResult)
 	if err != nil {
 		http.Error(w, "failed to re-serialize login response", http.StatusInternalServerError)
 	}

appview/router.go

···
 	"net/http"
 
 	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
···
 	directory *identity.BaseDirectory
 	keys      *KeyManager
 	client    *xrpc.Client
+	tidClock  syntax.TIDClock
 }
 
 func NewServer() *Server {
+	client := &xrpc.Client{}
 	return &Server{
 		directory: &identity.BaseDirectory{},
-		client:    &xrpc.Client{},
+		client:    client,
+		keys: &KeyManager{
+			client: client,
+		},
+		tidClock: syntax.NewTIDClock(0), // this int needs to be unique per instance-ish
 	}
 }
 
···
 
 	// app functionality
 	mux.HandleFunc("POST /ping/{target}", r.sendPing)
-	mux.HandleFunc("PUT /self/key", r.addPublicKey)
-	mux.HandleFunc("DELETE /self/key", r.removePublicKey)
 
 	mux.HandleFunc("POST /login", r.login)
 

appview/send_ping.go

···
 
 import (
 	"bytes"
+	"context"
 	"crypto/rand"
-	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"os"
 
+	"atyo.app/api"
 	"atyo.app/api/atyo"
+	"github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/atproto/identity"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/lex/util"
···
 		http.Error(w, hErr.Message, hErr.Code)
 	}
 
-	ping, hErr := s.buildPing(targetId)
+	ping, hErr := s.buildPing(req.Context(), targetId)
 	if hErr != nil {
 		http.Error(w, hErr.Error(), hErr.Code)
 		return
···
 		return
 	}
 
-	cborBuf := bytes.NewBuffer([]byte{})
-	err = ping.MarshalCBOR(cborBuf)
-	if err == nil {
-		fmt.Fprintln(os.Stderr, "ping length as CBOR:", cborBuf.Len())
-	} else {
-		fmt.Fprintln(os.Stderr, "failed to marshal as CBOR", err)
-	}
-
-	fmt.Fprintln(os.Stderr, hex.EncodeToString(cborBuf.Bytes()))
-
-	fmt.Fprintln(
-		os.Stderr,
-		"would write ping to PDS: "+string(jsonPing),
+	_, err = atproto.RepoPutRecord(
+		req.Context(),
+		s.client,
+		&atproto.RepoPutRecord_Input{
+			Collection: api.PingNSID,
+			Record:     &util.LexiconTypeDecoder{Val: ping},
+			Repo:       s.client.Auth.Did,
+			Rkey:       s.tidClock.Next().String(),
+		},
 	)
-
-	// TODO write records to our PDS
+	if err != nil {
+		http.Error(w, "failed to put record: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
 
 	_, err = w.Write(jsonPing)
 	if err != nil {
···
 //
 // Roughly based on the Scuttlebutt protocol for pivate messages:
 // https://ssbc.github.io/scuttlebutt-protocol-guide/#private-messages
-func (s *Server) buildPing(target *identity.Identity) (*atyo.Ping, *httpError) {
+func (s *Server) buildPing(ctx context.Context, target *identity.Identity) (*atyo.Ping, *httpError) {
 	// NOTE: CBOR marshaller needs to serialize Ping_Empty{} directly,
 	// while the JSON serializer needs Ping_Contents{}. Just an odd quirk
 	emptyPing := &atyo.Ping_Empty{}
···
 		}
 	}
 
-	targetPubkey, err := s.keys.fetchUserPubKey(target)
+	targetPubkey, err := s.keys.fetchUserPubKey(ctx, target)
 	if err != nil {
 		return nil, &httpError{
 			http.StatusNotFound,
-			"Target `" + target.Handle.String() + "` does not have an atyo.app identity",
+			"Could not find atyo.app id for `" + target.Handle.String() + "`: " + err.Error(),
 		}
 	}
 
···
 
 	encryptedMessage := secretbox.Seal(nil, secretMessageBytes, &nonce, &sharedSecretKey)
 
-	encSharedKey := box.Seal(nil, sharedSecretKey[:], &nonce, &targetPubkey, ephemeralPrivKey)
+	encSharedKey := box.Seal(nil, sharedSecretKey[:], &nonce, targetPubkey, ephemeralPrivKey)
 
 	// possible future enhancement: use a high few bits on the first byte here to indicate
 	// CBOR/JSON encoding, or a schema version? idk if that's really useful for any reason

gen/main.go

···
 		atyo.Ping_Location{},
 		atyo.Ping_Contents{},
 		atyo.PublicKey{},
+		atyo.ActorProfile_PublicKeys_Elem{},
+		atyo.ActorProfile{},
 	); err != nil {
 		panic(err)
 	}

lexicons/actor/profile.json

···
+{
+  "lexicon": 1,
+  "id": "app.atyo.actor.profile",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "Information about a user's profile. At least one public key is required, since otherwise there's no way to send pings to the user.",
+      "key": "literal:self",
+      "record": {
+        "type": "object",
+        "required": [
+          "publicKeys"
+        ],
+        "properties": {
+          "publicKeys": {
+            "type": "array",
+            "minLength": "1",
+            "items": {
+              "type": "object",
+              "required": [
+                "key",
+                "createdAt"
+              ],
+              "properties": {
+                "key": {
+                  "type": "bytes"
+                },
+                "createdAt": {
+                  "type": "string",
+                  "format": "datetime"
+                },
+                "expiresAt": {
+                  "type": "string",
+                  "format": "datetime"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/public_key.json

···
-{
-  "lexicon": 1,
-  "id": "app.atyo.publicKey",
-  "defs": {
-    "main": {
-      "type": "record",
-      "description": "A public key that can be used to encrypt `app.atyo.ping`s directed to this user",
-      "key": "tid",
-      "record": {
-        "type": "object",
-        "required": ["key", "createdAt"],
-        "properties": {
-          "key": { "type": "bytes" },
-          "createdAt": { "type": "string", "format": "datetime" },
-          "expiresAt": { "type": "string", "format": "datetime" }
-        }
-      }
-    }
-  }
-}