Moving around files and refactoring of common

client/account/service.go

@@ -1,21 +1,21 @@
 package account
 
 import (
-	commonaccount "github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
+	commonaccount "github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/config"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
 )
 
 type service struct {
-	accountData *account.AccountData
+	accountData *accountdata.AccountData
 	peerId      string
 }
 
-func (s *service) Account() *account.AccountData {
+func (s *service) Account() *accountdata.AccountData {
 	return s.accountData
 }
 
@@ -55,7 +55,7 @@ func (s *service) Init(a *app.App) (err error) {
 		return err
 	}
 
-	s.accountData = &account.AccountData{
+	s.accountData = &accountdata.AccountData{
 		Identity: identity,
 		PeerKey:  decodedPeerKey,
 		SignKey:  decodedSigningKey,

client/api/rpchandler.go

@@ -1,167 +0,0 @@
-package api
-
-import (
-	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/api/apiproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
-	"math/rand"
-)
-
-type rpcHandler struct {
-	spaceService   clientspace.Service
-	storageService storage.ClientStorage
-	docService     document.Service
-	account        account.Service
-}
-
-func (r *rpcHandler) Watch(ctx context.Context, request *apiproto.WatchRequest) (resp *apiproto.WatchResponse, err error) {
-	space, err := r.spaceService.GetSpace(context.Background(), request.SpaceId)
-	if err != nil {
-		return
-	}
-
-	space.StatusService().Watch(request.TreeId)
-	resp = &apiproto.WatchResponse{}
-	return
-}
-
-func (r *rpcHandler) Unwatch(ctx context.Context, request *apiproto.UnwatchRequest) (resp *apiproto.UnwatchResponse, err error) {
-	space, err := r.spaceService.GetSpace(context.Background(), request.SpaceId)
-	if err != nil {
-		return
-	}
-	space.StatusService().Unwatch(request.TreeId)
-	resp = &apiproto.UnwatchResponse{}
-	return
-}
-
-func (r *rpcHandler) LoadSpace(ctx context.Context, request *apiproto.LoadSpaceRequest) (resp *apiproto.LoadSpaceResponse, err error) {
-	_, err = r.spaceService.GetSpace(context.Background(), request.SpaceId)
-	if err != nil {
-		return
-	}
-	resp = &apiproto.LoadSpaceResponse{}
-	return
-}
-
-func (r *rpcHandler) CreateSpace(ctx context.Context, request *apiproto.CreateSpaceRequest) (resp *apiproto.CreateSpaceResponse, err error) {
-	key, err := symmetric.NewRandom()
-	if err != nil {
-		return
-	}
-	sp, err := r.spaceService.CreateSpace(context.Background(), commonspace.SpaceCreatePayload{
-		SigningKey:     r.account.Account().SignKey,
-		EncryptionKey:  r.account.Account().EncKey,
-		ReadKey:        key.Bytes(),
-		ReplicationKey: rand.Uint64(),
-	})
-	if err != nil {
-		return
-	}
-	id := sp.Id()
-	if err != nil {
-		return
-	}
-	resp = &apiproto.CreateSpaceResponse{Id: id}
-	return
-}
-
-func (r *rpcHandler) DeriveSpace(ctx context.Context, request *apiproto.DeriveSpaceRequest) (resp *apiproto.DeriveSpaceResponse, err error) {
-	sp, err := r.spaceService.DeriveSpace(context.Background(), commonspace.SpaceDerivePayload{
-		SigningKey:    r.account.Account().SignKey,
-		EncryptionKey: r.account.Account().EncKey,
-	})
-	if err != nil {
-		return
-	}
-	id := sp.Id()
-	if err != nil {
-		return
-	}
-	resp = &apiproto.DeriveSpaceResponse{Id: id}
-	return
-}
-
-func (r *rpcHandler) CreateDocument(ctx context.Context, request *apiproto.CreateDocumentRequest) (resp *apiproto.CreateDocumentResponse, err error) {
-	id, err := r.docService.CreateDocument(request.SpaceId)
-	if err != nil {
-		return
-	}
-	resp = &apiproto.CreateDocumentResponse{Id: id}
-	return
-}
-
-func (r *rpcHandler) DeleteDocument(ctx context.Context, request *apiproto.DeleteDocumentRequest) (resp *apiproto.DeleteDocumentResponse, err error) {
-	err = r.docService.DeleteDocument(request.SpaceId, request.DocumentId)
-	if err != nil {
-		return
-	}
-	resp = &apiproto.DeleteDocumentResponse{}
-	return
-}
-
-func (r *rpcHandler) AddText(ctx context.Context, request *apiproto.AddTextRequest) (resp *apiproto.AddTextResponse, err error) {
-	root, head, err := r.docService.AddText(request.SpaceId, request.DocumentId, request.Text, request.IsSnapshot)
-	if err != nil {
-		return
-	}
-	resp = &apiproto.AddTextResponse{
-		DocumentId: request.DocumentId,
-		HeadId:     head,
-		RootId:     root,
-	}
-	return
-}
-
-func (r *rpcHandler) DumpTree(ctx context.Context, request *apiproto.DumpTreeRequest) (resp *apiproto.DumpTreeResponse, err error) {
-	dump, err := r.docService.DumpDocumentTree(request.SpaceId, request.DocumentId)
-	if err != nil {
-		return
-	}
-	resp = &apiproto.DumpTreeResponse{
-		Dump: dump,
-	}
-	return
-}
-
-func (r *rpcHandler) AllTrees(ctx context.Context, request *apiproto.AllTreesRequest) (resp *apiproto.AllTreesResponse, err error) {
-	heads, err := r.docService.AllDocumentHeads(request.SpaceId)
-	if err != nil {
-		return
-	}
-	var trees []*apiproto.Tree
-	for _, head := range heads {
-		trees = append(trees, &apiproto.Tree{
-			Id:    head.Id,
-			Heads: head.Heads,
-		})
-	}
-	resp = &apiproto.AllTreesResponse{Trees: trees}
-	return
-}
-
-func (r *rpcHandler) AllSpaces(ctx context.Context, request *apiproto.AllSpacesRequest) (resp *apiproto.AllSpacesResponse, err error) {
-	ids, err := r.storageService.AllSpaceIds()
-	if err != nil {
-		return
-	}
-	resp = &apiproto.AllSpacesResponse{SpaceIds: ids}
-	return
-}
-
-func (r *rpcHandler) TreeParams(ctx context.Context, request *apiproto.TreeParamsRequest) (resp *apiproto.TreeParamsResponse, err error) {
-	root, heads, err := r.docService.TreeParams(request.SpaceId, request.DocumentId)
-	if err != nil {
-		return
-	}
-	resp = &apiproto.TreeParamsResponse{
-		RootId:  root,
-		HeadIds: heads,
-	}
-	return
-}

client/clientspace/clientcache/treecache.go

@@ -5,12 +5,12 @@ import (
 	"errors"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document/textdocument"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ocache"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ocache"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
 	"go.uber.org/zap"
 	"time"
 )
@@ -25,7 +25,7 @@ const spaceKey ctxKey = 0
 type treeCache struct {
 	gcttl         int
 	cache         ocache.OCache
-	account       account.Service
+	account       accountservice.Service
 	clientService clientspace.Service
 }
 
@@ -37,14 +37,14 @@ type TreeCache interface {
 type updateListener struct {
 }
 
-func (u *updateListener) Update(tree tree.ObjectTree) {
+func (u *updateListener) Update(tree objecttree.ObjectTree) {
 	log.With(
 		zap.Strings("heads", tree.Heads()),
 		zap.String("tree id", tree.ID())).
 		Debug("updating tree")
 }
 
-func (u *updateListener) Rebuild(tree tree.ObjectTree) {
+func (u *updateListener) Rebuild(tree objecttree.ObjectTree) {
 	log.With(
 		zap.Strings("heads", tree.Heads()),
 		zap.String("tree id", tree.ID())).
@@ -67,7 +67,7 @@ func (c *treeCache) Close(ctx context.Context) (err error) {
 
 func (c *treeCache) Init(a *app.App) (err error) {
 	c.clientService = a.MustComponent(clientspace.CName).(clientspace.Service)
-	c.account = a.MustComponent(account.CName).(account.Service)
+	c.account = a.MustComponent(accountservice.CName).(accountservice.Service)
 	c.cache = ocache.New(
 		func(ctx context.Context, id string) (value ocache.Object, err error) {
 			spaceId := ctx.Value(spaceKey).(string)
@@ -98,7 +98,7 @@ func (c *treeCache) GetDocument(ctx context.Context, spaceId, id string) (doc te
 	return
 }
 
-func (c *treeCache) GetTree(ctx context.Context, spaceId, id string) (tr tree.ObjectTree, err error) {
+func (c *treeCache) GetTree(ctx context.Context, spaceId, id string) (tr objecttree.ObjectTree, err error) {
 	doc, err := c.GetDocument(ctx, spaceId, id)
 	if err != nil {
 		return

client/clientspace/service.go

@@ -4,12 +4,13 @@ import (
 	"context"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ocache"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
 	config2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/config"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/rpc/server"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ocache"
 	"time"
 )
 
@@ -31,14 +32,14 @@ type Service interface {
 type service struct {
 	conf                 config2.Space
 	spaceCache           ocache.OCache
-	commonSpace          commonspace.Service
+	commonSpace          commonspace.SpaceService
-	spaceStorageProvider storage.SpaceStorageProvider
+	spaceStorageProvider spacestorage.SpaceStorageProvider
 }
 
 func (s *service) Init(a *app.App) (err error) {
 	s.conf = a.MustComponent(config2.CName).(*config2.Config).Space
-	s.commonSpace = a.MustComponent(commonspace.CName).(commonspace.Service)
+	s.commonSpace = a.MustComponent(commonspace.CName).(commonspace.SpaceService)
-	s.spaceStorageProvider = a.MustComponent(storage.CName).(storage.SpaceStorageProvider)
+	s.spaceStorageProvider = a.MustComponent(spacestorage.CName).(spacestorage.SpaceStorageProvider)
 	s.spaceCache = ocache.New(
 		s.loadSpace,
 		ocache.WithLogger(log.Sugar()),
@@ -99,7 +100,7 @@ func (s *service) loadSpace(ctx context.Context, id string) (value ocache.Object
 	if err != nil {
 		return
 	}
-	ns.StatusService().SetUpdateReceiver(&statusReceiver{})
+	ns.SyncStatus().(syncstatus.SyncStatusWatcher).SetUpdateReceiver(&statusReceiver{})
 	if err = ns.Init(ctx); err != nil {
 		return
 	}

client/cmd/client.go

@@ -5,10 +5,10 @@ import (
 	"flag"
 	"fmt"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/account"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/api"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/badgerprovider"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace/clientcache"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/debug/clientdebugrpc"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/filestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/filestorage/rpcstore"
@@ -22,7 +22,7 @@ import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/dialer"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/pool"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/rpc/server"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/secure"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/secureservice"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
 	"go.uber.org/zap"
 	"net/http"
@@ -104,7 +104,7 @@ func Bootstrap(a *app.App) {
 		Register(badgerprovider.New()).
 		Register(storage.New()).
 		Register(clientcache.New(200)).
-		Register(secure.New()).
+		Register(secureservice.New()).
 		Register(dialer.New()).
 		Register(pool.New()).
 		Register(commonspace.New()).
@@ -114,5 +114,5 @@ func Bootstrap(a *app.App) {
 		Register(rpcstore.New()).
 		Register(fileservice.New()).
 		Register(filestorage.New()).
-		Register(api.New())
+		Register(clientdebugrpc.New())
 }

client/debug/clientdebugrpc/clientdebugrpc.go

@@ -1,51 +1,54 @@
-package api
+package clientdebugrpc
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/api/apiproto"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/debug/clientdebugrpc/clientdebugrpcproto"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
 	clientstorage "github.com/anytypeio/go-anytype-infrastructure-experiments/client/storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonfile/fileservice"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/config"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/rpc/server"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/secure"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/secureservice"
 	"storj.io/drpc"
 )
 
-const CName = "api.service"
+const CName = "debug.clientdebugrpc"
 
 var log = logger.NewNamed(CName)
 
-func New() Service {
+func New() ClientDebugRpc {
 	return &service{BaseDrpcServer: server.NewBaseDrpcServer()}
 }
 
-type Service interface {
+type ClientDebugRpc interface {
 	app.ComponentRunnable
 	drpc.Mux
 }
 
 type service struct {
-	transport      secure.Service
+	transport      secureservice.SecureService
 	cfg            *config.Config
 	spaceService   clientspace.Service
 	storageService clientstorage.ClientStorage
 	docService     document.Service
-	account        account.Service
+	account        accountservice.Service
+	file           fileservice.FileService
 	*server.BaseDrpcServer
 }
 
 func (s *service) Init(a *app.App) (err error) {
 	s.spaceService = a.MustComponent(clientspace.CName).(clientspace.Service)
-	s.storageService = a.MustComponent(storage.CName).(clientstorage.ClientStorage)
+	s.storageService = a.MustComponent(spacestorage.CName).(clientstorage.ClientStorage)
 	s.docService = a.MustComponent(document.CName).(document.Service)
-	s.account = a.MustComponent(account.CName).(account.Service)
+	s.account = a.MustComponent(accountservice.CName).(accountservice.Service)
 	s.cfg = a.MustComponent(config.CName).(*config.Config)
-	s.transport = a.MustComponent(secure.CName).(secure.Service)
+	s.transport = a.MustComponent(secureservice.CName).(secureservice.SecureService)
+	s.file = a.MustComponent(fileservice.CName).(fileservice.FileService)
 	return nil
 }
 
@@ -67,11 +70,12 @@ func (s *service) Run(ctx context.Context) (err error) {
 	if err != nil {
 		return
 	}
-	return apiproto.DRPCRegisterClientApi(s, &rpcHandler{
+	return clientdebugrpcproto.DRPCRegisterClientApi(s, &rpcHandler{
 		spaceService:   s.spaceService,
 		storageService: s.storageService,
 		docService:     s.docService,
 		account:        s.account,
+		file:           s.file,
 	})
 }
 

client/debug/clientdebugrpc/clientdebugrpcproto/api.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: api/apiproto/protos/api.proto
 
-package apiproto
+package clientdebugrpcproto
 
 import (
 	fmt "fmt"

client/debug/clientdebugrpc/clientdebugrpcproto/api_drpc.pb.go

@@ -2,7 +2,7 @@
 // protoc-gen-go-drpc version: v0.0.32
 // source: api/apiproto/protos/api.proto
 
-package apiproto
+package clientdebugrpcproto
 
 import (
 	bytes "bytes"

client/debug/clientdebugrpc/rpchandler.go

@@ -0,0 +1,222 @@
+package clientdebugrpc
+
+import (
+	"context"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/debug/clientdebugrpc/clientdebugrpcproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonfile/fileservice"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
+	"github.com/ipfs/go-cid"
+	"go.uber.org/zap"
+	"io"
+	"math/rand"
+	"os"
+)
+
+type rpcHandler struct {
+	spaceService   clientspace.Service
+	storageService storage.ClientStorage
+	docService     document.Service
+	account        accountservice.Service
+	file           fileservice.FileService
+}
+
+func (r *rpcHandler) Watch(ctx context.Context, request *clientdebugrpcproto.WatchRequest) (resp *clientdebugrpcproto.WatchResponse, err error) {
+	space, err := r.spaceService.GetSpace(context.Background(), request.SpaceId)
+	if err != nil {
+		return
+	}
+	watcher := space.SyncStatus().(syncstatus.SyncStatusWatcher)
+	watcher.Watch(request.TreeId)
+	resp = &clientdebugrpcproto.WatchResponse{}
+	return
+}
+
+func (r *rpcHandler) Unwatch(ctx context.Context, request *clientdebugrpcproto.UnwatchRequest) (resp *clientdebugrpcproto.UnwatchResponse, err error) {
+	space, err := r.spaceService.GetSpace(context.Background(), request.SpaceId)
+	if err != nil {
+		return
+	}
+	watcher := space.SyncStatus().(syncstatus.SyncStatusWatcher)
+	watcher.Unwatch(request.TreeId)
+	resp = &clientdebugrpcproto.UnwatchResponse{}
+	return
+}
+
+func (r *rpcHandler) LoadSpace(ctx context.Context, request *clientdebugrpcproto.LoadSpaceRequest) (resp *clientdebugrpcproto.LoadSpaceResponse, err error) {
+	_, err = r.spaceService.GetSpace(context.Background(), request.SpaceId)
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.LoadSpaceResponse{}
+	return
+}
+
+func (r *rpcHandler) CreateSpace(ctx context.Context, request *clientdebugrpcproto.CreateSpaceRequest) (resp *clientdebugrpcproto.CreateSpaceResponse, err error) {
+	key, err := symmetric.NewRandom()
+	if err != nil {
+		return
+	}
+	sp, err := r.spaceService.CreateSpace(context.Background(), commonspace.SpaceCreatePayload{
+		SigningKey:     r.account.Account().SignKey,
+		EncryptionKey:  r.account.Account().EncKey,
+		ReadKey:        key.Bytes(),
+		ReplicationKey: rand.Uint64(),
+	})
+	if err != nil {
+		return
+	}
+	id := sp.Id()
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.CreateSpaceResponse{Id: id}
+	return
+}
+
+func (r *rpcHandler) DeriveSpace(ctx context.Context, request *clientdebugrpcproto.DeriveSpaceRequest) (resp *clientdebugrpcproto.DeriveSpaceResponse, err error) {
+	sp, err := r.spaceService.DeriveSpace(context.Background(), commonspace.SpaceDerivePayload{
+		SigningKey:    r.account.Account().SignKey,
+		EncryptionKey: r.account.Account().EncKey,
+	})
+	if err != nil {
+		return
+	}
+	id := sp.Id()
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.DeriveSpaceResponse{Id: id}
+	return
+}
+
+func (r *rpcHandler) CreateDocument(ctx context.Context, request *clientdebugrpcproto.CreateDocumentRequest) (resp *clientdebugrpcproto.CreateDocumentResponse, err error) {
+	id, err := r.docService.CreateDocument(request.SpaceId)
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.CreateDocumentResponse{Id: id}
+	return
+}
+
+func (r *rpcHandler) DeleteDocument(ctx context.Context, request *clientdebugrpcproto.DeleteDocumentRequest) (resp *clientdebugrpcproto.DeleteDocumentResponse, err error) {
+	err = r.docService.DeleteDocument(request.SpaceId, request.DocumentId)
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.DeleteDocumentResponse{}
+	return
+}
+
+func (r *rpcHandler) AddText(ctx context.Context, request *clientdebugrpcproto.AddTextRequest) (resp *clientdebugrpcproto.AddTextResponse, err error) {
+	root, head, err := r.docService.AddText(request.SpaceId, request.DocumentId, request.Text, request.IsSnapshot)
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.AddTextResponse{
+		DocumentId: request.DocumentId,
+		HeadId:     head,
+		RootId:     root,
+	}
+	return
+}
+
+func (r *rpcHandler) DumpTree(ctx context.Context, request *clientdebugrpcproto.DumpTreeRequest) (resp *clientdebugrpcproto.DumpTreeResponse, err error) {
+	dump, err := r.docService.DumpDocumentTree(request.SpaceId, request.DocumentId)
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.DumpTreeResponse{
+		Dump: dump,
+	}
+	return
+}
+
+func (r *rpcHandler) AllTrees(ctx context.Context, request *clientdebugrpcproto.AllTreesRequest) (resp *clientdebugrpcproto.AllTreesResponse, err error) {
+	heads, err := r.docService.AllDocumentHeads(request.SpaceId)
+	if err != nil {
+		return
+	}
+	var trees []*clientdebugrpcproto.Tree
+	for _, head := range heads {
+		trees = append(trees, &clientdebugrpcproto.Tree{
+			Id:    head.Id,
+			Heads: head.Heads,
+		})
+	}
+	resp = &clientdebugrpcproto.AllTreesResponse{Trees: trees}
+	return
+}
+
+func (r *rpcHandler) AllSpaces(ctx context.Context, request *clientdebugrpcproto.AllSpacesRequest) (resp *clientdebugrpcproto.AllSpacesResponse, err error) {
+	ids, err := r.storageService.AllSpaceIds()
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.AllSpacesResponse{SpaceIds: ids}
+	return
+}
+
+func (r *rpcHandler) TreeParams(ctx context.Context, request *clientdebugrpcproto.TreeParamsRequest) (resp *clientdebugrpcproto.TreeParamsResponse, err error) {
+	root, heads, err := r.docService.TreeParams(request.SpaceId, request.DocumentId)
+	if err != nil {
+		return
+	}
+	resp = &clientdebugrpcproto.TreeParamsResponse{
+		RootId:  root,
+		HeadIds: heads,
+	}
+	return
+}
+
+func (r *rpcHandler) PutFile(ctx context.Context, request *clientdebugrpcproto.PutFileRequest) (*clientdebugrpcproto.PutFileResponse, error) {
+	f, err := os.Open(request.Path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	n, err := r.file.AddFile(ctx, f)
+	if err != nil {
+		return nil, err
+	}
+	return &clientdebugrpcproto.PutFileResponse{
+		Hash: n.Cid().String(),
+	}, nil
+}
+
+func (r *rpcHandler) GetFile(ctx context.Context, request *clientdebugrpcproto.GetFileRequest) (*clientdebugrpcproto.GetFileResponse, error) {
+	c, err := cid.Parse(request.Hash)
+	if err != nil {
+		return nil, err
+	}
+
+	f, err := os.Create(request.Path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	rd, err := r.file.GetFile(ctx, c)
+	if err != nil {
+		return nil, err
+	}
+	defer rd.Close()
+	wr, err := io.Copy(f, rd)
+	if err != nil && err != io.EOF {
+		return nil, err
+	}
+	log.Info("copied bytes", zap.Int64("size", wr))
+	return &clientdebugrpcproto.GetFileResponse{
+		Path: request.Path,
+	}, nil
+}
+
+func (r *rpcHandler) DeleteFile(ctx context.Context, request *clientdebugrpcproto.DeleteFileRequest) (*clientdebugrpcproto.DeleteFileResponse, error) {
+	//TODO implement me
+	panic("implement me")
+}

client/document/service.go

@@ -5,10 +5,11 @@ import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace/clientcache"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document/textdocument"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/headsync"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
 )
 
 type Service interface {
@@ -27,7 +28,7 @@ const CName = "client.document"
 var log = logger.NewNamed(CName)
 
 type service struct {
-	account      account.Service
+	account      accountservice.Service
 	spaceService clientspace.Service
 	cache        clientcache.TreeCache
 }
@@ -37,7 +38,7 @@ func New() Service {
 }
 
 func (s *service) Init(a *app.App) (err error) {
-	s.account = a.MustComponent(account.CName).(account.Service)
+	s.account = a.MustComponent(accountservice.CName).(accountservice.Service)
 	s.spaceService = a.MustComponent(clientspace.CName).(clientspace.Service)
 	s.cache = a.MustComponent(treegetter.CName).(clientcache.TreeCache)
 	return

client/document/textchangeproto/protos/test.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
-package anytype;
+package textchange;
-option go_package = "testchanges";
+option go_package = "textchange";
 
 message TextContent {
   oneof value {

client/document/textchangeproto/test.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-gogo. DO NOT EDIT.
 // source: pkg/acl/testutils/testchanges/proto/test.proto
 
-package testchanges
+package textchangeproto
 
 import (
 	fmt "fmt"

client/document/textdocument/textdocument.go

@@ -2,17 +2,17 @@ package textdocument
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
+	textchange "github.com/anytypeio/go-anytype-infrastructure-experiments/client/document/textchangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
-	testchanges "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/testchanges/proto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
 	"github.com/gogo/protobuf/proto"
 )
 
 type TextDocument interface {
-	tree.ObjectTree
+	objecttree.ObjectTree
-	InnerTree() tree.ObjectTree
+	InnerTree() objecttree.ObjectTree
 	AddText(text string, isSnapshot bool) (string, string, error)
 	Text() (string, error)
 	TreeDump() string
@@ -20,15 +20,15 @@ type TextDocument interface {
 }
 
 type textDocument struct {
-	tree.ObjectTree
+	objecttree.ObjectTree
-	account account.Service
+	account accountservice.Service
 }
 
 func CreateTextDocument(
 	ctx context.Context,
 	space commonspace.Space,
-	account account.Service) (id string, err error) {
+	account accountservice.Service) (id string, err error) {
-	payload := tree.ObjectTreeCreatePayload{
+	payload := objecttree.ObjectTreeCreatePayload{
 		SignKey:  account.Account().SignKey,
 		SpaceId:  space.Id(),
 		Identity: account.Account().Identity,
@@ -36,7 +36,7 @@ func CreateTextDocument(
 	return space.CreateTree(ctx, payload)
 }
 
-func NewTextDocument(ctx context.Context, space commonspace.Space, id string, listener updatelistener.UpdateListener, account account.Service) (doc TextDocument, err error) {
+func NewTextDocument(ctx context.Context, space commonspace.Space, id string, listener updatelistener.UpdateListener, account accountservice.Service) (doc TextDocument, err error) {
 	t, err := space.BuildTree(ctx, id, listener)
 	if err != nil {
 		return
@@ -47,16 +47,16 @@ func NewTextDocument(ctx context.Context, space commonspace.Space, id string, li
 	}, nil
 }
 
-func (t *textDocument) InnerTree() tree.ObjectTree {
+func (t *textDocument) InnerTree() objecttree.ObjectTree {
 	return t.ObjectTree
 }
 
 func (t *textDocument) AddText(text string, isSnapshot bool) (root, head string, err error) {
-	content := &testchanges.TextContent_TextAppend{
+	content := &textchange.TextContent_TextAppend{
-		TextAppend: &testchanges.TextAppend{Text: text},
+		TextAppend: &textchange.TextAppend{Text: text},
 	}
-	change := &testchanges.TextData{
+	change := &textchange.TextData{
-		Content: []*testchanges.TextContent{
+		Content: []*textchange.TextContent{
 			{content},
 		},
 		Snapshot: nil,
@@ -67,7 +67,7 @@ func (t *textDocument) AddText(text string, isSnapshot bool) (root, head string,
 	}
 	t.Lock()
 	defer t.Unlock()
-	addRes, err := t.AddContent(context.Background(), tree.SignableChangeContent{
+	addRes, err := t.AddContent(context.Background(), objecttree.SignableChangeContent{
 		Data:       res,
 		Key:        t.account.Account().SignKey,
 		Identity:   t.account.Account().Identity,
@@ -87,7 +87,7 @@ func (t *textDocument) Text() (text string, err error) {
 
 	err = t.Iterate(
 		func(decrypted []byte) (any, error) {
-			textChange := &testchanges.TextData{}
+			textChange := &textchange.TextData{}
 			err = proto.Unmarshal(decrypted, textChange)
 			if err != nil {
 				return nil, err
@@ -98,7 +98,7 @@ func (t *textDocument) Text() (text string, err error) {
 				}
 			}
 			return textChange, nil
-		}, func(change *tree.Change) bool {
+		}, func(change *objecttree.Change) bool {
 			return true
 		})
 	return

client/filestorage/rpcstore/clientmgr.go

@@ -3,7 +3,7 @@ package rpcstore
 import (
 	"context"
 	"fmt"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ocache"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ocache"
 	"github.com/cheggaaa/mb/v3"
 	"go.uber.org/zap"
 	"math/rand"

client/storage/keys.go

@@ -1,7 +1,7 @@
 package storage
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 )
 
 type aclKeys struct {
@@ -13,8 +13,8 @@ type aclKeys struct {
 func newACLKeys(spaceId string) aclKeys {
 	return aclKeys{
 		spaceId: spaceId,
-		rootKey: storage.JoinStringsToBytes("space", spaceId, "a", "rootId"),
+		rootKey: treestorage.JoinStringsToBytes("space", spaceId, "a", "rootId"),
-		headKey: storage.JoinStringsToBytes("space", spaceId, "a", "headId"),
+		headKey: treestorage.JoinStringsToBytes("space", spaceId, "a", "headId"),
 	}
 }
 
@@ -27,7 +27,7 @@ func (a aclKeys) RootIdKey() []byte {
 }
 
 func (a aclKeys) RawRecordKey(id string) []byte {
-	return storage.JoinStringsToBytes("space", a.spaceId, "a", id)
+	return treestorage.JoinStringsToBytes("space", a.spaceId, "a", id)
 }
 
 type treeKeys struct {
@@ -42,9 +42,9 @@ func newTreeKeys(spaceId, id string) treeKeys {
 	return treeKeys{
 		id:              id,
 		spaceId:         spaceId,
-		headsKey:        storage.JoinStringsToBytes("space", spaceId, "t", id, "heads"),
+		headsKey:        treestorage.JoinStringsToBytes("space", spaceId, "t", id, "heads"),
-		rootKey:         storage.JoinStringsToBytes("space", spaceId, "t", "rootId", id),
+		rootKey:         treestorage.JoinStringsToBytes("space", spaceId, "t", "rootId", id),
-		rawChangePrefix: storage.JoinStringsToBytes("space", spaceId, "t", id),
+		rawChangePrefix: treestorage.JoinStringsToBytes("space", spaceId, "t", id),
 	}
 }
 
@@ -57,7 +57,7 @@ func (t treeKeys) RootIdKey() []byte {
 }
 
 func (t treeKeys) RawChangeKey(id string) []byte {
-	return storage.JoinStringsToBytes("space", t.spaceId, "t", t.id, id)
+	return treestorage.JoinStringsToBytes("space", t.spaceId, "t", t.id, id)
 }
 
 func (t treeKeys) RawChangePrefix() []byte {
@@ -74,9 +74,9 @@ type spaceKeys struct {
 func newSpaceKeys(spaceId string) spaceKeys {
 	return spaceKeys{
 		spaceId:            spaceId,
-		headerKey:          storage.JoinStringsToBytes("space", "header", spaceId),
+		headerKey:          treestorage.JoinStringsToBytes("space", "header", spaceId),
-		treePrefixKey:      storage.JoinStringsToBytes("space", spaceId, "t", "rootId"),
+		treePrefixKey:      treestorage.JoinStringsToBytes("space", spaceId, "t", "rootId"),
-		spaceSettingsIdKey: storage.JoinStringsToBytes("space", spaceId, "spaceSettingsId"),
+		spaceSettingsIdKey: treestorage.JoinStringsToBytes("space", spaceId, "spaceSettingsId"),
 	}
 }
 
@@ -93,7 +93,7 @@ func (s spaceKeys) SpaceSettingsId() []byte {
 }
 
 func (s spaceKeys) TreeDeletedKey(id string) []byte {
-	return storage.JoinStringsToBytes("space", s.spaceId, "deleted", id)
+	return treestorage.JoinStringsToBytes("space", s.spaceId, "deleted", id)
 }
 
 type storageServiceKeys struct {

client/storage/liststorage.go

@@ -3,8 +3,8 @@ package storage
 import (
 	"context"
 	"errors"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
 	"github.com/dgraph-io/badger/v3"
 )
 
@@ -17,7 +17,7 @@ type listStorage struct {
 	root *aclrecordproto.RawACLRecordWithId
 }
 
-func newListStorage(spaceId string, db *badger.DB, txn *badger.Txn) (ls storage.ListStorage, err error) {
+func newListStorage(spaceId string, db *badger.DB, txn *badger.Txn) (ls liststorage.ListStorage, err error) {
 	keys := newACLKeys(spaceId)
 	rootId, err := getTxn(txn, keys.RootIdKey())
 	if err != nil {
@@ -44,7 +44,7 @@ func newListStorage(spaceId string, db *badger.DB, txn *badger.Txn) (ls storage.
 	return
 }
 
-func createListStorage(spaceId string, db *badger.DB, txn *badger.Txn, root *aclrecordproto.RawACLRecordWithId) (ls storage.ListStorage, err error) {
+func createListStorage(spaceId string, db *badger.DB, txn *badger.Txn, root *aclrecordproto.RawACLRecordWithId) (ls liststorage.ListStorage, err error) {
 	keys := newACLKeys(spaceId)
 	_, err = getTxn(txn, keys.RootIdKey())
 	if err != badger.ErrKeyNotFound {
@@ -98,7 +98,7 @@ func (l *listStorage) GetRawRecord(ctx context.Context, id string) (raw *aclreco
 	res, err := getDB(l.db, l.keys.RawRecordKey(id))
 	if err != nil {
 		if err == badger.ErrKeyNotFound {
-			err = storage.ErrUnknownRecord
+			err = liststorage.ErrUnknownRecord
 		}
 		return
 	}

client/storage/liststorage_test.go

@@ -2,15 +2,15 @@ package storage
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
 	"github.com/dgraph-io/badger/v3"
 	"github.com/stretchr/testify/require"
 	"testing"
 )
 
-func testList(t *testing.T, store storage.ListStorage, root *aclrecordproto.RawACLRecordWithId, head string) {
+func testList(t *testing.T, store liststorage.ListStorage, root *aclrecordproto.RawACLRecordWithId, head string) {
-	require.Equal(t, store.ID(), root.Id)
+	require.Equal(t, store.Id(), root.Id)
 
 	aclRoot, err := store.Root()
 	require.NoError(t, err)
@@ -34,7 +34,7 @@ func TestListStorage(t *testing.T) {
 		return nil
 	})
 
-	var listStore storage.ListStorage
+	var listStore liststorage.ListStorage
 	fx.db.View(func(txn *badger.Txn) (err error) {
 		listStore, err = newListStorage(spaceId, fx.db, txn)
 		require.NoError(t, err)

client/storage/spacestorage.go

@@ -1,10 +1,11 @@
 package storage
 
 import (
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
+	storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
+	spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
-	storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 	"github.com/dgraph-io/badger/v3"
 )
 
@@ -13,7 +14,7 @@ type spaceStorage struct {
 	spaceSettingsId string
 	objDb           *badger.DB
 	keys            spaceKeys
-	aclStorage      storage.ListStorage
+	aclStorage      liststorage.ListStorage
 	header          *spacesyncproto.RawSpaceHeaderWithId
 }
 
@@ -119,7 +120,7 @@ func (s *spaceStorage) CreateTreeStorage(payload storage.TreeStorageCreatePayloa
 	return createTreeStorage(s.objDb, s.spaceId, payload)
 }
 
-func (s *spaceStorage) ACLStorage() (storage.ListStorage, error) {
+func (s *spaceStorage) ACLStorage() (liststorage.ListStorage, error) {
 	return s.aclStorage, nil
 }
 

client/storage/spacestorage_test.go

@@ -1,10 +1,10 @@
 package storage
 
 import (
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
+	spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 	"github.com/stretchr/testify/require"
 	"sort"
 	"strconv"

client/storage/storageservice.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/client/badgerprovider"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 	"github.com/dgraph-io/badger/v3"
 )
 
@@ -14,7 +14,7 @@ type storageService struct {
 }
 
 type ClientStorage interface {
-	storage.SpaceStorageProvider
+	spacestorage.SpaceStorageProvider
 	app.ComponentRunnable
 	AllSpaceIds() (ids []string, err error)
 }
@@ -31,14 +31,14 @@ func (s *storageService) Init(a *app.App) (err error) {
 }
 
 func (s *storageService) Name() (name string) {
-	return storage.CName
+	return spacestorage.CName
 }
 
-func (s *storageService) SpaceStorage(id string) (storage.SpaceStorage, error) {
+func (s *storageService) SpaceStorage(id string) (spacestorage.SpaceStorage, error) {
 	return newSpaceStorage(s.db, id)
 }
 
-func (s *storageService) CreateSpaceStorage(payload storage.SpaceStorageCreatePayload) (storage.SpaceStorage, error) {
+func (s *storageService) CreateSpaceStorage(payload spacestorage.SpaceStorageCreatePayload) (spacestorage.SpaceStorage, error) {
 	return createSpaceStorage(s.db, payload)
 }
 

client/storage/treestorage.go

@@ -2,8 +2,8 @@ package storage
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	"github.com/dgraph-io/badger/v3"
 )
 
@@ -14,7 +14,7 @@ type treeStorage struct {
 	root *treechangeproto.RawTreeChangeWithId
 }
 
-func newTreeStorage(db *badger.DB, spaceId, treeId string) (ts storage.TreeStorage, err error) {
+func newTreeStorage(db *badger.DB, spaceId, treeId string) (ts treestorage.TreeStorage, err error) {
 	keys := newTreeKeys(spaceId, treeId)
 	err = db.View(func(txn *badger.Txn) error {
 		_, err := txn.Get(keys.RootIdKey())
@@ -40,17 +40,20 @@ func newTreeStorage(db *badger.DB, spaceId, treeId string) (ts storage.TreeStora
 		}
 		return nil
 	})
+	if err == badger.ErrKeyNotFound {
+		err = treestorage.ErrUnknownTreeId
+	}
 	return
 }
 
-func createTreeStorage(db *badger.DB, spaceId string, payload storage.TreeStorageCreatePayload) (ts storage.TreeStorage, err error) {
+func createTreeStorage(db *badger.DB, spaceId string, payload treestorage.TreeStorageCreatePayload) (ts treestorage.TreeStorage, err error) {
-	keys := newTreeKeys(spaceId, payload.TreeId)
+	keys := newTreeKeys(spaceId, payload.RootRawChange.Id)
 	if hasDB(db, keys.RootIdKey()) {
-		err = storage.ErrTreeExists
+		err = treestorage.ErrTreeExists
 		return
 	}
 	err = db.Update(func(txn *badger.Txn) error {
-		heads := storage.CreateHeadsPayload(payload.Heads)
+		heads := treestorage.CreateHeadsPayload(payload.Heads)
 
 		for _, ch := range payload.Changes {
 			err = txn.Set(keys.RawChangeKey(ch.Id), ch.GetRawChange())
@@ -97,16 +100,16 @@ func (t *treeStorage) Heads() (heads []string, err error) {
 	headsBytes, err := getDB(t.db, t.keys.HeadsKey())
 	if err != nil {
 		if err == badger.ErrKeyNotFound {
-			err = storage.ErrUnknownTreeId
+			err = treestorage.ErrUnknownTreeId
 		}
 		return
 	}
-	heads = storage.ParseHeads(headsBytes)
+	heads = treestorage.ParseHeads(headsBytes)
 	return
 }
 
 func (t *treeStorage) SetHeads(heads []string) (err error) {
-	payload := storage.CreateHeadsPayload(heads)
+	payload := treestorage.CreateHeadsPayload(heads)
 	return putDB(t.db, t.keys.HeadsKey(), payload)
 }
 
@@ -118,7 +121,7 @@ func (t *treeStorage) GetRawChange(ctx context.Context, id string) (raw *treecha
 	res, err := getDB(t.db, t.keys.RawChangeKey(id))
 	if err != nil {
 		if err == badger.ErrKeyNotFound {
-			err = storage.ErrUnknownTreeId
+			err = treestorage.ErrUnknownTreeId
 		}
 		return
 	}

client/storage/treestorage_test.go

@@ -2,19 +2,19 @@ package storage
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	"github.com/dgraph-io/badger/v3"
 	"github.com/stretchr/testify/require"
 	"os"
 	"testing"
 )
 
-func treeTestPayload() storage.TreeStorageCreatePayload {
+func treeTestPayload() treestorage.TreeStorageCreatePayload {
 	rootRawChange := &treechangeproto.RawTreeChangeWithId{RawChange: []byte("some"), Id: "someRootId"}
 	otherChange := &treechangeproto.RawTreeChangeWithId{RawChange: []byte("some other"), Id: "otherId"}
 	changes := []*treechangeproto.RawTreeChangeWithId{rootRawChange, otherChange}
-	return storage.TreeStorageCreatePayload{
+	return treestorage.TreeStorageCreatePayload{
 		RootRawChange: rootRawChange,
 		Changes:       changes,
 		Heads:         []string{rootRawChange.Id},
@@ -26,8 +26,8 @@ type fixture struct {
 	db  *badger.DB
 }
 
-func testTreePayload(t *testing.T, store storage.TreeStorage, payload storage.TreeStorageCreatePayload) {
+func testTreePayload(t *testing.T, store treestorage.TreeStorage, payload treestorage.TreeStorageCreatePayload) {
-	require.Equal(t, payload.RootRawChange.Id, store.ID())
+	require.Equal(t, payload.RootRawChange.Id, store.Id())
 
 	root, err := store.Root()
 	require.NoError(t, err)
@@ -181,7 +181,7 @@ func TestTreeStorage_Delete(t *testing.T) {
 		require.NoError(t, err)
 
 		_, err = newTreeStorage(fx.db, spaceId, payload.RootRawChange.Id)
-		require.Equal(t, err, storage.ErrUnknownTreeId)
+		require.Equal(t, err, treestorage.ErrUnknownTreeId)
 
 		fx.testNoKeysExist(t, spaceId, payload.RootRawChange.Id)
 	})

common/accountservice/accountservice.go

@@ -1,17 +1,17 @@
-//go:generate mockgen -destination mock_account/mock_account.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/account Service
+//go:generate mockgen -destination mock_accountservice/mock_accountservice.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice Service
-package account
+package accountservice
 
 import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/config"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
 )
 
 const CName = "common.account"
 
 type Service interface {
 	app.Component
-	Account() *account.AccountData
+	Account() *accountdata.AccountData
 }
 
 type ConfigGetter interface {

common/accountservice/mock_accountservice/mock_accountservice.go

@@ -1,14 +1,14 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/account (interfaces: Service)
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice (interfaces: Service)
 
-// Package mock_account is a generated GoMock package.
+// Package mock_accountservice is a generated GoMock package.
-package mock_account
+package mock_accountservice
 
 import (
 	reflect "reflect"
 
 	app "github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
-	account "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
+	accountdata "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -36,10 +36,10 @@ func (m *MockService) EXPECT() *MockServiceMockRecorder {
 }
 
 // Account mocks base method.
-func (m *MockService) Account() *account.AccountData {
+func (m *MockService) Account() *accountdata.AccountData {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Account")
-	ret0, _ := ret[0].(*account.AccountData)
+	ret0, _ := ret[0].(*accountdata.AccountData)
 	return ret0
 }
 

common/app/ldiff/diff.go

@@ -1,7 +1,7 @@
 // Package ldiff provides a container of elements with fixed id and changeable content.
 // Diff can calculate the difference with another diff container (you can make it remote) with minimum hops and traffic.
 //
-//go:generate mockgen -destination mock_ldiff/mock_ldiff.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff Diff,Remote
+//go:generate mockgen -destination mock_ldiff/mock_ldiff.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff Diff,Remote
 package ldiff
 
 import (

common/app/ldiff/mock_ldiff/mock_ldiff.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff (interfaces: Diff,Remote)
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff (interfaces: Diff,Remote)
 
 // Package mock_ldiff is a generated GoMock package.
 package mock_ldiff
@@ -8,7 +8,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	ldiff "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
+	ldiff "github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
 	gomock "github.com/golang/mock/gomock"
 )
 

common/app/ocache/ocache.go

@@ -87,9 +87,9 @@ type entry struct {
 	refCount  uint32
 	isClosing bool
 	load      chan struct{}
-	loadErr   error
+	loadErr error
-	value     Object
+	value   Object
-	close     chan struct{}
+	close   chan struct{}
 }
 
 func (e *entry) locked() bool {

common/commonspace/commongetter.go

@@ -2,10 +2,10 @@ package commonspace
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectgetter"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/syncacl"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/syncobjectgetter"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncacl"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
 )
 
 type commonSpaceGetter struct {
@@ -15,7 +15,7 @@ type commonSpaceGetter struct {
 	settings   settings.SettingsObject
 }
 
-func newCommonSpaceGetter(spaceId string, aclList *syncacl.SyncACL, treeGetter treegetter.TreeGetter, settings settings.SettingsObject) objectgetter.ObjectGetter {
+func newCommonSpaceGetter(spaceId string, aclList *syncacl.SyncACL, treeGetter treegetter.TreeGetter, settings settings.SettingsObject) syncobjectgetter.SyncObjectGetter {
 	return &commonSpaceGetter{
 		spaceId:    spaceId,
 		aclList:    aclList,
@@ -24,19 +24,19 @@ func newCommonSpaceGetter(spaceId string, aclList *syncacl.SyncACL, treeGetter t
 	}
 }
 
-func (c *commonSpaceGetter) GetObject(ctx context.Context, objectId string) (obj objectgetter.Object, err error) {
+func (c *commonSpaceGetter) GetObject(ctx context.Context, objectId string) (obj syncobjectgetter.SyncObject, err error) {
 	if c.aclList.ID() == objectId {
 		obj = c.aclList
 		return
 	}
 	if c.settings.ID() == objectId {
-		obj = c.settings.(objectgetter.Object)
+		obj = c.settings.(syncobjectgetter.SyncObject)
 		return
 	}
 	t, err := c.treeGetter.GetTree(ctx, c.spaceId, objectId)
 	if err != nil {
 		return
 	}
-	obj = t.(objectgetter.Object)
+	obj = t.(syncobjectgetter.SyncObject)
 	return
 }

common/commonspace/commonstorage.go

@@ -1,15 +1,15 @@
 package commonspace
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
-	treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 )
 
 type commonStorage struct {
-	storage.SpaceStorage
+	spacestorage.SpaceStorage
 }
 
-func newCommonStorage(spaceStorage storage.SpaceStorage) storage.SpaceStorage {
+func newCommonStorage(spaceStorage spacestorage.SpaceStorage) spacestorage.SpaceStorage {
 	return &commonStorage{
 		SpaceStorage: spaceStorage,
 	}
@@ -23,6 +23,6 @@ func (c *commonStorage) CreateTreeStorage(payload treestorage.TreeStorageCreateP
 	if status == "" {
 		return c.SpaceStorage.CreateTreeStorage(payload)
 	}
-	err = storage.ErrTreeStorageAlreadyDeleted
+	err = spacestorage.ErrTreeStorageAlreadyDeleted
 	return
 }

common/commonspace/headsync/diffsyncer.go

@@ -2,16 +2,16 @@ package headsync
 
 import (
 	"context"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings/deletionstate"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/peer"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/rpc/rpcerr"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
 	"go.uber.org/zap"
 	"time"
 )
@@ -28,7 +28,7 @@ func newDiffSyncer(
 	diff ldiff.Diff,
 	confConnector nodeconf.ConfConnector,
 	cache treegetter.TreeGetter,
-	storage storage.SpaceStorage,
+	storage spacestorage.SpaceStorage,
 	clientFactory spacesyncproto.ClientFactory,
 	syncStatus syncstatus.SyncStatusUpdater,
 	log *zap.Logger) DiffSyncer {
@@ -49,7 +49,7 @@ type diffSyncer struct {
 	diff          ldiff.Diff
 	confConnector nodeconf.ConfConnector
 	cache         treegetter.TreeGetter
-	storage       storage.SpaceStorage
+	storage       spacestorage.SpaceStorage
 	clientFactory spacesyncproto.ClientFactory
 	log           *zap.Logger
 	deletionState deletionstate.DeletionState

common/commonspace/headsync/diffsyncer_test.go

@@ -3,21 +3,20 @@ package headsync
 import (
 	"context"
 	"fmt"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff/mock_ldiff"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
+	mock_treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage/mock_treestorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter/mock_treegetter"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings/deletionstate/mock_deletionstate"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage/mock_spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto/mock_spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage/mock_storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter/mock_treegetter"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/peer"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf/mock_nodeconf"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
-	mock_aclstorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage/mock_storage"
-	mock_treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage/mock_storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff/mock_ldiff"
 	"github.com/golang/mock/gomock"
 	"github.com/libp2p/go-libp2p/core/sec"
 	"github.com/stretchr/testify/require"
@@ -101,7 +100,7 @@ func TestDiffSyncer_Sync(t *testing.T) {
 	diffMock := mock_ldiff.NewMockDiff(ctrl)
 	connectorMock := mock_nodeconf.NewMockConfConnector(ctrl)
 	cacheMock := mock_treegetter.NewMockTreeGetter(ctrl)
-	stMock := mock_storage.NewMockSpaceStorage(ctrl)
+	stMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
 	clientMock := mock_spacesyncproto.NewMockDRPCSpaceClient(ctrl)
 	factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceClient {
 		return clientMock
@@ -158,7 +157,7 @@ func TestDiffSyncer_Sync(t *testing.T) {
 	})
 
 	t.Run("diff syncer sync space missing", func(t *testing.T) {
-		aclStorageMock := mock_aclstorage.NewMockListStorage(ctrl)
+		aclStorageMock := mock_treestorage.NewMockListStorage(ctrl)
 		settingsStorage := mock_treestorage.NewMockTreeStorage(ctrl)
 		settingsId := "settingsId"
 		aclRoot := &aclrecordproto.RawACLRecordWithId{

common/commonspace/headsync/headsync.go

@@ -3,13 +3,13 @@ package headsync
 
 import (
 	"context"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings/deletionstate"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/periodicsync"
 	"go.uber.org/zap"
 	"strings"
@@ -35,7 +35,7 @@ type HeadSync interface {
 type headSync struct {
 	spaceId      string
 	periodicSync periodicsync.PeriodicSync
-	storage      storage.SpaceStorage
+	storage      spacestorage.SpaceStorage
 	diff         ldiff.Diff
 	log          *zap.Logger
 	syncer       DiffSyncer
@@ -46,7 +46,7 @@ type headSync struct {
 func NewHeadSync(
 	spaceId string,
 	syncPeriod int,
-	storage storage.SpaceStorage,
+	storage spacestorage.SpaceStorage,
 	confConnector nodeconf.ConfConnector,
 	cache treegetter.TreeGetter,
 	syncStatus syncstatus.SyncStatusUpdater,

common/commonspace/headsync/headsync_test.go

@@ -1,13 +1,13 @@
 package headsync
 
 import (
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff/mock_ldiff"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/headsync/mock_headsync"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage/mock_treestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings/deletionstate/mock_deletionstate"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage/mock_storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage/mock_spacestorage"
-	mock_storage2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage/mock_storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff/mock_ldiff"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/periodicsync/mock_periodicsync"
 	"github.com/golang/mock/gomock"
 	"testing"
@@ -20,8 +20,8 @@ func TestDiffService(t *testing.T) {
 	spaceId := "spaceId"
 	l := logger.NewNamed("sync")
 	pSyncMock := mock_periodicsync.NewMockPeriodicSync(ctrl)
-	storageMock := mock_storage.NewMockSpaceStorage(ctrl)
+	storageMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
-	treeStorageMock := mock_storage2.NewMockTreeStorage(ctrl)
+	treeStorageMock := mock_treestorage.NewMockTreeStorage(ctrl)
 	diffMock := mock_ldiff.NewMockDiff(ctrl)
 	syncer := mock_headsync.NewMockDiffSyncer(ctrl)
 	delState := mock_deletionstate.NewMockDeletionState(ctrl)

common/commonspace/headsync/remotediff.go

@@ -2,8 +2,8 @@ package headsync
 
 import (
 	"context"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
 )
 
 type Client interface {

common/commonspace/headsync/remotediff_test.go

@@ -3,8 +3,8 @@ package headsync
 import (
 	"context"
 	"fmt"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"testing"

common/commonspace/object/accountdata/accountdata.go

@@ -1,4 +1,4 @@
-package account
+package accountdata
 
 import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"

common/commonspace/object/acl/list/aclrecordbuilder.go

@@ -1,9 +1,9 @@
 package list
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cid"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cidutil"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
 	"github.com/gogo/protobuf/proto"
@@ -17,10 +17,10 @@ type ACLRecordBuilder interface {
 
 type aclRecordBuilder struct {
 	id       string
-	keychain *common.Keychain
+	keychain *keychain.Keychain
 }
 
-func newACLRecordBuilder(id string, keychain *common.Keychain) ACLRecordBuilder {
+func newACLRecordBuilder(id string, keychain *keychain.Keychain) ACLRecordBuilder {
 	return &aclRecordBuilder{
 		id:       id,
 		keychain: keychain,
@@ -149,7 +149,7 @@ func (a *aclRecordBuilder) ConvertFromRaw(rawIdRecord *aclrecordproto.RawACLReco
 }
 
 func verifyRaw(
-	keychain *common.Keychain,
+	keychain *keychain.Keychain,
 	rawRec *aclrecordproto.RawACLRecord,
 	recWithId *aclrecordproto.RawACLRecordWithId,
 	identity []byte) (err error) {
@@ -169,7 +169,7 @@ func verifyRaw(
 	}
 
 	// verifying ID
-	if !cid.VerifyCID(recWithId.Payload, recWithId.Id) {
+	if !cidutil.VerifyCID(recWithId.Payload, recWithId.Id) {
 		err = ErrIncorrectCID
 	}
 	return

common/commonspace/object/acl/list/aclrecordbuilder_test.go

@@ -1,25 +1,25 @@
 package list
 
 import (
-	account "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
+	acllistbuilder2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/testutils/acllistbuilder"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/acllistbuilder"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cid"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cidutil"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
 	"github.com/stretchr/testify/require"
 	"testing"
 )
 
 func TestAclRecordBuilder_BuildUserJoin(t *testing.T) {
-	st, err := acllistbuilder.NewListStorageWithTestName("userjoinexample.yml")
+	st, err := acllistbuilder2.NewListStorageWithTestName("userjoinexample.yml")
 	require.NoError(t, err, "building storage should not result in error")
 
-	keychain := st.(*acllistbuilder.ACLListStorageBuilder).GetKeychain()
+	testKeychain := st.(*acllistbuilder2.ACLListStorageBuilder).GetKeychain()
-	identity := keychain.GeneratedIdentities["D"]
+	identity := testKeychain.GeneratedIdentities["D"]
-	signPrivKey := keychain.SigningKeysByYAMLName["D"]
+	signPrivKey := testKeychain.SigningKeysByYAMLName["D"]
-	encPrivKey := keychain.EncryptionKeysByYAMLName["D"]
+	encPrivKey := testKeychain.EncryptionKeysByYAMLName["D"]
-	acc := &account.AccountData{
+	acc := &accountdata.AccountData{
 		Identity: []byte(identity),
 		SignKey:  signPrivKey,
 		EncKey:   encPrivKey,
@@ -27,17 +27,17 @@ func TestAclRecordBuilder_BuildUserJoin(t *testing.T) {
 
 	aclList, err := BuildACLListWithIdentity(acc, st)
 	require.NoError(t, err, "building acl list should be without error")
-	recordBuilder := newACLRecordBuilder(aclList.ID(), common.NewKeychain())
+	recordBuilder := newACLRecordBuilder(aclList.ID(), keychain.NewKeychain())
-	rk, err := keychain.GetKey("key.Read.EncKey").(*acllistbuilder.SymKey).Key.Raw()
+	rk, err := testKeychain.GetKey("key.Read.EncKey").(*acllistbuilder2.SymKey).Key.Raw()
 	require.NoError(t, err)
-	privKey, err := keychain.GetKey("key.Sign.Onetime1").(signingkey.PrivKey).Raw()
+	privKey, err := testKeychain.GetKey("key.Sign.Onetime1").(signingkey.PrivKey).Raw()
 	require.NoError(t, err)
 
 	userJoin, err := recordBuilder.BuildUserJoin(privKey, rk, aclList.ACLState())
 	require.NoError(t, err)
 	marshalledJoin, err := userJoin.Marshal()
 	require.NoError(t, err)
-	id, err := cid.NewCIDFromBytes(marshalledJoin)
+	id, err := cidutil.NewCIDFromBytes(marshalledJoin)
 	require.NoError(t, err)
 	rawRec := &aclrecordproto.RawACLRecordWithId{
 		Payload: marshalledJoin,

common/commonspace/object/acl/list/aclstate.go

@@ -5,8 +5,8 @@ import (
 	"errors"
 	"fmt"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	aclrecordproto2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
@@ -18,31 +18,33 @@ import (
 
 var log = logger.NewNamed("acllist").Sugar()
 
-var ErrNoSuchUser = errors.New("no such user")
+var (
-var ErrFailedToDecrypt = errors.New("failed to decrypt key")
+	ErrNoSuchUser              = errors.New("no such user")
-var ErrUserRemoved = errors.New("user was removed from the document")
+	ErrFailedToDecrypt         = errors.New("failed to decrypt key")
-var ErrDocumentForbidden = errors.New("your user was forbidden access to the document")
+	ErrUserRemoved             = errors.New("user was removed from the document")
-var ErrUserAlreadyExists = errors.New("user already exists")
+	ErrDocumentForbidden       = errors.New("your user was forbidden access to the document")
-var ErrNoSuchRecord = errors.New("no such record")
+	ErrUserAlreadyExists       = errors.New("user already exists")
-var ErrNoSuchInvite = errors.New("no such invite")
+	ErrNoSuchRecord            = errors.New("no such record")
-var ErrOldInvite = errors.New("invite is too old")
+	ErrNoSuchInvite            = errors.New("no such invite")
-var ErrInsufficientPermissions = errors.New("insufficient permissions")
+	ErrOldInvite               = errors.New("invite is too old")
-var ErrNoReadKey = errors.New("acl state doesn't have a read key")
+	ErrInsufficientPermissions = errors.New("insufficient permissions")
-var ErrInvalidSignature = errors.New("signature is invalid")
+	ErrNoReadKey               = errors.New("acl state doesn't have a read key")
-var ErrIncorrectRoot = errors.New("incorrect root")
+	ErrInvalidSignature        = errors.New("signature is invalid")
-var ErrIncorrectRecordSequence = errors.New("incorrect prev id of a record")
+	ErrIncorrectRoot           = errors.New("incorrect root")
+	ErrIncorrectRecordSequence = errors.New("incorrect prev id of a record")
+)
 
 type UserPermissionPair struct {
 	Identity   string
-	Permission aclrecordproto.ACLUserPermissions
+	Permission aclrecordproto2.ACLUserPermissions
 }
 
 type ACLState struct {
 	id                 string
 	currentReadKeyHash uint64
 	userReadKeys       map[uint64]*symmetric.Key
-	userStates         map[string]*aclrecordproto.ACLUserState
+	userStates         map[string]*aclrecordproto2.ACLUserState
-	userInvites        map[string]*aclrecordproto.ACLUserInvite
+	userInvites        map[string]*aclrecordproto2.ACLUserInvite
 	encryptionKey      encryptionkey.PrivKey
 	signingKey         signingkey.PrivKey
 	totalReadKeys      int
@@ -51,7 +53,7 @@ type ACLState struct {
 	permissionsAtRecord map[string][]UserPermissionPair
 	lastRecordId        string
 
-	keychain *common.Keychain
+	keychain *keychain.Keychain
 }
 
 func newACLStateWithKeys(
@@ -68,8 +70,8 @@ func newACLStateWithKeys(
 		signingKey:          signingKey,
 		encryptionKey:       encryptionKey,
 		userReadKeys:        make(map[uint64]*symmetric.Key),
-		userStates:          make(map[string]*aclrecordproto.ACLUserState),
+		userStates:          make(map[string]*aclrecordproto2.ACLUserState),
-		userInvites:         make(map[string]*aclrecordproto.ACLUserInvite),
+		userInvites:         make(map[string]*aclrecordproto2.ACLUserInvite),
 		permissionsAtRecord: make(map[string][]UserPermissionPair),
 	}, nil
 }
@@ -78,8 +80,8 @@ func newACLState(id string) *ACLState {
 	return &ACLState{
 		id:                  id,
 		userReadKeys:        make(map[uint64]*symmetric.Key),
-		userStates:          make(map[string]*aclrecordproto.ACLUserState),
+		userStates:          make(map[string]*aclrecordproto2.ACLUserState),
-		userInvites:         make(map[string]*aclrecordproto.ACLUserInvite),
+		userInvites:         make(map[string]*aclrecordproto2.ACLUserInvite),
 		permissionsAtRecord: make(map[string][]UserPermissionPair),
 	}
 }
@@ -126,7 +128,7 @@ func (st *ACLState) applyRecord(record *ACLRecord) (err error) {
 		return
 	}
 	if record.Id == st.id {
-		root, ok := record.Model.(*aclrecordproto.ACLRoot)
+		root, ok := record.Model.(*aclrecordproto2.ACLRoot)
 		if !ok {
 			return ErrIncorrectRoot
 		}
@@ -135,14 +137,14 @@ func (st *ACLState) applyRecord(record *ACLRecord) (err error) {
 			return
 		}
 		st.permissionsAtRecord[record.Id] = []UserPermissionPair{
-			{Identity: string(root.Identity), Permission: aclrecordproto.ACLUserPermissions_Admin},
+			{Identity: string(root.Identity), Permission: aclrecordproto2.ACLUserPermissions_Admin},
 		}
 		return
 	}
-	aclData := &aclrecordproto.ACLData{}
+	aclData := &aclrecordproto2.ACLData{}
 
 	if record.Model != nil {
-		aclData = record.Model.(*aclrecordproto.ACLData)
+		aclData = record.Model.(*aclrecordproto2.ACLData)
 	} else {
 		err = proto.Unmarshal(record.Data, aclData)
 		if err != nil {
@@ -170,7 +172,7 @@ func (st *ACLState) applyRecord(record *ACLRecord) (err error) {
 	return
 }
 
-func (st *ACLState) applyRoot(root *aclrecordproto.ACLRoot) (err error) {
+func (st *ACLState) applyRoot(root *aclrecordproto2.ACLRoot) (err error) {
 	if st.signingKey != nil && st.encryptionKey != nil && st.identity == string(root.Identity) {
 		err = st.saveReadKeyFromRoot(root)
 		if err != nil {
@@ -179,10 +181,10 @@ func (st *ACLState) applyRoot(root *aclrecordproto.ACLRoot) (err error) {
 	}
 
 	// adding user to the list
-	userState := &aclrecordproto.ACLUserState{
+	userState := &aclrecordproto2.ACLUserState{
 		Identity:      root.Identity,
 		EncryptionKey: root.EncryptionKey,
-		Permissions:   aclrecordproto.ACLUserPermissions_Admin,
+		Permissions:   aclrecordproto2.ACLUserPermissions_Admin,
 	}
 	st.currentReadKeyHash = root.CurrentReadKeyHash
 	st.userStates[string(root.Identity)] = userState
@@ -190,7 +192,7 @@ func (st *ACLState) applyRoot(root *aclrecordproto.ACLRoot) (err error) {
 	return
 }
 
-func (st *ACLState) saveReadKeyFromRoot(root *aclrecordproto.ACLRoot) (err error) {
+func (st *ACLState) saveReadKeyFromRoot(root *aclrecordproto2.ACLRoot) (err error) {
 	var readKey *symmetric.Key
 	if len(root.GetDerivationScheme()) != 0 {
 		var encPrivKey []byte
@@ -204,7 +206,7 @@ func (st *ACLState) saveReadKeyFromRoot(root *aclrecordproto.ACLRoot) (err error
 			return
 		}
 
-		readKey, err = aclrecordproto.ACLReadKeyDerive(signPrivKey, encPrivKey)
+		readKey, err = aclrecordproto2.ACLReadKeyDerive(signPrivKey, encPrivKey)
 		if err != nil {
 			return
 		}
@@ -228,7 +230,7 @@ func (st *ACLState) saveReadKeyFromRoot(root *aclrecordproto.ACLRoot) (err error
 	return
 }
 
-func (st *ACLState) applyChangeData(changeData *aclrecordproto.ACLData, hash uint64, identity []byte) (err error) {
+func (st *ACLState) applyChangeData(changeData *aclrecordproto2.ACLData, hash uint64, identity []byte) (err error) {
 	defer func() {
 		if err != nil {
 			return
@@ -246,7 +248,7 @@ func (st *ACLState) applyChangeData(changeData *aclrecordproto.ACLData, hash uin
 			return
 		}
 
-		if !st.HasPermission(identity, aclrecordproto.ACLUserPermissions_Admin) {
+		if !st.HasPermission(identity, aclrecordproto2.ACLUserPermissions_Admin) {
 			err = fmt.Errorf("user %s must have admin permissions", identity)
 			return
 		}
@@ -262,7 +264,7 @@ func (st *ACLState) applyChangeData(changeData *aclrecordproto.ACLData, hash uin
 	return nil
 }
 
-func (st *ACLState) applyChangeContent(ch *aclrecordproto.ACLContentValue) error {
+func (st *ACLState) applyChangeContent(ch *aclrecordproto2.ACLContentValue) error {
 	switch {
 	case ch.GetUserPermissionChange() != nil:
 		return st.applyUserPermissionChange(ch.GetUserPermissionChange())
@@ -279,7 +281,7 @@ func (st *ACLState) applyChangeContent(ch *aclrecordproto.ACLContentValue) error
 	}
 }
 
-func (st *ACLState) applyUserPermissionChange(ch *aclrecordproto.ACLUserPermissionChange) error {
+func (st *ACLState) applyUserPermissionChange(ch *aclrecordproto2.ACLUserPermissionChange) error {
 	chIdentity := string(ch.Identity)
 	state, exists := st.userStates[chIdentity]
 	if !exists {
@@ -290,12 +292,12 @@ func (st *ACLState) applyUserPermissionChange(ch *aclrecordproto.ACLUserPermissi
 	return nil
 }
 
-func (st *ACLState) applyUserInvite(ch *aclrecordproto.ACLUserInvite) error {
+func (st *ACLState) applyUserInvite(ch *aclrecordproto2.ACLUserInvite) error {
 	st.userInvites[string(ch.AcceptPublicKey)] = ch
 	return nil
 }
 
-func (st *ACLState) applyUserJoin(ch *aclrecordproto.ACLUserJoin) error {
+func (st *ACLState) applyUserJoin(ch *aclrecordproto2.ACLUserJoin) error {
 	invite, exists := st.userInvites[string(ch.AcceptPubKey)]
 	if !exists {
 		return fmt.Errorf("no such invite with such public key %s", keys.EncodeBytesToString(ch.AcceptPubKey))
@@ -334,7 +336,7 @@ func (st *ACLState) applyUserJoin(ch *aclrecordproto.ACLUserJoin) error {
 	}
 
 	// adding user to the list
-	userState := &aclrecordproto.ACLUserState{
+	userState := &aclrecordproto2.ACLUserState{
 		Identity:      ch.Identity,
 		EncryptionKey: ch.EncryptionKey,
 		Permissions:   invite.Permissions,
@@ -343,13 +345,13 @@ func (st *ACLState) applyUserJoin(ch *aclrecordproto.ACLUserJoin) error {
 	return nil
 }
 
-func (st *ACLState) applyUserAdd(ch *aclrecordproto.ACLUserAdd) error {
+func (st *ACLState) applyUserAdd(ch *aclrecordproto2.ACLUserAdd) error {
 	chIdentity := string(ch.Identity)
 	if _, exists := st.userStates[chIdentity]; exists {
 		return ErrUserAlreadyExists
 	}
 
-	st.userStates[chIdentity] = &aclrecordproto.ACLUserState{
+	st.userStates[chIdentity] = &aclrecordproto2.ACLUserState{
 		Identity:      ch.Identity,
 		EncryptionKey: ch.EncryptionKey,
 		Permissions:   ch.Permissions,
@@ -369,7 +371,7 @@ func (st *ACLState) applyUserAdd(ch *aclrecordproto.ACLUserAdd) error {
 	return nil
 }
 
-func (st *ACLState) applyUserRemove(ch *aclrecordproto.ACLUserRemove) error {
+func (st *ACLState) applyUserRemove(ch *aclrecordproto2.ACLUserRemove) error {
 	chIdentity := string(ch.Identity)
 	if chIdentity == st.identity {
 		return ErrDocumentForbidden
@@ -413,7 +415,7 @@ func (st *ACLState) decryptReadKeyAndHash(msg []byte) (*symmetric.Key, uint64, e
 	return key, hasher.Sum64(), nil
 }
 
-func (st *ACLState) HasPermission(identity []byte, permission aclrecordproto.ACLUserPermissions) bool {
+func (st *ACLState) HasPermission(identity []byte, permission aclrecordproto2.ACLUserPermissions) bool {
 	state, exists := st.userStates[string(identity)]
 	if !exists {
 		return false
@@ -422,22 +424,22 @@ func (st *ACLState) HasPermission(identity []byte, permission aclrecordproto.ACL
 	return state.Permissions == permission
 }
 
-func (st *ACLState) isUserJoin(data *aclrecordproto.ACLData) bool {
+func (st *ACLState) isUserJoin(data *aclrecordproto2.ACLData) bool {
 	// if we have a UserJoin, then it should always be the first one applied
 	return data.GetAclContent() != nil && data.GetAclContent()[0].GetUserJoin() != nil
 }
 
-func (st *ACLState) isUserAdd(data *aclrecordproto.ACLData, identity []byte) bool {
+func (st *ACLState) isUserAdd(data *aclrecordproto2.ACLData, identity []byte) bool {
 	// if we have a UserAdd, then it should always be the first one applied
 	userAdd := data.GetAclContent()[0].GetUserAdd()
 	return data.GetAclContent() != nil && userAdd != nil && bytes.Compare(userAdd.GetIdentity(), identity) == 0
 }
 
-func (st *ACLState) UserStates() map[string]*aclrecordproto.ACLUserState {
+func (st *ACLState) UserStates() map[string]*aclrecordproto2.ACLUserState {
 	return st.userStates
 }
 
-func (st *ACLState) Invite(acceptPubKey []byte) (invite *aclrecordproto.ACLUserInvite, err error) {
+func (st *ACLState) Invite(acceptPubKey []byte) (invite *aclrecordproto2.ACLUserInvite, err error) {
 	invite, exists := st.userInvites[string(acceptPubKey)]
 	if !exists {
 		err = ErrNoSuchInvite

common/commonspace/object/acl/list/aclstatebuilder.go

@@ -1,7 +1,7 @@
 package list
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
 )
@@ -12,7 +12,7 @@ type aclStateBuilder struct {
 	id          string
 }
 
-func newACLStateBuilderWithIdentity(accountData *account.AccountData) *aclStateBuilder {
+func newACLStateBuilderWithIdentity(accountData *accountdata.AccountData) *aclStateBuilder {
 	return &aclStateBuilder{
 		signPrivKey: accountData.SignKey,
 		encPrivKey:  accountData.EncKey,

common/commonspace/object/acl/list/list.go

@@ -1,23 +1,20 @@
-//go:generate mockgen -destination mock_list/mock_list.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list ACLList
+//go:generate mockgen -destination mock_list/mock_list.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list ACLList
 package list
 
 import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
 	"sync"
 )
 
 type IterFunc = func(record *ACLRecord) (IsContinue bool)
 
-var (
+var ErrIncorrectCID = errors.New("incorrect CID")
-	ErrIncorrectCID = errors.New("incorrect CID")
-	ErrInconsistent = errors.New("inconsistent record")
-)
 
 type RWLocker interface {
 	sync.Locker
@@ -28,7 +25,7 @@ type RWLocker interface {
 type ACLList interface {
 	RWLocker
 	ID() string
-	Root() *aclrecordproto.ACLRoot
+	Root() *aclrecordproto.RawACLRecordWithId
 	Records() []*ACLRecord
 	ACLState() *ACLState
 	IsAfter(first string, second string) (bool, error)
@@ -43,39 +40,30 @@ type ACLList interface {
 }
 
 type aclList struct {
-	root    *aclrecordproto.ACLRoot
+	root    *aclrecordproto.RawACLRecordWithId
 	records []*ACLRecord
 	indexes map[string]int
 	id      string
 
-	recBuilder ACLRecordBuilder
+	stateBuilder  *aclStateBuilder
-	builder    *aclStateBuilder
+	recordBuilder ACLRecordBuilder
-	aclState   *ACLState
+	aclState      *ACLState
-	keychain   *common.Keychain
+	keychain      *keychain.Keychain
+	storage       liststorage.ListStorage
 
 	sync.RWMutex
 }
 
-func BuildACLListWithIdentity(acc *account.AccountData, storage storage.ListStorage) (ACLList, error) {
+func BuildACLListWithIdentity(acc *accountdata.AccountData, storage liststorage.ListStorage) (ACLList, error) {
 	builder := newACLStateBuilderWithIdentity(acc)
-	return build(storage.Id(), builder, newACLRecordBuilder(storage.Id(), common.NewKeychain()), storage)
+	return build(storage.Id(), builder, newACLRecordBuilder(storage.Id(), keychain.NewKeychain()), storage)
 }
 
-func BuildACLList(storage storage.ListStorage) (ACLList, error) {
+func BuildACLList(storage liststorage.ListStorage) (ACLList, error) {
-	return build(storage.Id(), newACLStateBuilder(), newACLRecordBuilder(storage.Id(), common.NewKeychain()), storage)
+	return build(storage.Id(), newACLStateBuilder(), newACLRecordBuilder(storage.Id(), keychain.NewKeychain()), storage)
 }
 
-func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder, storage storage.ListStorage) (list ACLList, err error) {
+func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder, storage liststorage.ListStorage) (list ACLList, err error) {
-	// TODO: need to add context here
-	rootWithId, err := storage.Root()
-	if err != nil {
-		return
-	}
-	aclRecRoot, err := recBuilder.ConvertFromRaw(rootWithId)
-	if err != nil {
-		return
-	}
-
 	head, err := storage.Head()
 	if err != nil {
 		return
@@ -92,7 +80,7 @@ func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder
 	}
 	records := []*ACLRecord{record}
 
-	for record.PrevId != "" && record.PrevId != id {
+	for record.PrevId != "" {
 		rawRecordWithId, err = storage.GetRawRecord(context.Background(), record.PrevId)
 		if err != nil {
 			return
@@ -104,8 +92,6 @@ func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder
 		}
 		records = append(records, record)
 	}
-	// adding root in the end, because we already parsed it
-	records = append(records, aclRecRoot)
 
 	indexes := make(map[string]int)
 	for i, j := 0, len(records)-1; i < j; i, j = i+1, j-1 {
@@ -124,14 +110,21 @@ func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder
 		return
 	}
 
+	// TODO: check if this is correct (raw model instead of unmarshalled)
+	rootWithId, err := storage.Root()
+	if err != nil {
+		return
+	}
+
 	list = &aclList{
-		root:       aclRecRoot.Model.(*aclrecordproto.ACLRoot),
+		root:          rootWithId,
-		records:    records,
+		records:       records,
-		indexes:    indexes,
+		indexes:       indexes,
-		builder:    stateBuilder,
+		stateBuilder:  stateBuilder,
-		recBuilder: recBuilder,
+		recordBuilder: recBuilder,
-		aclState:   state,
+		aclState:      state,
-		id:         id,
+		storage:       storage,
+		id:            id,
 	}
 	return
 }
@@ -144,34 +137,30 @@ func (a *aclList) AddRawRecord(rawRec *aclrecordproto.RawACLRecordWithId) (added
 	if _, ok := a.indexes[rawRec.Id]; ok {
 		return
 	}
-	record, err := a.recBuilder.ConvertFromRaw(rawRec)
+	record, err := a.recordBuilder.ConvertFromRaw(rawRec)
 	if err != nil {
 		return
 	}
-	var lastId string
+	if err = a.aclState.applyRecord(record); err != nil {
-	if len(a.records) > 0 {
+		return
-		lastId = a.records[len(a.records)-1].Id
-	}
-	if record.PrevId != lastId {
-		return false, ErrInconsistent
 	}
 	a.records = append(a.records, record)
 	a.indexes[record.Id] = len(a.records) - 1
+	if err = a.storage.AddRawRecord(context.Background(), rawRec); err != nil {
+		return
+	}
+	if err = a.storage.SetHead(rawRec.Id); err != nil {
+		return
+	}
 	return true, nil
 }
 
 func (a *aclList) IsValidNext(rawRec *aclrecordproto.RawACLRecordWithId) (err error) {
-	rec, err := a.recBuilder.ConvertFromRaw(rawRec)
+	_, err = a.recordBuilder.ConvertFromRaw(rawRec)
 	if err != nil {
 		return
 	}
-	var lastId string
+	// TODO: change state and add "check" method for records
-	if len(a.records) > 0 {
-		lastId = a.records[len(a.records)-1].Id
-	}
-	if rec.PrevId != lastId {
-		return ErrInconsistent
-	}
 	return
 }
 
@@ -179,7 +168,7 @@ func (a *aclList) ID() string {
 	return a.id
 }
 
-func (a *aclList) Root() *aclrecordproto.ACLRoot {
+func (a *aclList) Root() *aclrecordproto.RawACLRecordWithId {
 	return a.root
 }
 

common/commonspace/object/acl/list/list_test.go

@@ -1,8 +1,8 @@
 package list
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/acllistbuilder"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/testutils/acllistbuilder"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"testing"

common/commonspace/object/acl/list/mock_list/mock_list.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list (interfaces: ACLList)
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list (interfaces: ACLList)
 
 // Package mock_list is a generated GoMock package.
 package mock_list
@@ -7,8 +7,8 @@ package mock_list
 import (
 	reflect "reflect"
 
-	aclrecordproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	aclrecordproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	list "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
+	list "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
 	gomock "github.com/golang/mock/gomock"
 )
 

common/commonspace/object/acl/liststorage/inmemory.go

@@ -0,0 +1,78 @@
+package liststorage
+
+import (
+	"context"
+	"fmt"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
+	"sync"
+)
+
+type inMemoryACLListStorage struct {
+	id      string
+	root    *aclrecordproto.RawACLRecordWithId
+	head    string
+	records map[string]*aclrecordproto.RawACLRecordWithId
+
+	sync.RWMutex
+}
+
+func NewInMemoryACLListStorage(
+	id string,
+	records []*aclrecordproto.RawACLRecordWithId) (ListStorage, error) {
+
+	allRecords := make(map[string]*aclrecordproto.RawACLRecordWithId)
+	for _, ch := range records {
+		allRecords[ch.Id] = ch
+	}
+	root := records[0]
+	head := records[len(records)-1]
+
+	return &inMemoryACLListStorage{
+		id:      root.Id,
+		root:    root,
+		head:    head.Id,
+		records: allRecords,
+	}, nil
+}
+
+func (t *inMemoryACLListStorage) Id() string {
+	t.RLock()
+	defer t.RUnlock()
+	return t.id
+}
+
+func (t *inMemoryACLListStorage) Root() (*aclrecordproto.RawACLRecordWithId, error) {
+	t.RLock()
+	defer t.RUnlock()
+	return t.root, nil
+}
+
+func (t *inMemoryACLListStorage) Head() (string, error) {
+	t.RLock()
+	defer t.RUnlock()
+	return t.head, nil
+}
+
+func (t *inMemoryACLListStorage) SetHead(head string) error {
+	t.Lock()
+	defer t.Unlock()
+	t.head = head
+	return nil
+}
+
+func (t *inMemoryACLListStorage) AddRawRecord(ctx context.Context, record *aclrecordproto.RawACLRecordWithId) error {
+	t.Lock()
+	defer t.Unlock()
+	// TODO: better to do deep copy
+	t.records[record.Id] = record
+	return nil
+}
+
+func (t *inMemoryACLListStorage) GetRawRecord(ctx context.Context, recordId string) (*aclrecordproto.RawACLRecordWithId, error) {
+	t.RLock()
+	defer t.RUnlock()
+	if res, exists := t.records[recordId]; exists {
+		return res, nil
+	}
+	return nil, fmt.Errorf("could not get record with id: %s", recordId)
+}

common/commonspace/object/acl/liststorage/liststorage.go

@@ -1,15 +1,17 @@
-//go:generate mockgen -destination mock_storage/mock_storage.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage ListStorage,TreeStorage
+//go:generate mockgen -destination mock_liststorage/mock_liststorage.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage ListStorage
-package storage
+package liststorage
 
 import (
 	"context"
 	"errors"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
 )
 
-var ErrUnknownACLId = errors.New("acl does not exist")
+var (
-var ErrACLExists = errors.New("acl already exists")
+	ErrUnknownACLId  = errors.New("acl does not exist")
-var ErrUnknownRecord = errors.New("record doesn't exist")
+	ErrACLExists     = errors.New("acl already exists")
+	ErrUnknownRecord = errors.New("record doesn't exist")
+)
 
 type ListStorage interface {
 	Id() string

common/commonspace/object/acl/liststorage/mock_liststorage/mock_liststorage.go

@@ -0,0 +1,123 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage (interfaces: ListStorage)
+
+// Package mock_liststorage is a generated GoMock package.
+package mock_liststorage
+
+import (
+	context "context"
+	reflect "reflect"
+
+	aclrecordproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockListStorage is a mock of ListStorage interface.
+type MockListStorage struct {
+	ctrl     *gomock.Controller
+	recorder *MockListStorageMockRecorder
+}
+
+// MockListStorageMockRecorder is the mock recorder for MockListStorage.
+type MockListStorageMockRecorder struct {
+	mock *MockListStorage
+}
+
+// NewMockListStorage creates a new mock instance.
+func NewMockListStorage(ctrl *gomock.Controller) *MockListStorage {
+	mock := &MockListStorage{ctrl: ctrl}
+	mock.recorder = &MockListStorageMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockListStorage) EXPECT() *MockListStorageMockRecorder {
+	return m.recorder
+}
+
+// AddRawRecord mocks base method.
+func (m *MockListStorage) AddRawRecord(arg0 context.Context, arg1 *aclrecordproto.RawACLRecordWithId) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddRawRecord", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddRawRecord indicates an expected call of AddRawRecord.
+func (mr *MockListStorageMockRecorder) AddRawRecord(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockListStorage)(nil).AddRawRecord), arg0, arg1)
+}
+
+// GetRawRecord mocks base method.
+func (m *MockListStorage) GetRawRecord(arg0 context.Context, arg1 string) (*aclrecordproto.RawACLRecordWithId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetRawRecord", arg0, arg1)
+	ret0, _ := ret[0].(*aclrecordproto.RawACLRecordWithId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetRawRecord indicates an expected call of GetRawRecord.
+func (mr *MockListStorageMockRecorder) GetRawRecord(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawRecord", reflect.TypeOf((*MockListStorage)(nil).GetRawRecord), arg0, arg1)
+}
+
+// Head mocks base method.
+func (m *MockListStorage) Head() (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Head")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Head indicates an expected call of Head.
+func (mr *MockListStorageMockRecorder) Head() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockListStorage)(nil).Head))
+}
+
+// Id mocks base method.
+func (m *MockListStorage) Id() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Id")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Id indicates an expected call of Id.
+func (mr *MockListStorageMockRecorder) Id() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockListStorage)(nil).Id))
+}
+
+// Root mocks base method.
+func (m *MockListStorage) Root() (*aclrecordproto.RawACLRecordWithId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Root")
+	ret0, _ := ret[0].(*aclrecordproto.RawACLRecordWithId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Root indicates an expected call of Root.
+func (mr *MockListStorageMockRecorder) Root() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockListStorage)(nil).Root))
+}
+
+// SetHead mocks base method.
+func (m *MockListStorage) SetHead(arg0 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetHead", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SetHead indicates an expected call of SetHead.
+func (mr *MockListStorageMockRecorder) SetHead(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockListStorage)(nil).SetHead), arg0)
+}

common/commonspace/object/acl/syncacl/syncacl.go

@@ -1,18 +1,18 @@
 package syncacl
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice/synchandler"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync/synchandler"
 )
 
 type SyncACL struct {
 	list.ACLList
 	synchandler.SyncHandler
-	streamPool syncservice.StreamPool
+	streamPool objectsync.StreamPool
 }
 
-func NewSyncACL(aclList list.ACLList, streamPool syncservice.StreamPool) *SyncACL {
+func NewSyncACL(aclList list.ACLList, streamPool objectsync.StreamPool) *SyncACL {
 	return &SyncACL{
 		ACLList:     aclList,
 		SyncHandler: nil,

common/commonspace/object/acl/syncacl/syncaclhandler.go

@@ -3,9 +3,9 @@ package syncacl
 import (
 	"context"
 	"fmt"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
 )
 
 type syncAclHandler struct {

common/commonspace/object/acl/testutils/acllistbuilder/keychain.go

@@ -1,10 +1,10 @@
 package acllistbuilder
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys"
-	encryptionkey2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
-	signingkey2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
 	"hash/fnv"
 	"strings"
@@ -16,9 +16,9 @@ type SymKey struct {
 }
 
 type YAMLKeychain struct {
-	SigningKeysByYAMLName     map[string]signingkey2.PrivKey
+	SigningKeysByYAMLName     map[string]signingkey.PrivKey
-	SigningKeysByRealIdentity map[string]signingkey2.PrivKey
+	SigningKeysByRealIdentity map[string]signingkey.PrivKey
-	EncryptionKeysByYAMLName  map[string]encryptionkey2.PrivKey
+	EncryptionKeysByYAMLName  map[string]encryptionkey.PrivKey
 	ReadKeysByYAMLName        map[string]*SymKey
 	ReadKeysByHash            map[uint64]*SymKey
 	GeneratedIdentities       map[string]string
@@ -26,9 +26,9 @@ type YAMLKeychain struct {
 
 func NewKeychain() *YAMLKeychain {
 	return &YAMLKeychain{
-		SigningKeysByYAMLName:     map[string]signingkey2.PrivKey{},
+		SigningKeysByYAMLName:     map[string]signingkey.PrivKey{},
-		SigningKeysByRealIdentity: map[string]signingkey2.PrivKey{},
+		SigningKeysByRealIdentity: map[string]signingkey.PrivKey{},
-		EncryptionKeysByYAMLName:  map[string]encryptionkey2.PrivKey{},
+		EncryptionKeysByYAMLName:  map[string]encryptionkey.PrivKey{},
 		GeneratedIdentities:       map[string]string{},
 		ReadKeysByYAMLName:        map[string]*SymKey{},
 		ReadKeysByHash:            map[uint64]*SymKey{},
@@ -54,16 +54,16 @@ func (k *YAMLKeychain) AddEncryptionKey(key *Key) {
 		return
 	}
 	var (
-		newPrivKey encryptionkey2.PrivKey
+		newPrivKey encryptionkey.PrivKey
 		err        error
 	)
 	if key.Value == "generated" {
-		newPrivKey, _, err = encryptionkey2.GenerateRandomRSAKeyPair(2048)
+		newPrivKey, _, err = encryptionkey.GenerateRandomRSAKeyPair(2048)
 		if err != nil {
 			panic(err)
 		}
 	} else {
-		newPrivKey, err = keys.DecodeKeyFromString(key.Value, encryptionkey2.NewEncryptionRsaPrivKeyFromBytes, nil)
+		newPrivKey, err = keys.DecodeKeyFromString(key.Value, encryptionkey.NewEncryptionRsaPrivKeyFromBytes, nil)
 		if err != nil {
 			panic(err)
 		}
@@ -76,17 +76,17 @@ func (k *YAMLKeychain) AddSigningKey(key *Key) {
 		return
 	}
 	var (
-		newPrivKey signingkey2.PrivKey
+		newPrivKey signingkey.PrivKey
-		pubKey     signingkey2.PubKey
+		pubKey     signingkey.PubKey
 		err        error
 	)
 	if key.Value == "generated" {
-		newPrivKey, pubKey, err = signingkey2.GenerateRandomEd25519KeyPair()
+		newPrivKey, pubKey, err = signingkey.GenerateRandomEd25519KeyPair()
 		if err != nil {
 			panic(err)
 		}
 	} else {
-		newPrivKey, err = keys.DecodeKeyFromString(key.Value, signingkey2.NewSigningEd25519PrivKeyFromBytes, nil)
+		newPrivKey, err = keys.DecodeKeyFromString(key.Value, signingkey.NewSigningEd25519PrivKeyFromBytes, nil)
 		if err != nil {
 			panic(err)
 		}

common/commonspace/object/acl/testutils/acllistbuilder/liststoragebuilder.go

@@ -3,13 +3,13 @@ package acllistbuilder
 import (
 	"context"
 	"fmt"
-	aclrecordproto2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/yamltests"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/testutils/yamltests"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cid"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cidutil"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
-	"hash/fnv"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
 	"io/ioutil"
 	"path"
 	"time"
@@ -19,25 +19,17 @@ import (
 )
 
 type ACLListStorageBuilder struct {
-	aclList    string
+	liststorage.ListStorage
-	records    []*aclrecordproto2.ACLRecord
+	keychain *YAMLKeychain
-	rawRecords []*aclrecordproto2.RawACLRecordWithId
-	indexes    map[string]int
-	keychain   *YAMLKeychain
-	rawRoot    *aclrecordproto2.RawACLRecordWithId
-	root       *aclrecordproto2.ACLRoot
-	id         string
 }
 
 func NewACLListStorageBuilder(keychain *YAMLKeychain) *ACLListStorageBuilder {
 	return &ACLListStorageBuilder{
-		records:  make([]*aclrecordproto2.ACLRecord, 0),
-		indexes:  make(map[string]int),
 		keychain: keychain,
 	}
 }
 
-func NewListStorageWithTestName(name string) (storage.ListStorage, error) {
+func NewListStorageWithTestName(name string) (liststorage.ListStorage, error) {
 	filePath := path.Join(yamltests.Path(), name)
 	return NewACLListStorageBuilderFromFile(filePath)
 }
@@ -60,7 +52,7 @@ func NewACLListStorageBuilderFromFile(file string) (*ACLListStorageBuilder, erro
 	return tb, nil
 }
 
-func (t *ACLListStorageBuilder) createRaw(rec proto.Marshaler, identity []byte) *aclrecordproto2.RawACLRecordWithId {
+func (t *ACLListStorageBuilder) createRaw(rec proto.Marshaler, identity []byte) *aclrecordproto.RawACLRecordWithId {
 	protoMarshalled, err := rec.Marshal()
 	if err != nil {
 		panic("should be able to marshal final acl message!")
@@ -71,7 +63,7 @@ func (t *ACLListStorageBuilder) createRaw(rec proto.Marshaler, identity []byte)
 		panic("should be able to sign final acl message!")
 	}
 
-	rawRec := &aclrecordproto2.RawACLRecord{
+	rawRec := &aclrecordproto.RawACLRecord{
 		Payload:   protoMarshalled,
 		Signature: signature,
 	}
@@ -81,96 +73,64 @@ func (t *ACLListStorageBuilder) createRaw(rec proto.Marshaler, identity []byte)
 		panic(err)
 	}
 
-	id, _ := cid.NewCIDFromBytes(rawMarshalled)
+	id, _ := cidutil.NewCIDFromBytes(rawMarshalled)
 
-	return &aclrecordproto2.RawACLRecordWithId{
+	return &aclrecordproto.RawACLRecordWithId{
 		Payload: rawMarshalled,
 		Id:      id,
 	}
 }
 
-func (t *ACLListStorageBuilder) Head() (string, error) {
-	l := len(t.records)
-	if l > 0 {
-		return t.rawRecords[l-1].Id, nil
-	}
-	return t.rawRoot.Id, nil
-}
-
-func (t *ACLListStorageBuilder) SetHead(headId string) error {
-	panic("SetHead is not implemented")
-}
-
-func (t *ACLListStorageBuilder) Root() (*aclrecordproto2.RawACLRecordWithId, error) {
-	return t.rawRoot, nil
-}
-
-func (t *ACLListStorageBuilder) GetRawRecord(ctx context.Context, id string) (*aclrecordproto2.RawACLRecordWithId, error) {
-	recIdx, ok := t.indexes[id]
-	if !ok {
-		if id == t.rawRoot.Id {
-			return t.rawRoot, nil
-		}
-		return nil, fmt.Errorf("no such record")
-	}
-	return t.rawRecords[recIdx], nil
-}
-
-func (t *ACLListStorageBuilder) AddRawRecord(ctx context.Context, rec *aclrecordproto2.RawACLRecordWithId) error {
-	panic("implement me")
-}
-
-func (t *ACLListStorageBuilder) Id() string {
-	return t.id
-}
-
-func (t *ACLListStorageBuilder) GetRawRecords() []*aclrecordproto2.RawACLRecordWithId {
-	return t.rawRecords
-}
-
 func (t *ACLListStorageBuilder) GetKeychain() *YAMLKeychain {
 	return t.keychain
 }
 
-func (t *ACLListStorageBuilder) Parse(tree *YMLList) {
+func (t *ACLListStorageBuilder) Parse(l *YMLList) {
 	// Just to clarify - we are generating new identities for the ones that
 	// are specified in the yml file, because our identities should be Ed25519
 	// the same thing is happening for the encryption keys
-	t.keychain.ParseKeys(&tree.Keys)
+	t.keychain.ParseKeys(&l.Keys)
-	t.parseRoot(tree.Root)
+	rawRoot := t.parseRoot(l.Root)
-	prevId := t.id
+	var err error
-	for idx, rec := range tree.Records {
+	t.ListStorage, err = liststorage.NewInMemoryACLListStorage(rawRoot.Id, []*aclrecordproto.RawACLRecordWithId{rawRoot})
+	if err != nil {
+		panic(err)
+	}
+	prevId := rawRoot.Id
+	for _, rec := range l.Records {
 		newRecord := t.parseRecord(rec, prevId)
 		rawRecord := t.createRaw(newRecord, newRecord.Identity)
-		t.records = append(t.records, newRecord)
+		err = t.AddRawRecord(context.Background(), rawRecord)
-		t.rawRecords = append(t.rawRecords, rawRecord)
+		if err != nil {
-		t.indexes[rawRecord.Id] = idx
+			panic(err)
+		}
 		prevId = rawRecord.Id
 	}
+	t.SetHead(prevId)
 }
 
-func (t *ACLListStorageBuilder) parseRecord(rec *Record, prevId string) *aclrecordproto2.ACLRecord {
+func (t *ACLListStorageBuilder) parseRecord(rec *Record, prevId string) *aclrecordproto.ACLRecord {
 	k := t.keychain.GetKey(rec.ReadKey).(*SymKey)
-	var aclChangeContents []*aclrecordproto2.ACLContentValue
+	var aclChangeContents []*aclrecordproto.ACLContentValue
 	for _, ch := range rec.AclChanges {
 		aclChangeContent := t.parseACLChange(ch)
 		aclChangeContents = append(aclChangeContents, aclChangeContent)
 	}
-	data := &aclrecordproto2.ACLData{
+	data := &aclrecordproto.ACLData{
 		AclContent: aclChangeContents,
 	}
 	bytes, _ := data.Marshal()
 
-	return &aclrecordproto2.ACLRecord{
+	return &aclrecordproto.ACLRecord{
 		PrevId:             prevId,
 		Identity:           []byte(t.keychain.GetIdentity(rec.Identity)),
 		Data:               bytes,
 		CurrentReadKeyHash: k.Hash,
-		Timestamp:          time.Now().Unix(),
+		Timestamp:          time.Now().UnixNano(),
 	}
 }
 
-func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecordproto2.ACLContentValue) {
+func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecordproto.ACLContentValue) {
 	switch {
 	case ch.UserAdd != nil:
 		add := ch.UserAdd
@@ -178,12 +138,12 @@ func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecord
 		encKey := t.keychain.GetKey(add.EncryptionKey).(encryptionkey.PrivKey)
 		rawKey, _ := encKey.GetPublic().Raw()
 
-		convCh = &aclrecordproto2.ACLContentValue{
+		convCh = &aclrecordproto.ACLContentValue{
-			Value: &aclrecordproto2.ACLContentValue_UserAdd{
+			Value: &aclrecordproto.ACLContentValue_UserAdd{
-				UserAdd: &aclrecordproto2.ACLUserAdd{
+				UserAdd: &aclrecordproto.ACLUserAdd{
 					Identity:          []byte(t.keychain.GetIdentity(add.Identity)),
 					EncryptionKey:     rawKey,
-					EncryptedReadKeys: t.encryptReadKeys(add.EncryptedReadKeys, encKey),
+					EncryptedReadKeys: t.encryptReadKeysWithPubKey(add.EncryptedReadKeys, encKey),
 					Permissions:       t.convertPermission(add.Permission),
 				},
 			},
@@ -191,52 +151,50 @@ func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecord
 	case ch.UserJoin != nil:
 		join := ch.UserJoin
 
-		encKey := t.keychain.
+		encKey := t.keychain.GetKey(join.EncryptionKey).(encryptionkey.PrivKey)
-			GetKey(join.EncryptionKey).(encryptionkey.PrivKey)
 		rawKey, _ := encKey.GetPublic().Raw()
 
-		idKey, _ := t.keychain.SigningKeysByYAMLIdentity[join.Identity].GetPublic().Raw()
+		idKey, _ := t.keychain.SigningKeysByYAMLName[join.Identity].GetPublic().Raw()
-		signKey := t.keychain.GetKey(join.AcceptSignature).(signingkey.PrivKey)
+		signKey := t.keychain.GetKey(join.AcceptKey).(signingkey.PrivKey)
 		signature, err := signKey.Sign(idKey)
 		if err != nil {
 			panic(err)
 		}
+		acceptPubKey, _ := signKey.GetPublic().Raw()
 
-		convCh = &aclrecordproto2.ACLContentValue{
+		convCh = &aclrecordproto.ACLContentValue{
-			Value: &aclrecordproto2.ACLContentValue_UserJoin{
+			Value: &aclrecordproto.ACLContentValue_UserJoin{
-				UserJoin: &aclrecordproto2.ACLUserJoin{
+				UserJoin: &aclrecordproto.ACLUserJoin{
 					Identity:          []byte(t.keychain.GetIdentity(join.Identity)),
 					EncryptionKey:     rawKey,
 					AcceptSignature:   signature,
-					InviteId:          join.InviteId,
+					AcceptPubKey:      acceptPubKey,
-					EncryptedReadKeys: t.encryptReadKeys(join.EncryptedReadKeys, encKey),
+					EncryptedReadKeys: t.encryptReadKeysWithPubKey(join.EncryptedReadKeys, encKey),
 				},
 			},
 		}
 	case ch.UserInvite != nil:
 		invite := ch.UserInvite
 		rawAcceptKey, _ := t.keychain.GetKey(invite.AcceptKey).(signingkey.PrivKey).GetPublic().Raw()
-		encKey := t.keychain.
+		hash := t.keychain.GetKey(invite.EncryptionKey).(*SymKey).Hash
-			GetKey(invite.EncryptionKey).(encryptionkey.PrivKey)
+		encKey := t.keychain.ReadKeysByHash[hash]
-		rawEncKey, _ := encKey.GetPublic().Raw()
 
-		convCh = &aclrecordproto2.ACLContentValue{
+		convCh = &aclrecordproto.ACLContentValue{
-			Value: &aclrecordproto2.ACLContentValue_UserInvite{
+			Value: &aclrecordproto.ACLContentValue_UserInvite{
-				UserInvite: &aclrecordproto2.ACLUserInvite{
+				UserInvite: &aclrecordproto.ACLUserInvite{
 					AcceptPublicKey:   rawAcceptKey,
-					EncryptPublicKey:  rawEncKey,
+					EncryptSymKeyHash: hash,
-					EncryptedReadKeys: t.encryptReadKeys(invite.EncryptedReadKeys, encKey),
+					EncryptedReadKeys: t.encryptReadKeysWithSymKey(invite.EncryptedReadKeys, encKey.Key),
 					Permissions:       t.convertPermission(invite.Permissions),
-					InviteId:          invite.InviteId,
 				},
 			},
 		}
 	case ch.UserPermissionChange != nil:
 		permissionChange := ch.UserPermissionChange
 
-		convCh = &aclrecordproto2.ACLContentValue{
+		convCh = &aclrecordproto.ACLContentValue{
-			Value: &aclrecordproto2.ACLContentValue_UserPermissionChange{
+			Value: &aclrecordproto.ACLContentValue_UserPermissionChange{
-				UserPermissionChange: &aclrecordproto2.ACLUserPermissionChange{
+				UserPermissionChange: &aclrecordproto.ACLUserPermissionChange{
 					Identity:    []byte(t.keychain.GetIdentity(permissionChange.Identity)),
 					Permissions: t.convertPermission(permissionChange.Permission),
 				},
@@ -247,24 +205,24 @@ func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecord
 
 		newReadKey := t.keychain.GetKey(remove.NewReadKey).(*SymKey)
 
-		var replaces []*aclrecordproto2.ACLReadKeyReplace
+		var replaces []*aclrecordproto.ACLReadKeyReplace
 		for _, id := range remove.IdentitiesLeft {
-			encKey := t.keychain.EncryptionKeysByYAMLIdentity[id]
+			encKey := t.keychain.EncryptionKeysByYAMLName[id]
 			rawEncKey, _ := encKey.GetPublic().Raw()
 			encReadKey, err := encKey.GetPublic().Encrypt(newReadKey.Key.Bytes())
 			if err != nil {
 				panic(err)
 			}
-			replaces = append(replaces, &aclrecordproto2.ACLReadKeyReplace{
+			replaces = append(replaces, &aclrecordproto.ACLReadKeyReplace{
 				Identity:         []byte(t.keychain.GetIdentity(id)),
 				EncryptionKey:    rawEncKey,
 				EncryptedReadKey: encReadKey,
 			})
 		}
 
-		convCh = &aclrecordproto2.ACLContentValue{
+		convCh = &aclrecordproto.ACLContentValue{
-			Value: &aclrecordproto2.ACLContentValue_UserRemove{
+			Value: &aclrecordproto.ACLContentValue_UserRemove{
-				UserRemove: &aclrecordproto2.ACLUserRemove{
+				UserRemove: &aclrecordproto.ACLUserRemove{
 					Identity:        []byte(t.keychain.GetIdentity(remove.RemovedIdentity)),
 					ReadKeyReplaces: replaces,
 				},
@@ -278,7 +236,7 @@ func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecord
 	return convCh
 }
 
-func (t *ACLListStorageBuilder) encryptReadKeys(keys []string, encKey encryptionkey.PrivKey) (enc [][]byte) {
+func (t *ACLListStorageBuilder) encryptReadKeysWithPubKey(keys []string, encKey encryptionkey.PrivKey) (enc [][]byte) {
 	for _, k := range keys {
 		realKey := t.keychain.GetKey(k).(*SymKey).Key.Bytes()
 		res, err := encKey.GetPublic().Encrypt(realKey)
@@ -291,43 +249,47 @@ func (t *ACLListStorageBuilder) encryptReadKeys(keys []string, encKey encryption
 	return
 }
 
-func (t *ACLListStorageBuilder) convertPermission(perm string) aclrecordproto2.ACLUserPermissions {
+func (t *ACLListStorageBuilder) encryptReadKeysWithSymKey(keys []string, key *symmetric.Key) (enc [][]byte) {
+	for _, k := range keys {
+		realKey := t.keychain.GetKey(k).(*SymKey).Key.Bytes()
+		res, err := key.Encrypt(realKey)
+		if err != nil {
+			panic(err)
+		}
+
+		enc = append(enc, res)
+	}
+	return
+}
+
+func (t *ACLListStorageBuilder) convertPermission(perm string) aclrecordproto.ACLUserPermissions {
 	switch perm {
 	case "admin":
-		return aclrecordproto2.ACLUserPermissions_Admin
+		return aclrecordproto.ACLUserPermissions_Admin
 	case "writer":
-		return aclrecordproto2.ACLUserPermissions_Writer
+		return aclrecordproto.ACLUserPermissions_Writer
 	case "reader":
-		return aclrecordproto2.ACLUserPermissions_Reader
+		return aclrecordproto.ACLUserPermissions_Reader
 	default:
 		panic(fmt.Sprintf("incorrect permission: %s", perm))
 	}
 }
 
-func (t *ACLListStorageBuilder) traverseFromHead(f func(rec *aclrecordproto2.ACLRecord, id string) error) (err error) {
+func (t *ACLListStorageBuilder) traverseFromHead(f func(rec *aclrecordproto.ACLRecord, id string) error) (err error) {
-	for i := len(t.records) - 1; i >= 0; i-- {
+	panic("this was removed, add if needed")
-		err = f(t.records[i], t.rawRecords[i].Id)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
 }
 
-func (t *ACLListStorageBuilder) parseRoot(root *Root) {
+func (t *ACLListStorageBuilder) parseRoot(root *Root) (rawRoot *aclrecordproto.RawACLRecordWithId) {
-	rawSignKey, _ := t.keychain.SigningKeysByYAMLIdentity[root.Identity].GetPublic().Raw()
+	rawSignKey, _ := t.keychain.SigningKeysByYAMLName[root.Identity].GetPublic().Raw()
-	rawEncKey, _ := t.keychain.EncryptionKeysByYAMLIdentity[root.Identity].GetPublic().Raw()
+	rawEncKey, _ := t.keychain.EncryptionKeysByYAMLName[root.Identity].GetPublic().Raw()
-	readKey, _ := aclrecordproto2.ACLReadKeyDerive(rawSignKey, rawEncKey)
+	readKey := t.keychain.ReadKeysByYAMLName[root.Identity]
-	hasher := fnv.New64()
+	aclRoot := &aclrecordproto.ACLRoot{
-	hasher.Write(readKey.Bytes())
-	t.root = &aclrecordproto2.ACLRoot{
 		Identity:           rawSignKey,
 		EncryptionKey:      rawEncKey,
 		SpaceId:            root.SpaceId,
 		EncryptedReadKey:   nil,
 		DerivationScheme:   "scheme",
-		CurrentReadKeyHash: hasher.Sum64(),
+		CurrentReadKeyHash: readKey.Hash,
 	}
-	t.rawRoot = t.createRaw(t.root, rawSignKey)
+	return t.createRaw(aclRoot, rawSignKey)
-	t.id = t.rawRoot.Id
 }

common/commonspace/object/acl/testutils/acllistbuilder/liststoragebuildergraph_nix.go

@@ -9,7 +9,7 @@ package acllistbuilder
 
 import (
 	"fmt"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
 	"github.com/gogo/protobuf/proto"
 	"strings"
 	"unicode"

common/commonspace/object/keychain/keychain.go

@@ -0,0 +1,28 @@
+package keychain
+
+import (
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
+)
+
+type Keychain struct {
+	keys map[string]signingkey.PubKey
+}
+
+func NewKeychain() *Keychain {
+	return &Keychain{
+		keys: make(map[string]signingkey.PubKey),
+	}
+}
+
+func (k *Keychain) GetOrAdd(identity string) (signingkey.PubKey, error) {
+	if key, exists := k.keys[identity]; exists {
+		return key, nil
+	}
+	res, err := signingkey.NewSigningEd25519PubKeyFromBytes([]byte(identity))
+	if err != nil {
+		return nil, err
+	}
+
+	k.keys[identity] = res.(signingkey.PubKey)
+	return res.(signingkey.PubKey), nil
+}

common/commonspace/object/syncobjectgetter/syncobjectgetter.go

@@ -0,0 +1,14 @@
+package syncobjectgetter
+
+import (
+	"context"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync/synchandler"
+)
+
+type SyncObject interface {
+	synchandler.SyncHandler
+}
+
+type SyncObjectGetter interface {
+	GetObject(ctx context.Context, objectId string) (SyncObject, error)
+}

common/commonspace/object/tree/objecttree/change.go

@@ -1,8 +1,8 @@
-package tree
+package objecttree
 
 import (
 	"errors"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
 )
 
 var (

common/commonspace/object/tree/objecttree/changebuilder.go

@@ -1,10 +1,10 @@
-package tree
+package objecttree
 
 import (
 	"errors"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cid"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cidutil"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
 	"github.com/gogo/protobuf/proto"
@@ -45,10 +45,10 @@ type ChangeBuilder interface {
 
 type changeBuilder struct {
 	rootChange *treechangeproto.RawTreeChangeWithId
-	keys       *common.Keychain
+	keys       *keychain.Keychain
 }
 
-func NewChangeBuilder(keys *common.Keychain, rootChange *treechangeproto.RawTreeChangeWithId) ChangeBuilder {
+func NewChangeBuilder(keys *keychain.Keychain, rootChange *treechangeproto.RawTreeChangeWithId) ChangeBuilder {
 	return &changeBuilder{keys: keys, rootChange: rootChange}
 }
 
@@ -60,7 +60,7 @@ func (c *changeBuilder) ConvertFromRaw(rawIdChange *treechangeproto.RawTreeChang
 
 	if verify {
 		// verifying ID
-		if !cid.VerifyCID(rawIdChange.RawChange, rawIdChange.Id) {
+		if !cidutil.VerifyCID(rawIdChange.RawChange, rawIdChange.Id) {
 			err = ErrIncorrectCID
 			return
 		}
@@ -131,7 +131,7 @@ func (c *changeBuilder) BuildInitialContent(payload InitialContent) (ch *Change,
 		return
 	}
 
-	id, err := cid.NewCIDFromBytes(marshalledRawChange)
+	id, err := cidutil.NewCIDFromBytes(marshalledRawChange)
 	if err != nil {
 		return
 	}
@@ -186,7 +186,7 @@ func (c *changeBuilder) BuildContent(payload BuilderContent) (ch *Change, rawIdC
 		return
 	}
 
-	id, err := cid.NewCIDFromBytes(marshalledRawChange)
+	id, err := cidutil.NewCIDFromBytes(marshalledRawChange)
 	if err != nil {
 		return
 	}

common/commonspace/object/tree/objecttree/changevalidator.go

@@ -1,9 +1,9 @@
-package tree
+package objecttree
 
 import (
 	"fmt"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
 )
 
 type ObjectTreeValidator interface {

common/commonspace/object/tree/objecttree/descriptionparser.go

@@ -1,4 +1,4 @@
-package tree
+package objecttree
 
 type DescriptionParser interface {
 	ParseChange(*Change) ([]string, error)

common/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go

@@ -1,16 +1,16 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree (interfaces: ObjectTree)
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree (interfaces: ObjectTree)
 
-// Package mock_tree is a generated GoMock package.
+// Package mock_objecttree is a generated GoMock package.
-package mock_tree
+package mock_objecttree
 
 import (
 	context "context"
 	reflect "reflect"
 
-	storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	objecttree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
-	tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
+	treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -38,10 +38,10 @@ func (m *MockObjectTree) EXPECT() *MockObjectTreeMockRecorder {
 }
 
 // AddContent mocks base method.
-func (m *MockObjectTree) AddContent(arg0 context.Context, arg1 tree.SignableChangeContent) (tree.AddResult, error) {
+func (m *MockObjectTree) AddContent(arg0 context.Context, arg1 objecttree.SignableChangeContent) (objecttree.AddResult, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
-	ret0, _ := ret[0].(tree.AddResult)
+	ret0, _ := ret[0].(objecttree.AddResult)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -53,10 +53,10 @@ func (mr *MockObjectTreeMockRecorder) AddContent(arg0, arg1 interface{}) *gomock
 }
 
 // AddRawChanges mocks base method.
-func (m *MockObjectTree) AddRawChanges(arg0 context.Context, arg1 tree.RawChangesPayload) (tree.AddResult, error) {
+func (m *MockObjectTree) AddRawChanges(arg0 context.Context, arg1 objecttree.RawChangesPayload) (objecttree.AddResult, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddRawChanges", arg0, arg1)
-	ret0, _ := ret[0].(tree.AddResult)
+	ret0, _ := ret[0].(objecttree.AddResult)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -186,7 +186,7 @@ func (mr *MockObjectTreeMockRecorder) ID() *gomock.Call {
 }
 
 // Iterate mocks base method.
-func (m *MockObjectTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*tree.Change) bool) error {
+func (m *MockObjectTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*objecttree.Change) bool) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Iterate", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -200,7 +200,7 @@ func (mr *MockObjectTreeMockRecorder) Iterate(arg0, arg1 interface{}) *gomock.Ca
 }
 
 // IterateFrom mocks base method.
-func (m *MockObjectTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*tree.Change) bool) error {
+func (m *MockObjectTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*objecttree.Change) bool) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IterateFrom", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
@@ -250,10 +250,10 @@ func (mr *MockObjectTreeMockRecorder) RUnlock() *gomock.Call {
 }
 
 // Root mocks base method.
-func (m *MockObjectTree) Root() *tree.Change {
+func (m *MockObjectTree) Root() *objecttree.Change {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Root")
-	ret0, _ := ret[0].(*tree.Change)
+	ret0, _ := ret[0].(*objecttree.Change)
 	return ret0
 }
 
@@ -278,10 +278,10 @@ func (mr *MockObjectTreeMockRecorder) SnapshotPath() *gomock.Call {
 }
 
 // Storage mocks base method.
-func (m *MockObjectTree) Storage() storage.TreeStorage {
+func (m *MockObjectTree) Storage() treestorage.TreeStorage {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Storage")
-	ret0, _ := ret[0].(storage.TreeStorage)
+	ret0, _ := ret[0].(treestorage.TreeStorage)
 	return ret0
 }
 

common/commonspace/object/tree/objecttree/objecttree.go

@@ -1,14 +1,14 @@
-//go:generate mockgen -destination mock_objecttree/mock_objecttree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree ObjectTree
+//go:generate mockgen -destination mock_objecttree/mock_objecttree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree ObjectTree
-package tree
+package objecttree
 
 import (
 	"context"
 	"errors"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
+	list2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
-	list "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
 	"sync"
@@ -59,7 +59,7 @@ type ObjectTree interface {
 	SnapshotPath() []string
 	ChangesAfterCommonSnapshot(snapshotPath, heads []string) ([]*treechangeproto.RawTreeChangeWithId, error)
 
-	Storage() storage.TreeStorage
+	Storage() treestorage.TreeStorage
 
 	AddContent(ctx context.Context, content SignableChangeContent) (AddResult, error)
 	AddRawChanges(ctx context.Context, changes RawChangesPayload) (AddResult, error)
@@ -69,12 +69,12 @@ type ObjectTree interface {
 }
 
 type objectTree struct {
-	treeStorage     storage.TreeStorage
+	treeStorage     treestorage.TreeStorage
 	changeBuilder   ChangeBuilder
 	validator       ObjectTreeValidator
 	rawChangeLoader *rawChangeLoader
 	treeBuilder     *treeBuilder
-	aclList         list.ACLList
+	aclList         list2.ACLList
 
 	id   string
 	root *treechangeproto.RawTreeChangeWithId
@@ -96,18 +96,18 @@ type objectTree struct {
 type objectTreeDeps struct {
 	changeBuilder   ChangeBuilder
 	treeBuilder     *treeBuilder
-	treeStorage     storage.TreeStorage
+	treeStorage     treestorage.TreeStorage
 	validator       ObjectTreeValidator
 	rawChangeLoader *rawChangeLoader
-	aclList         list.ACLList
+	aclList         list2.ACLList
 }
 
 func defaultObjectTreeDeps(
 	rootChange *treechangeproto.RawTreeChangeWithId,
-	treeStorage storage.TreeStorage,
+	treeStorage treestorage.TreeStorage,
-	aclList list.ACLList) objectTreeDeps {
+	aclList list2.ACLList) objectTreeDeps {
 
-	keychain := common.NewKeychain()
+	keychain := keychain.NewKeychain()
 	changeBuilder := NewChangeBuilder(keychain, rootChange)
 	treeBuilder := newTreeBuilder(treeStorage, changeBuilder)
 	return objectTreeDeps{
@@ -145,7 +145,7 @@ func (ot *objectTree) Header() *treechangeproto.RawTreeChangeWithId {
 	return ot.root
 }
 
-func (ot *objectTree) Storage() storage.TreeStorage {
+func (ot *objectTree) Storage() treestorage.TreeStorage {
 	return ot.treeStorage
 }
 
@@ -202,7 +202,7 @@ func (ot *objectTree) prepareBuilderContent(content SignableChangeContent) (cnt
 	canWrite := state.HasPermission(content.Identity, aclrecordproto.ACLUserPermissions_Writer) ||
 		state.HasPermission(content.Identity, aclrecordproto.ACLUserPermissions_Admin)
 	if !canWrite {
-		err = list.ErrInsufficientPermissions
+		err = list2.ErrInsufficientPermissions
 		return
 	}
 
@@ -469,7 +469,7 @@ func (ot *objectTree) IterateFrom(id string, convert ChangeConvertFunc, iterate
 		}
 		readKey, exists := ot.keys[c.ReadKeyHash]
 		if !exists {
-			err = list.ErrNoReadKey
+			err = list2.ErrNoReadKey
 			return
 		}
 

common/commonspace/object/tree/objecttree/objecttree_test.go

@@ -1,11 +1,11 @@
-package tree
+package objecttree
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
-	storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/testutils/acllistbuilder"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/acllistbuilder"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"testing"
@@ -53,9 +53,9 @@ func (c *mockChangeCreator) createRaw(id, aclId, snapshotId string, isSnapshot b
 	}
 }
 
-func (c *mockChangeCreator) createNewTreeStorage(treeId, aclHeadId string) storage.TreeStorage {
+func (c *mockChangeCreator) createNewTreeStorage(treeId, aclHeadId string) treestorage.TreeStorage {
 	root := c.createRoot(treeId, aclHeadId)
-	treeStorage, _ := storage.NewInMemoryTreeStorage(root, []string{root.Id}, []*treechangeproto.RawTreeChangeWithId{root})
+	treeStorage, _ := treestorage.NewInMemoryTreeStorage(root, []string{root.Id}, []*treechangeproto.RawTreeChangeWithId{root})
 	return treeStorage
 }
 
@@ -95,7 +95,7 @@ func (m *mockChangeValidator) ValidateFullTree(tree *Tree, aclList list.ACLList)
 
 type testTreeContext struct {
 	aclList       list.ACLList
-	treeStorage   storage.TreeStorage
+	treeStorage   treestorage.TreeStorage
 	changeBuilder *mockChangeBuilder
 	changeCreator *mockChangeCreator
 	objTree       ObjectTree

common/commonspace/object/tree/objecttree/objecttreefactory.go

@@ -1,10 +1,10 @@
-package tree
+package objecttree
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
-	storage2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
@@ -21,7 +21,7 @@ type ObjectTreeCreatePayload struct {
 	IsEncrypted bool
 }
 
-func BuildObjectTree(treeStorage storage2.TreeStorage, aclList list.ACLList) (ObjectTree, error) {
+func BuildObjectTree(treeStorage treestorage.TreeStorage, aclList list.ACLList) (ObjectTree, error) {
 	rootChange, err := treeStorage.Root()
 	if err != nil {
 		return nil, err
@@ -33,14 +33,14 @@ func BuildObjectTree(treeStorage storage2.TreeStorage, aclList list.ACLList) (Ob
 func CreateDerivedObjectTree(
 	payload ObjectTreeCreatePayload,
 	aclList list.ACLList,
-	createStorage storage2.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
+	createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
 	return createObjectTree(payload, 0, nil, aclList, createStorage)
 }
 
 func CreateObjectTree(
 	payload ObjectTreeCreatePayload,
 	aclList list.ACLList,
-	createStorage storage2.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
+	createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
 	bytes := make([]byte, 32)
 	_, err = rand.Read(bytes)
 	if err != nil {
@@ -54,7 +54,7 @@ func createObjectTree(
 	timestamp int64,
 	seed []byte,
 	aclList list.ACLList,
-	createStorage storage2.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
+	createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
 	aclList.RLock()
 	aclHeadId := aclList.Head().Id
 	aclList.RUnlock()
@@ -72,14 +72,13 @@ func createObjectTree(
 		Seed:       seed,
 	}
 
-	_, raw, err := NewChangeBuilder(common.NewKeychain(), nil).BuildInitialContent(cnt)
+	_, raw, err := NewChangeBuilder(keychain.NewKeychain(), nil).BuildInitialContent(cnt)
 	if err != nil {
 		return
 	}
 
 	// create storage
-	st, err := createStorage(storage2.TreeStorageCreatePayload{
+	st, err := createStorage(treestorage.TreeStorageCreatePayload{
-		TreeId:        raw.Id,
 		RootRawChange: raw,
 		Changes:       []*treechangeproto.RawTreeChangeWithId{raw},
 		Heads:         []string{raw.Id},
@@ -130,6 +129,7 @@ func buildObjectTree(deps objectTreeDeps) (ObjectTree, error) {
 
 	objTree.id = objTree.treeStorage.Id()
 
+	objTree.id = objTree.treeStorage.Id()
 	objTree.root, err = objTree.treeStorage.Root()
 	if err != nil {
 		return nil, err

common/commonspace/object/tree/objecttree/rawloader.go

@@ -1,15 +1,15 @@
-package tree
+package objecttree
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
 	"time"
 )
 
 type rawChangeLoader struct {
-	treeStorage   storage.TreeStorage
+	treeStorage   treestorage.TreeStorage
 	changeBuilder ChangeBuilder
 
 	// buffers
@@ -23,7 +23,7 @@ type rawCacheEntry struct {
 	position  int
 }
 
-func newRawChangeLoader(treeStorage storage.TreeStorage, changeBuilder ChangeBuilder) *rawChangeLoader {
+func newRawChangeLoader(treeStorage treestorage.TreeStorage, changeBuilder ChangeBuilder) *rawChangeLoader {
 	return &rawChangeLoader{
 		treeStorage:   treeStorage,
 		changeBuilder: changeBuilder,

common/commonspace/object/tree/objecttree/rawtreevalidator.go

@@ -0,0 +1,17 @@
+package objecttree
+
+import (
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
+)
+
+func ValidateRawTree(payload treestorage.TreeStorageCreatePayload, aclList list.ACLList) (err error) {
+	provider := treestorage.NewInMemoryTreeStorageProvider()
+	treeStorage, err := provider.CreateTreeStorage(payload)
+	if err != nil {
+		return
+	}
+
+	_, err = BuildObjectTree(treeStorage, aclList)
+	return
+}

common/commonspace/object/tree/objecttree/signablecontent.go

@@ -1,4 +1,4 @@
-package tree
+package objecttree
 
 import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"

common/commonspace/object/tree/objecttree/tree.go

@@ -1,4 +1,4 @@
-package tree
+package objecttree
 
 import (
 	"bytes"

common/commonspace/object/tree/objecttree/tree_test.go

@@ -1,4 +1,4 @@
-package tree
+package objecttree
 
 import (
 	"fmt"

common/commonspace/object/tree/objecttree/treebuilder.go

@@ -1,11 +1,11 @@
-package tree
+package objecttree
 
 import (
 	"context"
 	"errors"
 	"fmt"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
 	"go.uber.org/zap"
 	"time"
@@ -17,7 +17,7 @@ var (
 )
 
 type treeBuilder struct {
-	treeStorage storage.TreeStorage
+	treeStorage treestorage.TreeStorage
 	builder     ChangeBuilder
 
 	cache map[string]*Change
@@ -28,7 +28,7 @@ type treeBuilder struct {
 	loadBuffer []*Change
 }
 
-func newTreeBuilder(storage storage.TreeStorage, builder ChangeBuilder) *treeBuilder {
+func newTreeBuilder(storage treestorage.TreeStorage, builder ChangeBuilder) *treeBuilder {
 	return &treeBuilder{
 		treeStorage: storage,
 		builder:     builder,

common/commonspace/object/tree/objecttree/treegraph.go

@@ -2,7 +2,7 @@
 // +build !linux,!darwin android ios nographviz
 // +build !amd64
 
-package tree
+package objecttree
 
 import "fmt"
 

common/commonspace/object/tree/objecttree/treegraph_nix.go

@@ -5,20 +5,18 @@
 // +build !nographviz
 // +build amd64 arm64
 
-package acltree
+package objecttree
 
 import (
 	"bytes"
 	"fmt"
-	"strings"
-	"time"
-	"unicode"
-
 	"github.com/goccy/go-graphviz"
 	"github.com/goccy/go-graphviz/cgraph"
+	"strings"
+	"time"
 )
 
-func (t *Tree) Graph() (data string, err error) {
+func (t *Tree) Graph(parser DescriptionParser) (data string, err error) {
 	var order = make(map[string]string)
 	var seq = 0
 	t.Iterate(t.RootId(), func(c *Change) (isContinue bool) {
@@ -46,44 +44,15 @@ func (t *Tree) Graph() (data string, err error) {
 		if e != nil {
 			return e
 		}
-		if c.Content.GetAclData() != nil {
+		n.SetStyle(cgraph.FilledNodeStyle)
-			n.SetStyle(cgraph.FilledNodeStyle)
-		} else if c.IsSnapshot {
-			n.SetStyle(cgraph.DashedNodeStyle)
-		}
 		nodes[c.Id] = n
 		ord := order[c.Id]
 		if ord == "" {
 			ord = "miss"
 		}
-		var chSymbs []string
+		chSymbs, err := parser.ParseChange(c)
-		if c.Content.AclData != nil {
+		if err != nil {
-			for _, chc := range c.Content.AclData.AclContent {
+			return err
-				tp := fmt.Sprintf("%T", chc.Value)
-				tp = strings.Replace(tp, "ACLChange_ACLContent_Value_", "", 1)
-				res := ""
-				for _, ts := range tp {
-					if unicode.IsUpper(ts) {
-						res += string(ts)
-					}
-				}
-				chSymbs = append(chSymbs, res)
-			}
-		}
-		if c.DecryptedDocumentChange != nil {
-			// TODO: add some parser to provide custom unmarshalling for the document change
-			//for _, chc := range c.DecryptedDocumentChange.Content {
-			//	tp := fmt.Sprintf("%T", chc.Value)
-			//	tp = strings.Replace(tp, "ChangeContent_Value_", "", 1)
-			//	res := ""
-			//	for _, ts := range tp {
-			//		if unicode.IsUpper(ts) {
-			//			res += string(ts)
-			//		}
-			//	}
-			//	chSymbs = append(chSymbs, res)
-			//}
-			chSymbs = append(chSymbs, "DEC")
 		}
 
 		shortId := c.Id

common/commonspace/object/tree/objecttree/treeiterator.go

@@ -1,4 +1,4 @@
-package tree
+package objecttree
 
 import (
 	"sync"

common/commonspace/object/tree/objecttree/treereduce.go

@@ -1,4 +1,4 @@
-package tree
+package objecttree
 
 import "math"
 

common/commonspace/object/tree/objecttree/util.go

@@ -1,4 +1,4 @@
-package tree
+package objecttree
 
 func commonSnapshotForTwoPaths(ourPath []string, theirPath []string) (string, error) {
 	var i int

common/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree (interfaces: SyncClient,SyncTree,ReceiveQueue,HeadNotifiable)
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree (interfaces: SyncClient,SyncTree,ReceiveQueue,HeadNotifiable)
 
 // Package mock_synctree is a generated GoMock package.
 package mock_synctree
@@ -8,10 +8,10 @@ import (
 	context "context"
 	reflect "reflect"
 
+	objecttree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
+	treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
+	treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
 	spacesyncproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
-	tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
-	treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -67,7 +67,7 @@ func (mr *MockSyncClientMockRecorder) BroadcastAsyncOrSendResponsible(arg0 inter
 }
 
 // CreateFullSyncRequest mocks base method.
-func (m *MockSyncClient) CreateFullSyncRequest(arg0 tree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) {
+func (m *MockSyncClient) CreateFullSyncRequest(arg0 objecttree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateFullSyncRequest", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage)
@@ -82,7 +82,7 @@ func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(arg0, arg1, arg2 int
 }
 
 // CreateFullSyncResponse mocks base method.
-func (m *MockSyncClient) CreateFullSyncResponse(arg0 tree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) {
+func (m *MockSyncClient) CreateFullSyncResponse(arg0 objecttree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateFullSyncResponse", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage)
@@ -97,7 +97,7 @@ func (mr *MockSyncClientMockRecorder) CreateFullSyncResponse(arg0, arg1, arg2 in
 }
 
 // CreateHeadUpdate mocks base method.
-func (m *MockSyncClient) CreateHeadUpdate(arg0 tree.ObjectTree, arg1 []*treechangeproto.RawTreeChangeWithId) *treechangeproto.TreeSyncMessage {
+func (m *MockSyncClient) CreateHeadUpdate(arg0 objecttree.ObjectTree, arg1 []*treechangeproto.RawTreeChangeWithId) *treechangeproto.TreeSyncMessage {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CreateHeadUpdate", arg0, arg1)
 	ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage)
@@ -162,10 +162,10 @@ func (m *MockSyncTree) EXPECT() *MockSyncTreeMockRecorder {
 }
 
 // AddContent mocks base method.
-func (m *MockSyncTree) AddContent(arg0 context.Context, arg1 tree.SignableChangeContent) (tree.AddResult, error) {
+func (m *MockSyncTree) AddContent(arg0 context.Context, arg1 objecttree.SignableChangeContent) (objecttree.AddResult, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
-	ret0, _ := ret[0].(tree.AddResult)
+	ret0, _ := ret[0].(objecttree.AddResult)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -177,10 +177,10 @@ func (mr *MockSyncTreeMockRecorder) AddContent(arg0, arg1 interface{}) *gomock.C
 }
 
 // AddRawChanges mocks base method.
-func (m *MockSyncTree) AddRawChanges(arg0 context.Context, arg1 tree.RawChangesPayload) (tree.AddResult, error) {
+func (m *MockSyncTree) AddRawChanges(arg0 context.Context, arg1 objecttree.RawChangesPayload) (objecttree.AddResult, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddRawChanges", arg0, arg1)
-	ret0, _ := ret[0].(tree.AddResult)
+	ret0, _ := ret[0].(objecttree.AddResult)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
@@ -324,7 +324,7 @@ func (mr *MockSyncTreeMockRecorder) ID() *gomock.Call {
 }
 
 // Iterate mocks base method.
-func (m *MockSyncTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*tree.Change) bool) error {
+func (m *MockSyncTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*objecttree.Change) bool) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Iterate", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -338,7 +338,7 @@ func (mr *MockSyncTreeMockRecorder) Iterate(arg0, arg1 interface{}) *gomock.Call
 }
 
 // IterateFrom mocks base method.
-func (m *MockSyncTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*tree.Change) bool) error {
+func (m *MockSyncTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*objecttree.Change) bool) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IterateFrom", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
@@ -402,10 +402,10 @@ func (mr *MockSyncTreeMockRecorder) RUnlock() *gomock.Call {
 }
 
 // Root mocks base method.
-func (m *MockSyncTree) Root() *tree.Change {
+func (m *MockSyncTree) Root() *objecttree.Change {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Root")
-	ret0, _ := ret[0].(*tree.Change)
+	ret0, _ := ret[0].(*objecttree.Change)
 	return ret0
 }
 
@@ -430,10 +430,10 @@ func (mr *MockSyncTreeMockRecorder) SnapshotPath() *gomock.Call {
 }
 
 // Storage mocks base method.
-func (m *MockSyncTree) Storage() storage.TreeStorage {
+func (m *MockSyncTree) Storage() treestorage.TreeStorage {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Storage")
-	ret0, _ := ret[0].(storage.TreeStorage)
+	ret0, _ := ret[0].(treestorage.TreeStorage)
 	return ret0
 }
 

common/commonspace/object/tree/synctree/queuedclient.go

@@ -1,16 +1,16 @@
 package synctree
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
 )
 
 type queuedClient struct {
 	SyncClient
-	queue syncservice.ActionQueue
+	queue objectsync.ActionQueue
 }
 
-func newQueuedClient(client SyncClient, queue syncservice.ActionQueue) SyncClient {
+func newQueuedClient(client SyncClient, queue objectsync.ActionQueue) SyncClient {
 	return &queuedClient{
 		SyncClient: client,
 		queue:      queue,

common/commonspace/object/tree/synctree/receivequeue.go

@@ -2,7 +2,7 @@ package synctree
 
 import (
 	"errors"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
 	"sync"
 )
 

common/commonspace/object/tree/synctree/requestfactory.go

@@ -2,16 +2,16 @@ package synctree
 
 import (
 	"fmt"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
 )
 
 type RequestFactory interface {
-	CreateHeadUpdate(t tree.ObjectTree, added []*treechangeproto.RawTreeChangeWithId) (msg *treechangeproto.TreeSyncMessage)
+	CreateHeadUpdate(t objecttree.ObjectTree, added []*treechangeproto.RawTreeChangeWithId) (msg *treechangeproto.TreeSyncMessage)
 	CreateNewTreeRequest() (msg *treechangeproto.TreeSyncMessage)
-	CreateFullSyncRequest(t tree.ObjectTree, theirHeads, theirSnapshotPath []string) (req *treechangeproto.TreeSyncMessage, err error)
+	CreateFullSyncRequest(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (req *treechangeproto.TreeSyncMessage, err error)
-	CreateFullSyncResponse(t tree.ObjectTree, theirHeads, theirSnapshotPath []string) (*treechangeproto.TreeSyncMessage, error)
+	CreateFullSyncResponse(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (*treechangeproto.TreeSyncMessage, error)
 }
 
 var sharedFactory = &requestFactory{}
@@ -22,7 +22,7 @@ func GetRequestFactory() RequestFactory {
 
 type requestFactory struct{}
 
-func (r *requestFactory) CreateHeadUpdate(t tree.ObjectTree, added []*treechangeproto.RawTreeChangeWithId) (msg *treechangeproto.TreeSyncMessage) {
+func (r *requestFactory) CreateHeadUpdate(t objecttree.ObjectTree, added []*treechangeproto.RawTreeChangeWithId) (msg *treechangeproto.TreeSyncMessage) {
 	return treechangeproto.WrapHeadUpdate(&treechangeproto.TreeHeadUpdate{
 		Heads:        t.Heads(),
 		Changes:      added,
@@ -34,7 +34,7 @@ func (r *requestFactory) CreateNewTreeRequest() (msg *treechangeproto.TreeSyncMe
 	return treechangeproto.WrapFullRequest(&treechangeproto.TreeFullSyncRequest{}, nil)
 }
 
-func (r *requestFactory) CreateFullSyncRequest(t tree.ObjectTree, theirHeads, theirSnapshotPath []string) (msg *treechangeproto.TreeSyncMessage, err error) {
+func (r *requestFactory) CreateFullSyncRequest(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (msg *treechangeproto.TreeSyncMessage, err error) {
 	req := &treechangeproto.TreeFullSyncRequest{}
 	if t == nil {
 		return nil, fmt.Errorf("tree should not be empty")
@@ -54,7 +54,7 @@ func (r *requestFactory) CreateFullSyncRequest(t tree.ObjectTree, theirHeads, th
 	return
 }
 
-func (r *requestFactory) CreateFullSyncResponse(t tree.ObjectTree, theirHeads, theirSnapshotPath []string) (msg *treechangeproto.TreeSyncMessage, err error) {
+func (r *requestFactory) CreateFullSyncResponse(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (msg *treechangeproto.TreeSyncMessage, err error) {
 	resp := &treechangeproto.TreeFullSyncResponse{
 		Heads:        t.Heads(),
 		SnapshotPath: t.SnapshotPath(),

common/commonspace/object/tree/synctree/syncclient.go

@@ -1,11 +1,11 @@
-//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree SyncClient,SyncTree,ReceiveQueue,HeadNotifiable
+//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree SyncClient,SyncTree,ReceiveQueue,HeadNotifiable
 package synctree
 
 import (
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 )
 
 type SyncClient interface {
@@ -16,21 +16,21 @@ type SyncClient interface {
 }
 
 type syncClient struct {
-	syncservice.StreamPool
+	objectsync.StreamPool
 	RequestFactory
 	spaceId       string
 	connector     nodeconf.ConfConnector
 	configuration nodeconf.Configuration
 
-	checker syncservice.StreamChecker
+	checker objectsync.StreamChecker
 }
 
 func newSyncClient(
 	spaceId string,
-	pool syncservice.StreamPool,
+	pool objectsync.StreamPool,
 	factory RequestFactory,
 	configuration nodeconf.Configuration,
-	checker syncservice.StreamChecker) SyncClient {
+	checker objectsync.StreamChecker) SyncClient {
 	return &syncClient{
 		StreamPool:     pool,
 		RequestFactory: factory,

common/commonspace/object/tree/synctree/synctree.go

@@ -5,17 +5,17 @@ import (
 	"errors"
 	"fmt"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
-	spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice/synchandler"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync/synchandler"
+	spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/peer"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 	"github.com/gogo/protobuf/proto"
 	"go.uber.org/zap"
 	"sync/atomic"
@@ -31,14 +31,14 @@ type HeadNotifiable interface {
 }
 
 type SyncTree interface {
-	tree.ObjectTree
+	objecttree.ObjectTree
 	synchandler.SyncHandler
 	Ping() (err error)
 }
 
 // SyncTree sends head updates to sync service and also sends new changes to update listener
 type syncTree struct {
-	tree.ObjectTree
+	objecttree.ObjectTree
 	synchandler.SyncHandler
 	syncClient SyncClient
 	syncStatus syncstatus.SyncStatusUpdater
@@ -51,16 +51,16 @@ type syncTree struct {
 
 var log = logger.NewNamed("commonspace.synctree").Sugar()
 
-var createDerivedObjectTree = tree.CreateDerivedObjectTree
+var createDerivedObjectTree = objecttree.CreateDerivedObjectTree
-var createObjectTree = tree.CreateObjectTree
+var createObjectTree = objecttree.CreateObjectTree
-var buildObjectTree = tree.BuildObjectTree
+var buildObjectTree = objecttree.BuildObjectTree
 var createSyncClient = newWrappedSyncClient
 
 type CreateDeps struct {
 	SpaceId        string
-	Payload        tree.ObjectTreeCreatePayload
+	Payload        objecttree.ObjectTreeCreatePayload
 	Configuration  nodeconf.Configuration
-	SyncService    syncservice.SyncService
+	ObjectSync     objectsync.ObjectSync
 	AclList        list.ACLList
 	SpaceStorage   spacestorage.SpaceStorage
 	SyncStatus     syncstatus.SyncStatusUpdater
@@ -69,13 +69,13 @@ type CreateDeps struct {
 
 type BuildDeps struct {
 	SpaceId        string
-	SyncService    syncservice.SyncService
+	ObjectSync     objectsync.ObjectSync
 	Configuration  nodeconf.Configuration
 	HeadNotifiable HeadNotifiable
 	Listener       updatelistener.UpdateListener
 	AclList        list.ACLList
 	SpaceStorage   spacestorage.SpaceStorage
-	TreeStorage    storage.TreeStorage
+	TreeStorage    treestorage.TreeStorage
 	TreeUsage      *atomic.Int32
 	SyncStatus     syncstatus.SyncStatusUpdater
 }
@@ -83,10 +83,10 @@ type BuildDeps struct {
 func newWrappedSyncClient(
 	spaceId string,
 	factory RequestFactory,
-	syncService syncservice.SyncService,
+	objectSync objectsync.ObjectSync,
 	configuration nodeconf.Configuration) SyncClient {
-	syncClient := newSyncClient(spaceId, syncService.StreamPool(), factory, configuration, syncService.StreamChecker())
+	syncClient := newSyncClient(spaceId, objectSync.StreamPool(), factory, configuration, objectSync.StreamChecker())
-	return newQueuedClient(syncClient, syncService.ActionQueue())
+	return newQueuedClient(syncClient, objectSync.ActionQueue())
 }
 
 func DeriveSyncTree(ctx context.Context, deps CreateDeps) (id string, err error) {
@@ -98,7 +98,7 @@ func DeriveSyncTree(ctx context.Context, deps CreateDeps) (id string, err error)
 	syncClient := createSyncClient(
 		deps.SpaceId,
 		sharedFactory,
-		deps.SyncService,
+		deps.ObjectSync,
 		deps.Configuration)
 
 	id = objTree.ID()
@@ -119,7 +119,7 @@ func CreateSyncTree(ctx context.Context, deps CreateDeps) (id string, err error)
 	syncClient := createSyncClient(
 		deps.SpaceId,
 		sharedFactory,
-		deps.SyncService,
+		deps.ObjectSync,
 		deps.Configuration)
 
 	id = objTree.ID()
@@ -145,12 +145,12 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
 			return
 		}
 
-		err = deps.SyncService.StreamChecker().CheckPeerConnection(peerId)
+		err = deps.ObjectSync.StreamChecker().CheckPeerConnection(peerId)
 		if err != nil {
 			return
 		}
 
-		resp, err := deps.SyncService.StreamPool().SendSync(peerId, objMsg)
+		resp, err := deps.ObjectSync.StreamPool().SendSync(peerId, objMsg)
 		if err != nil {
 			return
 		}
@@ -165,7 +165,7 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
 		return buildSyncTree(ctx, false, deps)
 	}
 
-	if err != nil && err != storage.ErrUnknownTreeId {
+	if err != nil && err != treestorage.ErrUnknownTreeId {
 		return
 	}
 
@@ -188,7 +188,7 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
 	}
 	fullSyncResp := resp.GetContent().GetFullSyncResponse()
 
-	payload := storage.TreeStorageCreatePayload{
+	payload := treestorage.TreeStorageCreatePayload{
 		RootRawChange: resp.RootChange,
 		Changes:       fullSyncResp.Changes,
 		Heads:         fullSyncResp.Heads,
@@ -196,7 +196,7 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
 
 	// basically building tree with in-memory storage and validating that it was without errors
 	log.With(zap.String("id", id)).Debug("validating tree")
-	err = tree.ValidateRawTree(payload, deps.AclList)
+	err = objecttree.ValidateRawTree(payload, deps.AclList)
 	if err != nil {
 		return
 	}
@@ -216,7 +216,7 @@ func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t Sy
 	syncClient := createSyncClient(
 		deps.SpaceId,
 		sharedFactory,
-		deps.SyncService,
+		deps.ObjectSync,
 		deps.Configuration)
 	syncTree := &syncTree{
 		ObjectTree: objTree,
@@ -241,21 +241,21 @@ func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t Sy
 	return
 }
 
-func (s *syncTree) IterateFrom(id string, convert tree.ChangeConvertFunc, iterate tree.ChangeIterateFunc) (err error) {
+func (s *syncTree) IterateFrom(id string, convert objecttree.ChangeConvertFunc, iterate objecttree.ChangeIterateFunc) (err error) {
 	if err = s.checkAlive(); err != nil {
 		return
 	}
 	return s.ObjectTree.IterateFrom(id, convert, iterate)
 }
 
-func (s *syncTree) Iterate(convert tree.ChangeConvertFunc, iterate tree.ChangeIterateFunc) (err error) {
+func (s *syncTree) Iterate(convert objecttree.ChangeConvertFunc, iterate objecttree.ChangeIterateFunc) (err error) {
 	if err = s.checkAlive(); err != nil {
 		return
 	}
 	return s.ObjectTree.Iterate(convert, iterate)
 }
 
-func (s *syncTree) AddContent(ctx context.Context, content tree.SignableChangeContent) (res tree.AddResult, err error) {
+func (s *syncTree) AddContent(ctx context.Context, content objecttree.SignableChangeContent) (res objecttree.AddResult, err error) {
 	if err = s.checkAlive(); err != nil {
 		return
 	}
@@ -272,7 +272,7 @@ func (s *syncTree) AddContent(ctx context.Context, content tree.SignableChangeCo
 	return
 }
 
-func (s *syncTree) AddRawChanges(ctx context.Context, changesPayload tree.RawChangesPayload) (res tree.AddResult, err error) {
+func (s *syncTree) AddRawChanges(ctx context.Context, changesPayload objecttree.RawChangesPayload) (res objecttree.AddResult, err error) {
 	if err = s.checkAlive(); err != nil {
 		return
 	}
@@ -282,15 +282,15 @@ func (s *syncTree) AddRawChanges(ctx context.Context, changesPayload tree.RawCha
 	}
 	if s.listener != nil {
 		switch res.Mode {
-		case tree.Nothing:
+		case objecttree.Nothing:
 			return
-		case tree.Append:
+		case objecttree.Append:
 			s.listener.Update(s)
-		case tree.Rebuild:
+		case objecttree.Rebuild:
 			s.listener.Rebuild(s)
 		}
 	}
-	if res.Mode != tree.Nothing {
+	if res.Mode != objecttree.Nothing {
 		if s.notifiable != nil {
 			s.notifiable.UpdateHeads(s.ID(), res.Heads)
 		}

common/commonspace/object/tree/synctree/synctree_test.go

@@ -2,26 +2,26 @@ package synctree
 
 import (
 	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage/mock_storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list/mock_list"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree/mock_objecttree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/mock_synctree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener/mock_updatelistener"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage/mock_spacestorage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/mock_synctree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener/mock_updatelistener"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list/mock_list"
-	storage2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
-	tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree/mock_objecttree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 	"testing"
 )
 
 type syncTreeMatcher struct {
-	objTree  tree.ObjectTree
+	objTree  objecttree.ObjectTree
 	client   SyncClient
 	listener updatelistener.UpdateListener
 }
@@ -38,8 +38,8 @@ func (s syncTreeMatcher) String() string {
 	return ""
 }
 
-func syncClientFuncCreator(client SyncClient) func(spaceId string, factory RequestFactory, syncService syncservice.SyncService, configuration nodeconf.Configuration) SyncClient {
+func syncClientFuncCreator(client SyncClient) func(spaceId string, factory RequestFactory, objectSync objectsync.ObjectSync, configuration nodeconf.Configuration) SyncClient {
-	return func(spaceId string, factory RequestFactory, syncService syncservice.SyncService, configuration nodeconf.Configuration) SyncClient {
+	return func(spaceId string, factory RequestFactory, objectSync objectsync.ObjectSync, configuration nodeconf.Configuration) SyncClient {
 		return client
 	}
 }
@@ -51,12 +51,12 @@ func Test_DeriveSyncTree(t *testing.T) {
 
 	syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
 	aclListMock := mock_list.NewMockACLList(ctrl)
-	objTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
+	objTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
-	spaceStorageMock := mock_storage.NewMockSpaceStorage(ctrl)
+	spaceStorageMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
 	headNotifiableMock := mock_synctree.NewMockHeadNotifiable(ctrl)
 	spaceId := "spaceId"
-	expectedPayload := tree.ObjectTreeCreatePayload{SpaceId: spaceId}
+	expectedPayload := objecttree.ObjectTreeCreatePayload{SpaceId: spaceId}
-	createDerivedObjectTree = func(payload tree.ObjectTreeCreatePayload, l list.ACLList, create storage2.TreeStorageCreatorFunc) (objTree tree.ObjectTree, err error) {
+	createDerivedObjectTree = func(payload objecttree.ObjectTreeCreatePayload, l list.ACLList, create treestorage.TreeStorageCreatorFunc) (objTree objecttree.ObjectTree, err error) {
 		require.Equal(t, l, aclListMock)
 		require.Equal(t, expectedPayload, payload)
 		return objTreeMock, nil
@@ -88,12 +88,12 @@ func Test_CreateSyncTree(t *testing.T) {
 
 	syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
 	aclListMock := mock_list.NewMockACLList(ctrl)
-	objTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
+	objTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
-	spaceStorageMock := mock_storage.NewMockSpaceStorage(ctrl)
+	spaceStorageMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
 	headNotifiableMock := mock_synctree.NewMockHeadNotifiable(ctrl)
 	spaceId := "spaceId"
-	expectedPayload := tree.ObjectTreeCreatePayload{SpaceId: spaceId}
+	expectedPayload := objecttree.ObjectTreeCreatePayload{SpaceId: spaceId}
-	createObjectTree = func(payload tree.ObjectTreeCreatePayload, l list.ACLList, create storage2.TreeStorageCreatorFunc) (objTree tree.ObjectTree, err error) {
+	createObjectTree = func(payload objecttree.ObjectTreeCreatePayload, l list.ACLList, create treestorage.TreeStorageCreatorFunc) (objTree objecttree.ObjectTree, err error) {
 		require.Equal(t, l, aclListMock)
 		require.Equal(t, expectedPayload, payload)
 		return objTreeMock, nil
@@ -126,7 +126,7 @@ func Test_BuildSyncTree(t *testing.T) {
 
 	updateListenerMock := mock_updatelistener.NewMockUpdateListener(ctrl)
 	syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
-	objTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
+	objTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
 	tr := &syncTree{
 		ObjectTree:  objTreeMock,
 		SyncHandler: nil,
@@ -139,13 +139,13 @@ func Test_BuildSyncTree(t *testing.T) {
 	headUpdate := &treechangeproto.TreeSyncMessage{}
 	t.Run("AddRawChanges update", func(t *testing.T) {
 		changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
-		payload := tree.RawChangesPayload{
+		payload := objecttree.RawChangesPayload{
 			NewHeads:   nil,
 			RawChanges: changes,
 		}
-		expectedRes := tree.AddResult{
+		expectedRes := objecttree.AddResult{
 			Added: changes,
-			Mode:  tree.Append,
+			Mode:  objecttree.Append,
 		}
 		objTreeMock.EXPECT().AddRawChanges(gomock.Any(), gomock.Eq(payload)).
 			Return(expectedRes, nil)
@@ -160,14 +160,14 @@ func Test_BuildSyncTree(t *testing.T) {
 
 	t.Run("AddRawChanges rebuild", func(t *testing.T) {
 		changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
-		payload := tree.RawChangesPayload{
+		payload := objecttree.RawChangesPayload{
 			NewHeads:   nil,
 			RawChanges: changes,
 		}
 
-		expectedRes := tree.AddResult{
+		expectedRes := objecttree.AddResult{
 			Added: changes,
-			Mode:  tree.Rebuild,
+			Mode:  objecttree.Rebuild,
 		}
 		objTreeMock.EXPECT().AddRawChanges(gomock.Any(), gomock.Eq(payload)).
 			Return(expectedRes, nil)
@@ -182,13 +182,13 @@ func Test_BuildSyncTree(t *testing.T) {
 
 	t.Run("AddRawChanges nothing", func(t *testing.T) {
 		changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
-		payload := tree.RawChangesPayload{
+		payload := objecttree.RawChangesPayload{
 			NewHeads:   nil,
 			RawChanges: changes,
 		}
-		expectedRes := tree.AddResult{
+		expectedRes := objecttree.AddResult{
 			Added: changes,
-			Mode:  tree.Nothing,
+			Mode:  objecttree.Nothing,
 		}
 		objTreeMock.EXPECT().AddRawChanges(gomock.Any(), gomock.Eq(payload)).
 			Return(expectedRes, nil)
@@ -200,11 +200,11 @@ func Test_BuildSyncTree(t *testing.T) {
 
 	t.Run("AddContent", func(t *testing.T) {
 		changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
-		content := tree.SignableChangeContent{
+		content := objecttree.SignableChangeContent{
 			Data: []byte("abcde"),
 		}
-		expectedRes := tree.AddResult{
+		expectedRes := objecttree.AddResult{
-			Mode:  tree.Append,
+			Mode:  objecttree.Append,
 			Added: changes,
 		}
 		objTreeMock.EXPECT().ID().Return("id").AnyTimes()

common/commonspace/object/tree/synctree/synctreehandler.go

@@ -2,11 +2,11 @@ package synctree
 
 import (
 	"context"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync/synchandler"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice/synchandler"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
 	"github.com/gogo/protobuf/proto"
 	"go.uber.org/zap"
@@ -14,7 +14,7 @@ import (
 )
 
 type syncTreeHandler struct {
-	objTree     tree.ObjectTree
+	objTree     objecttree.ObjectTree
 	syncClient  SyncClient
 	syncStatus  syncstatus.SyncStatusUpdater
 	handlerLock sync.Mutex
@@ -23,7 +23,7 @@ type syncTreeHandler struct {
 
 const maxQueueSize = 5
 
-func newSyncTreeHandler(objTree tree.ObjectTree, syncClient SyncClient, syncStatus syncstatus.SyncStatusUpdater) synchandler.SyncHandler {
+func newSyncTreeHandler(objTree objecttree.ObjectTree, syncClient SyncClient, syncStatus syncstatus.SyncStatusUpdater) synchandler.SyncHandler {
 	return &syncTreeHandler{
 		objTree:    objTree,
 		syncClient: syncClient,
@@ -118,7 +118,7 @@ func (s *syncTreeHandler) handleHeadUpdate(
 		return
 	}
 
-	_, err = objTree.AddRawChanges(ctx, tree.RawChangesPayload{
+	_, err = objTree.AddRawChanges(ctx, objecttree.RawChangesPayload{
 		NewHeads:   update.Heads,
 		RawChanges: update.Changes,
 	})
@@ -167,7 +167,7 @@ func (s *syncTreeHandler) handleFullSyncRequest(
 	}()
 
 	if len(request.Changes) != 0 && !s.alreadyHasHeads(objTree, request.Heads) {
-		_, err = objTree.AddRawChanges(ctx, tree.RawChangesPayload{
+		_, err = objTree.AddRawChanges(ctx, objecttree.RawChangesPayload{
 			NewHeads:   request.Heads,
 			RawChanges: request.Changes,
 		})
@@ -207,13 +207,13 @@ func (s *syncTreeHandler) handleFullSyncResponse(
 		return
 	}
 
-	_, err = objTree.AddRawChanges(ctx, tree.RawChangesPayload{
+	_, err = objTree.AddRawChanges(ctx, objecttree.RawChangesPayload{
 		NewHeads:   response.Heads,
 		RawChanges: response.Changes,
 	})
 	return
 }
 
-func (s *syncTreeHandler) alreadyHasHeads(t tree.ObjectTree, heads []string) bool {
+func (s *syncTreeHandler) alreadyHasHeads(t objecttree.ObjectTree, heads []string) bool {
 	return slice.UnsortedEquals(t.Heads(), heads) || t.HasChanges(heads...)
 }

common/commonspace/object/tree/synctree/synctreehandler_test.go

@@ -3,11 +3,11 @@ package synctree
 import (
 	"context"
 	"fmt"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree/mock_objecttree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/mock_synctree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/mock_synctree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree/mock_objecttree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
@@ -16,11 +16,11 @@ import (
 )
 
 type testObjTreeMock struct {
-	*mock_tree.MockObjectTree
+	*mock_objecttree.MockObjectTree
 	m sync.Mutex
 }
 
-func newTestObjMock(mockTree *mock_tree.MockObjectTree) *testObjTreeMock {
+func newTestObjMock(mockTree *mock_objecttree.MockObjectTree) *testObjTreeMock {
 	return &testObjTreeMock{
 		MockObjectTree: mockTree,
 	}
@@ -46,7 +46,7 @@ type syncHandlerFixture struct {
 func newSyncHandlerFixture(t *testing.T) *syncHandlerFixture {
 	ctrl := gomock.NewController(t)
 	syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
-	objectTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
+	objectTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
 	receiveQueueMock := mock_synctree.NewMockReceiveQueue(ctrl)
 
 	syncHandler := &syncTreeHandler{
@@ -93,11 +93,11 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).Times(2)
 		fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(false)
 		fx.objectTreeMock.EXPECT().
-			AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
+			AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
 				NewHeads:   []string{"h1"},
 				RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
 			})).
-			Return(tree.AddResult{}, nil)
+			Return(objecttree.AddResult{}, nil)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2", "h1"})
 		fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(true)
 
@@ -127,11 +127,11 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).AnyTimes()
 		fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(false)
 		fx.objectTreeMock.EXPECT().
-			AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
+			AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
 				NewHeads:   []string{"h1"},
 				RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
 			})).
-			Return(tree.AddResult{}, nil)
+			Return(objecttree.AddResult{}, nil)
 		fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(false)
 		fx.syncClientMock.EXPECT().
 			CreateFullSyncRequest(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
@@ -247,11 +247,11 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).AnyTimes()
 		fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(false)
 		fx.objectTreeMock.EXPECT().
-			AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
+			AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
 				NewHeads:   []string{"h1"},
 				RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
 			})).
-			Return(tree.AddResult{}, nil)
+			Return(objecttree.AddResult{}, nil)
 		fx.syncClientMock.EXPECT().
 			CreateFullSyncResponse(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
 			Return(fullResponse, nil)
@@ -351,11 +351,11 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			HasChanges(gomock.Eq([]string{"h1"})).
 			Return(false)
 		fx.objectTreeMock.EXPECT().
-			AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
+			AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
 				NewHeads:   []string{"h1"},
 				RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
 			})).
-			Return(tree.AddResult{}, fmt.Errorf(""))
+			Return(objecttree.AddResult{}, fmt.Errorf(""))
 		fx.syncClientMock.EXPECT().SendAsync(gomock.Eq(senderId), gomock.Any(), gomock.Eq(""))
 
 		fx.receiveQueueMock.EXPECT().ClearQueue(senderId)
@@ -393,11 +393,11 @@ func TestSyncHandler_HandleFullSyncResponse(t *testing.T) {
 			HasChanges(gomock.Eq([]string{"h1"})).
 			Return(false)
 		fx.objectTreeMock.EXPECT().
-			AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
+			AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
 				NewHeads:   []string{"h1"},
 				RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
 			})).
-			Return(tree.AddResult{}, nil)
+			Return(objecttree.AddResult{}, nil)
 
 		fx.receiveQueueMock.EXPECT().ClearQueue(senderId)
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)

common/commonspace/object/tree/synctree/updatelistener/mock_updatelistener/mock_updatelistener.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener (interfaces: UpdateListener)
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener (interfaces: UpdateListener)
 
 // Package mock_updatelistener is a generated GoMock package.
 package mock_updatelistener
@@ -7,7 +7,7 @@ package mock_updatelistener
 import (
 	reflect "reflect"
 
-	tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
+	objecttree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -35,7 +35,7 @@ func (m *MockUpdateListener) EXPECT() *MockUpdateListenerMockRecorder {
 }
 
 // Rebuild mocks base method.
-func (m *MockUpdateListener) Rebuild(arg0 tree.ObjectTree) {
+func (m *MockUpdateListener) Rebuild(arg0 objecttree.ObjectTree) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Rebuild", arg0)
 }
@@ -47,7 +47,7 @@ func (mr *MockUpdateListenerMockRecorder) Rebuild(arg0 interface{}) *gomock.Call
 }
 
 // Update mocks base method.
-func (m *MockUpdateListener) Update(arg0 tree.ObjectTree) {
+func (m *MockUpdateListener) Update(arg0 objecttree.ObjectTree) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Update", arg0)
 }

common/commonspace/object/tree/synctree/updatelistener/updatelistener.go

@@ -1,11 +1,11 @@
-//go:generate mockgen -destination mock_updatelistener/mock_updatelistener.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener UpdateListener
+//go:generate mockgen -destination mock_updatelistener/mock_updatelistener.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener UpdateListener
 package updatelistener
 
 import (
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
 )
 
 type UpdateListener interface {
-	Update(tree tree.ObjectTree)
+	Update(tree objecttree.ObjectTree)
-	Rebuild(tree tree.ObjectTree)
+	Rebuild(tree objecttree.ObjectTree)
 }

common/commonspace/object/tree/treestorage/helpers.go

@@ -1,4 +1,4 @@
-package storage
+package treestorage
 
 import (
 	"bytes"