Add code missing in the previous commit

util/plc/gen/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"log"
+
+	typegen "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/uabluerail/indexer/util/plc"
+)
+
+func main() {
+	if err := typegen.WriteMapEncodersToFile("cbor_gen.go", "plc", plc.Service{}, plc.Op{}, plc.Tombstone{}, plc.LegacyCreateOp{}); err != nil {
+		log.Fatalf("%s", err)
+	}
+}

util/plc/structs.go

@@ -0,0 +1,149 @@
+package plc
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+
+	cid "github.com/ipfs/go-cid"
+	"github.com/multiformats/go-multicodec"
+	"github.com/multiformats/go-multihash"
+	cbg "github.com/whyrusleeping/cbor-gen"
+)
+
+//go:generate go run ./gen
+
+type Op struct {
+	Type                string             `json:"type" cborgen:"type,const=plc_operation"`
+	RotationKeys        []string           `json:"rotationKeys" cborgen:"rotationKeys"`
+	VerificationMethods map[string]string  `json:"verificationMethods" cborgen:"verificationMethods"`
+	AlsoKnownAs         []string           `json:"alsoKnownAs" cborgen:"alsoKnownAs"`
+	Services            map[string]Service `json:"services" cborgen:"services"`
+	Prev                *string            `json:"prev" cborgen:"prev"`
+	Sig                 *string            `json:"sig" cborgen:"sig,omitempty"`
+}
+
+type Service struct {
+	Type     string `json:"type" cborgen:"type"`
+	Endpoint string `json:"endpoint" cborgen:"endpoint"`
+}
+
+type Tombstone struct {
+	Type string  `json:"type" cborgen:"type,const=plc_tombstone"`
+	Prev string  `json:"prev" cborgen:"prev"`
+	Sig  *string `json:"sig" cborgen:"sig,omitempty"`
+}
+
+type LegacyCreateOp struct {
+	Type        string  `json:"type" cborgen:"type,const=create"`
+	SigningKey  string  `json:"signingKey" cborgen:"signingKey"`
+	RecoveryKey string  `json:"recoveryKey" cborgen:"recoveryKey"`
+	Handle      string  `json:"handle" cborgen:"handle"`
+	Service     string  `json:"service" cborgen:"service"`
+	Prev        *string `json:"prev" cborgen:"prev"`
+	Sig         *string `json:"sig" cborgen:"sig,omitempty"`
+}
+
+func (op *LegacyCreateOp) AsUnsignedOp() Op {
+	return Op{
+		Type:         "plc_operation",
+		Prev:         op.Prev,
+		AlsoKnownAs:  []string{fmt.Sprintf("at://%s", op.Handle)},
+		RotationKeys: []string{op.RecoveryKey},
+		Services: map[string]Service{
+			"atproto_pds": {
+				Type:     "AtprotoPersonalDataServer",
+				Endpoint: op.Service,
+			}},
+		VerificationMethods: map[string]string{
+			"atproto": op.SigningKey,
+		},
+	}
+}
+
+type OperationKind interface {
+	CID() (cid.Cid, error)
+}
+
+type Operation struct {
+	Value OperationKind
+}
+
+type OperationLogEntry struct {
+	DID       string    `json:"did"`
+	Operation Operation `json:"operation"`
+	CID       string    `json:"cid"`
+	Nullified bool      `json:"nullified"`
+	CreatedAt string    `json:"createdAt"`
+}
+
+func unmarshal[T any](b []byte) (T, error) {
+	var out T
+	if err := json.Unmarshal(b, &out); err != nil {
+		return out, err
+	}
+	return out, nil
+}
+
+func (o *Operation) UnmarshalJSON(b []byte) error {
+	var partial struct {
+		Type string `json:"type"`
+	}
+
+	if err := json.Unmarshal(b, &partial); err != nil {
+		return err
+	}
+
+	switch partial.Type {
+	case "create":
+		v, err := unmarshal[LegacyCreateOp](b)
+		if err != nil {
+			return err
+		}
+		o.Value = v
+		return nil
+	case "plc_operation":
+		v, err := unmarshal[Op](b)
+		if err != nil {
+			return err
+		}
+		o.Value = v
+		return nil
+	case "plc_tombstone":
+		v, err := unmarshal[Tombstone](b)
+		if err != nil {
+			return err
+		}
+		o.Value = v
+		return nil
+	default:
+		return fmt.Errorf("unsupported 'type' value: %q", partial.Type)
+	}
+}
+
+func (o Operation) MarshalJSON() ([]byte, error) {
+	return json.Marshal(o.Value)
+}
+
+func calculateCid(v cbg.CBORMarshaler) (cid.Cid, error) {
+	b := bytes.NewBuffer(nil)
+	if err := v.MarshalCBOR(b); err != nil {
+		return cid.Cid{}, fmt.Errorf("marshaling as CBOR: %w", err)
+	}
+	return cid.V1Builder{
+		Codec:  uint64(multicodec.DagCbor),
+		MhType: multihash.SHA2_256,
+	}.Sum(b.Bytes())
+}
+
+func (o Op) CID() (cid.Cid, error) {
+	return calculateCid(&o)
+}
+
+func (o Tombstone) CID() (cid.Cid, error) {
+	return calculateCid(&o)
+}
+
+func (o LegacyCreateOp) CID() (cid.Cid, error) {
+	return calculateCid(&o)
+}