Update code to work with acl lists and new models

Makefile

@@ -18,19 +18,17 @@ protos-go:
 #   Uncomment if needed
 	@$(eval ROOT_PKG := pkg)
 	@$(eval GOGO_START := GOGO_NO_UNDERSCORE=1 GOGO_EXPORT_ONEOF_INTERFACE=1)
-	@$(eval P_TREE_STORAGE_PATH_PB := $(ROOT_PKG)/acl/treestorage/treepb)
 	@$(eval P_ACL_CHANGES_PATH_PB := $(ROOT_PKG)/acl/aclchanges/aclpb)
-	@$(eval P_PLAINTEXT_CHANGES_PATH_PB := $(ROOT_PKG)/acl/testutils/testchanges/testchangepb)
 	@$(eval P_SYNC_CHANGES_PATH_PB := syncproto)
+	@$(eval P_TEST_CHANGES_PATH_PB := $(ROOT_PKG)/acl/testutils/testchanges)
 	@$(eval P_TIMESTAMP := Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types)
 	@$(eval P_STRUCT := Mgoogle/protobuf/struct.proto=github.com/gogo/protobuf/types)
 	@$(eval P_ACL_CHANGES := M$(P_ACL_CHANGES_PATH_PB)/protos/aclchanges.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/$(P_ACL_CHANGES_PATH_PB))
-	@$(eval P_TREE_CHANGES := M$(P_TREE_STORAGE_PATH_PB)/protos/tree.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/$(P_TREE_STORAGE_PATH_PB))
 
 	# use if needed $(eval PKGMAP := $$(P_TIMESTAMP),$$(P_STRUCT))
 	$(GOGO_START) protoc --gogofaster_out=:. $(P_ACL_CHANGES_PATH_PB)/protos/*.proto; mv $(P_ACL_CHANGES_PATH_PB)/protos/*.go $(P_ACL_CHANGES_PATH_PB)
-	$(GOGO_START) protoc --gogofaster_out=:. $(P_TREE_STORAGE_PATH_PB)/protos/*.proto; mv $(P_TREE_STORAGE_PATH_PB)/protos/*.go $(P_TREE_STORAGE_PATH_PB)
+	$(GOGO_START) protoc --gogofaster_out=:. $(P_TEST_CHANGES_PATH_PB)/proto/*.proto
-	$(eval PKGMAP := $$(P_ACL_CHANGES),$$(P_TREE_CHANGES))
+	$(eval PKGMAP := $$(P_ACL_CHANGES))
 	$(GOGO_START) protoc --gogofaster_out=$(PKGMAP),plugins=grpc:. $(P_SYNC_CHANGES_PATH_PB)/proto/*.proto
 
 build:

pkg/acl/list/list.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/account"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree"
 	"sync"
 )
@@ -21,6 +22,7 @@ type ACLList interface {
 	Get(id string) (*Record, error)
 	Iterate(iterFunc IterFunc)
 	IterateFrom(startId string, iterFunc IterFunc)
+	Close() (err error)
 }
 
 type aclList struct {
@@ -35,7 +37,7 @@ type aclList struct {
 	sync.RWMutex
 }
 
-func BuildACLListWithIdentity(acc *account.AccountData, storage Storage) (ACLList, error) {
+func BuildACLListWithIdentity(acc *account.AccountData, storage storage.ListStorage) (ACLList, error) {
 	builder := newACLStateBuilderWithIdentity(acc.Decoder, acc)
 	header, err := storage.Header()
 	if err != nil {
@@ -54,7 +56,7 @@ func BuildACLListWithIdentity(acc *account.AccountData, storage Storage) (ACLLis
 	records := []*Record{record}
 
 	for record.Content.PrevId != "" {
-		rawRecord, err = storage.GetRecord(context.Background(), record.Content.PrevId)
+		rawRecord, err = storage.GetRawRecord(context.Background(), record.Content.PrevId)
 		if err != nil {
 			return nil, err
 		}
@@ -109,7 +111,7 @@ func (a *aclList) IsAfter(first string, second string) (bool, error) {
 	if !okFirst || !okSecond {
 		return false, fmt.Errorf("not all entries are there: first (%b), second (%b)", okFirst, okSecond)
 	}
-	return firstRec > secondRec, nil
+	return firstRec >= secondRec, nil
 }
 
 func (a *aclList) Head() *Record {
@@ -143,3 +145,7 @@ func (a *aclList) IterateFrom(startId string, iterFunc IterFunc) {
 		}
 	}
 }
+
+func (a *aclList) Close() (err error) {
+	return nil
+}

pkg/acl/list/storage.go

@@ -1,14 +0,0 @@
-package list
-
-import (
-	"context"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
-)
-
-type Storage interface {
-	ID() (string, error)
-	Head() (*aclpb.RawRecord, error)
-	Header() (*aclpb.Header, error)
-	GetRecord(ctx context.Context, id string) (*aclpb.RawRecord, error)
-	AddRecord(ctx context.Context, rec *aclpb.RawRecord) error
-}

pkg/acl/storage/inmemory.go

@@ -1,4 +1,4 @@
-package treestorage
+package storage
 
 import (
 	"context"
@@ -86,21 +86,21 @@ func (t *inMemoryTreeStorage) GetRawChange(ctx context.Context, changeId string)
 	return nil, fmt.Errorf("could not get change with id: %s", changeId)
 }
 
-type inMemoryTreeStorageProvider struct {
+type inMemoryStorageProvider struct {
-	trees map[string]TreeStorage
+	objects map[string]Storage
 	sync.RWMutex
 }
 
-func (i *inMemoryTreeStorageProvider) TreeStorage(treeId string) (TreeStorage, error) {
+func (i *inMemoryStorageProvider) Storage(id string) (Storage, error) {
 	i.RLock()
 	defer i.RUnlock()
-	if tree, exists := i.trees[treeId]; exists {
+	if tree, exists := i.objects[id]; exists {
 		return tree, nil
 	}
 	return nil, ErrUnknownTreeId
 }
 
-func (i *inMemoryTreeStorageProvider) CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (TreeStorage, error) {
+func (i *inMemoryStorageProvider) CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (TreeStorage, error) {
 	i.Lock()
 	defer i.Unlock()
 	res, err := NewInMemoryTreeStorage(treeId, header, changes)
@@ -108,12 +108,12 @@ func (i *inMemoryTreeStorageProvider) CreateTreeStorage(treeId string, header *a
 		return nil, err
 	}
 
-	i.trees[treeId] = res
+	i.objects[treeId] = res
 	return res, nil
 }
 
 func NewInMemoryTreeStorageProvider() Provider {
-	return &inMemoryTreeStorageProvider{
+	return &inMemoryStorageProvider{
-		trees: make(map[string]TreeStorage),
+		objects: make(map[string]Storage),
 	}
 }

pkg/acl/storage/liststorage.go

@@ -0,0 +1,14 @@
+package storage
+
+import (
+	"context"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
+)
+
+type ListStorage interface {
+	Storage
+	Head() (*aclpb.RawRecord, error)
+
+	GetRawRecord(ctx context.Context, id string) (*aclpb.RawRecord, error)
+	AddRawRecord(ctx context.Context, rec *aclpb.RawRecord) error
+}

pkg/acl/storage/provider.go

@@ -1,4 +1,4 @@
-package treestorage
+package storage
 
 import (
 	"errors"
@@ -8,6 +8,6 @@ import (
 var ErrUnknownTreeId = errors.New("tree does not exist")
 
 type Provider interface {
-	TreeStorage(treeId string) (TreeStorage, error)
+	Storage(id string) (Storage, error)
 	CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (TreeStorage, error)
 }

pkg/acl/storage/storage.go

@@ -0,0 +1,8 @@
+package storage
+
+import "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
+
+type Storage interface {
+	ID() (string, error)
+	Header() (*aclpb.Header, error)
+}

pkg/acl/storage/treestorage.go

@@ -1,4 +1,4 @@
-package treestorage
+package storage
 
 import (
 	"context"
@@ -6,9 +6,7 @@ import (
 )
 
 type TreeStorage interface {
-	ID() (string, error)
+	Storage
-
-	Header() (*aclpb.Header, error)
 	Heads() ([]string, error)
 	SetHeads(heads []string) error
 

pkg/acl/testutils/testchanges/proto/test.proto

@@ -0,0 +1,24 @@
+syntax = "proto3";
+package anytype;
+option go_package = "testchanges";
+
+message PlainTextChange {
+  message Content {
+    oneof value {
+      TextAppend textAppend = 1;
+    }
+  }
+
+  message TextAppend {
+    string text = 1;
+  }
+
+  message Snapshot {
+    string text = 1;
+  }
+
+  message Data {
+    repeated Content content = 1;
+    Snapshot snapshot = 2;
+  }
+}

pkg/acl/tree/commontree.go

@@ -2,7 +2,7 @@ package tree
 
 import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
 )
 
 type CommonTree interface {
@@ -15,7 +15,7 @@ type CommonTree interface {
 	HasChange(string) bool
 	SnapshotPath() []string
 	ChangesAfterCommonSnapshot(snapshotPath []string) ([]*aclpb.RawChange, error)
-	Storage() treestorage.TreeStorage
+	Storage() storage.TreeStorage
 	DebugDump() (string, error)
 	Close() error
 }

pkg/acl/tree/doctree.go

@@ -6,7 +6,7 @@ import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/account"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/util/cid"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys/asymmetric/signingkey"
@@ -56,7 +56,7 @@ type DocTree interface {
 }
 
 type docTree struct {
-	treeStorage    treestorage.TreeStorage
+	treeStorage    storage.TreeStorage
 	accountData    *account.AccountData
 	updateListener TreeUpdateListener
 
@@ -76,7 +76,7 @@ type docTree struct {
 	sync.RWMutex
 }
 
-func BuildDocTreeWithIdentity(t treestorage.TreeStorage, acc *account.AccountData, listener TreeUpdateListener, aclList list.ACLList) (DocTree, error) {
+func BuildDocTreeWithIdentity(t storage.TreeStorage, acc *account.AccountData, listener TreeUpdateListener, aclList list.ACLList) (DocTree, error) {
 	treeBuilder := newTreeBuilder(t, acc.Decoder)
 	validator := newTreeValidator()
 
@@ -112,7 +112,7 @@ func BuildDocTreeWithIdentity(t treestorage.TreeStorage, acc *account.AccountDat
 	return docTree, nil
 }
 
-func BuildDocTree(t treestorage.TreeStorage, decoder keys.Decoder, listener TreeUpdateListener, aclList list.ACLList) (DocTree, error) {
+func BuildDocTree(t storage.TreeStorage, decoder keys.Decoder, listener TreeUpdateListener, aclList list.ACLList) (DocTree, error) {
 	treeBuilder := newTreeBuilder(t, decoder)
 	validator := newTreeValidator()
 
@@ -182,7 +182,7 @@ func (d *docTree) Header() *aclpb.Header {
 	return d.header
 }
 
-func (d *docTree) Storage() treestorage.TreeStorage {
+func (d *docTree) Storage() storage.TreeStorage {
 	return d.treeStorage
 }
 

pkg/acl/tree/treebuilder.go

@@ -5,7 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys/asymmetric/signingkey"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice"
@@ -23,10 +23,10 @@ type treeBuilder struct {
 	identityKeys         map[string]signingkey.PubKey
 	signingPubKeyDecoder keys.Decoder
 	tree                 *Tree
-	treeStorage          treestorage.TreeStorage
+	treeStorage          storage.TreeStorage
 }
 
-func newTreeBuilder(t treestorage.TreeStorage, decoder keys.Decoder) *treeBuilder {
+func newTreeBuilder(t storage.TreeStorage, decoder keys.Decoder) *treeBuilder {
 	return &treeBuilder{
 		signingPubKeyDecoder: decoder,
 		treeStorage:          t,

pkg/acl/tree/treestorage.go

@@ -4,7 +4,7 @@ import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/account"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/util/cid"
 	"github.com/gogo/protobuf/proto"
 	"time"
@@ -14,7 +14,7 @@ import (
 //func CreateNewTreeStorageWithACL(
 //	acc *account.AccountData,
 //	build func(builder list.ACLChangeBuilder) error,
-//	create treestorage.CreatorFunc) (treestorage.TreeStorage, error) {
+//	create treestorage.CreatorFunc) (treestorage.Storage, error) {
 //	bld := list.newACLChangeBuilder()
 //	bld.Init(
 //		list.newACLStateWithIdentity(acc.Identity, acc.EncKey, signingkey.NewEd25519PubKeyDecoder()),
@@ -56,7 +56,7 @@ func CreateNewTreeStorage(
 	acc *account.AccountData,
 	aclList list.ACLList,
 	content proto.Marshaler,
-	create treestorage.CreatorFunc) (treestorage.TreeStorage, error) {
+	create storage.CreatorFunc) (storage.TreeStorage, error) {
 
 	state := aclList.ACLState()
 	change := &aclpb.Change{

service/api/service.go

@@ -54,7 +54,6 @@ func (s *service) Run(ctx context.Context) (err error) {
 	mux := http.NewServeMux()
 	mux.HandleFunc("/treeDump", s.treeDump)
 	mux.HandleFunc("/createDocumentTree", s.createDocumentTree)
-	mux.HandleFunc("/createACLTree", s.createACLTree)
 	mux.HandleFunc("/appendDocument", s.appendDocument)
 	s.srv.Handler = mux
 
@@ -99,21 +98,10 @@ func (s *service) createDocumentTree(w http.ResponseWriter, req *http.Request) {
 	var (
 		query     = req.URL.Query()
 		text      = query.Get("text")
-		aclTreeId = query.Get("aclTreeId")
+		aclListId = query.Get("aclListId")
 	)
 	timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*30)
-	treeId, err := s.documentService.CreateDocumentTree(timeoutCtx, aclTreeId, text)
+	treeId, err := s.documentService.CreateDocumentTree(timeoutCtx, aclListId, text)
-	cancel()
-	if err != nil {
-		sendText(w, http.StatusInternalServerError, err.Error())
-		return
-	}
-	sendText(w, http.StatusOK, treeId)
-}
-
-func (s *service) createACLTree(w http.ResponseWriter, req *http.Request) {
-	timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*30)
-	treeId, err := s.documentService.CreateACLTree(timeoutCtx)
 	cancel()
 	if err != nil {
 		sendText(w, http.StatusInternalServerError, err.Error())

service/document/service.go

@@ -7,9 +7,8 @@ import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/testutils/testchanges/testchangepb"
+	testchanges "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/testutils/testchanges/proto"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/service/account"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/service/node"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/service/storage"
@@ -35,7 +34,6 @@ type service struct {
 
 type Service interface {
 	UpdateDocumentTree(ctx context.Context, id, text string) error
-	CreateACLTree(ctx context.Context) (id string, err error)
 	CreateDocumentTree(ctx context.Context, aclTreeId string, text string) (id string, err error)
 }
 
@@ -60,7 +58,7 @@ func (s *service) Name() (name string) {
 }
 
 func (s *service) Run(ctx context.Context) (err error) {
-	return nil
+	return s.importACLList(ctx)
 }
 
 func (s *service) Close(ctx context.Context) (err error) {
@@ -70,7 +68,7 @@ func (s *service) Close(ctx context.Context) (err error) {
 func (s *service) UpdateDocumentTree(ctx context.Context, id, text string) (err error) {
 	var (
 		ch           *aclpb.RawChange
-		header       *treepb.TreeHeader
+		header       *aclpb.Header
 		snapshotPath []string
 		heads        []string
 	)
@@ -85,8 +83,8 @@ func (s *service) UpdateDocumentTree(ctx context.Context, id, text string) (err
 
 		docTree.Lock()
 		defer docTree.Unlock()
-		err = s.treeCache.Do(ctx, docTree.Header().AclTreeId, func(obj interface{}) error {
+		err = s.treeCache.Do(ctx, docTree.Header().AclListId, func(obj interface{}) error {
-			aclTree := obj.(tree.ACLTree)
+			aclTree := obj.(list.ACLList)
 			aclTree.RLock()
 			defer aclTree.RUnlock()
 
@@ -123,69 +121,20 @@ func (s *service) UpdateDocumentTree(ctx context.Context, id, text string) (err
 	}, header, id))
 }
 
-func (s *service) CreateACLTree(ctx context.Context) (id string, err error) {
+func (s *service) importACLList(ctx context.Context) (err error) {
-	acc := s.account.Account()
+	panic("not implemented")
-	var (
-		ch           *aclpb.RawChange
-		header       *treepb.TreeHeader
-		snapshotPath []string
-		heads        []string
-	)
-
-	t, err := tree.CreateNewTreeStorageWithACL(acc, func(builder list.ACLChangeBuilder) error {
-		err := builder.UserAdd(acc.Identity, acc.EncKey.GetPublic(), aclpb.ACLChange_Admin)
-		if err != nil {
-			return err
-		}
-		// adding all predefined nodes to the document as admins
-		for _, n := range s.nodes {
-			err = builder.UserAdd(n.SigningKeyString, n.EncryptionKey, aclpb.ACLChange_Admin)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	}, s.storage.CreateTreeStorage)
-
-	id, err = t.TreeID()
-	if err != nil {
-		return "", err
-	}
-
-	header, err = t.Header()
-	if err != nil {
-		return "", err
-	}
-
-	heads = []string{header.FirstChangeId}
-	snapshotPath = []string{header.FirstChangeId}
-	ch, err = t.GetChange(ctx, header.FirstChangeId)
-	if err != nil {
-		return "", err
-	}
-
-	if err != nil {
-		return "", err
-	}
-
-	err = s.messageService.SendToSpaceAsync("", syncproto.WrapHeadUpdate(&syncproto.SyncHeadUpdate{
-		Heads:        heads,
-		Changes:      []*aclpb.RawChange{ch},
-		SnapshotPath: snapshotPath,
-	}, header, id))
-	return id, nil
 }
 
-func (s *service) CreateDocumentTree(ctx context.Context, aclTreeId string, text string) (id string, err error) {
+func (s *service) CreateDocumentTree(ctx context.Context, aclListId string, text string) (id string, err error) {
 	acc := s.account.Account()
 	var (
 		ch           *aclpb.RawChange
-		header       *treepb.TreeHeader
+		header       *aclpb.Header
 		snapshotPath []string
 		heads        []string
 	)
-	err = s.treeCache.Do(ctx, aclTreeId, func(obj interface{}) error {
+	err = s.treeCache.Do(ctx, aclListId, func(obj interface{}) error {
-		t := obj.(tree.ACLTree)
+		t := obj.(list.ACLList)
 		t.RLock()
 		defer t.RUnlock()
 
@@ -205,9 +154,9 @@ func (s *service) CreateDocumentTree(ctx context.Context, aclTreeId string, text
 			return err
 		}
 
-		heads = []string{header.FirstChangeId}
+		heads = []string{header.FirstId}
-		snapshotPath = []string{header.FirstChangeId}
+		snapshotPath = []string{header.FirstId}
-		ch, err = doc.GetRawChange(ctx, header.FirstChangeId)
+		ch, err = doc.GetRawChange(ctx, header.FirstId)
 		if err != nil {
 			return err
 		}
@@ -233,26 +182,26 @@ func (s *service) CreateDocumentTree(ctx context.Context, aclTreeId string, text
 }
 
 func createInitialTextChange(text string) proto.Marshaler {
-	return &testchangepb.PlainTextChangeData{
+	return &testchanges.PlainTextChangeData{
-		Content: []*testchangepb.PlainTextChangeContent{
+		Content: []*testchanges.PlainTextChangeContent{
 			createAppendTextChangeContent(text),
 		},
-		Snapshot: &testchangepb.PlainTextChangeSnapshot{Text: text},
+		Snapshot: &testchanges.PlainTextChangeSnapshot{Text: text},
 	}
 }
 
 func createAppendTextChange(text string) proto.Marshaler {
-	return &testchangepb.PlainTextChangeData{
+	return &testchanges.PlainTextChangeData{
-		Content: []*testchangepb.PlainTextChangeContent{
+		Content: []*testchanges.PlainTextChangeContent{
 			createAppendTextChangeContent(text),
 		},
 	}
 }
 
-func createAppendTextChangeContent(text string) *testchangepb.PlainTextChangeContent {
+func createAppendTextChangeContent(text string) *testchanges.PlainTextChangeContent {
-	return &testchangepb.PlainTextChangeContent{
+	return &testchanges.PlainTextChangeContent{
-		Value: &testchangepb.PlainTextChangeContentValueOfTextAppend{
+		Value: &testchanges.PlainTextChangeContentValueOfTextAppend{
-			TextAppend: &testchangepb.PlainTextChangeTextAppend{
+			TextAppend: &testchanges.PlainTextChangeTextAppend{
 				Text: text,
 			},
 		},

service/storage/service.go

@@ -4,14 +4,13 @@ import (
 	"context"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/app"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
 )
 
 var CName = "storage"
 
 type Service interface {
-	treestorage.Provider
+	storage.Provider
 }
 
 func New() app.Component {
@@ -19,19 +18,19 @@ func New() app.Component {
 }
 
 type service struct {
-	storageProvider treestorage.Provider
+	storageProvider storage.Provider
 }
 
 func (s *service) Init(ctx context.Context, a *app.App) (err error) {
-	s.storageProvider = treestorage.NewInMemoryTreeStorageProvider()
+	s.storageProvider = storage.NewInMemoryTreeStorageProvider()
 	return nil
 }
 
-func (s *service) TreeStorage(treeId string) (treestorage.TreeStorage, error) {
+func (s *service) Storage(treeId string) (storage.Storage, error) {
-	return s.storageProvider.TreeStorage(treeId)
+	return s.storageProvider.Storage(treeId)
 }
 
-func (s *service) CreateTreeStorage(treeId string, header *treepb.TreeHeader, changes []*aclpb.RawChange) (treestorage.TreeStorage, error) {
+func (s *service) CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (storage.TreeStorage, error) {
 	return s.storageProvider.CreateTreeStorage(treeId, header, changes)
 }
 

service/sync/message/service.go

@@ -119,6 +119,6 @@ func msgInfo(content *syncproto.Sync) (syncMethod string) {
 	case msg.GetHeadUpdate() != nil:
 		syncMethod = "HeadUpdate"
 	}
-	syncMethod = fmt.Sprintf("method: %s, treeType: %s", syncMethod, content.TreeHeader.Type.String())
+	syncMethod = fmt.Sprintf("method: %s, treeType: %s", syncMethod, content.TreeHeader.DocType.String())
 	return
 }

service/sync/requesthandler/requesthandler.go

@@ -6,9 +6,9 @@ import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/app"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/service/account"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/service/treecache"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto"
@@ -77,7 +77,7 @@ func (r *requestHandler) HandleHeadUpdate(
 	ctx context.Context,
 	senderId string,
 	update *syncproto.SyncHeadUpdate,
-	header *treepb.TreeHeader,
+	header *aclpb.Header,
 	treeId string) (err error) {
 
 	var (
@@ -88,81 +88,41 @@ func (r *requestHandler) HandleHeadUpdate(
 	log.With(zap.String("peerId", senderId), zap.String("treeId", treeId)).
 		Debug("processing head update")
 
-	updateACLTree := func() {
+	err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
-		err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
+		docTree := obj.(tree.DocTree)
-			t := obj.(tree.ACLTree)
+		docTree.Lock()
-			t.Lock()
+		defer docTree.Unlock()
-			defer t.Unlock()
 
-			if slice.UnsortedEquals(update.Heads, t.Heads()) {
+		if slice.UnsortedEquals(update.Heads, docTree.Heads()) {
-				return nil
+			return nil
-			}
+		}
+
+		return r.treeCache.Do(ctx, docTree.Header().AclListId, func(obj interface{}) error {
+			aclTree := obj.(list.ACLList)
+			aclTree.RLock()
+			defer aclTree.RUnlock()
 
 			// TODO: check if we already have those changes
-			result, err = t.AddRawChanges(ctx, update.Changes...)
+			result, err = docTree.AddRawChanges(ctx, aclTree, update.Changes...)
 			if err != nil {
 				return err
 			}
-			log.With(zap.Strings("update heads", update.Heads), zap.Strings("tree heads", t.Heads())).
+			log.With(zap.Strings("update heads", update.Heads), zap.Strings("tree heads", docTree.Heads())).
 				Debug("comparing heads after head update")
-			shouldFullSync := !slice.UnsortedEquals(update.Heads, t.Heads())
+			shouldFullSync := !slice.UnsortedEquals(update.Heads, docTree.Heads())
-			snapshotPath = t.SnapshotPath()
+			snapshotPath = docTree.SnapshotPath()
 			if shouldFullSync {
-				fullRequest, err = r.prepareFullSyncRequest(treeId, header, update.SnapshotPath, t)
+				fullRequest, err = r.prepareFullSyncRequest(update.SnapshotPath, docTree)
 				if err != nil {
 					return err
 				}
 			}
 			return nil
 		})
-	}
+	})
-
-	updateDocTree := func() {
-		err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
-			docTree := obj.(tree.DocTree)
-			docTree.Lock()
-			defer docTree.Unlock()
-
-			if slice.UnsortedEquals(update.Heads, docTree.Heads()) {
-				return nil
-			}
-
-			return r.treeCache.Do(ctx, docTree.Header().AclTreeId, func(obj interface{}) error {
-				aclTree := obj.(tree.ACLTree)
-				aclTree.RLock()
-				defer aclTree.RUnlock()
-
-				// TODO: check if we already have those changes
-				result, err = docTree.AddRawChanges(ctx, aclTree, update.Changes...)
-				if err != nil {
-					return err
-				}
-				log.With(zap.Strings("update heads", update.Heads), zap.Strings("tree heads", docTree.Heads())).
-					Debug("comparing heads after head update")
-				shouldFullSync := !slice.UnsortedEquals(update.Heads, docTree.Heads())
-				snapshotPath = docTree.SnapshotPath()
-				if shouldFullSync {
-					fullRequest, err = r.prepareFullSyncRequest(treeId, header, update.SnapshotPath, docTree)
-					if err != nil {
-						return err
-					}
-				}
-				return nil
-			})
-		})
-	}
-
-	switch header.Type {
-	case treepb.TreeHeader_ACLTree:
-		updateACLTree()
-	case treepb.TreeHeader_DocTree:
-		updateDocTree()
-	default:
-		return ErrIncorrectDocType
-	}
 
 	// if there are no such tree
-	if err == treestorage.ErrUnknownTreeId {
+	if err == storage.ErrUnknownTreeId {
 		// TODO: maybe we can optimize this by sending the header and stuff right away, so when the tree is created we are able to add it on first request
 		fullRequest = &syncproto.SyncFullRequest{}
 	}
@@ -188,7 +148,7 @@ func (r *requestHandler) HandleFullSyncRequest(
 	ctx context.Context,
 	senderId string,
 	request *syncproto.SyncFullRequest,
-	header *treepb.TreeHeader,
+	header *aclpb.Header,
 	treeId string) (err error) {
 
 	var (
@@ -199,74 +159,36 @@ func (r *requestHandler) HandleFullSyncRequest(
 	log.With(zap.String("peerId", senderId), zap.String("treeId", treeId)).
 		Debug("processing full sync request")
 
-	requestACLTree := func() {
+	log.Info("getting doc tree from treeCache", zap.String("treeId", treeId))
-		err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
+	err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
-			t := obj.(tree.ACLTree)
+		docTree := obj.(tree.DocTree)
-			t.Lock()
+		docTree.Lock()
-			defer t.Unlock()
+		defer docTree.Unlock()
-
-			//if slice.UnsortedEquals(request.Heads, t.Heads()) {
-			//	return nil
-			//}
 
+		//if slice.UnsortedEquals(request.Heads, docTree.Heads()) {
+		//	return nil
+		//}
+		log.Info("getting tree from treeCache", zap.String("aclId", docTree.Header().AclListId))
+		return r.treeCache.Do(ctx, docTree.Header().AclListId, func(obj interface{}) error {
+			aclTree := obj.(list.ACLList)
+			aclTree.RLock()
+			defer aclTree.RUnlock()
 			// TODO: check if we already have those changes
 			// if we have non-empty request
 			if len(request.Heads) != 0 {
-				result, err = t.AddRawChanges(ctx, request.Changes...)
+				result, err = docTree.AddRawChanges(ctx, aclTree, request.Changes...)
 				if err != nil {
 					return err
 				}
 			}
-			snapshotPath = t.SnapshotPath()
+			snapshotPath = docTree.SnapshotPath()
-			fullResponse, err = r.prepareFullSyncResponse(treeId, request.SnapshotPath, request.Changes, t)
+			fullResponse, err = r.prepareFullSyncResponse(treeId, request.SnapshotPath, request.Changes, docTree)
 			if err != nil {
 				return err
 			}
 			return nil
 		})
-	}
+	})
-
-	requestDocTree := func() {
-		log.Info("getting doc tree from treeCache", zap.String("treeId", treeId))
-		err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
-			docTree := obj.(tree.DocTree)
-			docTree.Lock()
-			defer docTree.Unlock()
-
-			//if slice.UnsortedEquals(request.Heads, docTree.Heads()) {
-			//	return nil
-			//}
-			log.Info("getting tree from treeCache", zap.String("aclId", docTree.Header().AclTreeId))
-			return r.treeCache.Do(ctx, docTree.Header().AclTreeId, func(obj interface{}) error {
-				aclTree := obj.(tree.ACLTree)
-				aclTree.RLock()
-				defer aclTree.RUnlock()
-				// TODO: check if we already have those changes
-				// if we have non-empty request
-				if len(request.Heads) != 0 {
-					result, err = docTree.AddRawChanges(ctx, aclTree, request.Changes...)
-					if err != nil {
-						return err
-					}
-				}
-				snapshotPath = docTree.SnapshotPath()
-				fullResponse, err = r.prepareFullSyncResponse(treeId, request.SnapshotPath, request.Changes, docTree)
-				if err != nil {
-					return err
-				}
-				return nil
-			})
-		})
-	}
-
-	switch header.Type {
-	case treepb.TreeHeader_ACLTree:
-		requestACLTree()
-	case treepb.TreeHeader_DocTree:
-		requestDocTree()
-	default:
-		return ErrIncorrectDocType
-	}
 
 	if err != nil {
 		return err
@@ -290,7 +212,7 @@ func (r *requestHandler) HandleFullSyncResponse(
 	ctx context.Context,
 	senderId string,
 	response *syncproto.SyncFullResponse,
-	header *treepb.TreeHeader,
+	header *aclpb.Header,
 	treeId string) (err error) {
 
 	var (
@@ -300,66 +222,35 @@ func (r *requestHandler) HandleFullSyncResponse(
 	log.With(zap.String("peerId", senderId), zap.String("treeId", treeId)).
 		Debug("processing full sync response")
 
-	responseACLTree := func() {
+	err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
-		err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
+		docTree := obj.(tree.DocTree)
-			t := obj.(tree.ACLTree)
+		docTree.Lock()
-			t.Lock()
+		defer docTree.Unlock()
-			defer t.Unlock()
 
-			if slice.UnsortedEquals(response.Heads, t.Heads()) {
+		if slice.UnsortedEquals(response.Heads, docTree.Heads()) {
-				return nil
+			return nil
-			}
+		}
 
+		return r.treeCache.Do(ctx, docTree.Header().AclListId, func(obj interface{}) error {
+			aclTree := obj.(list.ACLList)
+			aclTree.RLock()
+			defer aclTree.RUnlock()
 			// TODO: check if we already have those changes
-			result, err = t.AddRawChanges(ctx, response.Changes...)
+			result, err = docTree.AddRawChanges(ctx, aclTree, response.Changes...)
 			if err != nil {
 				return err
 			}
-			snapshotPath = t.SnapshotPath()
+			snapshotPath = docTree.SnapshotPath()
 			return nil
 		})
-	}
+	})
-
-	responseDocTree := func() {
-		err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
-			docTree := obj.(tree.DocTree)
-			docTree.Lock()
-			defer docTree.Unlock()
-
-			if slice.UnsortedEquals(response.Heads, docTree.Heads()) {
-				return nil
-			}
-
-			return r.treeCache.Do(ctx, docTree.Header().AclTreeId, func(obj interface{}) error {
-				aclTree := obj.(tree.ACLTree)
-				aclTree.RLock()
-				defer aclTree.RUnlock()
-				// TODO: check if we already have those changes
-				result, err = docTree.AddRawChanges(ctx, aclTree, response.Changes...)
-				if err != nil {
-					return err
-				}
-				snapshotPath = docTree.SnapshotPath()
-				return nil
-			})
-		})
-	}
-
-	switch header.Type {
-	case treepb.TreeHeader_ACLTree:
-		responseACLTree()
-	case treepb.TreeHeader_DocTree:
-		responseDocTree()
-	default:
-		return ErrIncorrectDocType
-	}
 
 	// if error or nothing has changed
-	if (err != nil || len(result.Added) == 0) && err != treestorage.ErrUnknownTreeId {
+	if (err != nil || len(result.Added) == 0) && err != storage.ErrUnknownTreeId {
 		return err
 	}
 	// if we have a new tree
-	if err == treestorage.ErrUnknownTreeId {
+	if err == storage.ErrUnknownTreeId {
 		err = r.createTree(ctx, response, header, treeId)
 		if err != nil {
 			return err
@@ -379,7 +270,7 @@ func (r *requestHandler) HandleFullSyncResponse(
 	return r.messageService.SendToSpaceAsync("", syncproto.WrapHeadUpdate(newUpdate, header, treeId))
 }
 
-func (r *requestHandler) prepareFullSyncRequest(treeId string, header *treepb.TreeHeader, theirPath []string, t tree.CommonTree) (*syncproto.SyncFullRequest, error) {
+func (r *requestHandler) prepareFullSyncRequest(theirPath []string, t tree.CommonTree) (*syncproto.SyncFullRequest, error) {
 	ourChanges, err := t.ChangesAfterCommonSnapshot(theirPath)
 	if err != nil {
 		return nil, err
@@ -426,7 +317,7 @@ func (r *requestHandler) prepareFullSyncResponse(
 func (r *requestHandler) createTree(
 	ctx context.Context,
 	response *syncproto.SyncFullResponse,
-	header *treepb.TreeHeader,
+	header *aclpb.Header,
 	treeId string) error {
 
 	return r.treeCache.Add(

service/treecache/service.go

@@ -7,6 +7,7 @@ import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
+	aclstorage "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ocache"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/service/account"
@@ -17,13 +18,13 @@ import (
 const CName = "treecache"
 
 // TODO: add context
-type TreeFunc = func(tree interface{}) error
+type ObjFunc = func(obj interface{}) error
 
 var log = logger.NewNamed("treecache")
 
 type Service interface {
-	Do(ctx context.Context, treeId string, f TreeFunc) error
+	Do(ctx context.Context, treeId string, f ObjFunc) error
-	Add(ctx context.Context, treeId string, header *aclpb.Header, changes []*aclpb.RawChange, f TreeFunc) error
+	Add(ctx context.Context, treeId string, header *aclpb.Header, changes []*aclpb.RawChange, f ObjFunc) error
 }
 
 type service struct {
@@ -36,7 +37,7 @@ func New() app.ComponentRunnable {
 	return &service{}
 }
 
-func (s *service) Do(ctx context.Context, treeId string, f TreeFunc) error {
+func (s *service) Do(ctx context.Context, treeId string, f ObjFunc) error {
 	log.
 		With(zap.String("treeId", treeId)).
 		Debug("requesting tree from cache to perform operation")
@@ -49,7 +50,7 @@ func (s *service) Do(ctx context.Context, treeId string, f TreeFunc) error {
 	return f(t)
 }
 
-func (s *service) Add(ctx context.Context, treeId string, header *treepb.TreeHeader, changes []*aclpb.RawChange, f TreeFunc) error {
+func (s *service) Add(ctx context.Context, treeId string, header *aclpb.Header, changes []*aclpb.RawChange, f ObjFunc) error {
 	log.
 		With(zap.String("treeId", treeId), zap.Int("len(changes)", len(changes))).
 		Debug("adding tree with changes")
@@ -82,7 +83,7 @@ func (s *service) Close(ctx context.Context) (err error) {
 }
 
 func (s *service) loadTree(ctx context.Context, id string) (ocache.Object, error) {
-	t, err := s.storage.TreeStorage(id)
+	t, err := s.storage.Storage(id)
 	if err != nil {
 		return nil, err
 	}
@@ -93,7 +94,7 @@ func (s *service) loadTree(ctx context.Context, id string) (ocache.Object, error
 
 	switch header.DocType {
 	case aclpb.Header_ACL:
-		return list.BuildACLListWithIdentity(acc)
+		return list.BuildACLListWithIdentity(s.account.Account(), t.(aclstorage.ListStorage))
 	case aclpb.Header_DocTree:
 		break
 	default:
@@ -101,13 +102,13 @@ func (s *service) loadTree(ctx context.Context, id string) (ocache.Object, error
 	}
 	log.Info("got header", zap.String("header", header.String()))
 	var docTree tree.DocTree
-	// TODO: it is a question if we need to use ACLTree on the first tree build, because we can think that the tree is already validated
+	// TODO: it is a question if we need to use ACLList on the first tree build, because we can think that the tree is already validated
-	err = s.Do(ctx, header.AclTreeId, func(obj interface{}) error {
+	err = s.Do(ctx, header.AclListId, func(obj interface{}) error {
-		aclTree := obj.(tree.ACLTree)
+		aclTree := obj.(list.ACLList)
 		aclTree.RLock()
 		defer aclTree.RUnlock()
 
-		docTree, err = tree.BuildDocTreeWithIdentity(t, s.account.Account(), nil, aclTree)
+		docTree, err = tree.BuildDocTreeWithIdentity(t.(aclstorage.TreeStorage), s.account.Account(), nil, aclTree)
 		if err != nil {
 			return err
 		}

syncproto/helpers.go

@@ -1,6 +1,6 @@
 package syncproto
 
-import "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
+import "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage/treepb"
 
 func WrapHeadUpdate(update *SyncHeadUpdate, header *treepb.TreeHeader, treeId string) *Sync {
 	return &Sync{

syncproto/proto/sync.proto

@@ -3,7 +3,6 @@ package anytype;
 option go_package = "/syncproto";
 
 import "pkg/acl/aclchanges/aclpb/protos/aclchanges.proto";
-import "pkg/acl/treestorage/treepb/protos/tree.proto";
 
 message Message {
     Header header = 1;
@@ -64,7 +63,7 @@ message Subscription {
 message Sync {
     string spaceId = 1;
     ContentValue message = 2;
-    tree.TreeHeader treeHeader = 3;
+    acl.Header treeHeader = 3;
     string treeId = 4;
 
     message ContentValue {

syncproto/sync.pb.go

@@ -6,7 +6,6 @@ package syncproto
 import (
 	fmt "fmt"
 	aclpb "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
-	treepb "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
 	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
@@ -590,10 +589,10 @@ func (m *SubscriptionUnsubscribeSpace) GetSpaceId() string {
 }
 
 type Sync struct {
-	SpaceId    string             `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
+	SpaceId    string            `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
-	Message    *SyncContentValue  `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+	Message    *SyncContentValue `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
-	TreeHeader *treepb.TreeHeader `protobuf:"bytes,3,opt,name=treeHeader,proto3" json:"treeHeader,omitempty"`
+	TreeHeader *aclpb.Header     `protobuf:"bytes,3,opt,name=treeHeader,proto3" json:"treeHeader,omitempty"`
-	TreeId     string             `protobuf:"bytes,4,opt,name=treeId,proto3" json:"treeId,omitempty"`
+	TreeId     string            `protobuf:"bytes,4,opt,name=treeId,proto3" json:"treeId,omitempty"`
 }
 
 func (m *Sync) Reset()         { *m = Sync{} }
@@ -643,7 +642,7 @@ func (m *Sync) GetMessage() *SyncContentValue {
 	return nil
 }
 
-func (m *Sync) GetTreeHeader() *treepb.TreeHeader {
+func (m *Sync) GetTreeHeader() *aclpb.Header {
 	if m != nil {
 		return m.TreeHeader
 	}
@@ -996,61 +995,60 @@ func init() {
 func init() { proto.RegisterFile("syncproto/proto/sync.proto", fileDescriptor_4b28dfdd48a89166) }
 
 var fileDescriptor_4b28dfdd48a89166 = []byte{
-	// 858 bytes of a gzipped FileDescriptorProto
+	// 840 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xd1, 0x8e, 0xda, 0x46,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xd1, 0x8e, 0xdb, 0x44,
-	0x14, 0xc5, 0x60, 0x20, 0x5c, 0x10, 0xeb, 0x4e, 0x92, 0xd6, 0x75, 0x22, 0x84, 0x50, 0xda, 0x5a,
+	0x14, 0x8d, 0x13, 0x27, 0x69, 0x6e, 0xa2, 0xac, 0x99, 0xb6, 0x60, 0xdc, 0x2a, 0xb2, 0xac, 0x02,
-	0x69, 0xe4, 0x8d, 0x68, 0xa3, 0x4a, 0x7d, 0x4b, 0xb6, 0xbb, 0x02, 0x35, 0x05, 0x34, 0xc0, 0x56,
+	0x56, 0x8b, 0xbc, 0x28, 0x50, 0x21, 0xf1, 0xd6, 0x2e, 0xbb, 0x4a, 0x44, 0x49, 0xa2, 0xc9, 0x66,
-	0xea, 0x4b, 0x34, 0xd8, 0x13, 0x40, 0x78, 0xc7, 0xae, 0xc7, 0x6e, 0xcb, 0x2f, 0xf4, 0x29, 0xdf,
+	0x91, 0x78, 0xa9, 0x26, 0xf6, 0x34, 0x89, 0xe2, 0x1d, 0x1b, 0x8f, 0x0d, 0xe4, 0x17, 0x78, 0xea,
-	0xd0, 0x6f, 0xe8, 0x47, 0xf4, 0x31, 0x8f, 0x7d, 0xac, 0x76, 0xd5, 0x7e, 0x47, 0x35, 0x33, 0x36,
+	0x37, 0xf0, 0x0d, 0x7c, 0x04, 0x8f, 0x7d, 0xe4, 0x09, 0xa1, 0x5d, 0xc1, 0x77, 0xa0, 0x99, 0xb1,
-	0xf6, 0x3a, 0xe4, 0x35, 0x0f, 0xc0, 0xdc, 0x33, 0xe7, 0xdc, 0x7b, 0x2e, 0xe3, 0xb9, 0x06, 0x8b,
+	0x13, 0xaf, 0xbb, 0x7d, 0xed, 0x43, 0x92, 0xb9, 0xf7, 0x9e, 0x73, 0xe6, 0x5c, 0x8f, 0xef, 0x04,
-	0xef, 0x99, 0x1b, 0x46, 0x41, 0x1c, 0x9c, 0xaa, 0x6f, 0x11, 0x3b, 0x72, 0x89, 0x9a, 0x84, 0xed,
+	0x2c, 0xbe, 0x63, 0x7e, 0x9c, 0x44, 0x69, 0x74, 0xac, 0xbe, 0x45, 0xec, 0xc9, 0x25, 0x6a, 0x13,
-	0xe3, 0x7d, 0x48, 0xad, 0xa7, 0xe1, 0x6e, 0x7d, 0x4a, 0x5c, 0x5f, 0x7c, 0xdc, 0x0d, 0x61, 0x6b,
+	0xb6, 0x4b, 0x77, 0x31, 0xb5, 0xbe, 0x88, 0xb7, 0xab, 0x63, 0xe2, 0x87, 0xe2, 0xe3, 0xaf, 0x09,
-	0xca, 0xc5, 0x32, 0x5c, 0x29, 0x0d, 0x2f, 0xe0, 0x4a, 0x6a, 0x3d, 0xc9, 0x14, 0x71, 0x44, 0x29,
+	0x5b, 0x51, 0x2e, 0x96, 0xf1, 0x52, 0x71, 0x78, 0x29, 0xaf, 0xa8, 0xce, 0x19, 0xb4, 0xbf, 0xa7,
-	0x8f, 0x83, 0x88, 0xac, 0xa9, 0x5c, 0xe7, 0x1a, 0x11, 0x29, 0xf6, 0xe0, 0x02, 0x9a, 0x3f, 0x50,
+	0x9c, 0x93, 0x15, 0x45, 0x9f, 0x41, 0x6b, 0x4d, 0x49, 0x40, 0x13, 0x53, 0xb3, 0x35, 0xb7, 0x3b,
-	0xce, 0xc9, 0x9a, 0xa2, 0x2f, 0xa0, 0xb1, 0xa1, 0xc4, 0xa3, 0x91, 0xa9, 0xf5, 0x35, 0xbb, 0x3d,
+	0x3c, 0xf2, 0x72, 0x59, 0x6f, 0x24, 0xd3, 0x38, 0x2f, 0x23, 0x04, 0x7a, 0x40, 0x52, 0x62, 0xd6,
-	0x3c, 0x71, 0x52, 0x13, 0xce, 0x48, 0xc2, 0x38, 0xdd, 0x46, 0x08, 0x74, 0x8f, 0xc4, 0xc4, 0xac,
+	0x6d, 0xcd, 0xed, 0x61, 0xb9, 0x76, 0x7e, 0xd7, 0xa0, 0xa5, 0x60, 0xc8, 0x84, 0x76, 0x9a, 0x10,
-	0xf6, 0x35, 0xbb, 0x83, 0xe5, 0x7a, 0xf0, 0x87, 0x06, 0x0d, 0x45, 0x43, 0x26, 0x34, 0xe3, 0x88,
+	0x9f, 0x8e, 0x03, 0x29, 0xd4, 0xc3, 0x45, 0x88, 0x1e, 0x42, 0x27, 0xa1, 0x3f, 0x65, 0x94, 0xa7,
-	0xb8, 0x74, 0xec, 0xc9, 0x44, 0x1d, 0x9c, 0x85, 0xe8, 0x21, 0xb4, 0x22, 0xfa, 0x73, 0x42, 0x79,
+	0xe3, 0x40, 0xb2, 0x75, 0x7c, 0x48, 0x08, 0x5e, 0x42, 0xe3, 0x70, 0x37, 0x0e, 0xcc, 0x86, 0xac,
-	0x3c, 0xf6, 0xa4, 0x5a, 0xc7, 0x39, 0x20, 0x74, 0x11, 0x0d, 0xfd, 0xfd, 0xd8, 0x33, 0x6b, 0x72,
+	0x15, 0x21, 0x72, 0x41, 0x17, 0x3e, 0x4c, 0xdd, 0xd6, 0xdc, 0xfe, 0xf0, 0xde, 0xde, 0x57, 0xee,
-	0x2f, 0x0b, 0x91, 0x0d, 0xba, 0xf0, 0x61, 0xea, 0x7d, 0xcd, 0xee, 0x0e, 0xef, 0x1d, 0x7c, 0xa5,
+	0xfc, 0x7c, 0x17, 0x53, 0x2c, 0x11, 0x62, 0x87, 0x80, 0x2e, 0xb3, 0xd5, 0x98, 0xbd, 0x8a, 0xcc,
-	0xce, 0x17, 0xfb, 0x90, 0x62, 0xc9, 0x10, 0x15, 0x3c, 0xba, 0x4a, 0xd6, 0x63, 0xf6, 0x3a, 0x30,
+	0xa6, 0xad, 0xb9, 0x1d, 0x7c, 0x48, 0x38, 0x7f, 0x34, 0xa0, 0x35, 0xdf, 0xf1, 0x94, 0x5e, 0xa2,
-	0xeb, 0x7d, 0xcd, 0x6e, 0xe1, 0x1c, 0x18, 0xfc, 0x59, 0x83, 0xc6, 0x7c, 0xcf, 0x63, 0x7a, 0x85,
+	0xaf, 0xa1, 0xb3, 0x26, 0x2c, 0xe0, 0x6b, 0xb2, 0xa5, 0x79, 0xbf, 0x1f, 0xef, 0x75, 0x15, 0xc6,
-	0xbe, 0x81, 0xd6, 0x86, 0x30, 0x8f, 0x6f, 0xc8, 0x8e, 0xa6, 0xfd, 0x7e, 0x7a, 0xc8, 0xab, 0x38,
+	0x1b, 0x15, 0x00, 0x7c, 0xc0, 0x0a, 0x2f, 0xf1, 0x86, 0xad, 0xa4, 0xfd, 0x6e, 0xc9, 0x4b, 0xce,
-	0xce, 0x28, 0x23, 0xe0, 0x9c, 0x2b, 0xbc, 0x84, 0x5b, 0xb6, 0x96, 0xf6, 0xdb, 0x05, 0x2f, 0xa9,
+	0x99, 0x6d, 0xd8, 0x0a, 0x4b, 0x04, 0xfa, 0x04, 0x1a, 0xc4, 0xdf, 0xca, 0x5e, 0xba, 0xc3, 0xbb,
-	0x66, 0xb6, 0x65, 0x6b, 0x2c, 0x19, 0xe8, 0x33, 0xa8, 0x11, 0x77, 0x27, 0x7b, 0x69, 0x0f, 0xef,
+	0x55, 0xe0, 0x33, 0x7f, 0x8b, 0x45, 0xdd, 0x7a, 0x0a, 0x9d, 0x51, 0x49, 0xfd, 0x48, 0x9e, 0x8b,
-	0x96, 0x89, 0xcf, 0xdd, 0x1d, 0x16, 0xfb, 0xd6, 0x33, 0x68, 0x8d, 0x0a, 0xd9, 0x4f, 0xe4, 0xb9,
+	0x1f, 0x85, 0x17, 0x34, 0xe1, 0x9b, 0x88, 0x49, 0x73, 0x1d, 0x5c, 0x4d, 0x5b, 0x0e, 0xe8, 0x62,
-	0xb8, 0x81, 0x7f, 0x49, 0x23, 0xbe, 0x0d, 0x98, 0x34, 0xd7, 0xc2, 0x65, 0xd8, 0x1a, 0x80, 0x2e,
+	0x2f, 0x64, 0xc1, 0x9d, 0x8c, 0x6d, 0x7e, 0x3d, 0xdf, 0x5c, 0xaa, 0x3e, 0x74, 0xbc, 0x8f, 0xad,
-	0x6a, 0x21, 0x0b, 0xee, 0x24, 0x6c, 0xfb, 0xdb, 0x62, 0x7b, 0xa5, 0xfa, 0xd0, 0xf1, 0x21, 0xb6,
+	0x21, 0x34, 0x9e, 0xf9, 0x5b, 0xf4, 0x04, 0x9a, 0x34, 0x49, 0xa2, 0x24, 0xf7, 0x7c, 0xbf, 0x6a,
-	0x86, 0x50, 0x7b, 0xee, 0xee, 0xd0, 0x97, 0x50, 0xa7, 0x51, 0x14, 0x44, 0xa9, 0xe7, 0xfb, 0x65,
+	0xe5, 0x54, 0x14, 0xb1, 0xc2, 0x58, 0xaf, 0x35, 0x68, 0xca, 0x04, 0xf2, 0x40, 0xf7, 0xa3, 0x40,
-	0x2b, 0xe7, 0x62, 0x13, 0x2b, 0x8e, 0xf5, 0x46, 0x83, 0xba, 0x04, 0x90, 0x03, 0xba, 0x1b, 0x78,
+	0xa9, 0xf6, 0x87, 0xd6, 0xad, 0x2c, 0xef, 0x24, 0x0a, 0x28, 0x96, 0x38, 0x64, 0x43, 0x37, 0xa0,
-	0x2a, 0x6b, 0x77, 0x68, 0x1d, 0x55, 0x39, 0x67, 0x81, 0x47, 0xb1, 0xe4, 0xa1, 0x3e, 0xb4, 0x3d,
+	0xdc, 0x4f, 0x36, 0x71, 0x2a, 0x7c, 0xd7, 0xa5, 0xef, 0x72, 0xca, 0x79, 0x0a, 0xba, 0xc0, 0xa3,
-	0xca, 0xdd, 0x68, 0x1b, 0xc6, 0xc2, 0x77, 0x55, 0xfa, 0x2e, 0x42, 0x83, 0x67, 0xa0, 0x0b, 0x3e,
+	0x2e, 0xb4, 0x17, 0x93, 0xef, 0x26, 0xd3, 0x1f, 0x26, 0x46, 0x0d, 0xd9, 0xf0, 0x70, 0x31, 0x99,
-	0x6a, 0x43, 0x73, 0x39, 0xf9, 0x7e, 0x32, 0xfd, 0x71, 0x62, 0x54, 0x50, 0x1f, 0x1e, 0x2e, 0x27,
+	0x2f, 0x66, 0xb3, 0x29, 0x3e, 0x3f, 0xfd, 0xf6, 0xe5, 0x0c, 0x4f, 0xcf, 0xa7, 0x27, 0xd3, 0x17,
-	0xf3, 0xe5, 0x6c, 0x36, 0xc5, 0x8b, 0xf3, 0xef, 0x5e, 0xcd, 0xf0, 0x74, 0x31, 0x3d, 0x9b, 0xbe,
+	0x2f, 0x2f, 0x4e, 0xf1, 0x7c, 0x3c, 0x9d, 0x18, 0xe0, 0xfc, 0x56, 0x87, 0xde, 0x3c, 0x5b, 0xee,
-	0x7c, 0x75, 0x79, 0x8e, 0xe7, 0xe3, 0xe9, 0xc4, 0x80, 0xc1, 0xef, 0x55, 0xe8, 0xcc, 0x93, 0xd5,
+	0x75, 0xd0, 0x0b, 0xe8, 0x73, 0x15, 0x2f, 0xe9, 0x3c, 0x26, 0x7e, 0x71, 0x82, 0x8f, 0x0e, 0x1e,
-	0x21, 0x0f, 0x7a, 0x09, 0x5d, 0xae, 0xe2, 0x15, 0x9d, 0x87, 0xc4, 0xcd, 0x4e, 0xf0, 0x51, 0xee,
+	0x4b, 0xf0, 0x22, 0xc8, 0xb1, 0xb8, 0xc2, 0x45, 0x18, 0x8c, 0x8c, 0x55, 0xf4, 0xd4, 0x93, 0xfa,
-	0xb1, 0x40, 0xcf, 0x82, 0x94, 0x8b, 0x4b, 0x5a, 0x84, 0xc1, 0x48, 0x58, 0x29, 0x9f, 0xfa, 0xa7,
+	0xf4, 0x76, 0xbd, 0x45, 0x05, 0x8d, 0xdf, 0xe2, 0x5b, 0x8f, 0xa1, 0x7f, 0x73, 0x57, 0xf1, 0x76,
-	0x3e, 0x3f, 0x9e, 0x6f, 0x59, 0x62, 0xe3, 0x77, 0xf4, 0xd6, 0x63, 0xe8, 0xde, 0xae, 0x2a, 0x9e,
+	0xf3, 0xf8, 0x30, 0x15, 0x1d, 0x5c, 0x84, 0xd6, 0xe7, 0x60, 0x54, 0x15, 0xdf, 0x8d, 0x76, 0xfe,
-	0x6e, 0x1e, 0xe6, 0xb7, 0xa2, 0x85, 0xb3, 0xd0, 0x7a, 0x02, 0x46, 0x39, 0xe3, 0xfb, 0xd9, 0x83,
+	0x6e, 0x82, 0x3e, 0xdf, 0x31, 0xff, 0xdd, 0x10, 0xf4, 0x15, 0xb4, 0x2f, 0xd5, 0x64, 0xe4, 0x7d,
-	0x9b, 0x3a, 0xe8, 0xf3, 0x3d, 0x73, 0xdf, 0x4f, 0x41, 0x5f, 0x43, 0xf3, 0x4a, 0xdd, 0x8c, 0xb4,
+	0x94, 0xcf, 0x8e, 0xf9, 0xde, 0x49, 0xc4, 0x52, 0xca, 0xd2, 0x0b, 0x12, 0x66, 0x14, 0x17, 0x50,
-	0x8f, 0xe2, 0xd9, 0x31, 0xd7, 0x39, 0x0b, 0x58, 0x4c, 0x59, 0x7c, 0x49, 0xfc, 0x84, 0xe2, 0x8c,
+	0xf4, 0x04, 0x20, 0x4d, 0x28, 0x55, 0x43, 0x9c, 0xbf, 0xb5, 0x5d, 0x8f, 0xf8, 0x61, 0x31, 0xfe,
-	0x8a, 0x9e, 0x02, 0x88, 0xb9, 0xa0, 0x2e, 0x71, 0xfa, 0xd4, 0x1a, 0x8e, 0x1c, 0x15, 0x8b, 0x03,
+	0xa5, 0x32, 0xfa, 0x10, 0x5a, 0x22, 0x1a, 0x07, 0x72, 0x26, 0x3b, 0x38, 0x8f, 0xac, 0xff, 0x34,
-	0x8e, 0x0b, 0x1c, 0xf4, 0x31, 0x34, 0x44, 0x34, 0xf6, 0xe4, 0xc5, 0x6c, 0xe1, 0x34, 0xb2, 0xfe,
+	0xe8, 0x95, 0xe5, 0xd1, 0x37, 0x00, 0xe2, 0xd6, 0x58, 0xc4, 0x01, 0x49, 0x8b, 0x63, 0x32, 0x6f,
-	0xd3, 0xa0, 0x53, 0xac, 0x81, 0xbe, 0x05, 0x10, 0xa3, 0x63, 0x19, 0x7a, 0x24, 0xce, 0xce, 0xca,
+	0xda, 0x19, 0xed, 0xeb, 0xa3, 0x1a, 0x2e, 0xa1, 0xd1, 0x19, 0x1c, 0xbd, 0xca, 0xc2, 0x50, 0x80,
-	0xbc, 0xed, 0x69, 0x74, 0xd8, 0x1f, 0x55, 0x70, 0x81, 0x8d, 0x2e, 0xe0, 0xe4, 0x75, 0xe2, 0xfb,
+	0xb0, 0xba, 0x25, 0x6e, 0xef, 0xe7, 0x2c, 0x0b, 0x43, 0x2f, 0x47, 0x8c, 0x6a, 0xb8, 0x4a, 0x42,
-	0x82, 0x84, 0xd5, 0xa8, 0x38, 0xde, 0xd4, 0x45, 0xe2, 0xfb, 0x4e, 0xca, 0x18, 0x55, 0x70, 0x59,
+	0x63, 0x30, 0x0e, 0x29, 0x1e, 0x47, 0x8c, 0xd3, 0xbc, 0xbf, 0x07, 0xb7, 0x0a, 0x29, 0xc8, 0xa8,
-	0x84, 0xc6, 0x60, 0xe4, 0x10, 0x0f, 0x03, 0xc6, 0x69, 0xda, 0xe4, 0x83, 0xa3, 0x89, 0x14, 0x65,
+	0x86, 0xdf, 0xa2, 0x3d, 0x6f, 0x43, 0xf3, 0x67, 0xd1, 0x97, 0x15, 0x03, 0x1c, 0x7c, 0xa3, 0x7b,
-	0x54, 0xc1, 0xef, 0xc8, 0x5e, 0x34, 0xa1, 0xfe, 0x8b, 0xe8, 0xcb, 0x0a, 0x01, 0x72, 0xdf, 0xe8,
+	0xd0, 0x14, 0xbe, 0xb9, 0xa9, 0xd9, 0x0d, 0xb7, 0x83, 0x55, 0x80, 0x5c, 0x68, 0xe7, 0x97, 0xad,
-	0x1e, 0xd4, 0x85, 0x6f, 0x6e, 0x6a, 0xfd, 0x9a, 0xdd, 0xc2, 0x2a, 0x40, 0x36, 0x34, 0xd3, 0xf9,
+	0x59, 0xb7, 0x1b, 0x6e, 0x77, 0xd8, 0x97, 0x8f, 0x13, 0x93, 0x5f, 0x4e, 0x64, 0x1a, 0x17, 0x65,
-	0x6c, 0x56, 0xfb, 0x35, 0xbb, 0x3d, 0xec, 0x3a, 0xc4, 0xf5, 0x1d, 0x4c, 0x7e, 0x3d, 0x93, 0x30,
+	0xe4, 0x40, 0x8f, 0x33, 0x12, 0xf3, 0x75, 0x94, 0xce, 0x48, 0xba, 0x36, 0x1b, 0x52, 0xe6, 0x46,
-	0xce, 0xb6, 0xd1, 0x00, 0x3a, 0x9c, 0x91, 0x90, 0x6f, 0x82, 0x78, 0x46, 0xe2, 0x8d, 0x59, 0x93,
+	0xce, 0xfa, 0x57, 0x03, 0x5d, 0x18, 0xb4, 0x2e, 0xa1, 0x5d, 0x74, 0xf6, 0x3e, 0xf6, 0x65, 0x70,
-	0x69, 0x6e, 0x61, 0xd6, 0xbf, 0x1a, 0xe8, 0xc2, 0xa0, 0x75, 0x05, 0xcd, 0xac, 0xb3, 0x0f, 0x51,
+	0xa7, 0x68, 0xff, 0x7d, 0xec, 0xf7, 0xf8, 0x02, 0xba, 0xa5, 0x7b, 0x1d, 0xdd, 0x87, 0x0f, 0x4a,
-	0x97, 0xc1, 0x9d, 0xac, 0xfd, 0x0f, 0x51, 0xef, 0xf1, 0x25, 0xb4, 0x0b, 0xc3, 0x1d, 0xdd, 0x87,
+	0xa1, 0xba, 0x7b, 0x8c, 0x1a, 0x7a, 0x00, 0x1f, 0x95, 0xd3, 0xa5, 0xf1, 0x34, 0x34, 0x74, 0x17,
-	0x8f, 0x0a, 0xa1, 0x1a, 0x40, 0x46, 0x05, 0x3d, 0x80, 0x4f, 0x8a, 0x70, 0xe1, 0x8e, 0x1a, 0x1a,
+	0x8e, 0x6e, 0x70, 0x98, 0x6f, 0xd4, 0x9f, 0x3f, 0xfa, 0xf3, 0x6a, 0xa0, 0xbd, 0xb9, 0x1a, 0x68,
-	0xba, 0x0b, 0x27, 0xb7, 0x34, 0xcc, 0x35, 0xaa, 0x2f, 0x1e, 0xfd, 0x75, 0xdd, 0xd3, 0xde, 0x5e,
+	0xff, 0x5c, 0x0d, 0xb4, 0xd7, 0xd7, 0x83, 0xda, 0x9b, 0xeb, 0x41, 0xed, 0xaf, 0xeb, 0x41, 0xed,
-	0xf7, 0xb4, 0x7f, 0xae, 0x7b, 0xda, 0x9b, 0x9b, 0x5e, 0xe5, 0xed, 0x4d, 0xaf, 0xf2, 0xf7, 0x4d,
+	0x47, 0x38, 0xde, 0xff, 0xb7, 0x2e, 0x5b, 0xf2, 0xe7, 0xcb, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff,
-	0xaf, 0xf2, 0x13, 0x9c, 0x1e, 0x5e, 0xc7, 0xab, 0x86, 0xfc, 0xf9, 0xea, 0xff, 0x00, 0x00, 0x00,
+	0x34, 0xaa, 0x76, 0x9b, 0x6f, 0x07, 0x00, 0x00,
-	0xff, 0xff, 0x6a, 0x04, 0xc0, 0x87, 0xa2, 0x07, 0x00, 0x00,
 }
 
 func (m *Message) Marshal() (dAtA []byte, err error) {
@@ -3328,7 +3326,7 @@ func (m *Sync) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.TreeHeader == nil {
-				m.TreeHeader = &treepb.TreeHeader{}
+				m.TreeHeader = &aclpb.Header{}
 			}
 			if err := m.TreeHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err