fix

recording_blockstore/recording_blockstore.go

···
 	return &RecordingBlockstore{
 		base:    base,
 		inserts: make(map[cid.Cid]blockformat.Block),
+		reads:   make(map[cid.Cid]blockformat.Block),
 	}
 }
 

server/handle_sync_get_blocks.go

···
 	"github.com/labstack/echo/v4"
 )
 
+type ComAtprotoSyncGetBlocksRequest struct {
+	Did  string   `query:"did"`
+	Cids []string `query:"cids"`
+}
+
 func (s *Server) handleGetBlocks(e echo.Context) error {
 	ctx := e.Request().Context()
-	did := e.QueryParam("did")
-	if did == "" {
-		return helpers.InputError(e, nil)
-	}
 
-	cidstrs, ok := e.QueryParams()["cids"]
-	if !ok {
+	var req ComAtprotoSyncGetBlocksRequest
+	if err := e.Bind(&req); err != nil {
 		return helpers.InputError(e, nil)
 	}
+
 	var cids []cid.Cid
 
-	for _, cs := range cidstrs {
+	for _, cs := range req.Cids {
 		c, err := cid.Cast([]byte(cs))
 		if err != nil {
 			return err
···
 		cids = append(cids, c)
 	}
 
-	urepo, err := s.getRepoActorByDid(did)
+	urepo, err := s.getRepoActorByDid(req.Did)
 	if err != nil {
 		return helpers.ServerError(e, nil)
 	}

server/repo.go

···
 
 	dbs := rm.s.getBlockstore(urepo.Did)
 	bs := recording_blockstore.New(dbs)
-	r, err := repo.OpenRepo(context.TODO(), dbs, rootcid)
+	r, err := repo.OpenRepo(context.TODO(), bs, rootcid)
 
 	entries := []models.Record{}
 	var results []ApplyWriteResult

sqlite_blockstore/sqlite_blockstore.go

···
 func (bs *SqliteBlockstore) HashOnRead(enabled bool) {
 	panic("not implemented")
 }
-
-func (bs *SqliteBlockstore) Execute(ctx context.Context) error {
-	if !bs.readonly {
-		return fmt.Errorf("blockstore was not readonly")
-	}
-
-	bs.readonly = false
-	for _, b := range bs.inserts {
-		bs.Put(ctx, b)
-	}
-	bs.readonly = true
-
-	return nil
-}
-
-func (bs *SqliteBlockstore) GetLog() map[cid.Cid]blocks.Block {
-	return bs.inserts
-}