Complete migration onto cocoon (#37)

* Allow overwriting blocks during import repo

* Implement get recommended config

* Implement submit plc operation

plc/client.go

···
 }
 
 func (c *Client) CreateDID(sigkey *atcrypto.PrivateKeyK256, recovery string, handle string) (string, *Operation, error) {
-	pubsigkey, err := sigkey.PublicKey()
+	creds, err := c.CreateDidCredentials(sigkey, recovery, handle)
 	if err != nil {
 		return "", nil, err
 	}
 
-	pubrotkey, err := c.rotationKey.PublicKey()
+	op := Operation{
+		Type: "plc_operation",
+		VerificationMethods: creds.VerificationMethods,
+		RotationKeys: creds.RotationKeys,
+		AlsoKnownAs: creds.AlsoKnownAs,
+		Services: creds.Services,
+		Prev: nil,
+	}
+
+	if err := c.SignOp(sigkey, &op); err != nil {
+		return "", nil, err
+	}
+
+	did, err := DidFromOp(&op)
 	if err != nil {
 		return "", nil, err
 	}
 
+	return did, &op, nil
+}
+
+func (c *Client) CreateDidCredentials(sigkey *atcrypto.PrivateKeyK256, recovery string, handle string) (*DidCredentials, error) {
+	pubsigkey, err := sigkey.PublicKey()
+	if err != nil {
+		return nil, err
+	}
+
+	pubrotkey, err := c.rotationKey.PublicKey()
+	if err != nil {
+		return nil, err
+	}
+
 	// todo
 	rotationKeys := []string{pubrotkey.DIDKey()}
 	if recovery != "" {
···
 		}(recovery)
 	}
 
-	op := Operation{
-		Type: "plc_operation",
+	creds := DidCredentials{
 		VerificationMethods: map[string]string{
 			"atproto": pubsigkey.DIDKey(),
 		},
···
 				Endpoint: "https://" + c.pdsHostname,
 			},
 		},
-		Prev: nil,
 	}
 
-	if err := c.SignOp(sigkey, &op); err != nil {
-		return "", nil, err
-	}
-
-	did, err := DidFromOp(&op)
-	if err != nil {
-		return "", nil, err
-	}
-
-	return did, &op, nil
+	return &creds, nil
 }
 
 func (c *Client) SignOp(sigkey *atcrypto.PrivateKeyK256, op *Operation) error {

plc/types.go

···
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
+
+type DidCredentials struct {
+	VerificationMethods map[string]string                    `json:"verificationMethods"`
+	RotationKeys        []string                             `json:"rotationKeys"`
+	AlsoKnownAs         []string                             `json:"alsoKnownAs"`
+	Services            map[string]identity.OperationService `json:"services"`
+}
+
 type Operation struct {
 	Type                string                               `json:"type"`
 	VerificationMethods map[string]string                    `json:"verificationMethods"`

server/handle_identity_get_recommended_did_credentials.go

···
+package server
+
+import (
+	"github.com/bluesky-social/indigo/atproto/atcrypto"
+	"github.com/haileyok/cocoon/internal/helpers"
+	"github.com/haileyok/cocoon/models"
+	"github.com/labstack/echo/v4"
+)
+
+func (s *Server) handleGetRecommendedDidCredentials(e echo.Context) error {
+	repo := e.Get("repo").(*models.RepoActor)
+	k, err := atcrypto.ParsePrivateBytesK256(repo.SigningKey)
+	if err != nil {
+		s.logger.Error("error parsing key", "error", err)
+		return helpers.ServerError(e, nil)
+	}
+	creds, err := s.plcClient.CreateDidCredentials(k, "", repo.Actor.Handle)
+	if err != nil {
+		s.logger.Error("error crating did credentials", "error", err)
+		return helpers.ServerError(e, nil)
+	}
+
+	return e.JSON(200, creds)
+}

server/handle_identity_submit_plc_operation.go

···
+package server
+
+import (
+	"context"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/atproto/atcrypto"
+	"github.com/bluesky-social/indigo/events"
+	"github.com/bluesky-social/indigo/util"
+	"github.com/haileyok/cocoon/internal/helpers"
+	"github.com/haileyok/cocoon/models"
+	"github.com/haileyok/cocoon/plc"
+	"github.com/labstack/echo/v4"
+)
+
+type ComAtprotoSubmitPlcOperationRequest struct {
+	Operation plc.Operation `json:"operation"`
+}
+
+func (s *Server) handleSubmitPlcOperation(e echo.Context) error {
+	repo := e.Get("repo").(*models.RepoActor)
+
+	var req ComAtprotoSubmitPlcOperationRequest
+	if err := e.Bind(&req); err != nil {
+		s.logger.Error("error binding", "error", err)
+		return helpers.ServerError(e, nil)
+	}
+
+	if err := e.Validate(req); err != nil {
+		return helpers.InputError(e, nil)
+	}
+	if !strings.HasPrefix(repo.Repo.Did, "did:plc:") {
+		return helpers.InputError(e, nil)
+	}
+
+	op := req.Operation;
+
+	k, err := atcrypto.ParsePrivateBytesK256(repo.SigningKey)
+	if err != nil {
+		s.logger.Error("error parsing key", "error", err)
+		return helpers.ServerError(e, nil)
+	}
+	required, err := s.plcClient.CreateDidCredentials(k, "", repo.Actor.Handle)
+	if err != nil {
+		s.logger.Error("error crating did credentials", "error", err)
+		return helpers.ServerError(e, nil)
+	}
+
+	for _, expectedKey := range required.RotationKeys {
+		if !slices.Contains(op.RotationKeys, expectedKey) {
+			return helpers.InputError(e, nil)
+		}
+	}
+	if op.Services["atproto_pds"].Type != "AtprotoPersonalDataServer" {
+		return helpers.InputError(e, nil)
+	}
+	if op.Services["atproto_pds"].Endpoint != required.Services["atproto_pds"].Endpoint {
+		return helpers.InputError(e, nil)
+	}
+	if op.VerificationMethods["atproto"] != required.VerificationMethods["atproto"] {
+		return helpers.InputError(e, nil)
+	}
+	if op.AlsoKnownAs[0] != required.AlsoKnownAs[0] {
+		return helpers.InputError(e, nil)
+	}
+
+	if err := s.plcClient.SendOperation(e.Request().Context(), repo.Repo.Did, &op); err != nil {
+		return err
+	}
+
+	if err := s.passport.BustDoc(context.TODO(), repo.Repo.Did); err != nil {
+		s.logger.Warn("error busting did doc", "error", err)
+	}
+
+	s.evtman.AddEvent(context.TODO(), &events.XRPCStreamEvent{
+		RepoIdentity: &atproto.SyncSubscribeRepos_Identity{
+			Did:    repo.Repo.Did,
+			Seq:    time.Now().UnixMicro(), // TODO: no
+			Time:   time.Now().Format(util.ISO8601),
+		},
+	})
+
+	return nil
+}

server/handle_import_repo.go

···
 			Value:     b.RawData(),
 		}
 
-		if err := tx.Create(rec).Error; err != nil {
+		if err := tx.Save(rec).Error; err != nil {
 			return err
 		}
 

server/server.go

···
 	s.echo.GET("/xrpc/com.atproto.server.getSession", s.handleGetSession, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)
 	s.echo.POST("/xrpc/com.atproto.server.refreshSession", s.handleRefreshSession, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)
 	s.echo.POST("/xrpc/com.atproto.server.deleteSession", s.handleDeleteSession, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)
+	s.echo.GET("/xrpc/com.atproto.identity.getRecommendedDidCredentials", s.handleGetRecommendedDidCredentials, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)
 	s.echo.POST("/xrpc/com.atproto.identity.updateHandle", s.handleIdentityUpdateHandle, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)
+	s.echo.POST("/xrpc/com.atproto.identity.submitPlcOperation", s.handleSubmitPlcOperation, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)
 	s.echo.POST("/xrpc/com.atproto.server.confirmEmail", s.handleServerConfirmEmail, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)
 	s.echo.POST("/xrpc/com.atproto.server.requestEmailConfirmation", s.handleServerRequestEmailConfirmation, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware)
 	s.echo.POST("/xrpc/com.atproto.server.requestPasswordReset", s.handleServerRequestPasswordReset) // AUTH NOT REQUIRED FOR THIS ONE