Update dial timeout

Bumps [github.com/stretchr/testify](https://github.com/stretchr/testify) from 1.8.2 to 1.8.3.
- [Release notes](https://github.com/stretchr/testify/releases)
- [Commits](https://github.com/stretchr/testify/compare/v1.8.2...v1.8.3)

---
updated-dependencies:
- dependency-name: github.com/stretchr/testify
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/dependabot.yml

@@ -10,5 +10,5 @@ updates:
     schedule:
       interval: "weekly"
     ignore:
-      - dependency-name: "github.com/anytypeio/go-chash"
+      - dependency-name: "github.com/anyproto/go-chash"
       

.github/workflows/coverage.yml

@@ -7,7 +7,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     env:
-      GOPRIVATE: github.com/anytypeio
+      GOPRIVATE: github.com/anyproto
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v3

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Any Association
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

Makefile

@@ -1,5 +1,5 @@
 .PHONY: proto test deps
-export GOPRIVATE=github.com/anytypeio
+export GOPRIVATE=github.com/anyproto
 export PATH:=deps:$(PATH)
 
 proto:
@@ -7,15 +7,19 @@ proto:
 
 	@$(eval P_ACL_RECORDS_PATH_PB := commonspace/object/acl/aclrecordproto)
 	@$(eval P_TREE_CHANGES_PATH_PB := commonspace/object/tree/treechangeproto)
-	@$(eval P_ACL_RECORDS := M$(P_ACL_RECORDS_PATH_PB)/protos/aclrecord.proto=github.com/anytypeio/any-sync/$(P_ACL_RECORDS_PATH_PB))
-	@$(eval P_TREE_CHANGES := M$(P_TREE_CHANGES_PATH_PB)/protos/treechange.proto=github.com/anytypeio/any-sync/$(P_TREE_CHANGES_PATH_PB))
+	@$(eval P_CRYPTO_PATH_PB := util/crypto/cryptoproto)
+	@$(eval P_ACL_RECORDS := M$(P_ACL_RECORDS_PATH_PB)/protos/aclrecord.proto=github.com/anyproto/any-sync/$(P_ACL_RECORDS_PATH_PB))
+	@$(eval P_TREE_CHANGES := M$(P_TREE_CHANGES_PATH_PB)/protos/treechange.proto=github.com/anyproto/any-sync/$(P_TREE_CHANGES_PATH_PB))
 
 	protoc --gogofaster_out=:. $(P_ACL_RECORDS_PATH_PB)/protos/*.proto
 	protoc --gogofaster_out=:. $(P_TREE_CHANGES_PATH_PB)/protos/*.proto
+	protoc --gogofaster_out=:. $(P_CRYPTO_PATH_PB)/protos/*.proto
 	$(eval PKGMAP := $$(P_TREE_CHANGES),$$(P_ACL_RECORDS))
 	protoc --gogofaster_out=$(PKGMAP):. --go-drpc_out=protolib=github.com/gogo/protobuf:. commonspace/spacesyncproto/protos/*.proto
 	protoc --gogofaster_out=$(PKGMAP):. --go-drpc_out=protolib=github.com/gogo/protobuf:. commonfile/fileproto/protos/*.proto
 	protoc --gogofaster_out=$(PKGMAP):. --go-drpc_out=protolib=github.com/gogo/protobuf:. net/streampool/testservice/protos/*.proto
+	protoc --gogofaster_out=:. net/secureservice/handshake/handshakeproto/protos/*.proto
+	protoc --gogofaster_out=$(PKGMAP):. --go-drpc_out=protolib=github.com/gogo/protobuf:. coordinator/coordinatorproto/protos/*.proto
 
 deps:
 	go mod download

accountservice/accountservice.go

@@ -1,23 +1,22 @@
-//go:generate mockgen -destination mock_accountservice/mock_accountservice.go github.com/anytypeio/any-sync/accountservice Service
+//go:generate mockgen -destination mock_accountservice/mock_accountservice.go github.com/anyproto/any-sync/accountservice Service
 package accountservice
 
 import (
-	"github.com/anytypeio/any-sync/app"
-	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
+	"github.com/anyproto/any-sync/app"
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
 )
 
 const CName = "common.accountservice"
 
 type Service interface {
 	app.Component
-	Account() *accountdata.AccountData
+	Account() *accountdata.AccountKeys
 }
 
 type Config struct {
-	PeerId        string `yaml:"peerId"`
-	PeerKey       string `yaml:"peerKey"`
-	SigningKey    string `yaml:"signingKey"`
-	EncryptionKey string `yaml:"encryptionKey"`
+	PeerId     string `yaml:"peerId"`
+	PeerKey    string `yaml:"peerKey"`
+	SigningKey string `yaml:"signingKey"`
 }
 
 type ConfigGetter interface {

accountservice/mock_accountservice/helper.go

@@ -1,12 +1,12 @@
 package mock_accountservice
 
 import (
-	"github.com/anytypeio/any-sync/accountservice"
-	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
+	"github.com/anyproto/any-sync/accountservice"
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
 	"github.com/golang/mock/gomock"
 )
 
-func NewAccountServiceWithAccount(ctrl *gomock.Controller, acc *accountdata.AccountData) *MockService {
+func NewAccountServiceWithAccount(ctrl *gomock.Controller, acc *accountdata.AccountKeys) *MockService {
 	mock := NewMockService(ctrl)
 	mock.EXPECT().Name().Return(accountservice.CName).AnyTimes()
 	mock.EXPECT().Init(gomock.Any()).AnyTimes()

accountservice/mock_accountservice/mock_accountservice.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/any-sync/accountservice (interfaces: Service)
+// Source: github.com/anyproto/any-sync/accountservice (interfaces: Service)
 
 // Package mock_accountservice is a generated GoMock package.
 package mock_accountservice
@@ -7,8 +7,8 @@ package mock_accountservice
 import (
 	reflect "reflect"
 
-	app "github.com/anytypeio/any-sync/app"
-	accountdata "github.com/anytypeio/any-sync/commonspace/object/accountdata"
+	app "github.com/anyproto/any-sync/app"
+	accountdata "github.com/anyproto/any-sync/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() *accountdata.AccountData {
+func (m *MockService) Account() *accountdata.AccountKeys {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Account")
-	ret0, _ := ret[0].(*accountdata.AccountData)
+	ret0, _ := ret[0].(*accountdata.AccountKeys)
 	return ret0
 }
 

app/app.go

@@ -4,10 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/anytypeio/any-sync/app/logger"
+	"github.com/anyproto/any-sync/app/logger"
 	"go.uber.org/zap"
 	"os"
 	"runtime"
+	"runtime/debug"
 	"strings"
 	"sync"
 	"time"
@@ -15,12 +16,15 @@ import (
 
 var (
 	// values of this vars will be defined while compilation
-	GitCommit, GitBranch, GitState, GitSummary, BuildDate string
-	name                                                  string
+	AppName, GitCommit, GitBranch, GitState, GitSummary, BuildDate string
+	name                                                           string
 )
 
 var (
-	log = logger.NewNamed("app")
+	log               = logger.NewNamed("app")
+	StopDeadline      = time.Minute
+	StopWarningAfter  = time.Second * 10
+	StartWarningAfter = time.Second * 10
 )
 
 // Component is a minimal interface for a common app.Component
@@ -51,10 +55,12 @@ type ComponentStatable interface {
 // App is the central part of the application
 // It contains and manages all components
 type App struct {
-	components  []Component
-	mu          sync.RWMutex
-	startStat   StartStat
-	deviceState int
+	components     []Component
+	mu             sync.RWMutex
+	startStat      Stat
+	stopStat       Stat
+	deviceState    int
+	anySyncVersion string
 }
 
 // Name returns app name
@@ -62,23 +68,34 @@ func (app *App) Name() string {
 	return name
 }
 
+func (app *App) AppName() string {
+	return AppName
+}
+
 // Version return app version
 func (app *App) Version() string {
 	return GitSummary
 }
 
-type StartStat struct {
+type Stat struct {
 	SpentMsPerComp map[string]int64
 	SpentMsTotal   int64
 }
 
-// StartStat returns total time spent per comp
-func (app *App) StartStat() StartStat {
+// StartStat returns total time spent per comp for the last Start
+func (app *App) StartStat() Stat {
 	app.mu.Lock()
 	defer app.mu.Unlock()
 	return app.startStat
 }
 
+// StopStat returns total time spent per comp for the last Close
+func (app *App) StopStat() Stat {
+	app.mu.Lock()
+	defer app.mu.Unlock()
+	return app.stopStat
+}
+
 // VersionDescription return the full info about the build
 func (app *App) VersionDescription() string {
 	return VersionDescription()
@@ -158,7 +175,17 @@ func (app *App) Start(ctx context.Context) (err error) {
 	app.mu.RLock()
 	defer app.mu.RUnlock()
 	app.startStat.SpentMsPerComp = make(map[string]int64)
-
+	var currentComponentStarting string
+	done := make(chan struct{})
+	go func() {
+		select {
+		case <-done:
+			return
+		case <-time.After(StartWarningAfter):
+			l := statLogger(app.stopStat, log).With(zap.String("in_progress", currentComponentStarting))
+			l.Warn("components start in progress")
+		}
+	}()
 	closeServices := func(idx int) {
 		for i := idx; i >= 0; i-- {
 			if serviceClose, ok := app.components[i].(ComponentRunnable); ok {
@@ -172,7 +199,7 @@ func (app *App) Start(ctx context.Context) (err error) {
 	for i, s := range app.components {
 		if err = s.Init(app); err != nil {
 			closeServices(i)
-			return fmt.Errorf("can't init service '%s': %v", s.Name(), err)
+			return fmt.Errorf("can't init service '%s': %w", s.Name(), err)
 		}
 	}
 
@@ -181,14 +208,20 @@ func (app *App) Start(ctx context.Context) (err error) {
 			start := time.Now()
 			if err = serviceRun.Run(ctx); err != nil {
 				closeServices(i)
-				return fmt.Errorf("can't run service '%s': %v", serviceRun.Name(), err)
+				return fmt.Errorf("can't run service '%s': %w", serviceRun.Name(), err)
 			}
 			spent := time.Since(start).Milliseconds()
 			app.startStat.SpentMsTotal += spent
 			app.startStat.SpentMsPerComp[s.Name()] = spent
 		}
 	}
-	log.Debug("all components started")
+
+	close(done)
+	l := statLogger(app.stopStat, log)
+	if app.startStat.SpentMsTotal > StartWarningAfter.Milliseconds() {
+		l.Warn("all components started")
+	}
+	l.Debug("all components started")
 	return
 }
 
@@ -203,18 +236,41 @@ func stackAllGoroutines() []byte {
 	}
 }
 
+func statLogger(stat Stat, ctxLogger logger.CtxLogger) logger.CtxLogger {
+	l := ctxLogger
+	for k, v := range stat.SpentMsPerComp {
+		l = l.With(zap.Int64(k, v))
+	}
+	l = l.With(zap.Int64("total", stat.SpentMsTotal))
+
+	return l
+}
+
 // Close stops the application
 // All components with ComponentRunnable implementation will be closed in the reversed order
 func (app *App) Close(ctx context.Context) error {
 	log.Debug("close components...")
 	app.mu.RLock()
 	defer app.mu.RUnlock()
+	app.stopStat.SpentMsPerComp = make(map[string]int64)
+	var currentComponentStopping string
 	done := make(chan struct{})
+
 	go func() {
 		select {
 		case <-done:
 			return
-		case <-time.After(time.Minute):
+		case <-time.After(StopWarningAfter):
+			statLogger(app.stopStat, log).
+				With(zap.String("in_progress", currentComponentStopping)).
+				Warn("components close in progress")
+		}
+	}()
+	go func() {
+		select {
+		case <-done:
+			return
+		case <-time.After(StopDeadline):
 			_, _ = os.Stderr.Write([]byte("app.Close timeout\n"))
 			_, _ = os.Stderr.Write(stackAllGoroutines())
 			panic("app.Close timeout")
@@ -224,16 +280,27 @@ func (app *App) Close(ctx context.Context) error {
 	var errs []string
 	for i := len(app.components) - 1; i >= 0; i-- {
 		if serviceClose, ok := app.components[i].(ComponentRunnable); ok {
+			start := time.Now()
+			currentComponentStopping = app.components[i].Name()
 			if e := serviceClose.Close(ctx); e != nil {
 				errs = append(errs, fmt.Sprintf("Component '%s' close error: %v", serviceClose.Name(), e))
 			}
+			spent := time.Since(start).Milliseconds()
+			app.stopStat.SpentMsTotal += spent
+			app.stopStat.SpentMsPerComp[app.components[i].Name()] = spent
 		}
 	}
 	close(done)
 	if len(errs) > 0 {
 		return errors.New(strings.Join(errs, "\n"))
 	}
-	log.Debug("all components have been closed")
+
+	l := statLogger(app.stopStat, log)
+	if app.stopStat.SpentMsTotal > StopWarningAfter.Milliseconds() {
+		l.Warn("all components have been closed")
+	}
+
+	l.Debug("all components have been closed")
 	return nil
 }
 
@@ -250,3 +317,20 @@ func (app *App) SetDeviceState(state int) {
 		}
 	}
 }
+
+var onceVersion sync.Once
+
+func (app *App) AnySyncVersion() string {
+	onceVersion.Do(func() {
+		info, ok := debug.ReadBuildInfo()
+		if ok {
+			for _, mod := range info.Deps {
+				if mod.Path == "github.com/anyproto/any-sync" {
+					app.anySyncVersion = mod.Version
+					break
+				}
+			}
+		}
+	})
+	return app.anySyncVersion
+}

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/any-sync/app/ldiff Diff,Remote
+//go:generate mockgen -destination mock_ldiff/mock_ldiff.go github.com/anyproto/any-sync/app/ldiff Diff,Remote
 package ldiff
 
 import (

app/ldiff/diff_test.go

@@ -3,9 +3,9 @@ package ldiff
 import (
 	"context"
 	"fmt"
+	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"gopkg.in/mgo.v2/bson"
 	"math"
 	"sort"
 	"testing"
@@ -44,7 +44,7 @@ func TestDiff_Diff(t *testing.T) {
 		d2 := New(16, 16)
 		for i := 0; i < 1000; i++ {
 			id := fmt.Sprint(i)
-			head := bson.NewObjectId().Hex()
+			head := uuid.NewString()
 			d1.Set(Element{
 				Id:   id,
 				Head: head,
@@ -92,7 +92,7 @@ func TestDiff_Diff(t *testing.T) {
 		for i := 0; i < 10; i++ {
 			d2.Set(Element{
 				Id:   fmt.Sprint(i),
-				Head: bson.NewObjectId().Hex(),
+				Head: uuid.NewString(),
 			})
 		}
 
@@ -108,7 +108,7 @@ func TestDiff_Diff(t *testing.T) {
 		for i := 0; i < 10; i++ {
 			d2.Set(Element{
 				Id:   fmt.Sprint(i),
-				Head: bson.NewObjectId().Hex(),
+				Head: uuid.NewString(),
 			})
 		}
 		var cancel func()
@@ -123,7 +123,7 @@ func BenchmarkDiff_Ranges(b *testing.B) {
 	d := New(16, 16)
 	for i := 0; i < 10000; i++ {
 		id := fmt.Sprint(i)
-		head := bson.NewObjectId().Hex()
+		head := uuid.NewString()
 		d.Set(Element{
 			Id:   id,
 			Head: head,

app/ldiff/mock_ldiff/mock_ldiff.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/any-sync/app/ldiff (interfaces: Diff,Remote)
+// Source: github.com/anyproto/any-sync/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/any-sync/app/ldiff"
+	ldiff "github.com/anyproto/any-sync/app/ldiff"
 	gomock "github.com/golang/mock/gomock"
 )
 

app/logger/config.go

@@ -1,33 +1,124 @@
 package logger
 
-import "go.uber.org/zap"
+import (
+	"fmt"
+	"strings"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+
+	"github.com/anyproto/any-sync/util/slice"
+)
+
+type LogFormat int
+
+const (
+	ColorizedOutput LogFormat = iota
+	PlaintextOutput
+	JSONOutput
+)
+
+type NamedLevel struct {
+	Name  string `yaml:"name"`
+	Level string `yaml:"level"`
+}
 
 type Config struct {
-	Production   bool              `yaml:"production"`
-	DefaultLevel string            `yaml:"defaultLevel"`
-	NamedLevels  map[string]string `yaml:"namedLevels"`
+	Production     bool         `yaml:"production"`
+	DefaultLevel   string       `yaml:"defaultLevel"`
+	Levels         []NamedLevel `yaml:"levels"` // first match will be used
+	AddOutputPaths []string     `yaml:"outputPaths"`
+	DisableStdErr  bool         `yaml:"disableStdErr"`
+	Format         LogFormat    `yaml:"format"`
+	ZapConfig      *zap.Config  `yaml:"-"` // optional, if set it will be used instead of other config options
 }
 
 func (l Config) ApplyGlobal() {
 	var conf zap.Config
-	if l.Production {
-		conf = zap.NewProductionConfig()
+	if l.ZapConfig != nil {
+		conf = *l.ZapConfig
 	} else {
-		conf = zap.NewDevelopmentConfig()
-	}
-	if defaultLevel, err := zap.ParseAtomicLevel(l.DefaultLevel); err == nil {
-		conf.Level = defaultLevel
-	}
-	var levels = make(map[string]zap.AtomicLevel)
-	for k, v := range l.NamedLevels {
-		if lev, err := zap.ParseAtomicLevel(v); err != nil {
-			levels[k] = lev
+		if l.Production {
+			conf = zap.NewProductionConfig()
+		} else {
+			conf = zap.NewDevelopmentConfig()
+		}
+		encConfig := conf.EncoderConfig
+		switch l.Format {
+		case PlaintextOutput:
+			encConfig.EncodeLevel = zapcore.CapitalLevelEncoder
+			conf.Encoding = "console"
+		case JSONOutput:
+			encConfig.MessageKey = "msg"
+			encConfig.TimeKey = "ts"
+			encConfig.LevelKey = "level"
+			encConfig.NameKey = "logger"
+			encConfig.CallerKey = "caller"
+			encConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+			conf.Encoding = "json"
+		default:
+			// default is ColorizedOutput
+			conf.Encoding = "console"
+			encConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
+		}
+
+		conf.EncoderConfig = encConfig
+		if len(l.AddOutputPaths) > 0 {
+			conf.OutputPaths = append(conf.OutputPaths, l.AddOutputPaths...)
+		}
+		if l.DisableStdErr {
+			conf.OutputPaths = slice.Filter(conf.OutputPaths, func(path string) bool {
+				return path != "stderr"
+			})
+		}
+
+		if defaultLevel, err := zap.ParseAtomicLevel(l.DefaultLevel); err == nil {
+			conf.Level = defaultLevel
 		}
 	}
-	defaultLogger, err := conf.Build()
+	for _, v := range l.Levels {
+		if lev, err := zap.ParseAtomicLevel(v.Level); err == nil {
+			// we need to have a minimum level of all named loggers for the main logger
+			if lev.Level() < conf.Level.Level() {
+				conf.Level.SetLevel(lev.Level())
+			}
+		}
+	}
+
+	lg, err := conf.Build()
 	if err != nil {
 		Default().Fatal("can't build logger", zap.Error(err))
 	}
-	SetDefault(defaultLogger)
-	SetNamedLevels(levels)
+	SetDefault(lg)
+	SetNamedLevels(l.Levels)
+}
+
+// LevelsFromStr parses a string of the form "name1=DEBUG;prefix*=WARN;*=ERROR" into a slice of NamedLevel
+// it may be useful to parse the log level from the OS env var
+func LevelsFromStr(s string) (levels []NamedLevel) {
+	for _, kv := range strings.Split(s, ";") {
+		strings.TrimSpace(kv)
+		parts := strings.Split(kv, "=")
+		var key, value string
+		if len(parts) == 1 {
+			key = "*"
+			value = parts[0]
+			_, err := zap.ParseAtomicLevel(value)
+			if err != nil {
+				fmt.Printf("Can't parse log level %s: %s\n", parts[0], err.Error())
+				continue
+			}
+			levels = append(levels, NamedLevel{Name: key, Level: value})
+		} else if len(parts) == 2 {
+			key = parts[0]
+			value = parts[1]
+		}
+		_, err := zap.ParseAtomicLevel(value)
+		if err != nil {
+			fmt.Printf("Can't parse log level %s: %s\n", parts[0], err.Error())
+			continue
+		}
+		levels = append(levels, NamedLevel{Name: key, Level: value})
+	}
+	return levels
 }

app/logger/ctxfiled.go

@@ -32,6 +32,7 @@ func CtxGetFields(ctx context.Context) (fields []zap.Field) {
 
 type CtxLogger struct {
 	*zap.Logger
+	name string
 }
 
 func (cl CtxLogger) DebugCtx(ctx context.Context, msg string, fields ...zap.Field) {
@@ -51,5 +52,9 @@ func (cl CtxLogger) ErrorCtx(ctx context.Context, msg string, fields ...zap.Fiel
 }
 
 func (cl CtxLogger) With(fields ...zap.Field) CtxLogger {
-	return CtxLogger{cl.Logger.With(fields...)}
+	return CtxLogger{cl.Logger.With(fields...), cl.name}
+}
+
+func (cl CtxLogger) Sugar() *zap.SugaredLogger {
+	return NewNamedSugared(cl.name)
 }

app/logger/log.go

@@ -1,51 +1,137 @@
 package logger
 
 import (
-	"go.uber.org/zap"
 	"sync"
+
+	"github.com/gobwas/glob"
+	"go.uber.org/zap"
 )
 
 var (
-	mu            sync.Mutex
-	defaultLogger *zap.Logger
-	levels        = make(map[string]zap.AtomicLevel)
-	loggers       = make(map[string]CtxLogger)
+	mu                sync.Mutex
+	logger            *zap.Logger
+	loggerConfig      zap.Config
+	namedLevels       []namedLevel
+	namedGlobs        = make(map[string]glob.Glob)
+	namedLoggers      = make(map[string]CtxLogger)
+	namedSugarLoggers = make(map[string]*zap.SugaredLogger)
 )
 
-func init() {
-	defaultLogger, _ = zap.NewDevelopment()
-	zap.NewProduction()
+type namedLevel struct {
+	name  string
+	level zap.AtomicLevel
 }
 
+func init() {
+	loggerConfig = zap.NewDevelopmentConfig()
+	logger, _ = loggerConfig.Build()
+}
+
+// SetDefault replaces the default logger
+// you need to call SetNamedLevels after in case you have named loggers,
+// otherwise they will use the old logger
 func SetDefault(l *zap.Logger) {
 	mu.Lock()
 	defer mu.Unlock()
-	*defaultLogger = *l
-	for name, l := range loggers {
-		*l.Logger = *defaultLogger.Named(name)
-	}
+	*logger = *l
 }
 
-func SetNamedLevels(l map[string]zap.AtomicLevel) {
+// SetNamedLevels sets the namedLevels for named loggers
+// it also supports glob patterns for names, like "app*"
+// can be racy in case there are existing named loggers
+// so consider to call only once at the beginning
+func SetNamedLevels(nls []NamedLevel) {
 	mu.Lock()
 	defer mu.Unlock()
-	levels = l
+	namedLevels = namedLevels[:0]
+
+	var minLevel = logger.Level()
+	for _, nl := range nls {
+		l, err := zap.ParseAtomicLevel(nl.Level)
+		if err != nil {
+			continue
+		}
+		namedLevels = append(namedLevels, namedLevel{name: nl.Name, level: l})
+		g, err := glob.Compile(nl.Name)
+		if err == nil {
+			namedGlobs[nl.Name] = g
+		}
+
+		if l.Level() < minLevel {
+			minLevel = l.Level()
+		}
+	}
+
+	if minLevel < logger.Level() {
+		// recreate logger if the min level is lower than the current min one
+		loggerConfig.Level = zap.NewAtomicLevelAt(minLevel)
+		logger, _ = loggerConfig.Build()
+	}
+
+	for name, nl := range namedLoggers {
+		level := getLevel(name)
+		newCore := zap.New(logger.Core()).Named(name).WithOptions(
+			zap.IncreaseLevel(level),
+		)
+		*(nl.Logger) = *newCore
+	}
+
+	for name, nl := range namedSugarLoggers {
+		level := getLevel(name)
+		newCore := zap.New(logger.Core()).Named(name).WithOptions(
+			zap.IncreaseLevel(level),
+		).Sugar()
+		*(nl) = *newCore
+	}
 }
 
 func Default() *zap.Logger {
 	mu.Lock()
 	defer mu.Unlock()
-	return defaultLogger
+	return logger
+}
+
+// getLevel returns the level for the given name
+// it return the first matching name or glob pattern whatever comes first
+func getLevel(name string) zap.AtomicLevel {
+	for _, nl := range namedLevels {
+		if nl.name == name {
+			return nl.level
+		}
+		if g, ok := namedGlobs[nl.name]; ok && g.Match(name) {
+			return nl.level
+		}
+	}
+	return zap.NewAtomicLevelAt(logger.Level())
 }
 
 func NewNamed(name string, fields ...zap.Field) CtxLogger {
 	mu.Lock()
 	defer mu.Unlock()
-	l := defaultLogger.Named(name)
-	if len(fields) > 0 {
-		l = l.With(fields...)
+
+	if l, nameExists := namedLoggers[name]; nameExists {
+		return l
 	}
-	ctxL := CtxLogger{l}
-	loggers[name] = ctxL
+
+	level := getLevel(name)
+	l := zap.New(logger.Core()).Named(name).WithOptions(zap.IncreaseLevel(level),
+		zap.Fields(fields...))
+
+	ctxL := CtxLogger{Logger: l, name: name}
+	namedLoggers[name] = ctxL
 	return ctxL
 }
+
+func NewNamedSugared(name string) *zap.SugaredLogger {
+	mu.Lock()
+	defer mu.Unlock()
+
+	if l, nameExists := namedSugarLoggers[name]; nameExists {
+		return l
+	}
+
+	level := getLevel(name)
+	l := zap.New(logger.Core()).Named(name).Sugar().WithOptions(zap.IncreaseLevel(level))
+	namedSugarLoggers[name] = l
+	return l
+}

app/logger/log_test.go

@@ -0,0 +1,150 @@
+package logger
+
+import (
+	"reflect"
+	"testing"
+
+	"go.uber.org/zap"
+)
+
+func Test_getLevel1(t *testing.T) {
+	SetNamedLevels([]NamedLevel{
+		{Name: "app", Level: "debug"},
+		{Name: "app*", Level: "info"},
+		{Name: "app.sub", Level: "warn"},
+		{Name: "*", Level: "fatal"},
+	})
+
+	tests := []struct {
+		name string
+		want zap.AtomicLevel
+	}{
+		{
+			name: "app",
+			want: zap.NewAtomicLevelAt(zap.DebugLevel),
+		},
+		{
+			name: "app.aaa",
+			want: zap.NewAtomicLevelAt(zap.InfoLevel),
+		},
+		{
+			name: "app.sub",
+			want: zap.NewAtomicLevelAt(zap.InfoLevel),
+		},
+		{
+			name: "random",
+			want: zap.NewAtomicLevelAt(zap.FatalLevel),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := getLevel(tt.name); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("getLevel() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_getLevel2(t *testing.T) {
+	SetNamedLevels([]NamedLevel{
+		{Name: "*", Level: "ERROR"},
+		{Name: "app", Level: "info"},
+		{Name: "app.sub", Level: "warn"},
+		{Name: "*", Level: "fatal"},
+	})
+
+	tests := []struct {
+		name string
+		want zap.AtomicLevel
+	}{
+		{
+			name: "app",
+			want: zap.NewAtomicLevelAt(zap.ErrorLevel),
+		},
+		{
+			name: "app.aaa",
+			want: zap.NewAtomicLevelAt(zap.ErrorLevel),
+		},
+		{
+			name: "app.sub",
+			want: zap.NewAtomicLevelAt(zap.ErrorLevel),
+		},
+		{
+			name: "random",
+			want: zap.NewAtomicLevelAt(zap.ErrorLevel),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := getLevel(tt.name); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("getLevel() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_getLevel3(t *testing.T) {
+	SetNamedLevels([]NamedLevel{
+		{Name: "app", Level: "info"},
+		{Name: "*.sub", Level: "warn"},
+		{Name: "*", Level: "fatal"},
+	})
+
+	tests := []struct {
+		name string
+		want zap.AtomicLevel
+	}{
+		{
+			name: "app",
+			want: zap.NewAtomicLevelAt(zap.InfoLevel),
+		},
+		{
+			name: "app.sub",
+			want: zap.NewAtomicLevelAt(zap.WarnLevel),
+		},
+		{
+			name: "random",
+			want: zap.NewAtomicLevelAt(zap.FatalLevel),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := getLevel(tt.name); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("getLevel() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_getLevel4(t *testing.T) {
+	SetNamedLevels([]NamedLevel{
+		{Name: "*", Level: "invalid"},
+		{Name: "app", Level: "info"},
+		{Name: "b", Level: "invalid"},
+	})
+
+	tests := []struct {
+		name string
+		want zap.AtomicLevel
+	}{
+		{
+			name: "app",
+			want: zap.NewAtomicLevelAt(zap.InfoLevel),
+		},
+		{
+			name: "app.sub",
+			want: zap.NewAtomicLevelAt(logger.Level()),
+		},
+		{
+			name: "b",
+			want: zap.NewAtomicLevelAt(logger.Level()),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := getLevel(tt.name); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("getLevel() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

app/ocache/entry.go

@@ -0,0 +1,120 @@
+package ocache
+
+import (
+	"context"
+	"go.uber.org/zap"
+	"sync"
+	"time"
+)
+
+type entryState int
+
+const (
+	entryStateLoading = iota
+	entryStateActive
+	entryStateClosing
+	entryStateClosed
+)
+
+type entry struct {
+	id        string
+	state     entryState
+	lastUsage time.Time
+	load      chan struct{}
+	loadErr   error
+	value     Object
+	close     chan struct{}
+	mx        sync.Mutex
+}
+
+func newEntry(id string, value Object, state entryState) *entry {
+	return &entry{
+		id:        id,
+		load:      make(chan struct{}),
+		lastUsage: time.Now(),
+		state:     state,
+		value:     value,
+	}
+}
+
+func (e *entry) isActive() bool {
+	e.mx.Lock()
+	defer e.mx.Unlock()
+	return e.state == entryStateActive
+}
+
+func (e *entry) isClosing() bool {
+	e.mx.Lock()
+	defer e.mx.Unlock()
+	return e.state == entryStateClosed || e.state == entryStateClosing
+}
+
+func (e *entry) waitLoad(ctx context.Context, id string) (value Object, err error) {
+	select {
+	case <-ctx.Done():
+		log.DebugCtx(ctx, "ctx done while waiting on object load", zap.String("id", id))
+		return nil, ctx.Err()
+	case <-e.load:
+		return e.value, e.loadErr
+	}
+}
+
+func (e *entry) waitClose(ctx context.Context, id string) (res bool, err error) {
+	e.mx.Lock()
+	switch e.state {
+	case entryStateClosing:
+		waitCh := e.close
+		e.mx.Unlock()
+		select {
+		case <-ctx.Done():
+			log.DebugCtx(ctx, "ctx done while waiting on object close", zap.String("id", id))
+			return false, ctx.Err()
+		case <-waitCh:
+			return true, nil
+		}
+	case entryStateClosed:
+		e.mx.Unlock()
+		return true, nil
+	default:
+		e.mx.Unlock()
+		return false, nil
+	}
+}
+
+func (e *entry) setClosing(wait bool) (prevState, curState entryState) {
+	e.mx.Lock()
+	prevState = e.state
+	curState = e.state
+	if e.state == entryStateClosing {
+		waitCh := e.close
+		e.mx.Unlock()
+		if !wait {
+			return
+		}
+		<-waitCh
+		e.mx.Lock()
+	}
+	if e.state != entryStateClosed {
+		e.state = entryStateClosing
+		e.close = make(chan struct{})
+	}
+	curState = e.state
+	e.mx.Unlock()
+	return
+}
+
+func (e *entry) setActive(chClose bool) {
+	e.mx.Lock()
+	defer e.mx.Unlock()
+	if chClose {
+		close(e.close)
+	}
+	e.state = entryStateActive
+}
+
+func (e *entry) setClosed() {
+	e.mx.Lock()
+	defer e.mx.Unlock()
+	close(e.close)
+	e.state = entryStateClosed
+}

app/ocache/metrics.go

@@ -1,11 +1,18 @@
 package ocache
 
-import "github.com/prometheus/client_golang/prometheus"
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"strings"
+)
 
 func WithPrometheus(reg *prometheus.Registry, namespace, subsystem string) Option {
 	if subsystem == "" {
 		subsystem = "cache"
 	}
+	nameSplit := strings.Split(namespace, ".")
+	subSplit := strings.Split(subsystem, ".")
+	namespace = strings.Join(nameSplit, "_")
+	subsystem = strings.Join(subSplit, "_")
 	if reg == nil {
 		return nil
 	}

app/ocache/metrics_test.go

@@ -0,0 +1,19 @@
+package ocache
+
+import (
+	"context"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/stretchr/testify/require"
+	"strings"
+	"testing"
+)
+
+func TestWithPrometheus_MetricsConvertsDots(t *testing.T) {
+	opt := WithPrometheus(prometheus.NewRegistry(), "some.name", "some.system")
+	cache := New(func(ctx context.Context, id string) (value Object, err error) {
+		return &testObject{}, nil
+	}, opt).(*oCache)
+	_, err := cache.Get(context.Background(), "id")
+	require.NoError(t, err)
+	require.True(t, strings.Contains(cache.metrics.hit.Desc().String(), "some_name_some_system_hit"))
+}

app/ocache/ocache.go

@@ -3,7 +3,7 @@ package ocache
 import (
 	"context"
 	"errors"
-	"github.com/anytypeio/any-sync/app/logger"
+	"github.com/anyproto/any-sync/app/logger"
 	"go.uber.org/zap"
 	"sync"
 	"time"
@@ -44,12 +44,6 @@ var WithGCPeriod = func(gcPeriod time.Duration) Option {
 	}
 }
 
-var WithRefCounter = func(enable bool) Option {
-	return func(cache *oCache) {
-		cache.refCounter = enable
-	}
-}
-
 func New(loadFunc LoadFunc, opts ...Option) OCache {
 	c := &oCache{
 		data:     make(map[string]*entry),
@@ -73,33 +67,7 @@ func New(loadFunc LoadFunc, opts ...Option) OCache {
 
 type Object interface {
 	Close() (err error)
-}
-
-type ObjectLocker interface {
-	Object
-	Locked() bool
-}
-
-type ObjectLastUsage interface {
-	LastUsage() time.Time
-}
-
-type entry struct {
-	id        string
-	lastUsage time.Time
-	refCount  uint32
-	isClosing bool
-	load      chan struct{}
-	loadErr   error
-	value     Object
-	close     chan struct{}
-}
-
-func (e *entry) locked() bool {
-	if locker, ok := e.value.(ObjectLocker); ok {
-		return locker.Locked()
-	}
-	return false
+	TryClose(objectTTL time.Duration) (res bool, err error)
 }
 
 type OCache interface {
@@ -116,12 +84,8 @@ type OCache interface {
 	// Add adds new object to cache
 	// Returns error when object exists
 	Add(id string, value Object) (err error)
-	// Release decreases the refs counter
-	Release(id string) bool
-	// Reset sets refs counter to 0
-	Reset(id string) bool
 	// Remove closes and removes object
-	Remove(id string) (ok bool, err error)
+	Remove(ctx context.Context, id string) (ok bool, err error)
 	// ForEach iterates over all loaded objects, breaks when callback returns false
 	ForEach(f func(v Object) (isContinue bool))
 	// GC frees not used and expired objects
@@ -134,17 +98,16 @@ type OCache interface {
 }
 
 type oCache struct {
-	mu         sync.Mutex
-	data       map[string]*entry
-	loadFunc   LoadFunc
-	timeNow    func() time.Time
-	ttl        time.Duration
-	gc         time.Duration
-	closed     bool
-	closeCh    chan struct{}
-	log        *zap.SugaredLogger
-	metrics    *metrics
-	refCounter bool
+	mu       sync.Mutex
+	data     map[string]*entry
+	loadFunc LoadFunc
+	timeNow  func() time.Time
+	ttl      time.Duration
+	gc       time.Duration
+	closed   bool
+	closeCh  chan struct{}
+	log      *zap.SugaredLogger
+	metrics  *metrics
 }
 
 func (c *oCache) Get(ctx context.Context, id string) (value Object, err error) {
@@ -160,63 +123,36 @@ Load:
 		return nil, ErrClosed
 	}
 	if e, ok = c.data[id]; !ok {
+		e = newEntry(id, nil, entryStateLoading)
 		load = true
-		e = &entry{
-			id:   id,
-			load: make(chan struct{}),
-		}
 		c.data[id] = e
 	}
-	closing := e.isClosing
-	if !e.isClosing {
-		e.lastUsage = c.timeNow()
-		if c.refCounter {
-			e.refCount++
-		}
-	}
+	e.lastUsage = time.Now()
 	c.mu.Unlock()
-	if closing {
-		<-e.close
+	reload, err := e.waitClose(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if reload {
 		goto Load
 	}
-
 	if load {
 		go c.load(ctx, id, e)
 	}
-	if c.metrics != nil {
-		if load {
-			c.metrics.miss.Inc()
-		} else {
-			c.metrics.hit.Inc()
-		}
-	}
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	case <-e.load:
-	}
-	return e.value, e.loadErr
+	c.metricsGet(!load)
+	return e.waitLoad(ctx, id)
 }
 
 func (c *oCache) Pick(ctx context.Context, id string) (value Object, err error) {
 	c.mu.Lock()
 	val, ok := c.data[id]
-	if !ok || val.isClosing {
+	if !ok || val.isClosing() {
 		c.mu.Unlock()
 		return nil, ErrNotExists
 	}
 	c.mu.Unlock()
-
-	if c.metrics != nil {
-		c.metrics.hit.Inc()
-	}
-
-	select {
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	case <-val.load:
-		return val.value, val.loadErr
-	}
+	c.metricsGet(true)
+	return val.waitLoad(ctx, id)
 }
 
 func (c *oCache) load(ctx context.Context, id string, e *entry) {
@@ -230,63 +166,39 @@ func (c *oCache) load(ctx context.Context, id string, e *entry) {
 		delete(c.data, id)
 	} else {
 		e.value = value
+		e.setActive(false)
 	}
 }
 
-func (c *oCache) Release(id string) bool {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.closed {
-		return false
-	}
-	if e, ok := c.data[id]; ok {
-		if c.refCounter && e.refCount > 0 {
-			e.refCount--
-			return true
-		}
-	}
-	return false
-}
-
-func (c *oCache) Reset(id string) bool {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	if c.closed {
-		return false
-	}
-	if e, ok := c.data[id]; ok {
-		e.refCount = 0
-		return true
-	}
-	return false
-}
-
-func (c *oCache) Remove(id string) (ok bool, err error) {
+func (c *oCache) Remove(ctx context.Context, id string) (ok bool, err error) {
 	c.mu.Lock()
 	if c.closed {
 		c.mu.Unlock()
 		err = ErrClosed
 		return
 	}
-	var e *entry
-	e, ok = c.data[id]
-	if !ok || e.isClosing {
+	e, ok := c.data[id]
+	if !ok {
 		c.mu.Unlock()
-		return
+		return false, ErrNotExists
 	}
-	e.isClosing = true
-	e.close = make(chan struct{})
 	c.mu.Unlock()
+	return c.remove(ctx, e)
+}
 
-	<-e.load
-	if e.value != nil {
+func (c *oCache) remove(ctx context.Context, e *entry) (ok bool, err error) {
+	if _, err = e.waitLoad(ctx, e.id); err != nil {
+		return false, err
+	}
+	_, curState := e.setClosing(true)
+	if curState == entryStateClosing {
+		ok = true
 		err = e.value.Close()
+		c.mu.Lock()
+		e.setClosed()
+		delete(c.data, e.id)
+		c.mu.Unlock()
 	}
-	c.mu.Lock()
-	close(e.close)
-	delete(c.data, e.id)
-	c.mu.Unlock()
-
 	return
 }
 
@@ -308,13 +220,7 @@ func (c *oCache) Add(id string, value Object) (err error) {
 	if _, ok := c.data[id]; ok {
 		return ErrExists
 	}
-	e := &entry{
-		id:        id,
-		lastUsage: time.Now(),
-		refCount:  0,
-		load:      make(chan struct{}),
-		value:     value,
-	}
+	e := newEntry(id, value, entryStateActive)
 	close(e.load)
 	c.data[id] = e
 	return
@@ -326,7 +232,7 @@ func (c *oCache) ForEach(f func(obj Object) (isContinue bool)) {
 	for _, v := range c.data {
 		select {
 		case <-v.load:
-			if v.value != nil && !v.isClosing {
+			if v.value != nil && !v.isClosing() {
 				objects = append(objects, v.value)
 			}
 		default:
@@ -362,40 +268,35 @@ func (c *oCache) GC() {
 	deadline := c.timeNow().Add(-c.ttl)
 	var toClose []*entry
 	for _, e := range c.data {
-		if e.isClosing {
-			continue
-		}
-		lu := e.lastUsage
-		if lug, ok := e.value.(ObjectLastUsage); ok {
-			lu = lug.LastUsage()
-		}
-		if !e.locked() && e.refCount <= 0 && lu.Before(deadline) {
-			e.isClosing = true
+		if e.isActive() && e.lastUsage.Before(deadline) {
 			e.close = make(chan struct{})
 			toClose = append(toClose, e)
 		}
 	}
 	size := len(c.data)
 	c.mu.Unlock()
-
+	closedNum := 0
 	for _, e := range toClose {
-		<-e.load
-		if e.value != nil {
-			if err := e.value.Close(); err != nil {
-				c.log.With("object_id", e.id).Warnf("GC: object close error: %v", err)
-			}
+		prevState, _ := e.setClosing(false)
+		if prevState == entryStateClosing || prevState == entryStateClosed {
+			continue
+		}
+		closed, err := e.value.TryClose(c.ttl)
+		if err != nil {
+			c.log.With("object_id", e.id).Warnf("GC: object close error: %v", err)
+		}
+		if !closed {
+			e.setActive(true)
+			continue
+		} else {
+			closedNum++
+			c.mu.Lock()
+			e.setClosed()
+			delete(c.data, e.id)
+			c.mu.Unlock()
 		}
 	}
-	c.log.Infof("GC: removed %d; cache size: %d", len(toClose), size)
-	if len(toClose) > 0 && c.metrics != nil {
-		c.metrics.gc.Add(float64(len(toClose)))
-	}
-	c.mu.Lock()
-	for _, e := range toClose {
-		close(e.close)
-		delete(c.data, e.id)
-	}
-	c.mu.Unlock()
+	c.metricsClosed(closedNum, size)
 }
 
 func (c *oCache) Len() int {
@@ -412,25 +313,34 @@ func (c *oCache) Close() (err error) {
 	}
 	c.closed = true
 	close(c.closeCh)
-	var toClose, alreadyClosing []*entry
+	var toClose []*entry
 	for _, e := range c.data {
-		if e.isClosing {
-			alreadyClosing = append(alreadyClosing, e)
-		} else {
-			toClose = append(toClose, e)
-		}
+		toClose = append(toClose, e)
 	}
 	c.mu.Unlock()
 	for _, e := range toClose {
-		<-e.load
-		if e.value != nil {
-			if clErr := e.value.Close(); clErr != nil {
-				c.log.With("object_id", e.id).Warnf("cache close: object close error: %v", clErr)
-			}
+		if _, err := c.remove(context.Background(), e); err != nil && err != ErrNotExists {
+			c.log.With("object_id", e.id).Warnf("cache close: object close error: %v", err)
 		}
 	}
-	for _, e := range alreadyClosing {
-		<-e.close
-	}
 	return nil
 }
+
+func (c *oCache) metricsGet(hit bool) {
+	if c.metrics == nil {
+		return
+	}
+	if hit {
+		c.metrics.hit.Inc()
+	} else {
+		c.metrics.miss.Inc()
+	}
+}
+
+func (c *oCache) metricsClosed(closedLen, size int) {
+	c.log.Infof("GC: removed %d; cache size: %d", closedLen, size)
+	if c.metrics == nil || closedLen == 0 {
+		return
+	}
+	c.metrics.gc.Add(float64(closedLen))
+}

app/ocache/ocache_test.go

@@ -3,6 +3,8 @@ package ocache
 import (
 	"context"
 	"errors"
+	"fmt"
+	"sync"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -11,26 +13,48 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+var ctx = context.Background()
+
 type testObject struct {
-	name     string
-	closeErr error
-	closeCh  chan struct{}
+	name           string
+	closeErr       error
+	closeCh        chan struct{}
+	tryReturn      bool
+	closeCalled    bool
+	tryCloseCalled bool
 }
 
-func NewTestObject(name string, closeCh chan struct{}) *testObject {
+func NewTestObject(name string, tryReturn bool, closeCh chan struct{}) *testObject {
 	return &testObject{
-		name:    name,
-		closeCh: closeCh,
+		name:      name,
+		closeCh:   closeCh,
+		tryReturn: tryReturn,
 	}
 }
 
 func (t *testObject) Close() (err error) {
+	if t.closeCalled || (t.tryCloseCalled && t.tryReturn) {
+		panic("close called twice")
+	}
+	t.closeCalled = true
 	if t.closeCh != nil {
 		<-t.closeCh
 	}
 	return t.closeErr
 }
 
+func (t *testObject) TryClose(objectTTL time.Duration) (res bool, err error) {
+	if t.closeCalled || (t.tryCloseCalled && t.tryReturn) {
+		panic("close called twice")
+	}
+	t.tryCloseCalled = true
+	if t.closeCh != nil {
+		<-t.closeCh
+		return t.tryReturn, t.closeErr
+	}
+	return t.tryReturn, nil
+}
+
 func TestOCache_Get(t *testing.T) {
 	t.Run("successful", func(t *testing.T) {
 		c := New(func(ctx context.Context, id string) (value Object, err error) {
@@ -116,42 +140,37 @@ func TestOCache_Get(t *testing.T) {
 }
 
 func TestOCache_GC(t *testing.T) {
-	t.Run("test without close wait", func(t *testing.T) {
+	t.Run("test gc expired object", func(t *testing.T) {
 		c := New(func(ctx context.Context, id string) (value Object, err error) {
-			return &testObject{name: id}, nil
-		}, WithTTL(time.Millisecond*10), WithRefCounter(true))
+			return NewTestObject(id, true, nil), nil
+		}, WithTTL(time.Millisecond*10))
 		val, err := c.Get(context.TODO(), "id")
 		require.NoError(t, err)
 		require.NotNil(t, val)
 		assert.Equal(t, 1, c.Len())
 		c.GC()
 		assert.Equal(t, 1, c.Len())
-		time.Sleep(time.Millisecond * 30)
-		c.GC()
-		assert.Equal(t, 1, c.Len())
-		assert.True(t, c.Release("id"))
+		time.Sleep(time.Millisecond * 20)
 		c.GC()
 		assert.Equal(t, 0, c.Len())
-		assert.False(t, c.Release("id"))
 	})
-	t.Run("test with close wait", func(t *testing.T) {
+	t.Run("test gc tryClose true, close before get", func(t *testing.T) {
 		closeCh := make(chan struct{})
 		getCh := make(chan struct{})
 
 		c := New(func(ctx context.Context, id string) (value Object, err error) {
-			return NewTestObject(id, closeCh), nil
-		}, WithTTL(time.Millisecond*10), WithRefCounter(true))
+			return NewTestObject(id, true, closeCh), nil
+		}, WithTTL(time.Millisecond*10))
 		val, err := c.Get(context.TODO(), "id")
 		require.NoError(t, err)
 		require.NotNil(t, val)
 		assert.Equal(t, 1, c.Len())
-		assert.True(t, c.Release("id"))
 		// making ttl pass
-		time.Sleep(time.Millisecond * 40)
+		time.Sleep(time.Millisecond * 20)
 		// first gc will be run after 20 secs, so calling it manually
 		go c.GC()
 		// waiting until all objects are marked as closing
-		time.Sleep(time.Millisecond * 40)
+		time.Sleep(time.Millisecond * 20)
 		var events []string
 		go func() {
 			_, err := c.Get(context.TODO(), "id")
@@ -160,47 +179,313 @@ func TestOCache_GC(t *testing.T) {
 			events = append(events, "get")
 			close(getCh)
 		}()
-		events = append(events, "close")
 		// sleeping to make sure that Get is called
-		time.Sleep(time.Millisecond * 40)
+		time.Sleep(time.Millisecond * 20)
+		events = append(events, "close")
 		close(closeCh)
 
 		<-getCh
 		require.Equal(t, []string{"close", "get"}, events)
 	})
+	t.Run("test gc tryClose false, many parallel get", func(t *testing.T) {
+		timesCalled := &atomic.Int32{}
+		obj := NewTestObject("id", false, nil)
+		c := New(func(ctx context.Context, id string) (value Object, err error) {
+			timesCalled.Add(1)
+			return obj, nil
+		}, WithTTL(0))
+
+		val, err := c.Get(context.TODO(), "id")
+		require.NoError(t, err)
+		require.NotNil(t, val)
+		assert.Equal(t, 1, c.Len())
+		begin := make(chan struct{})
+		wg := sync.WaitGroup{}
+		once := sync.Once{}
+
+		wg.Add(1)
+		go func() {
+			<-begin
+			c.GC()
+			wg.Done()
+		}()
+		for i := 0; i < 50; i++ {
+			wg.Add(1)
+			go func(i int) {
+				once.Do(func() {
+					close(begin)
+				})
+				if i%2 != 0 {
+					time.Sleep(time.Millisecond)
+				}
+				_, err := c.Get(context.TODO(), "id")
+				require.NoError(t, err)
+				wg.Done()
+			}(i)
+		}
+		require.NoError(t, err)
+		wg.Wait()
+		require.Equal(t, timesCalled.Load(), int32(1))
+		require.True(t, obj.tryCloseCalled)
+	})
+	t.Run("test gc tryClose different, many objects", func(t *testing.T) {
+		tryCloseIds := make(map[string]bool)
+		called := make(map[string]int)
+		max := 1000
+		getId := func(i int) string {
+			return fmt.Sprintf("id%d", i)
+		}
+		for i := 0; i < max; i++ {
+			if i%2 == 1 {
+				tryCloseIds[getId(i)] = true
+			} else {
+				tryCloseIds[getId(i)] = false
+			}
+		}
+		c := New(func(ctx context.Context, id string) (value Object, err error) {
+			called[id] = called[id] + 1
+			return NewTestObject(id, tryCloseIds[id], nil), nil
+		}, WithTTL(time.Millisecond*10))
+
+		for i := 0; i < max; i++ {
+			val, err := c.Get(context.TODO(), getId(i))
+			require.NoError(t, err)
+			require.NotNil(t, val)
+		}
+		assert.Equal(t, max, c.Len())
+		time.Sleep(time.Millisecond * 20)
+		c.GC()
+		for i := 0; i < max; i++ {
+			val, err := c.Get(context.TODO(), getId(i))
+			require.NoError(t, err)
+			require.NotNil(t, val)
+		}
+		for i := 0; i < max; i++ {
+			val, err := c.Get(context.TODO(), getId(i))
+			require.NoError(t, err)
+			require.NotNil(t, val)
+			require.Equal(t, called[getId(i)], i%2+1)
+		}
+	})
 }
 
 func Test_OCache_Remove(t *testing.T) {
-	closeCh := make(chan struct{})
-	getCh := make(chan struct{})
+	t.Run("remove simple", func(t *testing.T) {
+		closeCh := make(chan struct{})
+		getCh := make(chan struct{})
+		c := New(func(ctx context.Context, id string) (value Object, err error) {
+			return NewTestObject(id, false, closeCh), nil
+		}, WithTTL(time.Millisecond*10))
 
-	c := New(func(ctx context.Context, id string) (value Object, err error) {
-		return NewTestObject(id, closeCh), nil
-	}, WithTTL(time.Millisecond*10))
-	val, err := c.Get(context.TODO(), "id")
-	require.NoError(t, err)
-	require.NotNil(t, val)
-	assert.Equal(t, 1, c.Len())
-	// removing the object, so we will wait on closing
-	go func() {
-		_, err := c.Remove("id")
-		require.NoError(t, err)
-	}()
-	time.Sleep(time.Millisecond * 40)
-
-	var events []string
-	go func() {
-		_, err := c.Get(context.TODO(), "id")
+		val, err := c.Get(context.TODO(), "id")
 		require.NoError(t, err)
 		require.NotNil(t, val)
-		events = append(events, "get")
-		close(getCh)
-	}()
-	events = append(events, "close")
-	// sleeping to make sure that Get is called
-	time.Sleep(time.Millisecond * 40)
-	close(closeCh)
+		assert.Equal(t, 1, c.Len())
+		// removing the object, so we will wait on closing
+		go func() {
+			_, err := c.Remove(ctx, "id")
+			require.NoError(t, err)
+		}()
+		time.Sleep(time.Millisecond * 20)
 
-	<-getCh
-	require.Equal(t, []string{"close", "get"}, events)
+		var events []string
+		go func() {
+			_, err := c.Get(context.TODO(), "id")
+			require.NoError(t, err)
+			require.NotNil(t, val)
+			events = append(events, "get")
+			close(getCh)
+		}()
+		// sleeping to make sure that Get is called
+		time.Sleep(time.Millisecond * 20)
+		events = append(events, "close")
+		close(closeCh)
+
+		<-getCh
+		require.Equal(t, []string{"close", "get"}, events)
+	})
+	t.Run("test remove while gc, tryClose false", func(t *testing.T) {
+		closeCh := make(chan struct{})
+		removeCh := make(chan struct{})
+
+		c := New(func(ctx context.Context, id string) (value Object, err error) {
+			return NewTestObject(id, false, closeCh), nil
+		}, WithTTL(time.Millisecond*10))
+		val, err := c.Get(context.TODO(), "id")
+		require.NoError(t, err)
+		require.NotNil(t, val)
+		assert.Equal(t, 1, c.Len())
+		time.Sleep(time.Millisecond * 20)
+		go c.GC()
+		time.Sleep(time.Millisecond * 20)
+		var events []string
+		go func() {
+			ok, err := c.Remove(ctx, "id")
+			require.NoError(t, err)
+			require.True(t, ok)
+			events = append(events, "remove")
+			close(removeCh)
+		}()
+		time.Sleep(time.Millisecond * 20)
+		events = append(events, "close")
+		close(closeCh)
+
+		<-removeCh
+		require.Equal(t, []string{"close", "remove"}, events)
+	})
+	t.Run("test remove while gc, tryClose true", func(t *testing.T) {
+		closeCh := make(chan struct{})
+		removeCh := make(chan struct{})
+
+		c := New(func(ctx context.Context, id string) (value Object, err error) {
+			return NewTestObject(id, true, closeCh), nil
+		}, WithTTL(time.Millisecond*10))
+		val, err := c.Get(context.TODO(), "id")
+		require.NoError(t, err)
+		require.NotNil(t, val)
+		assert.Equal(t, 1, c.Len())
+		time.Sleep(time.Millisecond * 20)
+		go c.GC()
+		time.Sleep(time.Millisecond * 20)
+		var events []string
+		go func() {
+			ok, err := c.Remove(ctx, "id")
+			require.NoError(t, err)
+			require.False(t, ok)
+			events = append(events, "remove")
+			close(removeCh)
+		}()
+		time.Sleep(time.Millisecond * 20)
+		events = append(events, "close")
+		close(closeCh)
+
+		<-removeCh
+		require.Equal(t, []string{"close", "remove"}, events)
+	})
+	t.Run("test gc while remove, tryClose true", func(t *testing.T) {
+		closeCh := make(chan struct{})
+		removeCh := make(chan struct{})
+
+		c := New(func(ctx context.Context, id string) (value Object, err error) {
+			return NewTestObject(id, true, closeCh), nil
+		}, WithTTL(time.Millisecond*10))
+		val, err := c.Get(context.TODO(), "id")
+		require.NoError(t, err)
+		require.NotNil(t, val)
+		assert.Equal(t, 1, c.Len())
+		go func() {
+			ok, err := c.Remove(ctx, "id")
+			require.NoError(t, err)
+			require.True(t, ok)
+			close(removeCh)
+		}()
+		time.Sleep(20 * time.Millisecond)
+		c.GC()
+		close(closeCh)
+		<-removeCh
+	})
+}
+
+func TestOCacheFuzzy(t *testing.T) {
+	t.Run("test many objects gc, get and remove simultaneously, close after", func(t *testing.T) {
+		tryCloseIds := make(map[string]bool)
+		max := 2000
+		getId := func(i int) string {
+			return fmt.Sprintf("id%d", i)
+		}
+		for i := 0; i < max; i++ {
+			if i%2 == 1 {
+				tryCloseIds[getId(i)] = true
+			} else {
+				tryCloseIds[getId(i)] = false
+			}
+		}
+		c := New(func(ctx context.Context, id string) (value Object, err error) {
+			return NewTestObject(id, tryCloseIds[id], nil), nil
+		}, WithTTL(time.Nanosecond))
+
+		stopGC := make(chan struct{})
+		wg := sync.WaitGroup{}
+		go func() {
+			for {
+				select {
+				case <-stopGC:
+					return
+				default:
+					c.GC()
+				}
+			}
+		}()
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 10; j++ {
+				for i := 0; i < max; i++ {
+					val, err := c.Get(context.TODO(), getId(i))
+					require.NoError(t, err)
+					require.NotNil(t, val)
+				}
+			}
+		}()
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 10; j++ {
+				for i := 0; i < max; i++ {
+					c.Remove(ctx, getId(i))
+				}
+			}
+		}()
+		wg.Wait()
+		close(stopGC)
+		err := c.Close()
+		require.NoError(t, err)
+		require.Equal(t, 0, c.Len())
+	})
+	t.Run("test many objects gc, get, remove and close simultaneously", func(t *testing.T) {
+		tryCloseIds := make(map[string]bool)
+		max := 2000
+		getId := func(i int) string {
+			return fmt.Sprintf("id%d", i)
+		}
+		for i := 0; i < max; i++ {
+			if i%2 == 1 {
+				tryCloseIds[getId(i)] = true
+			} else {
+				tryCloseIds[getId(i)] = false
+			}
+		}
+		c := New(func(ctx context.Context, id string) (value Object, err error) {
+			return NewTestObject(id, tryCloseIds[id], nil), nil
+		}, WithTTL(time.Nanosecond))
+
+		go func() {
+			for {
+				c.GC()
+			}
+		}()
+		go func() {
+			for j := 0; j < 10; j++ {
+				for i := 0; i < max; i++ {
+					val, err := c.Get(context.TODO(), getId(i))
+					if err == ErrClosed {
+						return
+					}
+					require.NoError(t, err)
+					require.NotNil(t, val)
+				}
+			}
+		}()
+		go func() {
+			for j := 0; j < 10; j++ {
+				for i := 0; i < max; i++ {
+					c.Remove(ctx, getId(i))
+				}
+			}
+		}()
+		time.Sleep(time.Millisecond)
+		err := c.Close()
+		require.NoError(t, err)
+		require.Equal(t, 0, c.Len())
+	})
 }

commonfile/fileblockstore/fileblockstore.go

@@ -2,8 +2,8 @@ package fileblockstore
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonfile/fileproto/fileprotoerr"
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonfile/fileproto/fileprotoerr"
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 )
@@ -21,6 +21,7 @@ type ctxKey uint
 
 const (
 	ctxKeySpaceId ctxKey = iota
+	ctxKeyFileId
 )
 
 type BlockStore interface {
@@ -48,3 +49,12 @@ func CtxGetSpaceId(ctx context.Context) (spaceId string) {
 	spaceId, _ = ctx.Value(ctxKeySpaceId).(string)
 	return
 }
+
+func CtxWithFileId(ctx context.Context, spaceId string) context.Context {
+	return context.WithValue(ctx, ctxKeyFileId, spaceId)
+}
+
+func CtxGetFileId(ctx context.Context) (spaceId string) {
+	spaceId, _ = ctx.Value(ctxKeyFileId).(string)
+	return
+}

commonfile/fileproto/file_drpc.pb.go

@@ -44,8 +44,10 @@ type DRPCFileClient interface {
 	BlockPush(ctx context.Context, in *BlockPushRequest) (*BlockPushResponse, error)
 	BlocksCheck(ctx context.Context, in *BlocksCheckRequest) (*BlocksCheckResponse, error)
 	BlocksBind(ctx context.Context, in *BlocksBindRequest) (*BlocksBindResponse, error)
-	BlocksDelete(ctx context.Context, in *BlocksDeleteRequest) (*BlocksDeleteResponse, error)
+	FilesDelete(ctx context.Context, in *FilesDeleteRequest) (*FilesDeleteResponse, error)
+	FilesInfo(ctx context.Context, in *FilesInfoRequest) (*FilesInfoResponse, error)
 	Check(ctx context.Context, in *CheckRequest) (*CheckResponse, error)
+	SpaceInfo(ctx context.Context, in *SpaceInfoRequest) (*SpaceInfoResponse, error)
 }
 
 type drpcFileClient struct {
@@ -94,9 +96,18 @@ func (c *drpcFileClient) BlocksBind(ctx context.Context, in *BlocksBindRequest)
 	return out, nil
 }
 
-func (c *drpcFileClient) BlocksDelete(ctx context.Context, in *BlocksDeleteRequest) (*BlocksDeleteResponse, error) {
-	out := new(BlocksDeleteResponse)
-	err := c.cc.Invoke(ctx, "/filesync.File/BlocksDelete", drpcEncoding_File_commonfile_fileproto_protos_file_proto{}, in, out)
+func (c *drpcFileClient) FilesDelete(ctx context.Context, in *FilesDeleteRequest) (*FilesDeleteResponse, error) {
+	out := new(FilesDeleteResponse)
+	err := c.cc.Invoke(ctx, "/filesync.File/FilesDelete", drpcEncoding_File_commonfile_fileproto_protos_file_proto{}, in, out)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *drpcFileClient) FilesInfo(ctx context.Context, in *FilesInfoRequest) (*FilesInfoResponse, error) {
+	out := new(FilesInfoResponse)
+	err := c.cc.Invoke(ctx, "/filesync.File/FilesInfo", drpcEncoding_File_commonfile_fileproto_protos_file_proto{}, in, out)
 	if err != nil {
 		return nil, err
 	}
@@ -112,13 +123,24 @@ func (c *drpcFileClient) Check(ctx context.Context, in *CheckRequest) (*CheckRes
 	return out, nil
 }
 
+func (c *drpcFileClient) SpaceInfo(ctx context.Context, in *SpaceInfoRequest) (*SpaceInfoResponse, error) {
+	out := new(SpaceInfoResponse)
+	err := c.cc.Invoke(ctx, "/filesync.File/SpaceInfo", drpcEncoding_File_commonfile_fileproto_protos_file_proto{}, in, out)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 type DRPCFileServer interface {
 	BlockGet(context.Context, *BlockGetRequest) (*BlockGetResponse, error)
 	BlockPush(context.Context, *BlockPushRequest) (*BlockPushResponse, error)
 	BlocksCheck(context.Context, *BlocksCheckRequest) (*BlocksCheckResponse, error)
 	BlocksBind(context.Context, *BlocksBindRequest) (*BlocksBindResponse, error)
-	BlocksDelete(context.Context, *BlocksDeleteRequest) (*BlocksDeleteResponse, error)
+	FilesDelete(context.Context, *FilesDeleteRequest) (*FilesDeleteResponse, error)
+	FilesInfo(context.Context, *FilesInfoRequest) (*FilesInfoResponse, error)
 	Check(context.Context, *CheckRequest) (*CheckResponse, error)
+	SpaceInfo(context.Context, *SpaceInfoRequest) (*SpaceInfoResponse, error)
 }
 
 type DRPCFileUnimplementedServer struct{}
@@ -139,7 +161,11 @@ func (s *DRPCFileUnimplementedServer) BlocksBind(context.Context, *BlocksBindReq
 	return nil, drpcerr.WithCode(errors.New("Unimplemented"), drpcerr.Unimplemented)
 }
 
-func (s *DRPCFileUnimplementedServer) BlocksDelete(context.Context, *BlocksDeleteRequest) (*BlocksDeleteResponse, error) {
+func (s *DRPCFileUnimplementedServer) FilesDelete(context.Context, *FilesDeleteRequest) (*FilesDeleteResponse, error) {
+	return nil, drpcerr.WithCode(errors.New("Unimplemented"), drpcerr.Unimplemented)
+}
+
+func (s *DRPCFileUnimplementedServer) FilesInfo(context.Context, *FilesInfoRequest) (*FilesInfoResponse, error) {
 	return nil, drpcerr.WithCode(errors.New("Unimplemented"), drpcerr.Unimplemented)
 }
 
@@ -147,9 +173,13 @@ func (s *DRPCFileUnimplementedServer) Check(context.Context, *CheckRequest) (*Ch
 	return nil, drpcerr.WithCode(errors.New("Unimplemented"), drpcerr.Unimplemented)
 }
 
+func (s *DRPCFileUnimplementedServer) SpaceInfo(context.Context, *SpaceInfoRequest) (*SpaceInfoResponse, error) {
+	return nil, drpcerr.WithCode(errors.New("Unimplemented"), drpcerr.Unimplemented)
+}
+
 type DRPCFileDescription struct{}
 
-func (DRPCFileDescription) NumMethods() int { return 6 }
+func (DRPCFileDescription) NumMethods() int { return 8 }
 
 func (DRPCFileDescription) Method(n int) (string, drpc.Encoding, drpc.Receiver, interface{}, bool) {
 	switch n {
@@ -190,15 +220,24 @@ func (DRPCFileDescription) Method(n int) (string, drpc.Encoding, drpc.Receiver,
 					)
 			}, DRPCFileServer.BlocksBind, true
 	case 4:
-		return "/filesync.File/BlocksDelete", drpcEncoding_File_commonfile_fileproto_protos_file_proto{},
+		return "/filesync.File/FilesDelete", drpcEncoding_File_commonfile_fileproto_protos_file_proto{},
 			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
 				return srv.(DRPCFileServer).
-					BlocksDelete(
+					FilesDelete(
 						ctx,
-						in1.(*BlocksDeleteRequest),
+						in1.(*FilesDeleteRequest),
 					)
-			}, DRPCFileServer.BlocksDelete, true
+			}, DRPCFileServer.FilesDelete, true
 	case 5:
+		return "/filesync.File/FilesInfo", drpcEncoding_File_commonfile_fileproto_protos_file_proto{},
+			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
+				return srv.(DRPCFileServer).
+					FilesInfo(
+						ctx,
+						in1.(*FilesInfoRequest),
+					)
+			}, DRPCFileServer.FilesInfo, true
+	case 6:
 		return "/filesync.File/Check", drpcEncoding_File_commonfile_fileproto_protos_file_proto{},
 			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
 				return srv.(DRPCFileServer).
@@ -207,6 +246,15 @@ func (DRPCFileDescription) Method(n int) (string, drpc.Encoding, drpc.Receiver,
 						in1.(*CheckRequest),
 					)
 			}, DRPCFileServer.Check, true
+	case 7:
+		return "/filesync.File/SpaceInfo", drpcEncoding_File_commonfile_fileproto_protos_file_proto{},
+			func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) {
+				return srv.(DRPCFileServer).
+					SpaceInfo(
+						ctx,
+						in1.(*SpaceInfoRequest),
+					)
+			}, DRPCFileServer.SpaceInfo, true
 	default:
 		return "", nil, nil, nil, false
 	}
@@ -280,16 +328,32 @@ func (x *drpcFile_BlocksBindStream) SendAndClose(m *BlocksBindResponse) error {
 	return x.CloseSend()
 }
 
-type DRPCFile_BlocksDeleteStream interface {
+type DRPCFile_FilesDeleteStream interface {
 	drpc.Stream
-	SendAndClose(*BlocksDeleteResponse) error
+	SendAndClose(*FilesDeleteResponse) error
 }
 
-type drpcFile_BlocksDeleteStream struct {
+type drpcFile_FilesDeleteStream struct {
 	drpc.Stream
 }
 
-func (x *drpcFile_BlocksDeleteStream) SendAndClose(m *BlocksDeleteResponse) error {
+func (x *drpcFile_FilesDeleteStream) SendAndClose(m *FilesDeleteResponse) error {
+	if err := x.MsgSend(m, drpcEncoding_File_commonfile_fileproto_protos_file_proto{}); err != nil {
+		return err
+	}
+	return x.CloseSend()
+}
+
+type DRPCFile_FilesInfoStream interface {
+	drpc.Stream
+	SendAndClose(*FilesInfoResponse) error
+}
+
+type drpcFile_FilesInfoStream struct {
+	drpc.Stream
+}
+
+func (x *drpcFile_FilesInfoStream) SendAndClose(m *FilesInfoResponse) error {
 	if err := x.MsgSend(m, drpcEncoding_File_commonfile_fileproto_protos_file_proto{}); err != nil {
 		return err
 	}
@@ -311,3 +375,19 @@ func (x *drpcFile_CheckStream) SendAndClose(m *CheckResponse) error {
 	}
 	return x.CloseSend()
 }
+
+type DRPCFile_SpaceInfoStream interface {
+	drpc.Stream
+	SendAndClose(*SpaceInfoResponse) error
+}
+
+type drpcFile_SpaceInfoStream struct {
+	drpc.Stream
+}
+
+func (x *drpcFile_SpaceInfoStream) SendAndClose(m *SpaceInfoResponse) error {
+	if err := x.MsgSend(m, drpcEncoding_File_commonfile_fileproto_protos_file_proto{}); err != nil {
+		return err
+	}
+	return x.CloseSend()
+}

commonfile/fileproto/fileprotoerr/fileprotoerr.go

@@ -2,12 +2,16 @@ package fileprotoerr
 
 import (
 	"fmt"
-	"github.com/anytypeio/any-sync/commonfile/fileproto"
-	"github.com/anytypeio/any-sync/net/rpc/rpcerr"
+	"github.com/anyproto/any-sync/commonfile/fileproto"
+	"github.com/anyproto/any-sync/net/rpc/rpcerr"
 )
 
 var (
-	errGroup       = rpcerr.ErrGroup(fileproto.ErrCodes_ErrorOffset)
-	ErrUnexpected  = errGroup.Register(fmt.Errorf("unexpected fileproto error"), uint64(fileproto.ErrCodes_Unexpected))
-	ErrCIDNotFound = errGroup.Register(fmt.Errorf("CID not found"), uint64(fileproto.ErrCodes_CIDNotFound))
+	errGroup              = rpcerr.ErrGroup(fileproto.ErrCodes_ErrorOffset)
+	ErrUnexpected         = errGroup.Register(fmt.Errorf("unexpected fileproto error"), uint64(fileproto.ErrCodes_Unexpected))
+	ErrCIDNotFound        = errGroup.Register(fmt.Errorf("CID not found"), uint64(fileproto.ErrCodes_CIDNotFound))
+	ErrForbidden          = errGroup.Register(fmt.Errorf("forbidden"), uint64(fileproto.ErrCodes_Forbidden))
+	ErrSpaceLimitExceeded = errGroup.Register(fmt.Errorf("space limit exceeded"), uint64(fileproto.ErrCodes_SpaceLimitExceeded))
+	ErrQuerySizeExceeded  = errGroup.Register(fmt.Errorf("query size exceeded"), uint64(fileproto.ErrCodes_QuerySizeExceeded))
+	ErrWrongHash          = errGroup.Register(fmt.Errorf("wrong block hash"), uint64(fileproto.ErrCodes_WrongHash))
 )

commonfile/fileproto/protos/file.proto

@@ -6,6 +6,10 @@ option go_package = "commonfile/fileproto";
 enum ErrCodes {
     Unexpected = 0;
     CIDNotFound = 1;
+    Forbidden = 2;
+    SpaceLimitExceeded = 3;
+    QuerySizeExceeded = 4;
+    WrongHash = 5;
     ErrorOffset = 200;
 }
 
@@ -18,10 +22,14 @@ service File {
     rpc BlocksCheck(BlocksCheckRequest) returns (BlocksCheckResponse);
     // BlocksBind binds CIDs to space
     rpc BlocksBind(BlocksBindRequest) returns (BlocksBindResponse);
-    // BlocksDelete deletes block from space
-    rpc BlocksDelete(BlocksDeleteRequest) returns (BlocksDeleteResponse);
+    // FilesDelete deletes files by id
+    rpc FilesDelete(FilesDeleteRequest) returns (FilesDeleteResponse);
+    // FilesInfo return info by given files id
+    rpc FilesInfo(FilesInfoRequest) returns (FilesInfoResponse);
     // Check checks the connection and credentials
     rpc Check(CheckRequest) returns (CheckResponse);
+    // SpaceInfo returns usage, limit, etc about space
+    rpc SpaceInfo(SpaceInfoRequest) returns (SpaceInfoResponse);
 }
 
 message BlockGetRequest {
@@ -36,19 +44,13 @@ message BlockGetResponse {
 
 message BlockPushRequest {
     string spaceId = 1;
-    bytes cid = 2;
-    bytes data = 3;
+    string fileId = 2;
+    bytes cid = 3;
+    bytes data = 4;
 }
 
 message BlockPushResponse {}
 
-message BlocksDeleteRequest {
-    string spaceId = 1;
-    repeated bytes cids = 2;
-}
-
-message BlocksDeleteResponse {}
-
 
 message BlocksCheckRequest {
     string spaceId = 1;
@@ -72,14 +74,50 @@ enum AvailabilityStatus {
 
 message BlocksBindRequest {
     string spaceId = 1;
-    repeated bytes cids = 2;
+    string fileId = 2;
+    repeated bytes cids = 3;
 }
 
 message BlocksBindResponse {}
 
+
+message FilesDeleteRequest {
+    string spaceId = 1;
+    repeated string fileIds = 2;
+}
+
+message FilesDeleteResponse {}
+
+message FilesInfoRequest {
+    string spaceId = 1;
+    repeated string fileIds = 2;
+}
+
+message FilesInfoResponse {
+    repeated FileInfo filesInfo = 1;
+}
+
+message FileInfo {
+    string fileId = 1;
+    uint64 usageBytes = 2;
+    uint32 cidsCount = 3;
+}
+
 message CheckRequest {}
 
 message CheckResponse {
     repeated string spaceIds = 1;
     bool allowWrite = 2;
 }
+
+message SpaceInfoRequest {
+    string spaceId = 1;
+}
+
+message SpaceInfoResponse {
+    uint64 limitBytes = 1;
+    uint64 usageBytes = 2;
+    uint64 cidsCount = 3;
+    uint64 filesCount = 4;
+}
+

commonfile/fileservice/blockservice.go

@@ -2,7 +2,7 @@ package fileservice
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/commonfile/fileblockstore"
+	"github.com/anyproto/any-sync/commonfile/fileblockstore"
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"

commonfile/fileservice/fileservice.go

@@ -3,9 +3,9 @@ package fileservice
 import (
 	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/app"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonfile/fileblockstore"
+	"github.com/anyproto/any-sync/app"
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonfile/fileblockstore"
 	"github.com/ipfs/go-cid"
 	chunker "github.com/ipfs/go-ipfs-chunker"
 	ipld "github.com/ipfs/go-ipld-format"
@@ -22,6 +22,10 @@ const CName = "common.commonfile.fileservice"
 
 var log = logger.NewNamed(CName)
 
+const (
+	ChunkSize = 1 << 20
+)
+
 func New() FileService {
 	return &fileService{}
 }
@@ -74,7 +78,7 @@ func (fs *fileService) AddFile(ctx context.Context, r io.Reader) (ipld.Node, err
 		Maxlinks:   helpers.DefaultLinksPerBlock,
 		CidBuilder: &fs.prefix,
 	}
-	dbh, err := dbp.New(chunker.DefaultSplitter(r))
+	dbh, err := dbp.New(chunker.NewSizeSplitter(r, ChunkSize))
 	if err != nil {
 		return nil, err
 	}

commonspace/commongetter.go

@@ -2,21 +2,24 @@ package commonspace
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/commonspace/object/syncobjectgetter"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/treegetter"
+	"github.com/anyproto/any-sync/commonspace/object/syncobjectgetter"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/treemanager"
+	"sync/atomic"
 )
 
 type commonGetter struct {
-	treegetter.TreeGetter
+	treemanager.TreeManager
 	spaceId         string
 	reservedObjects []syncobjectgetter.SyncObject
+	spaceIsClosed   *atomic.Bool
 }
 
-func newCommonGetter(spaceId string, getter treegetter.TreeGetter) *commonGetter {
+func newCommonGetter(spaceId string, getter treemanager.TreeManager, spaceIsClosed *atomic.Bool) *commonGetter {
 	return &commonGetter{
-		TreeGetter: getter,
-		spaceId:    spaceId,
+		TreeManager:   getter,
+		spaceId:       spaceId,
+		spaceIsClosed: spaceIsClosed,
 	}
 }
 
@@ -25,10 +28,13 @@ func (c *commonGetter) AddObject(object syncobjectgetter.SyncObject) {
 }
 
 func (c *commonGetter) GetTree(ctx context.Context, spaceId, treeId string) (objecttree.ObjectTree, error) {
+	if c.spaceIsClosed.Load() {
+		return nil, ErrSpaceClosed
+	}
 	if obj := c.getReservedObject(treeId); obj != nil {
 		return obj.(objecttree.ObjectTree), nil
 	}
-	return c.TreeGetter.GetTree(ctx, spaceId, treeId)
+	return c.TreeManager.GetTree(ctx, spaceId, treeId)
 }
 
 func (c *commonGetter) getReservedObject(id string) syncobjectgetter.SyncObject {
@@ -41,10 +47,13 @@ func (c *commonGetter) getReservedObject(id string) syncobjectgetter.SyncObject
 }
 
 func (c *commonGetter) GetObject(ctx context.Context, objectId string) (obj syncobjectgetter.SyncObject, err error) {
+	if c.spaceIsClosed.Load() {
+		return nil, ErrSpaceClosed
+	}
 	if obj := c.getReservedObject(objectId); obj != nil {
 		return obj, nil
 	}
-	t, err := c.TreeGetter.GetTree(ctx, c.spaceId, objectId)
+	t, err := c.TreeManager.GetTree(ctx, c.spaceId, objectId)
 	if err != nil {
 		return
 	}

commonspace/commonstorage.go

@@ -1,8 +1,8 @@
 package commonspace
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anytypeio/any-sync/commonspace/spacestorage"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/commonspace/spacestorage"
 )
 
 type commonStorage struct {

commonspace/config.go

@@ -5,6 +5,7 @@ type ConfigGetter interface {
 }
 
 type Config struct {
-	GCTTL      int `yaml:"gcTTL"`
-	SyncPeriod int `yaml:"syncPeriod"`
+	GCTTL                int  `yaml:"gcTTL"`
+	SyncPeriod           int  `yaml:"syncPeriod"`
+	KeepTreeDataInMemory bool `yaml:"keepTreeDataInMemory"`
 }

commonspace/credentialprovider/credentialprovider.go

@@ -0,0 +1,24 @@
+//go:generate mockgen -destination mock_credentialprovider/mock_credentialprovider.go github.com/anyproto/any-sync/commonspace/credentialprovider CredentialProvider
+package credentialprovider
+
+import (
+	"context"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+)
+
+const CName = "common.commonspace.credentialprovider"
+
+func NewNoOp() CredentialProvider {
+	return &noOpProvider{}
+}
+
+type CredentialProvider interface {
+	GetCredential(ctx context.Context, spaceHeader *spacesyncproto.RawSpaceHeaderWithId) ([]byte, error)
+}
+
+type noOpProvider struct {
+}
+
+func (n noOpProvider) GetCredential(ctx context.Context, spaceHeader *spacesyncproto.RawSpaceHeaderWithId) ([]byte, error) {
+	return nil, nil
+}

commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go

@@ -0,0 +1,51 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anyproto/any-sync/commonspace/credentialprovider (interfaces: CredentialProvider)
+
+// Package mock_credentialprovider is a generated GoMock package.
+package mock_credentialprovider
+
+import (
+	context "context"
+	reflect "reflect"
+
+	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockCredentialProvider is a mock of CredentialProvider interface.
+type MockCredentialProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockCredentialProviderMockRecorder
+}
+
+// MockCredentialProviderMockRecorder is the mock recorder for MockCredentialProvider.
+type MockCredentialProviderMockRecorder struct {
+	mock *MockCredentialProvider
+}
+
+// NewMockCredentialProvider creates a new mock instance.
+func NewMockCredentialProvider(ctrl *gomock.Controller) *MockCredentialProvider {
+	mock := &MockCredentialProvider{ctrl: ctrl}
+	mock.recorder = &MockCredentialProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCredentialProvider) EXPECT() *MockCredentialProviderMockRecorder {
+	return m.recorder
+}
+
+// GetCredential mocks base method.
+func (m *MockCredentialProvider) GetCredential(arg0 context.Context, arg1 *spacesyncproto.RawSpaceHeaderWithId) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCredential", arg0, arg1)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCredential indicates an expected call of GetCredential.
+func (mr *MockCredentialProviderMockRecorder) GetCredential(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredential", reflect.TypeOf((*MockCredentialProvider)(nil).GetCredential), arg0, arg1)
+}

commonspace/deletion_test.go

@@ -0,0 +1,271 @@
+package commonspace
+
+import (
+	"context"
+	"fmt"
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/commonspace/settings"
+	"github.com/anyproto/any-sync/commonspace/settings/settingsstate"
+	"github.com/anyproto/any-sync/commonspace/spacestorage"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/stretchr/testify/require"
+	"math/rand"
+	"testing"
+	"time"
+)
+
+func addIncorrectSnapshot(settingsObject settings.SettingsObject, acc *accountdata.AccountKeys, partialIds map[string]struct{}, newId string) (err error) {
+	factory := settingsstate.NewChangeFactory()
+	bytes, err := factory.CreateObjectDeleteChange(newId, &settingsstate.State{DeletedIds: partialIds}, true)
+	if err != nil {
+		return
+	}
+	ch, err := settingsObject.PrepareChange(objecttree.SignableChangeContent{
+		Data:        bytes,
+		Key:         acc.SignKey,
+		IsSnapshot:  true,
+		IsEncrypted: false,
+		Timestamp:   time.Now().Unix(),
+	})
+	if err != nil {
+		return
+	}
+	res, err := settingsObject.AddRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   []string{ch.Id},
+		RawChanges: []*treechangeproto.RawTreeChangeWithId{ch},
+	})
+	if err != nil {
+		return
+	}
+	if res.Mode != objecttree.Rebuild {
+		return fmt.Errorf("incorrect mode: %d", res.Mode)
+	}
+	return
+}
+
+func TestSpaceDeleteIds(t *testing.T) {
+	fx := newFixture(t)
+	acc := fx.account.Account()
+	rk := crypto.NewAES()
+	ctx := context.Background()
+	totalObjs := 1500
+
+	// creating space
+	sp, err := fx.spaceService.CreateSpace(ctx, SpaceCreatePayload{
+		SigningKey:     acc.SignKey,
+		SpaceType:      "type",
+		ReadKey:        rk.Bytes(),
+		ReplicationKey: 10,
+		MasterKey:      acc.PeerKey,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, sp)
+
+	// initializing space
+	spc, err := fx.spaceService.NewSpace(ctx, sp)
+	require.NoError(t, err)
+	require.NotNil(t, spc)
+	// adding space to tree manager
+	fx.treeManager.space = spc
+	err = spc.Init(ctx)
+	require.NoError(t, err)
+
+	var ids []string
+	for i := 0; i < totalObjs; i++ {
+		// creating a tree
+		bytes := make([]byte, 32)
+		rand.Read(bytes)
+		doc, err := spc.CreateTree(ctx, objecttree.ObjectTreeCreatePayload{
+			PrivKey:     acc.SignKey,
+			ChangeType:  "some",
+			SpaceId:     spc.Id(),
+			IsEncrypted: false,
+			Seed:        bytes,
+			Timestamp:   time.Now().Unix(),
+		})
+		require.NoError(t, err)
+		tr, err := spc.PutTree(ctx, doc, nil)
+		require.NoError(t, err)
+		ids = append(ids, tr.Id())
+		tr.Close()
+	}
+	// deleting trees
+	for _, id := range ids {
+		err = spc.DeleteTree(ctx, id)
+		require.NoError(t, err)
+	}
+	time.Sleep(3 * time.Second)
+	spc.Close()
+	require.Equal(t, len(ids), len(fx.treeManager.deletedIds))
+}
+
+func createTree(t *testing.T, ctx context.Context, spc Space, acc *accountdata.AccountKeys) string {
+	bytes := make([]byte, 32)
+	rand.Read(bytes)
+	doc, err := spc.CreateTree(ctx, objecttree.ObjectTreeCreatePayload{
+		PrivKey:     acc.SignKey,
+		ChangeType:  "some",
+		SpaceId:     spc.Id(),
+		IsEncrypted: false,
+		Seed:        bytes,
+		Timestamp:   time.Now().Unix(),
+	})
+	require.NoError(t, err)
+	tr, err := spc.PutTree(ctx, doc, nil)
+	require.NoError(t, err)
+	tr.Close()
+	return tr.Id()
+}
+
+func TestSpaceDeleteIdsIncorrectSnapshot(t *testing.T) {
+	fx := newFixture(t)
+	acc := fx.account.Account()
+	rk := crypto.NewAES()
+	ctx := context.Background()
+	totalObjs := 1500
+	partialObjs := 300
+
+	// creating space
+	sp, err := fx.spaceService.CreateSpace(ctx, SpaceCreatePayload{
+		SigningKey:     acc.SignKey,
+		SpaceType:      "type",
+		ReadKey:        rk.Bytes(),
+		ReplicationKey: 10,
+		MasterKey:      acc.PeerKey,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, sp)
+
+	// initializing space
+	spc, err := fx.spaceService.NewSpace(ctx, sp)
+	require.NoError(t, err)
+	require.NotNil(t, spc)
+	// adding space to tree manager
+	fx.treeManager.space = spc
+	err = spc.Init(ctx)
+	require.NoError(t, err)
+
+	settingsObject := spc.(*space).settingsObject
+	var ids []string
+	for i := 0; i < totalObjs; i++ {
+		id := createTree(t, ctx, spc, acc)
+		ids = append(ids, id)
+	}
+	// copying storage, so we will have all the trees locally
+	inmemory := spc.Storage().(*commonStorage).SpaceStorage.(*spacestorage.InMemorySpaceStorage)
+	storageCopy := inmemory.CopyStorage()
+	treesCopy := inmemory.AllTrees()
+
+	// deleting trees
+	for _, id := range ids {
+		err = spc.DeleteTree(ctx, id)
+		require.NoError(t, err)
+	}
+	mapIds := map[string]struct{}{}
+	for _, id := range ids[:partialObjs] {
+		mapIds[id] = struct{}{}
+	}
+	// adding snapshot that breaks the state
+	err = addIncorrectSnapshot(settingsObject, acc, mapIds, ids[partialObjs])
+	require.NoError(t, err)
+	// copying the contents of the settings tree
+	treesCopy[settingsObject.Id()] = settingsObject.Storage()
+	storageCopy.SetTrees(treesCopy)
+	spc.Close()
+	time.Sleep(100 * time.Millisecond)
+	// now we replace the storage, so the trees are back, but the settings object says that they are deleted
+	fx.storageProvider.(*spacestorage.InMemorySpaceStorageProvider).SetStorage(storageCopy)
+
+	spc, err = fx.spaceService.NewSpace(ctx, sp)
+	require.NoError(t, err)
+	require.NotNil(t, spc)
+	fx.treeManager.space = spc
+	fx.treeManager.deletedIds = nil
+	err = spc.Init(ctx)
+	require.NoError(t, err)
+
+	// waiting until everything is deleted
+	time.Sleep(3 * time.Second)
+	require.Equal(t, len(ids), len(fx.treeManager.deletedIds))
+
+	// checking that new snapshot will contain all the changes
+	settingsObject = spc.(*space).settingsObject
+	settings.DoSnapshot = func(treeLen int) bool {
+		return true
+	}
+	id := createTree(t, ctx, spc, acc)
+	err = spc.DeleteTree(ctx, id)
+	require.NoError(t, err)
+	delIds := settingsObject.Root().Model.(*spacesyncproto.SettingsData).Snapshot.DeletedIds
+	require.Equal(t, totalObjs+1, len(delIds))
+}
+
+func TestSpaceDeleteIdsMarkDeleted(t *testing.T) {
+	fx := newFixture(t)
+	acc := fx.account.Account()
+	rk := crypto.NewAES()
+	ctx := context.Background()
+	totalObjs := 1500
+
+	// creating space
+	sp, err := fx.spaceService.CreateSpace(ctx, SpaceCreatePayload{
+		SigningKey:     acc.SignKey,
+		SpaceType:      "type",
+		ReadKey:        rk.Bytes(),
+		ReplicationKey: 10,
+		MasterKey:      acc.PeerKey,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, sp)
+
+	// initializing space
+	spc, err := fx.spaceService.NewSpace(ctx, sp)
+	require.NoError(t, err)
+	require.NotNil(t, spc)
+	// adding space to tree manager
+	fx.treeManager.space = spc
+	err = spc.Init(ctx)
+	require.NoError(t, err)
+
+	settingsObject := spc.(*space).settingsObject
+	var ids []string
+	for i := 0; i < totalObjs; i++ {
+		id := createTree(t, ctx, spc, acc)
+		ids = append(ids, id)
+	}
+	// copying storage, so we will have the same contents, except for empty trees
+	inmemory := spc.Storage().(*commonStorage).SpaceStorage.(*spacestorage.InMemorySpaceStorage)
+	storageCopy := inmemory.CopyStorage()
+
+	// deleting trees, this will prepare the document to have all the deletion changes
+	for _, id := range ids {
+		err = spc.DeleteTree(ctx, id)
+		require.NoError(t, err)
+	}
+	treesMap := map[string]treestorage.TreeStorage{}
+	// copying the contents of the settings tree
+	treesMap[settingsObject.Id()] = settingsObject.Storage()
+	storageCopy.SetTrees(treesMap)
+	spc.Close()
+	time.Sleep(100 * time.Millisecond)
+	// now we replace the storage, so the trees are back, but the settings object says that they are deleted
+	fx.storageProvider.(*spacestorage.InMemorySpaceStorageProvider).SetStorage(storageCopy)
+
+	spc, err = fx.spaceService.NewSpace(ctx, sp)
+	require.NoError(t, err)
+	require.NotNil(t, spc)
+	fx.treeManager.space = spc
+	fx.treeManager.deletedIds = nil
+	fx.treeManager.markedIds = nil
+	err = spc.Init(ctx)
+	require.NoError(t, err)
+
+	// waiting until everything is deleted
+	time.Sleep(3 * time.Second)
+	require.Equal(t, len(ids), len(fx.treeManager.markedIds))
+	require.Zero(t, len(fx.treeManager.deletedIds))
+}

commonspace/headsync/diffsyncer.go

@@ -3,17 +3,17 @@ package headsync
 import (
 	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/app/ldiff"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/synctree"
-	"github.com/anytypeio/any-sync/commonspace/object/treegetter"
-	"github.com/anytypeio/any-sync/commonspace/peermanager"
-	"github.com/anytypeio/any-sync/commonspace/settings/deletionstate"
-	"github.com/anytypeio/any-sync/commonspace/spacestorage"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
-	"github.com/anytypeio/any-sync/commonspace/syncstatus"
-	"github.com/anytypeio/any-sync/net/peer"
-	"github.com/anytypeio/any-sync/net/rpc/rpcerr"
+	"github.com/anyproto/any-sync/app/ldiff"
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonspace/credentialprovider"
+	"github.com/anyproto/any-sync/commonspace/object/treemanager"
+	"github.com/anyproto/any-sync/commonspace/peermanager"
+	"github.com/anyproto/any-sync/commonspace/settings/settingsstate"
+	"github.com/anyproto/any-sync/commonspace/spacestorage"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/commonspace/syncstatus"
+	"github.com/anyproto/any-sync/net/peer"
+	"github.com/anyproto/any-sync/net/rpc/rpcerr"
 	"go.uber.org/zap"
 	"time"
 )
@@ -22,45 +22,51 @@ type DiffSyncer interface {
 	Sync(ctx context.Context) error
 	RemoveObjects(ids []string)
 	UpdateHeads(id string, heads []string)
-	Init(deletionState deletionstate.DeletionState)
+	Init(deletionState settingsstate.ObjectDeletionState)
+	Close() error
 }
 
 func newDiffSyncer(
 	spaceId string,
 	diff ldiff.Diff,
 	peerManager peermanager.PeerManager,
-	cache treegetter.TreeGetter,
+	cache treemanager.TreeManager,
 	storage spacestorage.SpaceStorage,
 	clientFactory spacesyncproto.ClientFactory,
 	syncStatus syncstatus.StatusUpdater,
+	credentialProvider credentialprovider.CredentialProvider,
 	log logger.CtxLogger) DiffSyncer {
 	return &diffSyncer{
-		diff:          diff,
-		spaceId:       spaceId,
-		cache:         cache,
-		storage:       storage,
-		peerManager:   peerManager,
-		clientFactory: clientFactory,
-		log:           log,
-		syncStatus:    syncStatus,
+		diff:               diff,
+		spaceId:            spaceId,
+		treeManager:        cache,
+		storage:            storage,
+		peerManager:        peerManager,
+		clientFactory:      clientFactory,
+		credentialProvider: credentialProvider,
+		log:                log,
+		syncStatus:         syncStatus,
 	}
 }
 
 type diffSyncer struct {
-	spaceId       string
-	diff          ldiff.Diff
-	peerManager   peermanager.PeerManager
-	cache         treegetter.TreeGetter
-	storage       spacestorage.SpaceStorage
-	clientFactory spacesyncproto.ClientFactory
-	log           logger.CtxLogger
-	deletionState deletionstate.DeletionState
-	syncStatus    syncstatus.StatusUpdater
+	spaceId            string
+	diff               ldiff.Diff
+	peerManager        peermanager.PeerManager
+	treeManager        treemanager.TreeManager
+	storage            spacestorage.SpaceStorage
+	clientFactory      spacesyncproto.ClientFactory
+	log                logger.CtxLogger
+	deletionState      settingsstate.ObjectDeletionState
+	credentialProvider credentialprovider.CredentialProvider
+	syncStatus         syncstatus.StatusUpdater
+	treeSyncer         treemanager.TreeSyncer
 }
 
-func (d *diffSyncer) Init(deletionState deletionstate.DeletionState) {
+func (d *diffSyncer) Init(deletionState settingsstate.ObjectDeletionState) {
 	d.deletionState = deletionState
 	d.deletionState.AddObserver(d.RemoveObjects)
+	d.treeSyncer = d.treeManager.NewTreeSyncer(d.spaceId, d.treeManager)
 }
 
 func (d *diffSyncer) RemoveObjects(ids []string) {
@@ -86,6 +92,7 @@ func (d *diffSyncer) UpdateHeads(id string, heads []string) {
 }
 
 func (d *diffSyncer) Sync(ctx context.Context) error {
+	// TODO: split diffsyncer into components
 	st := time.Now()
 	// diffing with responsible peers according to configuration
 	peers, err := d.peerManager.GetResponsiblePeers(ctx)
@@ -117,57 +124,40 @@ func (d *diffSyncer) syncWithPeer(ctx context.Context, p peer.Peer) (err error)
 	newIds, changedIds, removedIds, err := d.diff.Diff(ctx, rdiff)
 	err = rpcerr.Unwrap(err)
 	if err != nil && err != spacesyncproto.ErrSpaceMissing {
+		if err == spacesyncproto.ErrSpaceIsDeleted {
+			d.log.Debug("got space deleted while syncing")
+			d.treeSyncer.SyncAll(ctx, p.Id(), []string{d.storage.SpaceSettingsId()}, nil)
+		}
 		d.syncStatus.SetNodesOnline(p.Id(), false)
 		return fmt.Errorf("diff error: %v", err)
 	}
 	d.syncStatus.SetNodesOnline(p.Id(), true)
 
 	if err == spacesyncproto.ErrSpaceMissing {
-		return d.sendPushSpaceRequest(ctx, cl)
+		return d.sendPushSpaceRequest(ctx, p.Id(), cl)
 	}
 
 	totalLen := len(newIds) + len(changedIds) + len(removedIds)
 	// not syncing ids which were removed through settings document
-	filteredIds := d.deletionState.FilterJoin(newIds, changedIds, removedIds)
+	missingIds := d.deletionState.Filter(newIds)
+	existingIds := append(d.deletionState.Filter(removedIds), d.deletionState.Filter(changedIds)...)
 
-	d.syncStatus.RemoveAllExcept(p.Id(), filteredIds, stateCounter)
-
-	d.syncTrees(ctx, p.Id(), filteredIds)
+	d.syncStatus.RemoveAllExcept(p.Id(), existingIds, stateCounter)
 
+	err = d.treeSyncer.SyncAll(ctx, p.Id(), existingIds, missingIds)
+	if err != nil {
+		return err
+	}
 	d.log.Info("sync done:", zap.Int("newIds", len(newIds)),
 		zap.Int("changedIds", len(changedIds)),
 		zap.Int("removedIds", len(removedIds)),
-		zap.Int("already deleted ids", totalLen-len(filteredIds)),
+		zap.Int("already deleted ids", totalLen-len(existingIds)-len(missingIds)),
 		zap.String("peerId", p.Id()),
 	)
 	return
 }
 
-func (d *diffSyncer) syncTrees(ctx context.Context, peerId string, trees []string) {
-	for _, tId := range trees {
-		tree, err := d.cache.GetTree(ctx, d.spaceId, tId)
-		if err != nil {
-			d.log.InfoCtx(ctx, "can't load tree", zap.Error(err))
-			continue
-		}
-		syncTree, ok := tree.(synctree.SyncTree)
-		if !ok {
-			d.log.InfoCtx(ctx, "not a sync tree", zap.String("objectId", tId))
-			continue
-		}
-		// the idea why we call it directly is that if we try to get it from cache
-		// it may be already there (i.e. loaded)
-		// and build func will not be called, thus we won't sync the tree
-		// therefore we just do it manually
-		if err = syncTree.SyncWithPeer(ctx, peerId); err != nil {
-			d.log.WarnCtx(ctx, "synctree.SyncWithPeer error", zap.Error(err), zap.String("treeId", tId))
-		} else {
-			d.log.DebugCtx(ctx, "success synctree.SyncWithPeer", zap.String("treeId", tId))
-		}
-	}
-}
-
-func (d *diffSyncer) sendPushSpaceRequest(ctx context.Context, cl spacesyncproto.DRPCSpaceSyncClient) (err error) {
+func (d *diffSyncer) sendPushSpaceRequest(ctx context.Context, peerId string, cl spacesyncproto.DRPCSpaceSyncClient) (err error) {
 	aclStorage, err := d.storage.AclStorage()
 	if err != nil {
 		return
@@ -192,6 +182,10 @@ func (d *diffSyncer) sendPushSpaceRequest(ctx context.Context, cl spacesyncproto
 		return
 	}
 
+	cred, err := d.credentialProvider.GetCredential(ctx, header)
+	if err != nil {
+		return
+	}
 	spacePayload := &spacesyncproto.SpacePayload{
 		SpaceHeader:            header,
 		AclPayload:             root.Payload,
@@ -200,7 +194,32 @@ func (d *diffSyncer) sendPushSpaceRequest(ctx context.Context, cl spacesyncproto
 		SpaceSettingsPayloadId: spaceSettingsRoot.Id,
 	}
 	_, err = cl.SpacePush(ctx, &spacesyncproto.SpacePushRequest{
-		Payload: spacePayload,
+		Payload:    spacePayload,
+		Credential: cred,
 	})
+	if err != nil {
+		return
+	}
+	if e := d.subscribe(ctx, peerId); e != nil {
+		d.log.WarnCtx(ctx, "error subscribing for space", zap.Error(e))
+	}
 	return
 }
+
+func (d *diffSyncer) subscribe(ctx context.Context, peerId string) (err error) {
+	var msg = &spacesyncproto.SpaceSubscription{
+		SpaceIds: []string{d.spaceId},
+		Action:   spacesyncproto.SpaceSubscriptionAction_Subscribe,
+	}
+	payload, err := msg.Marshal()
+	if err != nil {
+		return
+	}
+	return d.peerManager.SendPeer(ctx, peerId, &spacesyncproto.ObjectSyncMessage{
+		Payload: payload,
+	})
+}
+
+func (d *diffSyncer) Close() error {
+	return d.treeSyncer.Close()
+}

commonspace/headsync/diffsyncer_test.go

@@ -1,23 +1,25 @@
 package headsync
 
 import (
+	"bytes"
 	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/app/ldiff"
-	"github.com/anytypeio/any-sync/app/ldiff/mock_ldiff"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/liststorage/mock_liststorage"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	mock_treestorage "github.com/anytypeio/any-sync/commonspace/object/tree/treestorage/mock_treestorage"
-	"github.com/anytypeio/any-sync/commonspace/object/treegetter/mock_treegetter"
-	"github.com/anytypeio/any-sync/commonspace/peermanager/mock_peermanager"
-	"github.com/anytypeio/any-sync/commonspace/settings/deletionstate/mock_deletionstate"
-	"github.com/anytypeio/any-sync/commonspace/spacestorage/mock_spacestorage"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto/mock_spacesyncproto"
-	"github.com/anytypeio/any-sync/commonspace/syncstatus"
-	"github.com/anytypeio/any-sync/net/peer"
+	"github.com/anyproto/any-sync/app/ldiff"
+	"github.com/anyproto/any-sync/app/ldiff/mock_ldiff"
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonspace/credentialprovider/mock_credentialprovider"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/liststorage/mock_liststorage"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	mock_treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage/mock_treestorage"
+	"github.com/anyproto/any-sync/commonspace/object/treemanager/mock_treemanager"
+	"github.com/anyproto/any-sync/commonspace/peermanager/mock_peermanager"
+	"github.com/anyproto/any-sync/commonspace/settings/settingsstate/mock_settingsstate"
+	"github.com/anyproto/any-sync/commonspace/spacestorage/mock_spacestorage"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto/mock_spacesyncproto"
+	"github.com/anyproto/any-sync/commonspace/syncstatus"
+	"github.com/anyproto/any-sync/net/peer"
 	"github.com/golang/mock/gomock"
 	"github.com/libp2p/go-libp2p/core/sec"
 	"github.com/stretchr/testify/require"
@@ -30,6 +32,7 @@ type pushSpaceRequestMatcher struct {
 	spaceId     string
 	aclRootId   string
 	settingsId  string
+	credential  []byte
 	spaceHeader *spacesyncproto.RawSpaceHeaderWithId
 }
 
@@ -39,7 +42,7 @@ func (p pushSpaceRequestMatcher) Matches(x interface{}) bool {
 		return false
 	}
 
-	return res.Payload.AclPayloadId == p.aclRootId && res.Payload.SpaceHeader == p.spaceHeader && res.Payload.SpaceSettingsPayloadId == p.settingsId
+	return res.Payload.AclPayloadId == p.aclRootId && res.Payload.SpaceHeader == p.spaceHeader && res.Payload.SpaceSettingsPayloadId == p.settingsId && bytes.Equal(p.credential, res.Credential)
 }
 
 func (p pushSpaceRequestMatcher) String() string {
@@ -48,6 +51,14 @@ func (p pushSpaceRequestMatcher) String() string {
 
 type mockPeer struct{}
 
+func (m mockPeer) Addr() string {
+	return ""
+}
+
+func (m mockPeer) TryClose(objectTTL time.Duration) (res bool, err error) {
+	return true, m.Close()
+}
+
 func (m mockPeer) Id() string {
 	return "mockId"
 }
@@ -83,11 +94,13 @@ func newPushSpaceRequestMatcher(
 	spaceId string,
 	aclRootId string,
 	settingsId string,
+	credential []byte,
 	spaceHeader *spacesyncproto.RawSpaceHeaderWithId) *pushSpaceRequestMatcher {
 	return &pushSpaceRequestMatcher{
 		spaceId:     spaceId,
 		aclRootId:   aclRootId,
 		settingsId:  settingsId,
+		credential:  credential,
 		spaceHeader: spaceHeader,
 	}
 }
@@ -100,33 +113,35 @@ func TestDiffSyncer_Sync(t *testing.T) {
 
 	diffMock := mock_ldiff.NewMockDiff(ctrl)
 	peerManagerMock := mock_peermanager.NewMockPeerManager(ctrl)
-	cacheMock := mock_treegetter.NewMockTreeGetter(ctrl)
+	cacheMock := mock_treemanager.NewMockTreeManager(ctrl)
 	stMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
 	clientMock := mock_spacesyncproto.NewMockDRPCSpaceSyncClient(ctrl)
 	factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceSyncClient {
 		return clientMock
 	})
-	delState := mock_deletionstate.NewMockDeletionState(ctrl)
+	treeSyncerMock := mock_treemanager.NewMockTreeSyncer(ctrl)
+	credentialProvider := mock_credentialprovider.NewMockCredentialProvider(ctrl)
+	delState := mock_settingsstate.NewMockObjectDeletionState(ctrl)
 	spaceId := "spaceId"
 	aclRootId := "aclRootId"
 	l := logger.NewNamed(spaceId)
-	diffSyncer := newDiffSyncer(spaceId, diffMock, peerManagerMock, cacheMock, stMock, factory, syncstatus.NewNoOpSyncStatus(), l)
+	diffSyncer := newDiffSyncer(spaceId, diffMock, peerManagerMock, cacheMock, stMock, factory, syncstatus.NewNoOpSyncStatus(), credentialProvider, l)
 	delState.EXPECT().AddObserver(gomock.Any())
+	cacheMock.EXPECT().NewTreeSyncer(spaceId, gomock.Any()).Return(treeSyncerMock)
 	diffSyncer.Init(delState)
 
 	t.Run("diff syncer sync", func(t *testing.T) {
+		mPeer := mockPeer{}
 		peerManagerMock.EXPECT().
 			GetResponsiblePeers(gomock.Any()).
-			Return([]peer.Peer{mockPeer{}}, nil)
+			Return([]peer.Peer{mPeer}, nil)
 		diffMock.EXPECT().
 			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
 			Return([]string{"new"}, []string{"changed"}, nil, nil)
-		delState.EXPECT().FilterJoin(gomock.Any()).Return([]string{"new", "changed"})
-		for _, arg := range []string{"new", "changed"} {
-			cacheMock.EXPECT().
-				GetTree(gomock.Any(), spaceId, arg).
-				Return(nil, nil)
-		}
+		delState.EXPECT().Filter([]string{"new"}).Return([]string{"new"}).Times(1)
+		delState.EXPECT().Filter([]string{"changed"}).Return([]string{"changed"}).Times(1)
+		delState.EXPECT().Filter(nil).Return(nil).Times(1)
+		treeSyncerMock.EXPECT().SyncAll(gomock.Any(), mPeer.Id(), []string{"changed"}, []string{"new"}).Return(nil)
 		require.NoError(t, diffSyncer.Sync(ctx))
 	})
 
@@ -172,6 +187,7 @@ func TestDiffSyncer_Sync(t *testing.T) {
 		}
 		spaceHeader := &spacesyncproto.RawSpaceHeaderWithId{}
 		spaceSettingsId := "spaceSettingsId"
+		credential := []byte("credential")
 
 		peerManagerMock.EXPECT().
 			GetResponsiblePeers(gomock.Any()).
@@ -189,14 +205,18 @@ func TestDiffSyncer_Sync(t *testing.T) {
 		aclStorageMock.EXPECT().
 			Root().
 			Return(aclRoot, nil)
+		credentialProvider.EXPECT().
+			GetCredential(gomock.Any(), spaceHeader).
+			Return(credential, nil)
 		clientMock.EXPECT().
-			SpacePush(gomock.Any(), newPushSpaceRequestMatcher(spaceId, aclRootId, settingsId, spaceHeader)).
+			SpacePush(gomock.Any(), newPushSpaceRequestMatcher(spaceId, aclRootId, settingsId, credential, spaceHeader)).
 			Return(nil, nil)
+		peerManagerMock.EXPECT().SendPeer(gomock.Any(), "mockId", gomock.Any())
 
 		require.NoError(t, diffSyncer.Sync(ctx))
 	})
 
-	t.Run("diff syncer sync other error", func(t *testing.T) {
+	t.Run("diff syncer sync unexpected", func(t *testing.T) {
 		peerManagerMock.EXPECT().
 			GetResponsiblePeers(gomock.Any()).
 			Return([]peer.Peer{mockPeer{}}, nil)
@@ -206,4 +226,18 @@ func TestDiffSyncer_Sync(t *testing.T) {
 
 		require.NoError(t, diffSyncer.Sync(ctx))
 	})
+
+	t.Run("diff syncer sync space is deleted error", func(t *testing.T) {
+		mPeer := mockPeer{}
+		peerManagerMock.EXPECT().
+			GetResponsiblePeers(gomock.Any()).
+			Return([]peer.Peer{mPeer}, nil)
+		diffMock.EXPECT().
+			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
+			Return(nil, nil, nil, spacesyncproto.ErrSpaceIsDeleted)
+		stMock.EXPECT().SpaceSettingsId().Return("settingsId")
+		treeSyncerMock.EXPECT().SyncAll(gomock.Any(), mPeer.Id(), []string{"settingsId"}, nil).Return(nil)
+
+		require.NoError(t, diffSyncer.Sync(ctx))
+	})
 }

commonspace/headsync/headsync.go

@@ -1,19 +1,24 @@
-//go:generate mockgen -destination mock_headsync/mock_headsync.go github.com/anytypeio/any-sync/commonspace/headsync DiffSyncer
+//go:generate mockgen -destination mock_headsync/mock_headsync.go github.com/anyproto/any-sync/commonspace/headsync DiffSyncer
 package headsync
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/app/ldiff"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonspace/object/treegetter"
-	"github.com/anytypeio/any-sync/commonspace/peermanager"
-	"github.com/anytypeio/any-sync/commonspace/settings/deletionstate"
-	"github.com/anytypeio/any-sync/commonspace/spacestorage"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
-	"github.com/anytypeio/any-sync/commonspace/syncstatus"
-	"github.com/anytypeio/any-sync/util/periodicsync"
+	"github.com/anyproto/any-sync/app/ldiff"
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonspace/credentialprovider"
+	"github.com/anyproto/any-sync/commonspace/object/treemanager"
+	"github.com/anyproto/any-sync/commonspace/peermanager"
+	"github.com/anyproto/any-sync/commonspace/settings/settingsstate"
+	"github.com/anyproto/any-sync/commonspace/spacestorage"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/commonspace/syncstatus"
+	"github.com/anyproto/any-sync/net/peer"
+	"github.com/anyproto/any-sync/nodeconf"
+	"github.com/anyproto/any-sync/util/periodicsync"
 	"go.uber.org/zap"
+	"golang.org/x/exp/slices"
 	"strings"
+	"sync/atomic"
 	"time"
 )
 
@@ -23,7 +28,7 @@ type TreeHeads struct {
 }
 
 type HeadSync interface {
-	Init(objectIds []string, deletionState deletionstate.DeletionState)
+	Init(objectIds []string, deletionState settingsstate.ObjectDeletionState)
 
 	UpdateHeads(id string, heads []string)
 	HandleRangeRequest(ctx context.Context, req *spacesyncproto.HeadSyncRequest) (resp *spacesyncproto.HeadSyncResponse, err error)
@@ -35,49 +40,73 @@ type HeadSync interface {
 }
 
 type headSync struct {
-	spaceId      string
-	periodicSync periodicsync.PeriodicSync
-	storage      spacestorage.SpaceStorage
-	diff         ldiff.Diff
-	log          logger.CtxLogger
-	syncer       DiffSyncer
+	spaceId        string
+	periodicSync   periodicsync.PeriodicSync
+	storage        spacestorage.SpaceStorage
+	diff           ldiff.Diff
+	log            logger.CtxLogger
+	syncer         DiffSyncer
+	configuration  nodeconf.NodeConf
+	spaceIsDeleted *atomic.Bool
 
 	syncPeriod int
 }
 
 func NewHeadSync(
 	spaceId string,
+	spaceIsDeleted *atomic.Bool,
 	syncPeriod int,
+	configuration nodeconf.NodeConf,
 	storage spacestorage.SpaceStorage,
 	peerManager peermanager.PeerManager,
-	cache treegetter.TreeGetter,
+	cache treemanager.TreeManager,
 	syncStatus syncstatus.StatusUpdater,
+	credentialProvider credentialprovider.CredentialProvider,
 	log logger.CtxLogger) HeadSync {
 
 	diff := ldiff.New(16, 16)
 	l := log.With(zap.String("spaceId", spaceId))
 	factory := spacesyncproto.ClientFactoryFunc(spacesyncproto.NewDRPCSpaceSyncClient)
-	syncer := newDiffSyncer(spaceId, diff, peerManager, cache, storage, factory, syncStatus, l)
-	periodicSync := periodicsync.NewPeriodicSync(syncPeriod, time.Minute*10, syncer.Sync, l)
+	syncer := newDiffSyncer(spaceId, diff, peerManager, cache, storage, factory, syncStatus, credentialProvider, l)
+	sync := func(ctx context.Context) (err error) {
+		// for clients cancelling the sync process
+		if spaceIsDeleted.Load() && !configuration.IsResponsible(spaceId) {
+			return spacesyncproto.ErrSpaceIsDeleted
+		}
+		return syncer.Sync(ctx)
+	}
+	periodicSync := periodicsync.NewPeriodicSync(syncPeriod, time.Minute, sync, l)
 
 	return &headSync{
-		spaceId:      spaceId,
-		storage:      storage,
-		syncer:       syncer,
-		periodicSync: periodicSync,
-		diff:         diff,
-		log:          log,
-		syncPeriod:   syncPeriod,
+		spaceId:        spaceId,
+		storage:        storage,
+		syncer:         syncer,
+		periodicSync:   periodicSync,
+		diff:           diff,
+		log:            log,
+		syncPeriod:     syncPeriod,
+		configuration:  configuration,
+		spaceIsDeleted: spaceIsDeleted,
 	}
 }
 
-func (d *headSync) Init(objectIds []string, deletionState deletionstate.DeletionState) {
+func (d *headSync) Init(objectIds []string, deletionState settingsstate.ObjectDeletionState) {
 	d.fillDiff(objectIds)
 	d.syncer.Init(deletionState)
 	d.periodicSync.Run()
 }
 
 func (d *headSync) HandleRangeRequest(ctx context.Context, req *spacesyncproto.HeadSyncRequest) (resp *spacesyncproto.HeadSyncResponse, err error) {
+	if d.spaceIsDeleted.Load() {
+		peerId, err := peer.CtxPeerId(ctx)
+		if err != nil {
+			return nil, err
+		}
+		// stop receiving all request for sync from clients
+		if !slices.Contains(d.configuration.NodeIds(d.spaceId), peerId) {
+			return nil, spacesyncproto.ErrSpaceIsDeleted
+		}
+	}
 	return HandleRangeRequest(ctx, d.diff, req)
 }
 
@@ -107,7 +136,7 @@ func (d *headSync) RemoveObjects(ids []string) {
 
 func (d *headSync) Close() (err error) {
 	d.periodicSync.Close()
-	return nil
+	return d.syncer.Close()
 }
 
 func (d *headSync) fillDiff(objectIds []string) {

commonspace/headsync/headsync_test.go

@@ -1,14 +1,14 @@
 package headsync
 
 import (
-	"github.com/anytypeio/any-sync/app/ldiff"
-	"github.com/anytypeio/any-sync/app/ldiff/mock_ldiff"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonspace/headsync/mock_headsync"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage/mock_treestorage"
-	"github.com/anytypeio/any-sync/commonspace/settings/deletionstate/mock_deletionstate"
-	"github.com/anytypeio/any-sync/commonspace/spacestorage/mock_spacestorage"
-	"github.com/anytypeio/any-sync/util/periodicsync/mock_periodicsync"
+	"github.com/anyproto/any-sync/app/ldiff"
+	"github.com/anyproto/any-sync/app/ldiff/mock_ldiff"
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonspace/headsync/mock_headsync"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage/mock_treestorage"
+	"github.com/anyproto/any-sync/commonspace/settings/settingsstate/mock_settingsstate"
+	"github.com/anyproto/any-sync/commonspace/spacestorage/mock_spacestorage"
+	"github.com/anyproto/any-sync/util/periodicsync/mock_periodicsync"
 	"github.com/golang/mock/gomock"
 	"testing"
 )
@@ -24,7 +24,7 @@ func TestDiffService(t *testing.T) {
 	treeStorageMock := mock_treestorage.NewMockTreeStorage(ctrl)
 	diffMock := mock_ldiff.NewMockDiff(ctrl)
 	syncer := mock_headsync.NewMockDiffSyncer(ctrl)
-	delState := mock_deletionstate.NewMockDeletionState(ctrl)
+	delState := mock_settingsstate.NewMockObjectDeletionState(ctrl)
 	syncPeriod := 1
 	initId := "initId"
 
@@ -65,6 +65,7 @@ func TestDiffService(t *testing.T) {
 
 	t.Run("close", func(t *testing.T) {
 		pSyncMock.EXPECT().Close()
+		syncer.EXPECT().Close()
 		service.Close()
 	})
 }

commonspace/headsync/mock_headsync/mock_headsync.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/any-sync/commonspace/headsync (interfaces: DiffSyncer)
+// Source: github.com/anyproto/any-sync/commonspace/headsync (interfaces: DiffSyncer)
 
 // Package mock_headsync is a generated GoMock package.
 package mock_headsync
@@ -8,7 +8,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	deletionstate "github.com/anytypeio/any-sync/commonspace/settings/deletionstate"
+	settingsstate "github.com/anyproto/any-sync/commonspace/settings/settingsstate"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -35,8 +35,22 @@ func (m *MockDiffSyncer) EXPECT() *MockDiffSyncerMockRecorder {
 	return m.recorder
 }
 
+// Close mocks base method.
+func (m *MockDiffSyncer) Close() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Close")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Close indicates an expected call of Close.
+func (mr *MockDiffSyncerMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockDiffSyncer)(nil).Close))
+}
+
 // Init mocks base method.
-func (m *MockDiffSyncer) Init(arg0 deletionstate.DeletionState) {
+func (m *MockDiffSyncer) Init(arg0 settingsstate.ObjectDeletionState) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Init", arg0)
 }

commonspace/headsync/remotediff.go

@@ -2,8 +2,8 @@ package headsync
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/app/ldiff"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/app/ldiff"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
 )
 
 type Client interface {

commonspace/headsync/remotediff_test.go

@@ -3,8 +3,8 @@ package headsync
 import (
 	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/app/ldiff"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/app/ldiff"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"testing"

commonspace/object/accountdata/accountdata.go

@@ -1,14 +1,36 @@
 package accountdata
 
 import (
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/encryptionkey"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
+	"crypto/rand"
+	"github.com/anyproto/any-sync/util/crypto"
 )
 
-type AccountData struct { // TODO: create a convenient constructor for this
-	Identity []byte // public key
-	PeerKey  signingkey.PrivKey
-	SignKey  signingkey.PrivKey
-	EncKey   encryptionkey.PrivKey
-	PeerId   string
+type AccountKeys struct {
+	PeerKey crypto.PrivKey
+	SignKey crypto.PrivKey
+	PeerId  string
+}
+
+func New(peerKey, signKey crypto.PrivKey) *AccountKeys {
+	return &AccountKeys{
+		PeerKey: peerKey,
+		SignKey: signKey,
+		PeerId:  peerKey.GetPublic().PeerId(),
+	}
+}
+
+func NewRandom() (*AccountKeys, error) {
+	peerKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
+	if err != nil {
+		return nil, err
+	}
+	signKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
+	if err != nil {
+		return nil, err
+	}
+	return &AccountKeys{
+		PeerKey: peerKey,
+		SignKey: signKey,
+		PeerId:  peerKey.GetPublic().PeerId(),
+	}, nil
 }

commonspace/object/acl/aclrecordproto/aclreadkeyderive.go

@@ -1,12 +0,0 @@
-package aclrecordproto
-
-import (
-	"github.com/anytypeio/any-sync/util/keys/symmetric"
-)
-
-func AclReadKeyDerive(signKey []byte, encKey []byte) (*symmetric.Key, error) {
-	concBuf := make([]byte, 0, len(signKey)+len(encKey))
-	concBuf = append(concBuf, signKey...)
-	concBuf = append(concBuf, encKey...)
-	return symmetric.DeriveFromBytes(concBuf)
-}

commonspace/object/acl/aclrecordproto/protos/aclrecord.proto

@@ -18,18 +18,17 @@ message AclRecord {
     string prevId = 1;
     bytes identity = 2;
     bytes data = 3;
-    uint64 currentReadKeyHash = 4;
+    string readKeyId = 4;
     int64 timestamp = 5;
 }
 
 message AclRoot {
     bytes identity = 1;
-    bytes encryptionKey = 2;
+    bytes masterKey = 2;
     string spaceId = 3;
     bytes encryptedReadKey = 4;
-    string derivationScheme = 5;
-    uint64 currentReadKeyHash = 6;
-    int64 timestamp = 7;
+    int64 timestamp = 5;
+    bytes identitySignature = 6;
 }
 
 message AclContentValue {
@@ -47,37 +46,33 @@ message AclData {
 }
 
 message AclState {
-    repeated uint64 readKeyHashes = 1;
+    repeated string readKeyIds = 1;
     repeated AclUserState userStates = 2;
     map<string, AclUserInvite> invites = 3;
 }
 
 message AclUserState {
     bytes identity = 1;
-    bytes encryptionKey = 2;
-    AclUserPermissions permissions = 3;
+    AclUserPermissions permissions = 2;
 }
 
 message AclUserAdd {
     bytes identity = 1;
-    bytes encryptionKey = 2;
-    repeated bytes encryptedReadKeys = 3;
-    AclUserPermissions permissions = 4;
+    repeated bytes encryptedReadKeys = 2;
+    AclUserPermissions permissions = 3;
 }
 
 message AclUserInvite {
     bytes acceptPublicKey = 1;
-    uint64 encryptSymKeyHash = 2;
-    repeated bytes encryptedReadKeys = 3;
-    AclUserPermissions permissions = 4;
+    repeated bytes encryptedReadKeys = 2;
+    AclUserPermissions permissions = 3;
 }
 
 message AclUserJoin {
     bytes identity = 1;
-    bytes encryptionKey = 2;
-    bytes acceptSignature = 3;
-    bytes acceptPubKey = 4;
-    repeated bytes encryptedReadKeys = 5;
+    bytes acceptSignature = 2;
+    bytes acceptPubKey = 3;
+    repeated bytes encryptedReadKeys = 4;
 }
 
 message AclUserRemove {
@@ -87,8 +82,7 @@ message AclUserRemove {
 
 message AclReadKeyReplace {
     bytes identity = 1;
-    bytes encryptionKey = 2;
-    bytes encryptedReadKey = 3;
+    bytes encryptedReadKey = 2;
 }
 
 message AclUserPermissionChange {
@@ -103,7 +97,7 @@ enum AclUserPermissions {
 }
 
 message AclSyncMessage {
-    AclSyncContentValue content = 2;
+    AclSyncContentValue content = 1;
 }
 
 // AclSyncContentValue provides different types for acl sync

commonspace/object/acl/list/aclrecordbuilder.go

@@ -1,131 +1,63 @@
 package list
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/commonspace/object/keychain"
-	"github.com/anytypeio/any-sync/util/cidutil"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
-	"github.com/anytypeio/any-sync/util/keys/symmetric"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/util/cidutil"
+	"github.com/anyproto/any-sync/util/crypto"
 	"github.com/gogo/protobuf/proto"
 	"time"
 )
 
-// remove interface
+type RootContent struct {
+	PrivKey          crypto.PrivKey
+	MasterKey        crypto.PrivKey
+	SpaceId          string
+	EncryptedReadKey []byte
+}
+
 type AclRecordBuilder interface {
-	ConvertFromRaw(rawIdRecord *aclrecordproto.RawAclRecordWithId) (rec *AclRecord, err error)
-	BuildUserJoin(acceptPrivKeyBytes []byte, encSymKeyBytes []byte, state *AclState) (rec *aclrecordproto.RawAclRecord, err error)
+	Unmarshall(rawIdRecord *aclrecordproto.RawAclRecordWithId) (rec *AclRecord, err error)
+	BuildRoot(content RootContent) (rec *aclrecordproto.RawAclRecordWithId, err error)
 }
 
 type aclRecordBuilder struct {
-	id       string
-	keychain *keychain.Keychain
+	id         string
+	keyStorage crypto.KeyStorage
 }
 
-func newAclRecordBuilder(id string, keychain *keychain.Keychain) AclRecordBuilder {
+func NewAclRecordBuilder(id string, keyStorage crypto.KeyStorage) AclRecordBuilder {
 	return &aclRecordBuilder{
-		id:       id,
-		keychain: keychain,
+		id:         id,
+		keyStorage: keyStorage,
 	}
 }
 
-func (a *aclRecordBuilder) BuildUserJoin(acceptPrivKeyBytes []byte, encSymKeyBytes []byte, state *AclState) (rec *aclrecordproto.RawAclRecord, err error) {
-	acceptPrivKey, err := signingkey.NewSigningEd25519PrivKeyFromBytes(acceptPrivKeyBytes)
-	if err != nil {
-		return
-	}
-	acceptPubKeyBytes, err := acceptPrivKey.GetPublic().Raw()
-	if err != nil {
-		return
-	}
-	encSymKey, err := symmetric.FromBytes(encSymKeyBytes)
-	if err != nil {
-		return
-	}
-
-	invite, err := state.Invite(acceptPubKeyBytes)
-	if err != nil {
-		return
-	}
-
-	encPrivKey, signPrivKey := state.UserKeys()
-	var symKeys [][]byte
-	for _, rk := range invite.EncryptedReadKeys {
-		dec, err := encSymKey.Decrypt(rk)
-		if err != nil {
-			return nil, err
-		}
-		newEnc, err := encPrivKey.GetPublic().Encrypt(dec)
-		if err != nil {
-			return nil, err
-		}
-		symKeys = append(symKeys, newEnc)
-	}
-	idSignature, err := acceptPrivKey.Sign(state.Identity())
-	if err != nil {
-		return
-	}
-	encPubKeyBytes, err := encPrivKey.GetPublic().Raw()
-	if err != nil {
-		return
-	}
-
-	userJoin := &aclrecordproto.AclUserJoin{
-		Identity:          state.Identity(),
-		EncryptionKey:     encPubKeyBytes,
-		AcceptSignature:   idSignature,
-		AcceptPubKey:      acceptPubKeyBytes,
-		EncryptedReadKeys: symKeys,
-	}
-	aclData := &aclrecordproto.AclData{AclContent: []*aclrecordproto.AclContentValue{
-		{Value: &aclrecordproto.AclContentValue_UserJoin{UserJoin: userJoin}},
-	}}
-	marshalledJoin, err := aclData.Marshal()
-	if err != nil {
-		return
-	}
-	aclRecord := &aclrecordproto.AclRecord{
-		PrevId:             state.LastRecordId(),
-		Identity:           state.Identity(),
-		Data:               marshalledJoin,
-		CurrentReadKeyHash: state.CurrentReadKeyHash(),
-		Timestamp:          time.Now().UnixNano(),
-	}
-	marshalledRecord, err := aclRecord.Marshal()
-	if err != nil {
-		return
-	}
-	recSignature, err := signPrivKey.Sign(marshalledRecord)
-	if err != nil {
-		return
-	}
-	rec = &aclrecordproto.RawAclRecord{
-		Payload:   marshalledRecord,
-		Signature: recSignature,
-	}
-	return
-}
-
-func (a *aclRecordBuilder) ConvertFromRaw(rawIdRecord *aclrecordproto.RawAclRecordWithId) (rec *AclRecord, err error) {
-	rawRec := &aclrecordproto.RawAclRecord{}
+func (a *aclRecordBuilder) Unmarshall(rawIdRecord *aclrecordproto.RawAclRecordWithId) (rec *AclRecord, err error) {
+	var (
+		rawRec = &aclrecordproto.RawAclRecord{}
+		pubKey crypto.PubKey
+	)
 	err = proto.Unmarshal(rawIdRecord.Payload, rawRec)
 	if err != nil {
 		return
 	}
-
 	if rawIdRecord.Id == a.id {
 		aclRoot := &aclrecordproto.AclRoot{}
 		err = proto.Unmarshal(rawRec.Payload, aclRoot)
 		if err != nil {
 			return
 		}
-
+		pubKey, err = a.keyStorage.PubKeyFromProto(aclRoot.Identity)
+		if err != nil {
+			return
+		}
 		rec = &AclRecord{
-			Id:                 rawIdRecord.Id,
-			CurrentReadKeyHash: aclRoot.CurrentReadKeyHash,
-			Timestamp:          aclRoot.Timestamp,
-			Signature:          rawRec.Signature,
-			Identity:           aclRoot.Identity,
-			Model:              aclRoot,
+			Id:        rawIdRecord.Id,
+			ReadKeyId: rawIdRecord.Id,
+			Timestamp: aclRoot.Timestamp,
+			Signature: rawRec.Signature,
+			Identity:  pubKey,
+			Model:     aclRoot,
 		}
 	} else {
 		aclRecord := &aclrecordproto.AclRecord{}
@@ -133,34 +65,63 @@ func (a *aclRecordBuilder) ConvertFromRaw(rawIdRecord *aclrecordproto.RawAclReco
 		if err != nil {
 			return
 		}
-
+		pubKey, err = a.keyStorage.PubKeyFromProto(aclRecord.Identity)
+		if err != nil {
+			return
+		}
 		rec = &AclRecord{
-			Id:                 rawIdRecord.Id,
-			PrevId:             aclRecord.PrevId,
-			CurrentReadKeyHash: aclRecord.CurrentReadKeyHash,
-			Timestamp:          aclRecord.Timestamp,
-			Data:               aclRecord.Data,
-			Signature:          rawRec.Signature,
-			Identity:           aclRecord.Identity,
+			Id:        rawIdRecord.Id,
+			PrevId:    aclRecord.PrevId,
+			ReadKeyId: aclRecord.ReadKeyId,
+			Timestamp: aclRecord.Timestamp,
+			Data:      aclRecord.Data,
+			Signature: rawRec.Signature,
+			Identity:  pubKey,
 		}
 	}
 
-	err = verifyRaw(a.keychain, rawRec, rawIdRecord, rec.Identity)
+	err = verifyRaw(pubKey, rawRec, rawIdRecord)
 	return
 }
 
-func verifyRaw(
-	keychain *keychain.Keychain,
-	rawRec *aclrecordproto.RawAclRecord,
-	recWithId *aclrecordproto.RawAclRecordWithId,
-	identity []byte) (err error) {
-	identityKey, err := keychain.GetOrAdd(string(identity))
+func (a *aclRecordBuilder) BuildRoot(content RootContent) (rec *aclrecordproto.RawAclRecordWithId, err error) {
+	rawIdentity, err := content.PrivKey.GetPublic().Raw()
 	if err != nil {
 		return
 	}
+	identity, err := content.PrivKey.GetPublic().Marshall()
+	if err != nil {
+		return
+	}
+	masterKey, err := content.MasterKey.GetPublic().Marshall()
+	if err != nil {
+		return
+	}
+	identitySignature, err := content.MasterKey.Sign(rawIdentity)
+	if err != nil {
+		return
+	}
+	var timestamp int64
+	if content.EncryptedReadKey != nil {
+		timestamp = time.Now().Unix()
+	}
+	aclRoot := &aclrecordproto.AclRoot{
+		Identity:          identity,
+		SpaceId:           content.SpaceId,
+		EncryptedReadKey:  content.EncryptedReadKey,
+		MasterKey:         masterKey,
+		IdentitySignature: identitySignature,
+		Timestamp:         timestamp,
+	}
+	return marshalAclRoot(aclRoot, content.PrivKey)
+}
 
+func verifyRaw(
+	pubKey crypto.PubKey,
+	rawRec *aclrecordproto.RawAclRecord,
+	recWithId *aclrecordproto.RawAclRecordWithId) (err error) {
 	// verifying signature
-	res, err := identityKey.Verify(rawRec.Payload, rawRec.Signature)
+	res, err := pubKey.Verify(rawRec.Payload, rawRec.Signature)
 	if err != nil {
 		return
 	}
@@ -175,3 +136,31 @@ func verifyRaw(
 	}
 	return
 }
+
+func marshalAclRoot(aclRoot *aclrecordproto.AclRoot, key crypto.PrivKey) (rawWithId *aclrecordproto.RawAclRecordWithId, err error) {
+	marshalledRoot, err := aclRoot.Marshal()
+	if err != nil {
+		return
+	}
+	signature, err := key.Sign(marshalledRoot)
+	if err != nil {
+		return
+	}
+	raw := &aclrecordproto.RawAclRecord{
+		Payload:   marshalledRoot,
+		Signature: signature,
+	}
+	marshalledRaw, err := raw.Marshal()
+	if err != nil {
+		return
+	}
+	aclHeadId, err := cidutil.NewCidFromBytes(marshalledRaw)
+	if err != nil {
+		return
+	}
+	rawWithId = &aclrecordproto.RawAclRecordWithId{
+		Payload: marshalledRaw,
+		Id:      aclHeadId,
+	}
+	return
+}

commonspace/object/acl/list/aclrecordbuilder_test.go

@@ -1,50 +1,9 @@
 package list
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	acllistbuilder2 "github.com/anytypeio/any-sync/commonspace/object/acl/testutils/acllistbuilder"
-	"github.com/anytypeio/any-sync/commonspace/object/keychain"
-	"github.com/anytypeio/any-sync/util/cidutil"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
-	"github.com/stretchr/testify/require"
 	"testing"
 )
 
 func TestAclRecordBuilder_BuildUserJoin(t *testing.T) {
-	st, err := acllistbuilder2.NewListStorageWithTestName("userjoinexample.yml")
-	require.NoError(t, err, "building storage should not result in error")
-
-	testKeychain := st.(*acllistbuilder2.AclListStorageBuilder).GetKeychain()
-	identity := testKeychain.GeneratedIdentities["D"]
-	signPrivKey := testKeychain.SigningKeysByYAMLName["D"]
-	encPrivKey := testKeychain.EncryptionKeysByYAMLName["D"]
-	acc := &accountdata.AccountData{
-		Identity: []byte(identity),
-		SignKey:  signPrivKey,
-		EncKey:   encPrivKey,
-	}
-
-	aclList, err := BuildAclListWithIdentity(acc, st)
-	require.NoError(t, err, "building acl list should be without error")
-	recordBuilder := newAclRecordBuilder(aclList.Id(), keychain.NewKeychain())
-	rk, err := testKeychain.GetKey("key.Read.EncKey").(*acllistbuilder2.SymKey).Key.Raw()
-	require.NoError(t, err)
-	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 := cidutil.NewCidFromBytes(marshalledJoin)
-	require.NoError(t, err)
-	rawRec := &aclrecordproto.RawAclRecordWithId{
-		Payload: marshalledJoin,
-		Id:      id,
-	}
-	res, err := aclList.AddRawRecord(rawRec)
-	require.True(t, res)
-	require.NoError(t, err)
-	require.Equal(t, aclrecordproto.AclUserPermissions_Writer, aclList.AclState().UserStates()[identity].Permissions)
+	return
 }

commonspace/object/acl/list/aclstate.go

@@ -1,22 +1,16 @@
 package list
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
-	"github.com/anytypeio/any-sync/app/logger"
-	aclrecordproto "github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/commonspace/object/keychain"
-	"github.com/anytypeio/any-sync/util/keys"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/encryptionkey"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
-	"github.com/anytypeio/any-sync/util/keys/symmetric"
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/util/crypto"
 	"github.com/gogo/protobuf/proto"
 	"go.uber.org/zap"
-	"hash/fnv"
 )
 
-var log = logger.NewNamed("acllist").Sugar()
+var log = logger.NewNamedSugared("common.commonspace.acllist")
 
 var (
 	ErrNoSuchUser              = errors.New("no such user")
@@ -35,86 +29,75 @@ var (
 )
 
 type UserPermissionPair struct {
-	Identity   string
+	Identity   crypto.PubKey
 	Permission aclrecordproto.AclUserPermissions
 }
 
 type AclState struct {
-	id                 string
-	currentReadKeyHash uint64
-	userReadKeys       map[uint64]*symmetric.Key
-	userStates         map[string]*aclrecordproto.AclUserState
-	userInvites        map[string]*aclrecordproto.AclUserInvite
-	encryptionKey      encryptionkey.PrivKey
-	signingKey         signingkey.PrivKey
-	totalReadKeys      int
+	id               string
+	currentReadKeyId string
+	userReadKeys     map[string]crypto.SymKey
+	userStates       map[string]AclUserState
+	statesAtRecord   map[string][]AclUserState
+	key              crypto.PrivKey
+	pubKey           crypto.PubKey
+	keyStore         crypto.KeyStorage
+	totalReadKeys    int
 
-	identity            string
-	permissionsAtRecord map[string][]UserPermissionPair
-	lastRecordId        string
-
-	keychain *keychain.Keychain
+	lastRecordId string
 }
 
 func newAclStateWithKeys(
 	id string,
-	signingKey signingkey.PrivKey,
-	encryptionKey encryptionkey.PrivKey) (*AclState, error) {
-	identity, err := signingKey.GetPublic().Raw()
-	if err != nil {
-		return nil, err
-	}
+	key crypto.PrivKey) (*AclState, error) {
 	return &AclState{
-		id:                  id,
-		identity:            string(identity),
-		signingKey:          signingKey,
-		encryptionKey:       encryptionKey,
-		userReadKeys:        make(map[uint64]*symmetric.Key),
-		userStates:          make(map[string]*aclrecordproto.AclUserState),
-		userInvites:         make(map[string]*aclrecordproto.AclUserInvite),
-		permissionsAtRecord: make(map[string][]UserPermissionPair),
+		id:             id,
+		key:            key,
+		pubKey:         key.GetPublic(),
+		userReadKeys:   make(map[string]crypto.SymKey),
+		userStates:     make(map[string]AclUserState),
+		statesAtRecord: make(map[string][]AclUserState),
 	}, nil
 }
 
 func newAclState(id string) *AclState {
 	return &AclState{
-		id:                  id,
-		userReadKeys:        make(map[uint64]*symmetric.Key),
-		userStates:          make(map[string]*aclrecordproto.AclUserState),
-		userInvites:         make(map[string]*aclrecordproto.AclUserInvite),
-		permissionsAtRecord: make(map[string][]UserPermissionPair),
+		id:             id,
+		userReadKeys:   make(map[string]crypto.SymKey),
+		userStates:     make(map[string]AclUserState),
+		statesAtRecord: make(map[string][]AclUserState),
 	}
 }
 
-func (st *AclState) CurrentReadKeyHash() uint64 {
-	return st.currentReadKeyHash
+func (st *AclState) CurrentReadKeyId() string {
+	return st.currentReadKeyId
 }
 
-func (st *AclState) CurrentReadKey() (*symmetric.Key, error) {
-	key, exists := st.userReadKeys[st.currentReadKeyHash]
+func (st *AclState) CurrentReadKey() (crypto.SymKey, error) {
+	key, exists := st.userReadKeys[st.currentReadKeyId]
 	if !exists {
 		return nil, ErrNoReadKey
 	}
 	return key, nil
 }
 
-func (st *AclState) UserReadKeys() map[uint64]*symmetric.Key {
+func (st *AclState) UserReadKeys() map[string]crypto.SymKey {
 	return st.userReadKeys
 }
 
-func (st *AclState) PermissionsAtRecord(id string, identity string) (UserPermissionPair, error) {
-	permissions, ok := st.permissionsAtRecord[id]
+func (st *AclState) StateAtRecord(id string, pubKey crypto.PubKey) (AclUserState, error) {
+	userState, ok := st.statesAtRecord[id]
 	if !ok {
 		log.Errorf("missing record at id %s", id)
-		return UserPermissionPair{}, ErrNoSuchRecord
+		return AclUserState{}, ErrNoSuchRecord
 	}
 
-	for _, perm := range permissions {
-		if perm.Identity == identity {
+	for _, perm := range userState {
+		if perm.PubKey.Equals(pubKey) {
 			return perm, nil
 		}
 	}
-	return UserPermissionPair{}, ErrNoSuchUser
+	return AclUserState{}, ErrNoSuchUser
 }
 
 func (st *AclState) applyRecord(record *AclRecord) (err error) {
@@ -128,24 +111,18 @@ func (st *AclState) applyRecord(record *AclRecord) (err error) {
 		return
 	}
 	if record.Id == st.id {
-		root, ok := record.Model.(*aclrecordproto.AclRoot)
-		if !ok {
-			return ErrIncorrectRoot
-		}
-		err = st.applyRoot(root)
+		err = st.applyRoot(record)
 		if err != nil {
 			return
 		}
-		st.permissionsAtRecord[record.Id] = []UserPermissionPair{
-			{Identity: string(root.Identity), Permission: aclrecordproto.AclUserPermissions_Admin},
+		st.statesAtRecord[record.Id] = []AclUserState{
+			{PubKey: record.Identity, Permissions: aclrecordproto.AclUserPermissions_Admin},
 		}
 		return
 	}
-	aclData := &aclrecordproto.AclData{}
 
-	if record.Model != nil {
-		aclData = record.Model.(*aclrecordproto.AclData)
-	} else {
+	if record.Model == nil {
+		aclData := &aclrecordproto.AclData{}
 		err = proto.Unmarshal(record.Data, aclData)
 		if err != nil {
 			return
@@ -153,109 +130,90 @@ func (st *AclState) applyRecord(record *AclRecord) (err error) {
 		record.Model = aclData
 	}
 
-	err = st.applyChangeData(aclData, record.CurrentReadKeyHash, record.Identity)
+	err = st.applyChangeData(record)
 	if err != nil {
 		return
 	}
 
-	// getting all permissions for users at record
-	var permissions []UserPermissionPair
+	// getting all states for users at record
+	var states []AclUserState
 	for _, state := range st.userStates {
-		permission := UserPermissionPair{
-			Identity:   string(state.Identity),
-			Permission: state.Permissions,
-		}
-		permissions = append(permissions, permission)
+		states = append(states, state)
 	}
 
-	st.permissionsAtRecord[record.Id] = permissions
+	st.statesAtRecord[record.Id] = states
 	return
 }
 
-func (st *AclState) applyRoot(root *aclrecordproto.AclRoot) (err error) {
-	if st.signingKey != nil && st.encryptionKey != nil && st.identity == string(root.Identity) {
-		err = st.saveReadKeyFromRoot(root)
+func (st *AclState) applyRoot(record *AclRecord) (err error) {
+	if st.key != nil && st.pubKey.Equals(record.Identity) {
+		err = st.saveReadKeyFromRoot(record)
 		if err != nil {
 			return
 		}
 	}
 
 	// adding user to the list
-	userState := &aclrecordproto.AclUserState{
-		Identity:      root.Identity,
-		EncryptionKey: root.EncryptionKey,
-		Permissions:   aclrecordproto.AclUserPermissions_Admin,
+	userState := AclUserState{
+		PubKey:      record.Identity,
+		Permissions: aclrecordproto.AclUserPermissions_Admin,
 	}
-	st.currentReadKeyHash = root.CurrentReadKeyHash
-	st.userStates[string(root.Identity)] = userState
+	st.currentReadKeyId = record.ReadKeyId
+	st.userStates[mapKeyFromPubKey(record.Identity)] = userState
 	st.totalReadKeys++
 	return
 }
 
-func (st *AclState) saveReadKeyFromRoot(root *aclrecordproto.AclRoot) (err error) {
-	var readKey *symmetric.Key
-	if len(root.GetDerivationScheme()) != 0 {
-		var encPrivKey []byte
-		encPrivKey, err = st.encryptionKey.Raw()
-		if err != nil {
-			return
-		}
-		var signPrivKey []byte
-		signPrivKey, err = st.signingKey.Raw()
-		if err != nil {
-			return
-		}
-
-		readKey, err = aclrecordproto.AclReadKeyDerive(signPrivKey, encPrivKey)
+func (st *AclState) saveReadKeyFromRoot(record *AclRecord) (err error) {
+	var readKey crypto.SymKey
+	root, ok := record.Model.(*aclrecordproto.AclRoot)
+	if !ok {
+		return ErrIncorrectRoot
+	}
+	if root.EncryptedReadKey == nil {
+		readKey, err = st.deriveKey()
 		if err != nil {
 			return
 		}
 	} else {
-		readKey, _, err = st.decryptReadKeyAndHash(root.EncryptedReadKey)
+		readKey, err = st.decryptReadKey(root.EncryptedReadKey)
 		if err != nil {
 			return
 		}
 	}
 
-	hasher := fnv.New64()
-	_, err = hasher.Write(readKey.Bytes())
-	if err != nil {
-		return
-	}
-	if hasher.Sum64() != root.CurrentReadKeyHash {
-		return ErrIncorrectRoot
-	}
-	st.userReadKeys[root.CurrentReadKeyHash] = readKey
-
+	st.userReadKeys[record.Id] = readKey
 	return
 }
 
-func (st *AclState) applyChangeData(changeData *aclrecordproto.AclData, hash uint64, identity []byte) (err error) {
+func (st *AclState) applyChangeData(record *AclRecord) (err error) {
 	defer func() {
 		if err != nil {
 			return
 		}
-		if hash != st.currentReadKeyHash {
+		if record.ReadKeyId != st.currentReadKeyId {
 			st.totalReadKeys++
-			st.currentReadKeyHash = hash
+			st.currentReadKeyId = record.ReadKeyId
 		}
 	}()
-
-	if !st.isUserJoin(changeData) {
+	model := record.Model.(*aclrecordproto.AclData)
+	if !st.isUserJoin(model) {
 		// we check signature when we add this to the List, so no need to do it here
-		if _, exists := st.userStates[string(identity)]; !exists {
+		if _, exists := st.userStates[mapKeyFromPubKey(record.Identity)]; !exists {
 			err = ErrNoSuchUser
 			return
 		}
 
-		if !st.HasPermission(identity, aclrecordproto.AclUserPermissions_Admin) {
-			err = fmt.Errorf("user %s must have admin permissions", identity)
+		// only Admins can do non-user join changes
+		if !st.HasPermission(record.Identity, aclrecordproto.AclUserPermissions_Admin) {
+			// TODO: add string encoding
+			err = fmt.Errorf("user %s must have admin permissions", record.Identity.Account())
 			return
 		}
 	}
 
-	for _, ch := range changeData.GetAclContent() {
-		if err = st.applyChangeContent(ch); err != nil {
+	for _, ch := range model.GetAclContent() {
+		if err = st.applyChangeContent(ch, record.Id); err != nil {
 			log.Info("error while applying changes: %v; ignore", zap.Error(err))
 			return err
 		}
@@ -264,26 +222,29 @@ func (st *AclState) applyChangeData(changeData *aclrecordproto.AclData, hash uin
 	return nil
 }
 
-func (st *AclState) applyChangeContent(ch *aclrecordproto.AclContentValue) error {
+func (st *AclState) applyChangeContent(ch *aclrecordproto.AclContentValue, recordId string) error {
 	switch {
 	case ch.GetUserPermissionChange() != nil:
-		return st.applyUserPermissionChange(ch.GetUserPermissionChange())
+		return st.applyUserPermissionChange(ch.GetUserPermissionChange(), recordId)
 	case ch.GetUserAdd() != nil:
-		return st.applyUserAdd(ch.GetUserAdd())
+		return st.applyUserAdd(ch.GetUserAdd(), recordId)
 	case ch.GetUserRemove() != nil:
-		return st.applyUserRemove(ch.GetUserRemove())
+		return st.applyUserRemove(ch.GetUserRemove(), recordId)
 	case ch.GetUserInvite() != nil:
-		return st.applyUserInvite(ch.GetUserInvite())
+		return st.applyUserInvite(ch.GetUserInvite(), recordId)
 	case ch.GetUserJoin() != nil:
-		return st.applyUserJoin(ch.GetUserJoin())
+		return st.applyUserJoin(ch.GetUserJoin(), recordId)
 	default:
 		return fmt.Errorf("unexpected change type: %v", ch)
 	}
 }
 
-func (st *AclState) applyUserPermissionChange(ch *aclrecordproto.AclUserPermissionChange) error {
-	chIdentity := string(ch.Identity)
-	state, exists := st.userStates[chIdentity]
+func (st *AclState) applyUserPermissionChange(ch *aclrecordproto.AclUserPermissionChange, recordId string) error {
+	chIdentity, err := st.keyStore.PubKeyFromProto(ch.Identity)
+	if err != nil {
+		return err
+	}
+	state, exists := st.userStates[mapKeyFromPubKey(chIdentity)]
 	if !exists {
 		return ErrNoSuchUser
 	}
@@ -292,131 +253,38 @@ func (st *AclState) applyUserPermissionChange(ch *aclrecordproto.AclUserPermissi
 	return nil
 }
 
-func (st *AclState) applyUserInvite(ch *aclrecordproto.AclUserInvite) error {
-	st.userInvites[string(ch.AcceptPublicKey)] = ch
+func (st *AclState) applyUserInvite(ch *aclrecordproto.AclUserInvite, recordId string) error {
+	// TODO: check old code and bring it back :-)
 	return nil
 }
 
-func (st *AclState) applyUserJoin(ch *aclrecordproto.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))
-	}
-	chIdentity := string(ch.Identity)
-
-	if _, exists = st.userStates[chIdentity]; exists {
-		return ErrUserAlreadyExists
-	}
-
-	// validating signature
-	signature := ch.GetAcceptSignature()
-	verificationKey, err := signingkey.NewSigningEd25519PubKeyFromBytes(invite.AcceptPublicKey)
-	if err != nil {
-		return fmt.Errorf("public key verifying invite accepts is given in incorrect format: %v", err)
-	}
-
-	res, err := verificationKey.Verify(ch.Identity, signature)
-	if err != nil {
-		return fmt.Errorf("verification returned error: %w", err)
-	}
-	if !res {
-		return ErrInvalidSignature
-	}
-
-	// if ourselves -> we need to decrypt the read keys
-	if st.identity == chIdentity {
-		for _, key := range ch.EncryptedReadKeys {
-			key, hash, err := st.decryptReadKeyAndHash(key)
-			if err != nil {
-				return ErrFailedToDecrypt
-			}
-
-			st.userReadKeys[hash] = key
-		}
-	}
-
-	// adding user to the list
-	userState := &aclrecordproto.AclUserState{
-		Identity:      ch.Identity,
-		EncryptionKey: ch.EncryptionKey,
-		Permissions:   invite.Permissions,
-	}
-	st.userStates[chIdentity] = userState
+func (st *AclState) applyUserJoin(ch *aclrecordproto.AclUserJoin, recordId string) error {
 	return nil
 }
 
-func (st *AclState) applyUserAdd(ch *aclrecordproto.AclUserAdd) error {
-	chIdentity := string(ch.Identity)
-	if _, exists := st.userStates[chIdentity]; exists {
-		return ErrUserAlreadyExists
-	}
-
-	st.userStates[chIdentity] = &aclrecordproto.AclUserState{
-		Identity:      ch.Identity,
-		EncryptionKey: ch.EncryptionKey,
-		Permissions:   ch.Permissions,
-	}
-
-	if chIdentity == st.identity {
-		for _, key := range ch.EncryptedReadKeys {
-			key, hash, err := st.decryptReadKeyAndHash(key)
-			if err != nil {
-				return ErrFailedToDecrypt
-			}
-
-			st.userReadKeys[hash] = key
-		}
-	}
-
+func (st *AclState) applyUserAdd(ch *aclrecordproto.AclUserAdd, recordId string) error {
 	return nil
 }
 
-func (st *AclState) applyUserRemove(ch *aclrecordproto.AclUserRemove) error {
-	chIdentity := string(ch.Identity)
-	if chIdentity == st.identity {
-		return ErrDocumentForbidden
-	}
-
-	if _, exists := st.userStates[chIdentity]; !exists {
-		return ErrNoSuchUser
-	}
-
-	delete(st.userStates, chIdentity)
-
-	for _, replace := range ch.ReadKeyReplaces {
-		repIdentity := string(replace.Identity)
-		// if this is our identity then we have to decrypt the key
-		if repIdentity == st.identity {
-			key, hash, err := st.decryptReadKeyAndHash(replace.EncryptedReadKey)
-			if err != nil {
-				return ErrFailedToDecrypt
-			}
-
-			st.userReadKeys[hash] = key
-			break
-		}
-	}
+func (st *AclState) applyUserRemove(ch *aclrecordproto.AclUserRemove, recordId string) error {
 	return nil
 }
 
-func (st *AclState) decryptReadKeyAndHash(msg []byte) (*symmetric.Key, uint64, error) {
-	decrypted, err := st.encryptionKey.Decrypt(msg)
+func (st *AclState) decryptReadKey(msg []byte) (crypto.SymKey, error) {
+	decrypted, err := st.key.Decrypt(msg)
 	if err != nil {
-		return nil, 0, ErrFailedToDecrypt
+		return nil, ErrFailedToDecrypt
 	}
 
-	key, err := symmetric.FromBytes(decrypted)
+	key, err := crypto.UnmarshallAESKey(decrypted)
 	if err != nil {
-		return nil, 0, ErrFailedToDecrypt
+		return nil, ErrFailedToDecrypt
 	}
-
-	hasher := fnv.New64()
-	hasher.Write(decrypted)
-	return key, hasher.Sum64(), nil
+	return key, nil
 }
 
-func (st *AclState) HasPermission(identity []byte, permission aclrecordproto.AclUserPermissions) bool {
-	state, exists := st.userStates[string(identity)]
+func (st *AclState) HasPermission(identity crypto.PubKey, permission aclrecordproto.AclUserPermissions) bool {
+	state, exists := st.userStates[mapKeyFromPubKey(identity)]
 	if !exists {
 		return false
 	}
@@ -430,35 +298,29 @@ func (st *AclState) isUserJoin(data *aclrecordproto.AclData) bool {
 }
 
 func (st *AclState) isUserAdd(data *aclrecordproto.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
+	return false
 }
 
-func (st *AclState) UserStates() map[string]*aclrecordproto.AclUserState {
+func (st *AclState) UserStates() map[string]AclUserState {
 	return st.userStates
 }
 
 func (st *AclState) Invite(acceptPubKey []byte) (invite *aclrecordproto.AclUserInvite, err error) {
-	invite, exists := st.userInvites[string(acceptPubKey)]
-	if !exists {
-		err = ErrNoSuchInvite
-		return
-	}
-	if len(invite.EncryptedReadKeys) != st.totalReadKeys {
-		err = ErrOldInvite
-	}
 	return
 }
 
-func (st *AclState) UserKeys() (encKey encryptionkey.PrivKey, signKey signingkey.PrivKey) {
-	return st.encryptionKey, st.signingKey
-}
-
-func (st *AclState) Identity() []byte {
-	return []byte(st.identity)
-}
-
 func (st *AclState) LastRecordId() string {
 	return st.lastRecordId
 }
+
+func (st *AclState) deriveKey() (crypto.SymKey, error) {
+	keyBytes, err := st.key.Raw()
+	if err != nil {
+		return nil, err
+	}
+	return crypto.DeriveSymmetricKey(keyBytes, crypto.AnysyncSpacePath)
+}
+
+func mapKeyFromPubKey(pubKey crypto.PubKey) string {
+	return string(pubKey.Storage())
+}

commonspace/object/acl/list/aclstatebuilder.go

@@ -1,21 +1,18 @@
 package list
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/encryptionkey"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anyproto/any-sync/util/crypto"
 )
 
 type aclStateBuilder struct {
-	signPrivKey signingkey.PrivKey
-	encPrivKey  encryptionkey.PrivKey
-	id          string
+	privKey crypto.PrivKey
+	id      string
 }
 
-func newAclStateBuilderWithIdentity(accountData *accountdata.AccountData) *aclStateBuilder {
+func newAclStateBuilderWithIdentity(keys *accountdata.AccountKeys) *aclStateBuilder {
 	return &aclStateBuilder{
-		signPrivKey: accountData.SignKey,
-		encPrivKey:  accountData.EncKey,
+		privKey: keys.SignKey,
 	}
 }
 
@@ -28,8 +25,8 @@ func (sb *aclStateBuilder) Init(id string) {
 }
 
 func (sb *aclStateBuilder) Build(records []*AclRecord) (state *AclState, err error) {
-	if sb.encPrivKey != nil && sb.signPrivKey != nil {
-		state, err = newAclStateWithKeys(sb.id, sb.signPrivKey, sb.encPrivKey)
+	if sb.privKey != nil {
+		state, err = newAclStateWithKeys(sb.id, sb.privKey)
 		if err != nil {
 			return
 		}

commonspace/object/acl/list/list.go

@@ -1,14 +1,14 @@
-//go:generate mockgen -destination mock_list/mock_list.go github.com/anytypeio/any-sync/commonspace/object/acl/list AclList
+//go:generate mockgen -destination mock_list/mock_list.go github.com/anyproto/any-sync/commonspace/object/acl/list AclList
 package list
 
 import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/liststorage"
-	"github.com/anytypeio/any-sync/commonspace/object/keychain"
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/liststorage"
+	"github.com/anyproto/any-sync/util/crypto"
 	"sync"
 )
 
@@ -33,6 +33,7 @@ type AclList interface {
 	Get(id string) (*AclRecord, error)
 	Iterate(iterFunc IterFunc)
 	IterateFrom(startId string, iterFunc IterFunc)
+	KeyStorage() crypto.KeyStorage
 
 	AddRawRecord(rawRec *aclrecordproto.RawAclRecordWithId) (added bool, err error)
 
@@ -47,23 +48,25 @@ type aclList struct {
 
 	stateBuilder  *aclStateBuilder
 	recordBuilder AclRecordBuilder
+	keyStorage    crypto.KeyStorage
 	aclState      *AclState
-	keychain      *keychain.Keychain
 	storage       liststorage.ListStorage
 
 	sync.RWMutex
 }
 
-func BuildAclListWithIdentity(acc *accountdata.AccountData, storage liststorage.ListStorage) (AclList, error) {
+func BuildAclListWithIdentity(acc *accountdata.AccountKeys, storage liststorage.ListStorage) (AclList, error) {
 	builder := newAclStateBuilderWithIdentity(acc)
-	return build(storage.Id(), builder, newAclRecordBuilder(storage.Id(), keychain.NewKeychain()), storage)
+	keyStorage := crypto.NewKeyStorage()
+	return build(storage.Id(), keyStorage, builder, NewAclRecordBuilder(storage.Id(), keyStorage), storage)
 }
 
 func BuildAclList(storage liststorage.ListStorage) (AclList, error) {
-	return build(storage.Id(), newAclStateBuilder(), newAclRecordBuilder(storage.Id(), keychain.NewKeychain()), storage)
+	keyStorage := crypto.NewKeyStorage()
+	return build(storage.Id(), keyStorage, newAclStateBuilder(), NewAclRecordBuilder(storage.Id(), crypto.NewKeyStorage()), storage)
 }
 
-func build(id string, stateBuilder *aclStateBuilder, recBuilder AclRecordBuilder, storage liststorage.ListStorage) (list AclList, err error) {
+func build(id string, keyStorage crypto.KeyStorage, stateBuilder *aclStateBuilder, recBuilder AclRecordBuilder, storage liststorage.ListStorage) (list AclList, err error) {
 	head, err := storage.Head()
 	if err != nil {
 		return
@@ -74,7 +77,7 @@ func build(id string, stateBuilder *aclStateBuilder, recBuilder AclRecordBuilder
 		return
 	}
 
-	record, err := recBuilder.ConvertFromRaw(rawRecordWithId)
+	record, err := recBuilder.Unmarshall(rawRecordWithId)
 	if err != nil {
 		return
 	}
@@ -86,7 +89,7 @@ func build(id string, stateBuilder *aclStateBuilder, recBuilder AclRecordBuilder
 			return
 		}
 
-		record, err = recBuilder.ConvertFromRaw(rawRecordWithId)
+		record, err = recBuilder.Unmarshall(rawRecordWithId)
 		if err != nil {
 			return
 		}
@@ -137,7 +140,7 @@ func (a *aclList) AddRawRecord(rawRec *aclrecordproto.RawAclRecordWithId) (added
 	if _, ok := a.indexes[rawRec.Id]; ok {
 		return
 	}
-	record, err := a.recordBuilder.ConvertFromRaw(rawRec)
+	record, err := a.recordBuilder.Unmarshall(rawRec)
 	if err != nil {
 		return
 	}
@@ -156,7 +159,7 @@ func (a *aclList) AddRawRecord(rawRec *aclrecordproto.RawAclRecordWithId) (added
 }
 
 func (a *aclList) IsValidNext(rawRec *aclrecordproto.RawAclRecordWithId) (err error) {
-	_, err = a.recordBuilder.ConvertFromRaw(rawRec)
+	_, err = a.recordBuilder.Unmarshall(rawRec)
 	if err != nil {
 		return
 	}
@@ -176,6 +179,10 @@ func (a *aclList) AclState() *AclState {
 	return a.aclState
 }
 
+func (a *aclList) KeyStorage() crypto.KeyStorage {
+	return a.keyStorage
+}
+
 func (a *aclList) IsAfter(first string, second string) (bool, error) {
 	firstRec, okFirst := a.indexes[first]
 	secondRec, okSecond := a.indexes[second]

commonspace/object/acl/list/list_test.go

@@ -1,91 +1,16 @@
 package list
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/testutils/acllistbuilder"
-	"github.com/stretchr/testify/assert"
+	"fmt"
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
 	"github.com/stretchr/testify/require"
 	"testing"
 )
 
-func TestAclList_AclState_UserInviteAndJoin(t *testing.T) {
-	st, err := acllistbuilder.NewListStorageWithTestName("userjoinexample.yml")
-	require.NoError(t, err, "building storage should not result in error")
-
-	keychain := st.(*acllistbuilder.AclListStorageBuilder).GetKeychain()
-
-	aclList, err := BuildAclList(st)
-	require.NoError(t, err, "building acl list should be without error")
-
-	idA := keychain.GetIdentity("A")
-	idB := keychain.GetIdentity("B")
-	idC := keychain.GetIdentity("C")
-
-	// checking final state
-	assert.Equal(t, aclrecordproto.AclUserPermissions_Admin, aclList.AclState().UserStates()[idA].Permissions)
-	assert.Equal(t, aclrecordproto.AclUserPermissions_Writer, aclList.AclState().UserStates()[idB].Permissions)
-	assert.Equal(t, aclrecordproto.AclUserPermissions_Reader, aclList.AclState().UserStates()[idC].Permissions)
-	assert.Equal(t, aclList.Head().CurrentReadKeyHash, aclList.AclState().CurrentReadKeyHash())
-
-	var records []*AclRecord
-	aclList.Iterate(func(record *AclRecord) (IsContinue bool) {
-		records = append(records, record)
-		return true
-	})
-
-	// checking permissions at specific records
-	assert.Equal(t, 3, len(records))
-
-	_, err = aclList.AclState().PermissionsAtRecord(records[1].Id, idB)
-	assert.Error(t, err, "B should have no permissions at record 1")
-
-	perm, err := aclList.AclState().PermissionsAtRecord(records[2].Id, idB)
-	assert.NoError(t, err, "should have no error with permissions of B in the record 2")
-	assert.Equal(t, UserPermissionPair{
-		Identity:   idB,
-		Permission: aclrecordproto.AclUserPermissions_Writer,
-	}, perm)
-}
-
-func TestAclList_AclState_UserJoinAndRemove(t *testing.T) {
-	st, err := acllistbuilder.NewListStorageWithTestName("userremoveexample.yml")
-	require.NoError(t, err, "building storage should not result in error")
-
-	keychain := st.(*acllistbuilder.AclListStorageBuilder).GetKeychain()
-
-	aclList, err := BuildAclList(st)
-	require.NoError(t, err, "building acl list should be without error")
-
-	idA := keychain.GetIdentity("A")
-	idB := keychain.GetIdentity("B")
-	idC := keychain.GetIdentity("C")
-
-	// checking final state
-	assert.Equal(t, aclrecordproto.AclUserPermissions_Admin, aclList.AclState().UserStates()[idA].Permissions)
-	assert.Equal(t, aclrecordproto.AclUserPermissions_Reader, aclList.AclState().UserStates()[idC].Permissions)
-	assert.Equal(t, aclList.Head().CurrentReadKeyHash, aclList.AclState().CurrentReadKeyHash())
-
-	_, exists := aclList.AclState().UserStates()[idB]
-	assert.Equal(t, false, exists)
-
-	var records []*AclRecord
-	aclList.Iterate(func(record *AclRecord) (IsContinue bool) {
-		records = append(records, record)
-		return true
-	})
-
-	// checking permissions at specific records
-	assert.Equal(t, 4, len(records))
-
-	assert.NotEqual(t, records[2].CurrentReadKeyHash, aclList.AclState().CurrentReadKeyHash())
-
-	perm, err := aclList.AclState().PermissionsAtRecord(records[2].Id, idB)
-	assert.NoError(t, err, "should have no error with permissions of B in the record 2")
-	assert.Equal(t, UserPermissionPair{
-		Identity:   idB,
-		Permission: aclrecordproto.AclUserPermissions_Writer,
-	}, perm)
-
-	_, err = aclList.AclState().PermissionsAtRecord(records[3].Id, idB)
-	assert.Error(t, err, "B should have no permissions at record 3, because user should be removed")
+func TestAclList_BuildRoot(t *testing.T) {
+	randomKeys, err := accountdata.NewRandom()
+	require.NoError(t, err)
+	randomAcl, err := NewTestDerivedAcl("spaceId", randomKeys)
+	require.NoError(t, err)
+	fmt.Println(randomAcl.Id())
 }

commonspace/object/acl/list/listutils.go

@@ -0,0 +1,31 @@
+package list
+
+import (
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/liststorage"
+	"github.com/anyproto/any-sync/util/crypto"
+)
+
+func NewTestDerivedAcl(spaceId string, keys *accountdata.AccountKeys) (AclList, error) {
+	builder := NewAclRecordBuilder("", crypto.NewKeyStorage())
+	masterKey, _, err := crypto.GenerateRandomEd25519KeyPair()
+	if err != nil {
+		return nil, err
+	}
+	root, err := builder.BuildRoot(RootContent{
+		PrivKey:   keys.SignKey,
+		SpaceId:   spaceId,
+		MasterKey: masterKey,
+	})
+	if err != nil {
+		return nil, err
+	}
+	st, err := liststorage.NewInMemoryAclListStorage(root.Id, []*aclrecordproto.RawAclRecordWithId{
+		root,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return BuildAclListWithIdentity(keys, st)
+}

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

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/any-sync/commonspace/object/acl/list (interfaces: AclList)
+// Source: github.com/anyproto/any-sync/commonspace/object/acl/list (interfaces: AclList)
 
 // Package mock_list is a generated GoMock package.
 package mock_list
@@ -7,8 +7,9 @@ package mock_list
 import (
 	reflect "reflect"
 
-	aclrecordproto "github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	list "github.com/anytypeio/any-sync/commonspace/object/acl/list"
+	aclrecordproto "github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	list "github.com/anyproto/any-sync/commonspace/object/acl/list"
+	crypto "github.com/anyproto/any-sync/util/crypto"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -160,6 +161,20 @@ func (mr *MockAclListMockRecorder) IterateFrom(arg0, arg1 interface{}) *gomock.C
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockAclList)(nil).IterateFrom), arg0, arg1)
 }
 
+// KeyStorage mocks base method.
+func (m *MockAclList) KeyStorage() crypto.KeyStorage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "KeyStorage")
+	ret0, _ := ret[0].(crypto.KeyStorage)
+	return ret0
+}
+
+// KeyStorage indicates an expected call of KeyStorage.
+func (mr *MockAclListMockRecorder) KeyStorage() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyStorage", reflect.TypeOf((*MockAclList)(nil).KeyStorage))
+}
+
 // Lock mocks base method.
 func (m *MockAclList) Lock() {
 	m.ctrl.T.Helper()

commonspace/object/acl/list/models.go

@@ -0,0 +1,22 @@
+package list
+
+import (
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/util/crypto"
+)
+
+type AclRecord struct {
+	Id        string
+	PrevId    string
+	ReadKeyId string
+	Timestamp int64
+	Data      []byte
+	Identity  crypto.PubKey
+	Model     interface{}
+	Signature []byte
+}
+
+type AclUserState struct {
+	PubKey      crypto.PubKey
+	Permissions aclrecordproto.AclUserPermissions
+}

commonspace/object/acl/list/record.go

@@ -1,12 +0,0 @@
-package list
-
-type AclRecord struct {
-	Id                 string
-	PrevId             string
-	CurrentReadKeyHash uint64
-	Timestamp          int64
-	Data               []byte
-	Identity           []byte
-	Model              interface{}
-	Signature          []byte
-}

commonspace/object/acl/liststorage/inmemory.go

@@ -3,7 +3,7 @@ package liststorage
 import (
 	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
 	"sync"
 )
 

commonspace/object/acl/liststorage/liststorage.go

@@ -1,10 +1,10 @@
-//go:generate mockgen -destination mock_liststorage/mock_liststorage.go github.com/anytypeio/any-sync/commonspace/object/acl/liststorage ListStorage
+//go:generate mockgen -destination mock_liststorage/mock_liststorage.go github.com/anyproto/any-sync/commonspace/object/acl/liststorage ListStorage
 package liststorage
 
 import (
 	"context"
 	"errors"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
 )
 
 var (

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

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/any-sync/commonspace/object/acl/liststorage (interfaces: ListStorage)
+// Source: github.com/anyproto/any-sync/commonspace/object/acl/liststorage (interfaces: ListStorage)
 
 // Package mock_liststorage is a generated GoMock package.
 package mock_liststorage
@@ -8,7 +8,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	aclrecordproto "github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
+	aclrecordproto "github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
 	gomock "github.com/golang/mock/gomock"
 )
 

commonspace/object/acl/syncacl/syncacl.go

@@ -1,9 +1,9 @@
 package syncacl
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	"github.com/anytypeio/any-sync/commonspace/objectsync"
-	"github.com/anytypeio/any-sync/commonspace/objectsync/synchandler"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/objectsync"
+	"github.com/anyproto/any-sync/commonspace/objectsync/synchandler"
 )
 
 type SyncAcl struct {

commonspace/object/acl/syncacl/syncaclhandler.go

@@ -3,9 +3,9 @@ package syncacl
 import (
 	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
 )
 
 type syncAclHandler struct {

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

@@ -1,194 +0,0 @@
-package acllistbuilder
-
-import (
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/util/keys"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/encryptionkey"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
-	"github.com/anytypeio/any-sync/util/keys/symmetric"
-	"hash/fnv"
-	"strings"
-)
-
-type SymKey struct {
-	Hash uint64
-	Key  *symmetric.Key
-}
-
-type YAMLKeychain struct {
-	SigningKeysByYAMLName     map[string]signingkey.PrivKey
-	SigningKeysByRealIdentity map[string]signingkey.PrivKey
-	EncryptionKeysByYAMLName  map[string]encryptionkey.PrivKey
-	ReadKeysByYAMLName        map[string]*SymKey
-	ReadKeysByHash            map[uint64]*SymKey
-	GeneratedIdentities       map[string]string
-}
-
-func NewKeychain() *YAMLKeychain {
-	return &YAMLKeychain{
-		SigningKeysByYAMLName:     map[string]signingkey.PrivKey{},
-		SigningKeysByRealIdentity: map[string]signingkey.PrivKey{},
-		EncryptionKeysByYAMLName:  map[string]encryptionkey.PrivKey{},
-		GeneratedIdentities:       map[string]string{},
-		ReadKeysByYAMLName:        map[string]*SymKey{},
-		ReadKeysByHash:            map[uint64]*SymKey{},
-	}
-}
-
-func (k *YAMLKeychain) ParseKeys(keys *Keys) {
-	for _, encKey := range keys.Enc {
-		k.AddEncryptionKey(encKey)
-	}
-
-	for _, signKey := range keys.Sign {
-		k.AddSigningKey(signKey)
-	}
-
-	for _, readKey := range keys.Read {
-		k.AddReadKey(readKey)
-	}
-}
-
-func (k *YAMLKeychain) AddEncryptionKey(key *Key) {
-	if _, exists := k.EncryptionKeysByYAMLName[key.Name]; exists {
-		return
-	}
-	var (
-		newPrivKey encryptionkey.PrivKey
-		err        error
-	)
-	if key.Value == "generated" {
-		newPrivKey, _, err = encryptionkey.GenerateRandomRSAKeyPair(2048)
-		if err != nil {
-			panic(err)
-		}
-	} else {
-		newPrivKey, err = keys.DecodeKeyFromString(key.Value, encryptionkey.NewEncryptionRsaPrivKeyFromBytes, nil)
-		if err != nil {
-			panic(err)
-		}
-	}
-	k.EncryptionKeysByYAMLName[key.Name] = newPrivKey
-}
-
-func (k *YAMLKeychain) AddSigningKey(key *Key) {
-	if _, exists := k.SigningKeysByYAMLName[key.Name]; exists {
-		return
-	}
-	var (
-		newPrivKey signingkey.PrivKey
-		pubKey     signingkey.PubKey
-		err        error
-	)
-	if key.Value == "generated" {
-		newPrivKey, pubKey, err = signingkey.GenerateRandomEd25519KeyPair()
-		if err != nil {
-			panic(err)
-		}
-	} else {
-		newPrivKey, err = keys.DecodeKeyFromString(key.Value, signingkey.NewSigningEd25519PrivKeyFromBytes, nil)
-		if err != nil {
-			panic(err)
-		}
-		pubKey = newPrivKey.GetPublic()
-	}
-
-	k.SigningKeysByYAMLName[key.Name] = newPrivKey
-	rawPubKey, err := pubKey.Raw()
-	if err != nil {
-		panic(err)
-	}
-	encoded := string(rawPubKey)
-
-	k.SigningKeysByRealIdentity[encoded] = newPrivKey
-	k.GeneratedIdentities[key.Name] = encoded
-}
-
-func (k *YAMLKeychain) AddReadKey(key *Key) {
-	if _, exists := k.ReadKeysByYAMLName[key.Name]; exists {
-		return
-	}
-
-	var (
-		rkey *symmetric.Key
-		err  error
-	)
-	if key.Value == "generated" {
-		rkey, err = symmetric.NewRandom()
-		if err != nil {
-			panic("should be able to generate symmetric key")
-		}
-	} else if key.Value == "derived" {
-		signKey, _ := k.SigningKeysByYAMLName[key.Name].Raw()
-		encKey, _ := k.EncryptionKeysByYAMLName[key.Name].Raw()
-		rkey, err = aclrecordproto.AclReadKeyDerive(signKey, encKey)
-		if err != nil {
-			panic("should be able to derive symmetric key")
-		}
-	} else {
-		rkey, err = symmetric.FromString(key.Value)
-		if err != nil {
-			panic("should be able to parse symmetric key")
-		}
-	}
-
-	hasher := fnv.New64()
-	hasher.Write(rkey.Bytes())
-
-	k.ReadKeysByYAMLName[key.Name] = &SymKey{
-		Hash: hasher.Sum64(),
-		Key:  rkey,
-	}
-	k.ReadKeysByHash[hasher.Sum64()] = &SymKey{
-		Hash: hasher.Sum64(),
-		Key:  rkey,
-	}
-}
-
-func (k *YAMLKeychain) AddKey(key *Key) {
-	parts := strings.Split(key.Name, ".")
-	if len(parts) != 3 {
-		panic("cannot parse a key")
-	}
-
-	switch parts[1] {
-	case "Signature":
-		k.AddSigningKey(key)
-	case "Enc":
-		k.AddEncryptionKey(key)
-	case "Read":
-		k.AddReadKey(key)
-	default:
-		panic("incorrect format")
-	}
-}
-
-func (k *YAMLKeychain) GetKey(key string) interface{} {
-	parts := strings.Split(key, ".")
-	if len(parts) != 3 {
-		panic("cannot parse a key")
-	}
-	name := parts[2]
-
-	switch parts[1] {
-	case "Sign":
-		if key, exists := k.SigningKeysByYAMLName[name]; exists {
-			return key
-		}
-	case "Enc":
-		if key, exists := k.EncryptionKeysByYAMLName[name]; exists {
-			return key
-		}
-	case "Read":
-		if key, exists := k.ReadKeysByYAMLName[name]; exists {
-			return key
-		}
-	default:
-		panic("incorrect format")
-	}
-	return nil
-}
-
-func (k *YAMLKeychain) GetIdentity(name string) string {
-	return k.GeneratedIdentities[name]
-}

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

@@ -1,295 +0,0 @@
-package acllistbuilder
-
-import (
-	"context"
-	"fmt"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/liststorage"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/testutils/yamltests"
-	"github.com/anytypeio/any-sync/util/cidutil"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/encryptionkey"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
-	"github.com/anytypeio/any-sync/util/keys/symmetric"
-	"gopkg.in/yaml.v3"
-	"io/ioutil"
-	"path"
-	"time"
-
-	"github.com/gogo/protobuf/proto"
-)
-
-type AclListStorageBuilder struct {
-	liststorage.ListStorage
-	keychain *YAMLKeychain
-}
-
-func NewAclListStorageBuilder(keychain *YAMLKeychain) *AclListStorageBuilder {
-	return &AclListStorageBuilder{
-		keychain: keychain,
-	}
-}
-
-func NewListStorageWithTestName(name string) (liststorage.ListStorage, error) {
-	filePath := path.Join(yamltests.Path(), name)
-	return NewAclListStorageBuilderFromFile(filePath)
-}
-
-func NewAclListStorageBuilderFromFile(file string) (*AclListStorageBuilder, error) {
-	content, err := ioutil.ReadFile(file)
-	if err != nil {
-		return nil, err
-	}
-
-	ymlTree := YMLList{}
-	err = yaml.Unmarshal(content, &ymlTree)
-	if err != nil {
-		return nil, err
-	}
-
-	tb := NewAclListStorageBuilder(NewKeychain())
-	tb.Parse(&ymlTree)
-
-	return tb, nil
-}
-
-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!")
-	}
-
-	signature, err := t.keychain.SigningKeysByRealIdentity[string(identity)].Sign(protoMarshalled)
-	if err != nil {
-		panic("should be able to sign final acl message!")
-	}
-
-	rawRec := &aclrecordproto.RawAclRecord{
-		Payload:   protoMarshalled,
-		Signature: signature,
-	}
-
-	rawMarshalled, err := proto.Marshal(rawRec)
-	if err != nil {
-		panic(err)
-	}
-
-	id, _ := cidutil.NewCidFromBytes(rawMarshalled)
-
-	return &aclrecordproto.RawAclRecordWithId{
-		Payload: rawMarshalled,
-		Id:      id,
-	}
-}
-
-func (t *AclListStorageBuilder) GetKeychain() *YAMLKeychain {
-	return t.keychain
-}
-
-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(&l.Keys)
-	rawRoot := t.parseRoot(l.Root)
-	var err error
-	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)
-		err = t.AddRawRecord(context.Background(), rawRecord)
-		if err != nil {
-			panic(err)
-		}
-		prevId = rawRecord.Id
-	}
-	t.SetHead(prevId)
-}
-
-func (t *AclListStorageBuilder) parseRecord(rec *Record, prevId string) *aclrecordproto.AclRecord {
-	k := t.keychain.GetKey(rec.ReadKey).(*SymKey)
-	var aclChangeContents []*aclrecordproto.AclContentValue
-	for _, ch := range rec.AclChanges {
-		aclChangeContent := t.parseAclChange(ch)
-		aclChangeContents = append(aclChangeContents, aclChangeContent)
-	}
-	data := &aclrecordproto.AclData{
-		AclContent: aclChangeContents,
-	}
-	bytes, _ := data.Marshal()
-
-	return &aclrecordproto.AclRecord{
-		PrevId:             prevId,
-		Identity:           []byte(t.keychain.GetIdentity(rec.Identity)),
-		Data:               bytes,
-		CurrentReadKeyHash: k.Hash,
-		Timestamp:          time.Now().UnixNano(),
-	}
-}
-
-func (t *AclListStorageBuilder) parseAclChange(ch *AclChange) (convCh *aclrecordproto.AclContentValue) {
-	switch {
-	case ch.UserAdd != nil:
-		add := ch.UserAdd
-
-		encKey := t.keychain.GetKey(add.EncryptionKey).(encryptionkey.PrivKey)
-		rawKey, _ := encKey.GetPublic().Raw()
-
-		convCh = &aclrecordproto.AclContentValue{
-			Value: &aclrecordproto.AclContentValue_UserAdd{
-				UserAdd: &aclrecordproto.AclUserAdd{
-					Identity:          []byte(t.keychain.GetIdentity(add.Identity)),
-					EncryptionKey:     rawKey,
-					EncryptedReadKeys: t.encryptReadKeysWithPubKey(add.EncryptedReadKeys, encKey),
-					Permissions:       t.convertPermission(add.Permission),
-				},
-			},
-		}
-	case ch.UserJoin != nil:
-		join := ch.UserJoin
-
-		encKey := t.keychain.GetKey(join.EncryptionKey).(encryptionkey.PrivKey)
-		rawKey, _ := encKey.GetPublic().Raw()
-
-		idKey, _ := t.keychain.SigningKeysByYAMLName[join.Identity].GetPublic().Raw()
-		signKey := t.keychain.GetKey(join.AcceptKey).(signingkey.PrivKey)
-		signature, err := signKey.Sign(idKey)
-		if err != nil {
-			panic(err)
-		}
-		acceptPubKey, _ := signKey.GetPublic().Raw()
-
-		convCh = &aclrecordproto.AclContentValue{
-			Value: &aclrecordproto.AclContentValue_UserJoin{
-				UserJoin: &aclrecordproto.AclUserJoin{
-					Identity:          []byte(t.keychain.GetIdentity(join.Identity)),
-					EncryptionKey:     rawKey,
-					AcceptSignature:   signature,
-					AcceptPubKey:      acceptPubKey,
-					EncryptedReadKeys: t.encryptReadKeysWithPubKey(join.EncryptedReadKeys, encKey),
-				},
-			},
-		}
-	case ch.UserInvite != nil:
-		invite := ch.UserInvite
-		rawAcceptKey, _ := t.keychain.GetKey(invite.AcceptKey).(signingkey.PrivKey).GetPublic().Raw()
-		hash := t.keychain.GetKey(invite.EncryptionKey).(*SymKey).Hash
-		encKey := t.keychain.ReadKeysByHash[hash]
-
-		convCh = &aclrecordproto.AclContentValue{
-			Value: &aclrecordproto.AclContentValue_UserInvite{
-				UserInvite: &aclrecordproto.AclUserInvite{
-					AcceptPublicKey:   rawAcceptKey,
-					EncryptSymKeyHash: hash,
-					EncryptedReadKeys: t.encryptReadKeysWithSymKey(invite.EncryptedReadKeys, encKey.Key),
-					Permissions:       t.convertPermission(invite.Permissions),
-				},
-			},
-		}
-	case ch.UserPermissionChange != nil:
-		permissionChange := ch.UserPermissionChange
-
-		convCh = &aclrecordproto.AclContentValue{
-			Value: &aclrecordproto.AclContentValue_UserPermissionChange{
-				UserPermissionChange: &aclrecordproto.AclUserPermissionChange{
-					Identity:    []byte(t.keychain.GetIdentity(permissionChange.Identity)),
-					Permissions: t.convertPermission(permissionChange.Permission),
-				},
-			},
-		}
-	case ch.UserRemove != nil:
-		remove := ch.UserRemove
-
-		newReadKey := t.keychain.GetKey(remove.NewReadKey).(*SymKey)
-
-		var replaces []*aclrecordproto.AclReadKeyReplace
-		for _, id := range remove.IdentitiesLeft {
-			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, &aclrecordproto.AclReadKeyReplace{
-				Identity:         []byte(t.keychain.GetIdentity(id)),
-				EncryptionKey:    rawEncKey,
-				EncryptedReadKey: encReadKey,
-			})
-		}
-
-		convCh = &aclrecordproto.AclContentValue{
-			Value: &aclrecordproto.AclContentValue_UserRemove{
-				UserRemove: &aclrecordproto.AclUserRemove{
-					Identity:        []byte(t.keychain.GetIdentity(remove.RemovedIdentity)),
-					ReadKeyReplaces: replaces,
-				},
-			},
-		}
-	}
-	if convCh == nil {
-		panic("cannot have empty acl change")
-	}
-
-	return convCh
-}
-
-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)
-		if err != nil {
-			panic(err)
-		}
-
-		enc = append(enc, res)
-	}
-	return
-}
-
-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 aclrecordproto.AclUserPermissions_Admin
-	case "writer":
-		return aclrecordproto.AclUserPermissions_Writer
-	case "reader":
-		return aclrecordproto.AclUserPermissions_Reader
-	default:
-		panic(fmt.Sprintf("incorrect permission: %s", perm))
-	}
-}
-
-func (t *AclListStorageBuilder) traverseFromHead(f func(rec *aclrecordproto.AclRecord, id string) error) (err error) {
-	panic("this was removed, add if needed")
-}
-
-func (t *AclListStorageBuilder) parseRoot(root *Root) (rawRoot *aclrecordproto.RawAclRecordWithId) {
-	rawSignKey, _ := t.keychain.SigningKeysByYAMLName[root.Identity].GetPublic().Raw()
-	rawEncKey, _ := t.keychain.EncryptionKeysByYAMLName[root.Identity].GetPublic().Raw()
-	readKey := t.keychain.ReadKeysByYAMLName[root.Identity]
-	aclRoot := &aclrecordproto.AclRoot{
-		Identity:           rawSignKey,
-		EncryptionKey:      rawEncKey,
-		SpaceId:            root.SpaceId,
-		EncryptedReadKey:   nil,
-		DerivationScheme:   "scheme",
-		CurrentReadKeyHash: readKey.Hash,
-	}
-	return t.createRaw(aclRoot, rawSignKey)
-}

commonspace/object/acl/testutils/acllistbuilder/liststoragebuildergraph.go

@@ -1,11 +0,0 @@
-//go:build ((!linux && !darwin) || android || ios || nographviz) && !amd64
-// +build !linux,!darwin android ios nographviz
-// +build !amd64
-
-package acllistbuilder
-
-import "fmt"
-
-func (t *AclListStorageBuilder) Graph() (string, error) {
-	return "", fmt.Errorf("building graphs is not supported")
-}

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

@@ -1,120 +0,0 @@
-//go:build (linux || darwin) && !android && !ios && !nographviz && (amd64 || arm64)
-// +build linux darwin
-// +build !android
-// +build !ios
-// +build !nographviz
-// +build amd64 arm64
-
-package acllistbuilder
-
-import (
-	"fmt"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/gogo/protobuf/proto"
-	"strings"
-	"unicode"
-
-	"github.com/awalterschulze/gographviz"
-)
-
-// To quickly look at visualized string you can use https://dreampuf.github.io/GraphvizOnline
-
-type EdgeParameters struct {
-	style string
-	color string
-	label string
-}
-
-func (t *AclListStorageBuilder) Graph() (string, error) {
-	// TODO: check updates on https://github.com/goccy/go-graphviz/issues/52 or make a fix yourself to use better library here
-	graph := gographviz.NewGraph()
-	graph.SetName("G")
-	graph.SetDir(true)
-	var nodes = make(map[string]struct{})
-
-	var addNodes = func(r *aclrecordproto.AclRecord, id string) error {
-		style := "solid"
-
-		var chSymbs []string
-		aclData := &aclrecordproto.AclData{}
-		err := proto.Unmarshal(r.GetData(), aclData)
-		if err != nil {
-			return err
-		}
-
-		for _, chc := range aclData.AclContent {
-			tp := fmt.Sprintf("%T", chc.Value)
-			tp = strings.Replace(tp, "AclChangeAclContentValueValueOf", "", 1)
-			res := ""
-			for _, ts := range tp {
-				if unicode.IsUpper(ts) {
-					res += string(ts)
-				}
-			}
-			chSymbs = append(chSymbs, res)
-		}
-
-		shortId := id
-		label := fmt.Sprintf("Id: %s\nChanges: %s\n",
-			shortId,
-			strings.Join(chSymbs, ","),
-		)
-		e := graph.AddNode("G", "\""+id+"\"", map[string]string{
-			"label": "\"" + label + "\"",
-			"style": "\"" + style + "\"",
-		})
-		if e != nil {
-			return e
-		}
-		nodes[id] = struct{}{}
-		return nil
-	}
-
-	var createEdge = func(firstId, secondId string, params EdgeParameters) error {
-		_, exists := nodes[firstId]
-		if !exists {
-			return fmt.Errorf("no such node")
-		}
-		_, exists = nodes[secondId]
-		if !exists {
-			return fmt.Errorf("no previous node")
-		}
-
-		err := graph.AddEdge("\""+firstId+"\"", "\""+secondId+"\"", true, map[string]string{
-			"color": params.color,
-			"style": params.style,
-		})
-		if err != nil {
-			return err
-		}
-
-		return nil
-	}
-
-	var addLinks = func(r *aclrecordproto.AclRecord, id string) error {
-		if r.PrevId == "" {
-			return nil
-		}
-		err := createEdge(id, r.PrevId, EdgeParameters{
-			style: "dashed",
-			color: "red",
-		})
-		if err != nil {
-			return err
-		}
-
-		return nil
-	}
-
-	err := t.traverseFromHead(addNodes)
-	if err != nil {
-		return "", err
-	}
-
-	err = t.traverseFromHead(addLinks)
-	if err != nil {
-		return "", err
-	}
-
-	return graph.String(), nil
-}

commonspace/object/acl/testutils/acllistbuilder/ymlentities.go

@@ -1,70 +0,0 @@
-package acllistbuilder
-
-type Key struct {
-	Name  string `yaml:"name"`
-	Value string `yaml:"value"`
-}
-
-type Keys struct {
-	Derived string `yaml:"Derived"`
-	Enc     []*Key `yaml:"Enc"`
-	Sign    []*Key `yaml:"Sign"`
-	Read    []*Key `yaml:"Read"`
-}
-
-type AclChange struct {
-	UserAdd *struct {
-		Identity          string   `yaml:"identity"`
-		EncryptionKey     string   `yaml:"encryptionKey"`
-		EncryptedReadKeys []string `yaml:"encryptedReadKeys"`
-		Permission        string   `yaml:"permission"`
-	} `yaml:"userAdd"`
-
-	UserJoin *struct {
-		Identity          string   `yaml:"identity"`
-		EncryptionKey     string   `yaml:"encryptionKey"`
-		AcceptKey         string   `yaml:"acceptKey"`
-		EncryptedReadKeys []string `yaml:"encryptedReadKeys"`
-	} `yaml:"userJoin"`
-
-	UserInvite *struct {
-		AcceptKey         string   `yaml:"acceptKey"`
-		EncryptionKey     string   `yaml:"encryptionKey"`
-		EncryptedReadKeys []string `yaml:"encryptedReadKeys"`
-		Permissions       string   `yaml:"permissions"`
-	} `yaml:"userInvite"`
-
-	UserRemove *struct {
-		RemovedIdentity string   `yaml:"removedIdentity"`
-		NewReadKey      string   `yaml:"newReadKey"`
-		IdentitiesLeft  []string `yaml:"identitiesLeft"`
-	} `yaml:"userRemove"`
-
-	UserPermissionChange *struct {
-		Identity   string `yaml:"identity"`
-		Permission string `yaml:"permission"`
-	}
-}
-
-type Record struct {
-	Identity   string       `yaml:"identity"`
-	AclChanges []*AclChange `yaml:"aclChanges"`
-	ReadKey    string       `yaml:"readKey"`
-}
-
-type Header struct {
-	FirstChangeId string `yaml:"firstChangeId"`
-	IsWorkspace   bool   `yaml:"isWorkspace"`
-}
-
-type Root struct {
-	Identity string `yaml:"identity"`
-	SpaceId  string `yaml:"spaceId"`
-}
-
-type YMLList struct {
-	Root    *Root
-	Records []*Record `yaml:"records"`
-
-	Keys Keys `yaml:"keys"`
-}

commonspace/object/acl/testutils/yamltests/path.go

@@ -1,15 +0,0 @@
-package yamltests
-
-import (
-	"path/filepath"
-	"runtime"
-)
-
-var (
-	_, b, _, _ = runtime.Caller(0)
-	basepath   = filepath.Dir(b)
-)
-
-func Path() string {
-	return basepath
-}

commonspace/object/acl/testutils/yamltests/userjoinexample.yml

@@ -1,53 +0,0 @@
-root:
-  identity: A
-  spaceId: space
-records:
-  - identity: A
-    aclChanges:
-      - userInvite:
-          acceptKey: key.Sign.Onetime1
-          encryptionKey: key.Read.EncKey
-          encryptedReadKeys: [key.Read.A]
-          permissions: writer
-      - userAdd:
-          identity: C
-          permission: reader
-          encryptionKey: key.Enc.C
-          encryptedReadKeys: [key.Read.A]
-    readKey: key.Read.A
-  - identity: B
-    aclChanges:
-      - userJoin:
-          identity: B
-          encryptionKey: key.Enc.B
-          acceptKey: key.Sign.Onetime1
-          encryptedReadKeys: [key.Read.A]
-    readKey: key.Read.A
-keys:
-  Enc:
-    - name: A
-      value: generated
-    - name: B
-      value: generated
-    - name: C
-      value: generated
-    - name: D
-      value: generated
-    - name: Onetime1
-      value: generated
-  Sign:
-    - name: A
-      value: generated
-    - name: B
-      value: generated
-    - name: C
-      value: generated
-    - name: D
-      value: generated
-    - name: Onetime1
-      value: generated
-  Read:
-    - name: A
-      value: derived
-    - name: EncKey
-      value: generated

commonspace/object/acl/testutils/yamltests/userremoveexample.yml

@@ -1,58 +0,0 @@
-root:
-  identity: A
-  spaceId: space
-records:
-  - identity: A
-    aclChanges:
-      - userInvite:
-          acceptKey: key.Sign.Onetime1
-          encryptionKey: key.Read.EncKey
-          encryptedReadKeys: [key.Read.A]
-          permissions: writer
-      - userAdd:
-          identity: C
-          permission: reader
-          encryptionKey: key.Enc.C
-          encryptedReadKeys: [key.Read.A]
-    readKey: key.Read.A
-  - identity: B
-    aclChanges:
-      - userJoin:
-          identity: B
-          encryptionKey: key.Enc.B
-          acceptKey: key.Sign.Onetime1
-          encryptedReadKeys: [key.Read.A]
-    readKey: key.Read.A
-  - identity: A
-    aclChanges:
-      - userRemove:
-          removedIdentity: B
-          newReadKey: key.Read.2
-          identitiesLeft: [A, C]
-    readKey: key.Read.2
-keys:
-  Enc:
-    - name: A
-      value: generated
-    - name: B
-      value: generated
-    - name: C
-      value: generated
-    - name: Onetime1
-      value: generated
-  Sign:
-    - name: A
-      value: generated
-    - name: B
-      value: generated
-    - name: C
-      value: generated
-    - name: Onetime1
-      value: generated
-  Read:
-    - name: A
-      value: derived
-    - name: 2
-      value: generated
-    - name: EncKey
-      value: generated

commonspace/object/keychain/keychain.go

@@ -1,28 +0,0 @@
-package keychain
-
-import (
-	"github.com/anytypeio/any-sync/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
-}

commonspace/object/syncobjectgetter/syncobjectgetter.go

@@ -2,7 +2,7 @@ package syncobjectgetter
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/commonspace/objectsync/synchandler"
+	"github.com/anyproto/any-sync/commonspace/objectsync/synchandler"
 )
 
 type SyncObject interface {

commonspace/object/tree/exporter/treeexporter.go

@@ -1,11 +1,11 @@
 package exporter
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/acl/liststorage"
-	"github.com/anytypeio/any-sync/commonspace/object/keychain"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/commonspace/object/acl/liststorage"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/util/crypto"
 )
 
 type DataConverter interface {
@@ -48,7 +48,7 @@ func (t *treeExporter) ExportUnencrypted(tree objecttree.ReadableObjectTree) (er
 	if err != nil {
 		return
 	}
-	changeBuilder := objecttree.NewChangeBuilder(keychain.NewKeychain(), tree.Header())
+	changeBuilder := objecttree.NewChangeBuilder(crypto.NewKeyStorage(), tree.Header())
 	putStorage := func(change *objecttree.Change) (err error) {
 		var raw *treechangeproto.RawTreeChangeWithId
 		raw, err = changeBuilder.Marshall(change)
@@ -68,7 +68,7 @@ func (t *treeExporter) ExportUnencrypted(tree objecttree.ReadableObjectTree) (er
 			return false
 		}
 		// that means that change is unencrypted
-		change.ReadKeyHash = 0
+		change.ReadKeyId = ""
 		change.Data = data
 		err = putStorage(change)
 		return err == nil

commonspace/object/tree/exporter/treeimport.go

@@ -1,10 +1,10 @@
 package exporter
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/liststorage"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/object/acl/liststorage"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
 )
 
 type TreeImportParams struct {

commonspace/object/tree/objecttree/change.go

@@ -2,7 +2,9 @@ package objecttree
 
 import (
 	"errors"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/gogo/protobuf/proto"
 )
 
 var (
@@ -17,46 +19,51 @@ type Change struct {
 	AclHeadId   string
 	Id          string
 	SnapshotId  string
-	IsSnapshot  bool
 	Timestamp   int64
-	ReadKeyHash uint64
-	Identity    string
+	ReadKeyId   string
+	Identity    crypto.PubKey
 	Data        []byte
 	Model       interface{}
+	Signature   []byte
 
 	// iterator helpers
 	visited          bool
 	branchesFinished bool
-
-	Signature []byte
+	IsSnapshot       bool
 }
 
-func NewChange(id string, ch *treechangeproto.TreeChange, signature []byte) *Change {
+func NewChange(id string, identity crypto.PubKey, ch *treechangeproto.TreeChange, signature []byte) *Change {
 	return &Change{
 		Next:        nil,
 		PreviousIds: ch.TreeHeadIds,
 		AclHeadId:   ch.AclHeadId,
 		Timestamp:   ch.Timestamp,
-		ReadKeyHash: ch.CurrentReadKeyHash,
+		ReadKeyId:   ch.ReadKeyId,
 		Id:          id,
 		Data:        ch.ChangesData,
 		SnapshotId:  ch.SnapshotBaseId,
 		IsSnapshot:  ch.IsSnapshot,
-		Identity:    string(ch.Identity),
+		Identity:    identity,
 		Signature:   signature,
 	}
 }
 
-func NewChangeFromRoot(id string, ch *treechangeproto.RootChange, signature []byte) *Change {
+func NewChangeFromRoot(id string, identity crypto.PubKey, ch *treechangeproto.RootChange, signature []byte) *Change {
+	changeInfo := &treechangeproto.TreeChangeInfo{
+		ChangeType:    ch.ChangeType,
+		ChangePayload: ch.ChangePayload,
+	}
+	data, _ := proto.Marshal(changeInfo)
 	return &Change{
 		Next:       nil,
 		AclHeadId:  ch.AclHeadId,
 		Id:         id,
 		IsSnapshot: true,
 		Timestamp:  ch.Timestamp,
-		Identity:   string(ch.Identity),
+		Identity:   identity,
 		Signature:  signature,
-		Data:       []byte(ch.ChangeType),
+		Data:       data,
+		Model:      changeInfo,
 	}
 }
 

commonspace/object/tree/objecttree/changebuilder.go

@@ -2,37 +2,34 @@ package objecttree
 
 import (
 	"errors"
-	"github.com/anytypeio/any-sync/commonspace/object/keychain"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/util/cidutil"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
-	"github.com/anytypeio/any-sync/util/keys/symmetric"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/util/cidutil"
+	"github.com/anyproto/any-sync/util/crypto"
 	"github.com/gogo/protobuf/proto"
-	"time"
 )
 
 var ErrEmptyChange = errors.New("change payload should not be empty")
 
 type BuilderContent struct {
-	TreeHeadIds        []string
-	AclHeadId          string
-	SnapshotBaseId     string
-	CurrentReadKeyHash uint64
-	Identity           []byte
-	IsSnapshot         bool
-	SigningKey         signingkey.PrivKey
-	ReadKey            *symmetric.Key
-	Content            []byte
+	TreeHeadIds    []string
+	AclHeadId      string
+	SnapshotBaseId string
+	ReadKeyId      string
+	IsSnapshot     bool
+	PrivKey        crypto.PrivKey
+	ReadKey        crypto.SymKey
+	Content        []byte
+	Timestamp      int64
 }
 
 type InitialContent struct {
-	AclHeadId  string
-	Identity   []byte
-	SigningKey signingkey.PrivKey
-	SpaceId    string
-	Seed       []byte
-	ChangeType string
-	Timestamp  int64
+	AclHeadId     string
+	PrivKey       crypto.PrivKey
+	SpaceId       string
+	Seed          []byte
+	ChangeType    string
+	ChangePayload []byte
+	Timestamp     int64
 }
 
 type nonVerifiableChangeBuilder struct {
@@ -62,13 +59,16 @@ type ChangeBuilder interface {
 	Marshall(ch *Change) (*treechangeproto.RawTreeChangeWithId, error)
 }
 
+type newChangeFunc = func(id string, identity crypto.PubKey, ch *treechangeproto.TreeChange, signature []byte) *Change
+
 type changeBuilder struct {
 	rootChange *treechangeproto.RawTreeChangeWithId
-	keys       *keychain.Keychain
+	keys       crypto.KeyStorage
+	newChange  newChangeFunc
 }
 
-func NewChangeBuilder(keys *keychain.Keychain, rootChange *treechangeproto.RawTreeChangeWithId) ChangeBuilder {
-	return &changeBuilder{keys: keys, rootChange: rootChange}
+func NewChangeBuilder(keys crypto.KeyStorage, rootChange *treechangeproto.RawTreeChangeWithId) ChangeBuilder {
+	return &changeBuilder{keys: keys, rootChange: rootChange, newChange: NewChange}
 }
 
 func (c *changeBuilder) Unmarshall(rawIdChange *treechangeproto.RawTreeChangeWithId, verify bool) (ch *Change, err error) {
@@ -96,15 +96,9 @@ func (c *changeBuilder) Unmarshall(rawIdChange *treechangeproto.RawTreeChangeWit
 	}
 
 	if verify {
-		var identityKey signingkey.PubKey
-		identityKey, err = c.keys.GetOrAdd(ch.Identity)
-		if err != nil {
-			return
-		}
-
 		// verifying signature
 		var res bool
-		res, err = identityKey.Verify(raw.Payload, raw.Signature)
+		res, err = ch.Identity.Verify(raw.Payload, raw.Signature)
 		if err != nil {
 			return
 		}
@@ -121,42 +115,40 @@ func (c *changeBuilder) SetRootRawChange(rawIdChange *treechangeproto.RawTreeCha
 }
 
 func (c *changeBuilder) BuildRoot(payload InitialContent) (ch *Change, rawIdChange *treechangeproto.RawTreeChangeWithId, err error) {
-	change := &treechangeproto.RootChange{
-		AclHeadId:  payload.AclHeadId,
-		Timestamp:  payload.Timestamp,
-		Identity:   payload.Identity,
-		ChangeType: payload.ChangeType,
-		SpaceId:    payload.SpaceId,
-		Seed:       payload.Seed,
+	identity, err := payload.PrivKey.GetPublic().Marshall()
+	if err != nil {
+		return
+	}
+	change := &treechangeproto.RootChange{
+		AclHeadId:     payload.AclHeadId,
+		Timestamp:     payload.Timestamp,
+		Identity:      identity,
+		ChangeType:    payload.ChangeType,
+		ChangePayload: payload.ChangePayload,
+		SpaceId:       payload.SpaceId,
+		Seed:          payload.Seed,
 	}
-
 	marshalledChange, err := proto.Marshal(change)
 	if err != nil {
 		return
 	}
-
-	signature, err := payload.SigningKey.Sign(marshalledChange)
+	signature, err := payload.PrivKey.Sign(marshalledChange)
 	if err != nil {
 		return
 	}
-
 	raw := &treechangeproto.RawTreeChange{
 		Payload:   marshalledChange,
 		Signature: signature,
 	}
-
 	marshalledRawChange, err := proto.Marshal(raw)
 	if err != nil {
 		return
 	}
-
 	id, err := cidutil.NewCidFromBytes(marshalledRawChange)
 	if err != nil {
 		return
 	}
-
-	ch = NewChangeFromRoot(id, change, signature)
-
+	ch = NewChangeFromRoot(id, payload.PrivKey.GetPublic(), change, signature)
 	rawIdChange = &treechangeproto.RawTreeChangeWithId{
 		RawChange: marshalledRawChange,
 		Id:        id,
@@ -165,14 +157,18 @@ func (c *changeBuilder) BuildRoot(payload InitialContent) (ch *Change, rawIdChan
 }
 
 func (c *changeBuilder) Build(payload BuilderContent) (ch *Change, rawIdChange *treechangeproto.RawTreeChangeWithId, err error) {
+	identity, err := payload.PrivKey.GetPublic().Marshall()
+	if err != nil {
+		return
+	}
 	change := &treechangeproto.TreeChange{
-		TreeHeadIds:        payload.TreeHeadIds,
-		AclHeadId:          payload.AclHeadId,
-		SnapshotBaseId:     payload.SnapshotBaseId,
-		CurrentReadKeyHash: payload.CurrentReadKeyHash,
-		Timestamp:          time.Now().UnixNano(),
-		Identity:           payload.Identity,
-		IsSnapshot:         payload.IsSnapshot,
+		TreeHeadIds:    payload.TreeHeadIds,
+		AclHeadId:      payload.AclHeadId,
+		SnapshotBaseId: payload.SnapshotBaseId,
+		ReadKeyId:      payload.ReadKeyId,
+		Timestamp:      payload.Timestamp,
+		Identity:       identity,
+		IsSnapshot:     payload.IsSnapshot,
 	}
 	if payload.ReadKey != nil {
 		var encrypted []byte
@@ -184,34 +180,27 @@ func (c *changeBuilder) Build(payload BuilderContent) (ch *Change, rawIdChange *
 	} else {
 		change.ChangesData = payload.Content
 	}
-
 	marshalledChange, err := proto.Marshal(change)
 	if err != nil {
 		return
 	}
-
-	signature, err := payload.SigningKey.Sign(marshalledChange)
+	signature, err := payload.PrivKey.Sign(marshalledChange)
 	if err != nil {
 		return
 	}
-
 	raw := &treechangeproto.RawTreeChange{
 		Payload:   marshalledChange,
 		Signature: signature,
 	}
-
 	marshalledRawChange, err := proto.Marshal(raw)
 	if err != nil {
 		return
 	}
-
 	id, err := cidutil.NewCidFromBytes(marshalledRawChange)
 	if err != nil {
 		return
 	}
-
-	ch = NewChange(id, change, signature)
-
+	ch = c.newChange(id, payload.PrivKey.GetPublic(), change, signature)
 	rawIdChange = &treechangeproto.RawTreeChangeWithId{
 		RawChange: marshalledRawChange,
 		Id:        id,
@@ -220,18 +209,22 @@ func (c *changeBuilder) Build(payload BuilderContent) (ch *Change, rawIdChange *
 }
 
 func (c *changeBuilder) Marshall(ch *Change) (raw *treechangeproto.RawTreeChangeWithId, err error) {
-	if ch.Id == c.rootChange.Id {
+	if c.isRoot(ch.Id) {
 		return c.rootChange, nil
 	}
+	identity, err := ch.Identity.Marshall()
+	if err != nil {
+		return
+	}
 	treeChange := &treechangeproto.TreeChange{
-		TreeHeadIds:        ch.PreviousIds,
-		AclHeadId:          ch.AclHeadId,
-		SnapshotBaseId:     ch.SnapshotId,
-		ChangesData:        ch.Data,
-		CurrentReadKeyHash: ch.ReadKeyHash,
-		Timestamp:          ch.Timestamp,
-		Identity:           []byte(ch.Identity),
-		IsSnapshot:         ch.IsSnapshot,
+		TreeHeadIds:    ch.PreviousIds,
+		AclHeadId:      ch.AclHeadId,
+		SnapshotBaseId: ch.SnapshotId,
+		ChangesData:    ch.Data,
+		ReadKeyId:      ch.ReadKeyId,
+		Timestamp:      ch.Timestamp,
+		Identity:       identity,
+		IsSnapshot:     ch.IsSnapshot,
 	}
 	var marshalled []byte
 	marshalled, err = treeChange.Marshal()
@@ -255,22 +248,36 @@ func (c *changeBuilder) Marshall(ch *Change) (raw *treechangeproto.RawTreeChange
 }
 
 func (c *changeBuilder) unmarshallRawChange(raw *treechangeproto.RawTreeChange, id string) (ch *Change, err error) {
-	if c.rootChange.Id == id {
+	var key crypto.PubKey
+	if c.isRoot(id) {
 		unmarshalled := &treechangeproto.RootChange{}
 		err = proto.Unmarshal(raw.Payload, unmarshalled)
 		if err != nil {
 			return
 		}
-		ch = NewChangeFromRoot(id, unmarshalled, raw.Signature)
+		key, err = c.keys.PubKeyFromProto(unmarshalled.Identity)
+		if err != nil {
+			return
+		}
+		ch = NewChangeFromRoot(id, key, unmarshalled, raw.Signature)
 		return
 	}
-
 	unmarshalled := &treechangeproto.TreeChange{}
 	err = proto.Unmarshal(raw.Payload, unmarshalled)
 	if err != nil {
 		return
 	}
-
-	ch = NewChange(id, unmarshalled, raw.Signature)
+	key, err = c.keys.PubKeyFromProto(unmarshalled.Identity)
+	if err != nil {
+		return
+	}
+	ch = c.newChange(id, key, unmarshalled, raw.Signature)
 	return
 }
+
+func (c *changeBuilder) isRoot(id string) bool {
+	if c.rootChange != nil {
+		return c.rootChange.Id == id
+	}
+	return false
+}

commonspace/object/tree/objecttree/historytree.go

@@ -14,39 +14,47 @@ type historyTree struct {
 	*objectTree
 }
 
-func (h *historyTree) rebuildFromStorage(beforeId string, include bool) (err error) {
-	ot := h.objectTree
-	ot.treeBuilder.Reset()
-	if beforeId == ot.Id() && !include {
+func (h *historyTree) rebuildFromStorage(params HistoryTreeParams) (err error) {
+	err = h.rebuild(params)
+	if err != nil {
+		return
+	}
+	h.aclList.RLock()
+	defer h.aclList.RUnlock()
+	state := h.aclList.AclState()
+
+	return h.readKeysFromAclState(state)
+}
+
+func (h *historyTree) rebuild(params HistoryTreeParams) (err error) {
+	var (
+		beforeId = params.BeforeId
+		include  = params.IncludeBeforeId
+		full     = params.BuildFullTree
+	)
+	h.treeBuilder.Reset()
+	if full {
+		h.tree, err = h.treeBuilder.BuildFull()
+		return
+	}
+	if beforeId == h.Id() && !include {
 		return ErrLoadBeforeRoot
 	}
 
 	heads := []string{beforeId}
 	if beforeId == "" {
-		heads, err = ot.treeStorage.Heads()
+		heads, err = h.treeStorage.Heads()
 		if err != nil {
 			return
 		}
 	} else if !include {
-		beforeChange, err := ot.treeBuilder.loadChange(beforeId)
+		beforeChange, err := h.treeBuilder.loadChange(beforeId)
 		if err != nil {
 			return err
 		}
 		heads = beforeChange.PreviousIds
 	}
 
-	ot.tree, err = ot.treeBuilder.build(heads, nil, nil)
-	if err != nil {
-		return
-	}
-	ot.aclList.RLock()
-	defer ot.aclList.RUnlock()
-	state := ot.aclList.AclState()
-
-	if len(ot.keys) != len(state.UserReadKeys()) {
-		for key, value := range state.UserReadKeys() {
-			ot.keys[key] = value
-		}
-	}
+	h.tree, err = h.treeBuilder.build(heads, nil, nil)
 	return
 }

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

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/any-sync/commonspace/object/tree/objecttree (interfaces: ObjectTree)
+// Source: github.com/anyproto/any-sync/commonspace/object/tree/objecttree (interfaces: ObjectTree)
 
 // Package mock_objecttree is a generated GoMock package.
 package mock_objecttree
@@ -7,11 +7,12 @@ package mock_objecttree
 import (
 	context "context"
 	reflect "reflect"
+	time "time"
 
-	list "github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	objecttree "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	treechangeproto "github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	treestorage "github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
+	list "github.com/anyproto/any-sync/commonspace/object/acl/list"
+	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -82,6 +83,20 @@ func (mr *MockObjectTreeMockRecorder) AddRawChanges(arg0, arg1 interface{}) *gom
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockObjectTree)(nil).AddRawChanges), arg0, arg1)
 }
 
+// ChangeInfo mocks base method.
+func (m *MockObjectTree) ChangeInfo() *treechangeproto.TreeChangeInfo {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChangeInfo")
+	ret0, _ := ret[0].(*treechangeproto.TreeChangeInfo)
+	return ret0
+}
+
+// ChangeInfo indicates an expected call of ChangeInfo.
+func (mr *MockObjectTreeMockRecorder) ChangeInfo() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeInfo", reflect.TypeOf((*MockObjectTree)(nil).ChangeInfo))
+}
+
 // ChangesAfterCommonSnapshot mocks base method.
 func (m *MockObjectTree) ChangesAfterCommonSnapshot(arg0, arg1 []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
 	m.ctrl.T.Helper()
@@ -243,6 +258,20 @@ func (mr *MockObjectTreeMockRecorder) IterateRoot(arg0, arg1 interface{}) *gomoc
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateRoot", reflect.TypeOf((*MockObjectTree)(nil).IterateRoot), arg0, arg1)
 }
 
+// Len mocks base method.
+func (m *MockObjectTree) Len() int {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Len")
+	ret0, _ := ret[0].(int)
+	return ret0
+}
+
+// Len indicates an expected call of Len.
+func (mr *MockObjectTreeMockRecorder) Len() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockObjectTree)(nil).Len))
+}
+
 // Lock mocks base method.
 func (m *MockObjectTree) Lock() {
 	m.ctrl.T.Helper()
@@ -255,6 +284,21 @@ func (mr *MockObjectTreeMockRecorder) Lock() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockObjectTree)(nil).Lock))
 }
 
+// PrepareChange mocks base method.
+func (m *MockObjectTree) PrepareChange(arg0 objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrepareChange", arg0)
+	ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PrepareChange indicates an expected call of PrepareChange.
+func (mr *MockObjectTreeMockRecorder) PrepareChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockObjectTree)(nil).PrepareChange), arg0)
+}
+
 // RLock mocks base method.
 func (m *MockObjectTree) RLock() {
 	m.ctrl.T.Helper()
@@ -321,6 +365,49 @@ func (mr *MockObjectTreeMockRecorder) Storage() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Storage", reflect.TypeOf((*MockObjectTree)(nil).Storage))
 }
 
+// TryClose mocks base method.
+func (m *MockObjectTree) TryClose(arg0 time.Duration) (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TryClose", arg0)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TryClose indicates an expected call of TryClose.
+func (mr *MockObjectTreeMockRecorder) TryClose(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockObjectTree)(nil).TryClose), arg0)
+}
+
+// TryLock mocks base method.
+func (m *MockObjectTree) TryLock() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TryLock")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// TryLock indicates an expected call of TryLock.
+func (mr *MockObjectTreeMockRecorder) TryLock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLock", reflect.TypeOf((*MockObjectTree)(nil).TryLock))
+}
+
+// TryRLock mocks base method.
+func (m *MockObjectTree) TryRLock() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TryRLock")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// TryRLock indicates an expected call of TryRLock.
+func (mr *MockObjectTreeMockRecorder) TryRLock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryRLock", reflect.TypeOf((*MockObjectTree)(nil).TryRLock))
+}
+
 // Unlock mocks base method.
 func (m *MockObjectTree) Unlock() {
 	m.ctrl.T.Helper()
@@ -346,3 +433,18 @@ func (mr *MockObjectTreeMockRecorder) UnmarshalledHeader() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalledHeader", reflect.TypeOf((*MockObjectTree)(nil).UnmarshalledHeader))
 }
+
+// UnpackChange mocks base method.
+func (m *MockObjectTree) UnpackChange(arg0 *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnpackChange", arg0)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UnpackChange indicates an expected call of UnpackChange.
+func (mr *MockObjectTreeMockRecorder) UnpackChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockObjectTree)(nil).UnpackChange), arg0)
+}

commonspace/object/tree/objecttree/objecttree.go

@@ -1,28 +1,33 @@
-//go:generate mockgen -destination mock_objecttree/mock_objecttree.go github.com/anytypeio/any-sync/commonspace/object/tree/objecttree ObjectTree
+//go:generate mockgen -destination mock_objecttree/mock_objecttree.go github.com/anyproto/any-sync/commonspace/object/tree/objecttree ObjectTree
 package objecttree
 
 import (
 	"context"
 	"errors"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	list "github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anytypeio/any-sync/util/keys/symmetric"
-	"github.com/anytypeio/any-sync/util/slice"
+	"github.com/anyproto/any-sync/util/crypto"
 	"sync"
+	"time"
+
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/util/slice"
 )
 
 type RWLocker interface {
 	sync.Locker
 	RLock()
 	RUnlock()
+	TryRLock() bool
+	TryLock() bool
 }
 
 var (
 	ErrHasInvalidChanges = errors.New("the change is invalid")
 	ErrNoCommonSnapshot  = errors.New("trees doesn't have a common snapshot")
 	ErrNoChangeInTree    = errors.New("no such change in tree")
+	ErrMissingKey        = errors.New("missing current read key")
 )
 
 type AddResultSummary int
@@ -49,8 +54,10 @@ type ReadableObjectTree interface {
 	Id() string
 	Header() *treechangeproto.RawTreeChangeWithId
 	UnmarshalledHeader() *Change
+	ChangeInfo() *treechangeproto.TreeChangeInfo
 	Heads() []string
 	Root() *Change
+	Len() int
 
 	AclList() list.AclList
 
@@ -73,8 +80,12 @@ type ObjectTree interface {
 	AddContent(ctx context.Context, content SignableChangeContent) (AddResult, error)
 	AddRawChanges(ctx context.Context, changes RawChangesPayload) (AddResult, error)
 
+	UnpackChange(raw *treechangeproto.RawTreeChangeWithId) (data []byte, err error)
+	PrepareChange(content SignableChangeContent) (res *treechangeproto.RawTreeChangeWithId, err error)
+
 	Delete() error
 	Close() error
+	TryClose(objectTTL time.Duration) (bool, error)
 }
 
 type objectTree struct {
@@ -90,7 +101,8 @@ type objectTree struct {
 	root    *Change
 	tree    *Tree
 
-	keys map[uint64]*symmetric.Key
+	keys           map[string]crypto.SymKey
+	currentReadKey crypto.SymKey
 
 	// buffers
 	difSnapshotBuf  []*treechangeproto.RawTreeChangeWithId
@@ -104,13 +116,25 @@ type objectTree struct {
 }
 
 func (ot *objectTree) rebuildFromStorage(theirHeads []string, newChanges []*Change) (err error) {
+	oldTree := ot.tree
 	ot.treeBuilder.Reset()
-
 	ot.tree, err = ot.treeBuilder.Build(theirHeads, newChanges)
 	if err != nil {
 		return
 	}
 
+	// in case there are new heads
+	if theirHeads != nil && oldTree != nil {
+		// checking that old root is still in tree
+		rootCh, rootExists := ot.tree.attached[oldTree.RootId()]
+
+		// checking the case where theirHeads were actually below prevHeads
+		// so if we did load some extra data in the tree, let's reduce it to old root
+		if slice.UnsortedEquals(oldTree.headIds, ot.tree.headIds) && rootExists && ot.tree.RootId() != oldTree.RootId() {
+			ot.tree.makeRootAndRemove(rootCh)
+		}
+	}
+
 	// during building the tree we may have marked some changes as possible roots,
 	// but obviously they are not roots, because of the way how we construct the tree
 	ot.tree.clearPossibleRoots()
@@ -124,6 +148,10 @@ func (ot *objectTree) Id() string {
 	return ot.id
 }
 
+func (ot *objectTree) Len() int {
+	return ot.tree.Len()
+}
+
 func (ot *objectTree) AclList() list.AclList {
 	return ot.aclList
 }
@@ -136,6 +164,10 @@ func (ot *objectTree) UnmarshalledHeader() *Change {
 	return ot.root
 }
 
+func (ot *objectTree) ChangeInfo() *treechangeproto.TreeChangeInfo {
+	return ot.root.Model.(*treechangeproto.TreeChangeInfo)
+}
+
 func (ot *objectTree) Storage() treestorage.TreeStorage {
 	return ot.treeStorage
 }
@@ -167,7 +199,7 @@ func (ot *objectTree) AddContent(ctx context.Context, content SignableChangeCont
 		panic(err)
 	}
 
-	err = ot.treeStorage.TransactionAdd([]*treechangeproto.RawTreeChangeWithId{rawChange}, []string{objChange.Id})
+	err = ot.treeStorage.AddRawChangesSetHeads([]*treechangeproto.RawTreeChangeWithId{rawChange}, []string{objChange.Id})
 	if err != nil {
 		return
 	}
@@ -188,39 +220,63 @@ func (ot *objectTree) AddContent(ctx context.Context, content SignableChangeCont
 	return
 }
 
+func (ot *objectTree) UnpackChange(raw *treechangeproto.RawTreeChangeWithId) (data []byte, err error) {
+	unmarshalled, err := ot.changeBuilder.Unmarshall(raw, true)
+	if err != nil {
+		return
+	}
+	data = unmarshalled.Data
+	return
+}
+
+func (ot *objectTree) PrepareChange(content SignableChangeContent) (res *treechangeproto.RawTreeChangeWithId, err error) {
+	payload, err := ot.prepareBuilderContent(content)
+	if err != nil {
+		return
+	}
+	_, res, err = ot.changeBuilder.Build(payload)
+	return
+}
+
 func (ot *objectTree) prepareBuilderContent(content SignableChangeContent) (cnt BuilderContent, err error) {
 	ot.aclList.RLock()
 	defer ot.aclList.RUnlock()
 
 	var (
-		state       = ot.aclList.AclState() // special method for own keys
-		readKey     *symmetric.Key
-		readKeyHash uint64
+		state     = ot.aclList.AclState() // special method for own keys
+		readKey   crypto.SymKey
+		pubKey    = content.Key.GetPublic()
+		readKeyId string
 	)
-	canWrite := state.HasPermission(content.Identity, aclrecordproto.AclUserPermissions_Writer) ||
-		state.HasPermission(content.Identity, aclrecordproto.AclUserPermissions_Admin)
+	canWrite := state.HasPermission(pubKey, aclrecordproto.AclUserPermissions_Writer) ||
+		state.HasPermission(pubKey, aclrecordproto.AclUserPermissions_Admin)
 	if !canWrite {
 		err = list.ErrInsufficientPermissions
 		return
 	}
 
 	if content.IsEncrypted {
-		readKeyHash = state.CurrentReadKeyHash()
-		readKey, err = state.CurrentReadKey()
-		if err != nil {
+		readKeyId = state.CurrentReadKeyId()
+		if ot.currentReadKey == nil {
+			err = ErrMissingKey
 			return
 		}
+		readKey = ot.currentReadKey
+	}
+	timestamp := content.Timestamp
+	if timestamp <= 0 {
+		timestamp = time.Now().Unix()
 	}
 	cnt = BuilderContent{
-		TreeHeadIds:        ot.tree.Heads(),
-		AclHeadId:          ot.aclList.Head().Id,
-		SnapshotBaseId:     ot.tree.RootId(),
-		CurrentReadKeyHash: readKeyHash,
-		Identity:           content.Identity,
-		IsSnapshot:         content.IsSnapshot,
-		SigningKey:         content.Key,
-		ReadKey:            readKey,
-		Content:            content.Data,
+		TreeHeadIds:    ot.tree.Heads(),
+		AclHeadId:      ot.aclList.Head().Id,
+		SnapshotBaseId: ot.tree.RootId(),
+		ReadKeyId:      readKeyId,
+		IsSnapshot:     content.IsSnapshot,
+		PrivKey:        content.Key,
+		ReadKey:        readKey,
+		Content:        content.Data,
+		Timestamp:      timestamp,
 	}
 	return
 }
@@ -240,7 +296,11 @@ func (ot *objectTree) AddRawChanges(ctx context.Context, changesPayload RawChang
 		addResult.Mode = Rebuild
 	}
 
-	err = ot.treeStorage.TransactionAdd(addResult.Added, addResult.Heads)
+	err = ot.treeStorage.AddRawChangesSetHeads(addResult.Added, addResult.Heads)
+	if err != nil {
+		// rolling back all changes made to inmemory state
+		ot.rebuildFromStorage(nil, nil)
+	}
 	return
 }
 
@@ -303,7 +363,7 @@ func (ot *objectTree) addRawChanges(ctx context.Context, changesPayload RawChang
 	}
 
 	// checks if we need to go to database
-	isOldSnapshot := func(ch *Change) bool {
+	snapshotNotInTree := func(ch *Change) bool {
 		if ch.SnapshotId == ot.tree.RootId() {
 			return false
 		}
@@ -318,26 +378,12 @@ func (ot *objectTree) addRawChanges(ctx context.Context, changesPayload RawChang
 
 	shouldRebuildFromStorage := false
 	// checking if we have some changes with different snapshot and then rebuilding
-	for idx, ch := range ot.newChangesBuf {
-		if isOldSnapshot(ch) {
-			var exists bool
-			// checking if it exists in the storage, if yes, then at some point it was added to the tree
-			// thus we don't need to look at this change
-			exists, err = ot.treeStorage.HasChange(ctx, ch.Id)
-			if err != nil {
-				return
-			}
-			if exists {
-				// marking as nil to delete after
-				ot.newChangesBuf[idx] = nil
-				continue
-			}
-			// we haven't seen the change, and it refers to old snapshot, so we should rebuild
+	for _, ch := range ot.newChangesBuf {
+		if snapshotNotInTree(ch) {
 			shouldRebuildFromStorage = true
+			break
 		}
 	}
-	// discarding all previously seen changes
-	ot.newChangesBuf = slice.DiscardFromSlice(ot.newChangesBuf, func(ch *Change) bool { return ch == nil })
 
 	if shouldRebuildFromStorage {
 		err = ot.rebuildFromStorage(changesPayload.NewHeads, ot.newChangesBuf)
@@ -434,6 +480,11 @@ func (ot *objectTree) createAddResult(oldHeads []string, mode Mode, treeChangesA
 
 	var added []*treechangeproto.RawTreeChangeWithId
 	added, err = getAddedChanges(treeChangesAdded)
+	if !ot.treeBuilder.keepInMemoryData {
+		for _, ch := range treeChangesAdded {
+			ch.Data = nil
+		}
+	}
 	if err != nil {
 		return
 	}
@@ -457,11 +508,11 @@ func (ot *objectTree) IterateFrom(id string, convert ChangeConvertFunc, iterate
 	}
 	decrypt := func(c *Change) (decrypted []byte, err error) {
 		// the change is not encrypted
-		if c.ReadKeyHash == 0 {
+		if c.ReadKeyId == "" {
 			decrypted = c.Data
 			return
 		}
-		readKey, exists := ot.keys[c.ReadKeyHash]
+		readKey, exists := ot.keys[c.ReadKeyId]
 		if !exists {
 			err = list.ErrNoReadKey
 			return
@@ -500,22 +551,8 @@ func (ot *objectTree) IterateFrom(id string, convert ChangeConvertFunc, iterate
 }
 
 func (ot *objectTree) HasChanges(chs ...string) bool {
-	hasChange := func(s string) bool {
-		_, attachedExists := ot.tree.attached[s]
-		if attachedExists {
-			return attachedExists
-		}
-
-		has, err := ot.treeStorage.HasChange(context.Background(), s)
-		if err != nil {
-			return false
-		}
-
-		return has
-	}
-
 	for _, ch := range chs {
-		if !hasChange(ch) {
+		if _, attachedExists := ot.tree.attached[ch]; !attachedExists {
 			return false
 		}
 	}
@@ -531,6 +568,10 @@ func (ot *objectTree) Root() *Change {
 	return ot.tree.Root()
 }
 
+func (ot *objectTree) TryClose(objectTTL time.Duration) (bool, error) {
+	return true, ot.Close()
+}
+
 func (ot *objectTree) Close() error {
 	return nil
 }
@@ -578,19 +619,7 @@ func (ot *objectTree) ChangesAfterCommonSnapshot(theirPath, theirHeads []string)
 		}
 	}
 
-	if commonSnapshot == ot.tree.RootId() {
-		return ot.getChangesFromTree(theirHeads)
-	} else {
-		return ot.getChangesFromDB(commonSnapshot, theirHeads)
-	}
-}
-
-func (ot *objectTree) getChangesFromTree(theirHeads []string) (rawChanges []*treechangeproto.RawTreeChangeWithId, err error) {
-	return ot.rawChangeLoader.LoadFromTree(ot.tree, theirHeads)
-}
-
-func (ot *objectTree) getChangesFromDB(commonSnapshot string, theirHeads []string) (rawChanges []*treechangeproto.RawTreeChangeWithId, err error) {
-	return ot.rawChangeLoader.LoadFromStorage(commonSnapshot, ot.tree.headIds, theirHeads)
+	return ot.rawChangeLoader.Load(commonSnapshot, ot.tree, theirHeads)
 }
 
 func (ot *objectTree) snapshotPathIsActual() bool {
@@ -602,11 +631,9 @@ func (ot *objectTree) validateTree(newChanges []*Change) error {
 	defer ot.aclList.RUnlock()
 	state := ot.aclList.AclState()
 
-	// just not to take lock many times, updating the key map from aclList
-	if len(ot.keys) != len(state.UserReadKeys()) {
-		for key, value := range state.UserReadKeys() {
-			ot.keys[key] = value
-		}
+	err := ot.readKeysFromAclState(state)
+	if err != nil {
+		return err
 	}
 	if len(newChanges) == 0 {
 		return ot.validator.ValidateFullTree(ot.tree, ot.aclList)
@@ -615,6 +642,26 @@ func (ot *objectTree) validateTree(newChanges []*Change) error {
 	return ot.validator.ValidateNewChanges(ot.tree, ot.aclList, newChanges)
 }
 
+func (ot *objectTree) readKeysFromAclState(state *list.AclState) (err error) {
+	// just not to take lock many times, updating the key map from aclList
+	if len(ot.keys) == len(state.UserReadKeys()) {
+		return nil
+	}
+	for key, value := range state.UserReadKeys() {
+		treeKey, err := deriveTreeKey(value, ot.id)
+		if err != nil {
+			return err
+		}
+		ot.keys[key] = treeKey
+	}
+	curKey, err := state.CurrentReadKey()
+	if err != nil {
+		return err
+	}
+	ot.currentReadKey, err = deriveTreeKey(curKey, ot.id)
+	return err
+}
+
 func (ot *objectTree) Debug(parser DescriptionParser) (DebugInfo, error) {
 	return objectTreeDebug{}.debugInfo(ot, parser)
 }

commonspace/object/tree/objecttree/objecttree_test.go

@@ -2,91 +2,44 @@ package objecttree
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/testutils/acllistbuilder"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
+	"fmt"
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"testing"
+	"time"
 )
 
-type mockChangeCreator struct{}
-
-func (c *mockChangeCreator) createRoot(id, aclId string) *treechangeproto.RawTreeChangeWithId {
-	aclChange := &treechangeproto.RootChange{
-		AclHeadId: aclId,
-	}
-	res, _ := aclChange.Marshal()
-
-	raw := &treechangeproto.RawTreeChange{
-		Payload:   res,
-		Signature: nil,
-	}
-	rawMarshalled, _ := raw.Marshal()
-
-	return &treechangeproto.RawTreeChangeWithId{
-		RawChange: rawMarshalled,
-		Id:        id,
-	}
-}
-
-func (c *mockChangeCreator) createRaw(id, aclId, snapshotId string, isSnapshot bool, prevIds ...string) *treechangeproto.RawTreeChangeWithId {
-	aclChange := &treechangeproto.TreeChange{
-		TreeHeadIds:    prevIds,
-		AclHeadId:      aclId,
-		SnapshotBaseId: snapshotId,
-		ChangesData:    nil,
-		IsSnapshot:     isSnapshot,
-	}
-	res, _ := aclChange.Marshal()
-
-	raw := &treechangeproto.RawTreeChange{
-		Payload:   res,
-		Signature: nil,
-	}
-	rawMarshalled, _ := raw.Marshal()
-
-	return &treechangeproto.RawTreeChangeWithId{
-		RawChange: rawMarshalled,
-		Id:        id,
-	}
-}
-
-func (c *mockChangeCreator) createNewTreeStorage(treeId, aclHeadId string) treestorage.TreeStorage {
-	root := c.createRoot(treeId, aclHeadId)
-	treeStorage, _ := treestorage.NewInMemoryTreeStorage(root, []string{root.Id}, []*treechangeproto.RawTreeChangeWithId{root})
-	return treeStorage
-}
-
 type testTreeContext struct {
 	aclList       list.AclList
 	treeStorage   treestorage.TreeStorage
-	changeBuilder ChangeBuilder
-	changeCreator *mockChangeCreator
+	changeCreator *MockChangeCreator
 	objTree       ObjectTree
 }
 
-func prepareAclList(t *testing.T) list.AclList {
-	st, err := acllistbuilder.NewListStorageWithTestName("userjoinexample.yml")
-	require.NoError(t, err, "building storage should not result in error")
-
-	aclList, err := list.BuildAclList(st)
+func prepareAclList(t *testing.T) (list.AclList, *accountdata.AccountKeys) {
+	randKeys, err := accountdata.NewRandom()
+	require.NoError(t, err)
+	aclList, err := list.NewTestDerivedAcl("spaceId", randKeys)
 	require.NoError(t, err, "building acl list should be without error")
 
-	return aclList
+	return aclList, randKeys
 }
 
-func prepareTreeDeps(aclList list.AclList) (*mockChangeCreator, objectTreeDeps) {
-	changeCreator := &mockChangeCreator{}
-	treeStorage := changeCreator.createNewTreeStorage("0", aclList.Head().Id)
+func prepareHistoryTreeDeps(aclList list.AclList) (*MockChangeCreator, objectTreeDeps) {
+	changeCreator := NewMockChangeCreator()
+	treeStorage := changeCreator.CreateNewTreeStorage("0", aclList.Head().Id)
 	root, _ := treeStorage.Root()
 	changeBuilder := &nonVerifiableChangeBuilder{
-		ChangeBuilder: NewChangeBuilder(nil, root),
+		ChangeBuilder: NewChangeBuilder(newMockKeyStorage(), root),
 	}
 	deps := objectTreeDeps{
 		changeBuilder:   changeBuilder,
-		treeBuilder:     newTreeBuilder(treeStorage, changeBuilder),
+		treeBuilder:     newTreeBuilder(true, treeStorage, changeBuilder),
 		treeStorage:     treeStorage,
 		rawChangeLoader: newRawChangeLoader(treeStorage, changeBuilder),
 		validator:       &noOpTreeValidator{},
@@ -96,23 +49,26 @@ func prepareTreeDeps(aclList list.AclList) (*mockChangeCreator, objectTreeDeps)
 }
 
 func prepareTreeContext(t *testing.T, aclList list.AclList) testTreeContext {
-	changeCreator := &mockChangeCreator{}
-	treeStorage := changeCreator.createNewTreeStorage("0", aclList.Head().Id)
-	root, _ := treeStorage.Root()
-	changeBuilder := &nonVerifiableChangeBuilder{
-		ChangeBuilder: NewChangeBuilder(nil, root),
-	}
-	deps := objectTreeDeps{
-		changeBuilder:   changeBuilder,
-		treeBuilder:     newTreeBuilder(treeStorage, changeBuilder),
-		treeStorage:     treeStorage,
-		rawChangeLoader: newRawChangeLoader(treeStorage, changeBuilder),
-		validator:       &noOpTreeValidator{},
-		aclList:         aclList,
-	}
+	return prepareContext(t, aclList, BuildTestableTree, nil)
+}
 
-	// check build
-	objTree, err := buildObjectTree(deps)
+func prepareEmptyDataTreeContext(t *testing.T, aclList list.AclList, additionalChanges func(changeCreator *MockChangeCreator) RawChangesPayload) testTreeContext {
+	return prepareContext(t, aclList, BuildEmptyDataTestableTree, additionalChanges)
+}
+
+func prepareContext(
+	t *testing.T,
+	aclList list.AclList,
+	objTreeBuilder BuildObjectTreeFunc,
+	additionalChanges func(changeCreator *MockChangeCreator) RawChangesPayload) testTreeContext {
+	changeCreator := NewMockChangeCreator()
+	treeStorage := changeCreator.CreateNewTreeStorage("0", aclList.Head().Id)
+	if additionalChanges != nil {
+		payload := additionalChanges(changeCreator)
+		err := treeStorage.AddRawChangesSetHeads(payload.RawChanges, payload.NewHeads)
+		require.NoError(t, err)
+	}
+	objTree, err := objTreeBuilder(treeStorage, aclList)
 	require.NoError(t, err, "building tree should be without error")
 
 	// check tree iterate
@@ -122,18 +78,69 @@ func prepareTreeContext(t *testing.T, aclList list.AclList) testTreeContext {
 		return true
 	})
 	require.NoError(t, err, "iterate should be without error")
-	assert.Equal(t, []string{"0"}, iterChangesId)
+	if additionalChanges == nil {
+		assert.Equal(t, []string{"0"}, iterChangesId)
+	}
 	return testTreeContext{
 		aclList:       aclList,
 		treeStorage:   treeStorage,
-		changeBuilder: changeBuilder,
 		changeCreator: changeCreator,
 		objTree:       objTree,
 	}
 }
 
 func TestObjectTree(t *testing.T) {
-	aclList := prepareAclList(t)
+	aclList, keys := prepareAclList(t)
+	ctx := context.Background()
+
+	t.Run("add content", func(t *testing.T) {
+		root, err := CreateObjectTreeRoot(ObjectTreeCreatePayload{
+			PrivKey:       keys.SignKey,
+			ChangeType:    "changeType",
+			ChangePayload: nil,
+			SpaceId:       "spaceId",
+			IsEncrypted:   true,
+		}, aclList)
+		require.NoError(t, err)
+		store, _ := treestorage.NewInMemoryTreeStorage(root, []string{root.Id}, []*treechangeproto.RawTreeChangeWithId{root})
+		oTree, err := BuildObjectTree(store, aclList)
+		require.NoError(t, err)
+
+		t.Run("0 timestamp is changed to current", func(t *testing.T) {
+			start := time.Now()
+			res, err := oTree.AddContent(ctx, SignableChangeContent{
+				Data:        []byte("some"),
+				Key:         keys.SignKey,
+				IsSnapshot:  false,
+				IsEncrypted: true,
+				Timestamp:   0,
+			})
+			end := time.Now()
+			require.NoError(t, err)
+			require.Len(t, oTree.Heads(), 1)
+			require.Equal(t, res.Added[0].Id, oTree.Heads()[0])
+			ch, err := oTree.(*objectTree).changeBuilder.Unmarshall(res.Added[0], true)
+			require.NoError(t, err)
+			require.GreaterOrEqual(t, start.Unix(), ch.Timestamp)
+			require.LessOrEqual(t, end.Unix(), ch.Timestamp)
+		})
+		t.Run("timestamp is set correctly", func(t *testing.T) {
+			someTs := time.Now().Add(time.Hour).Unix()
+			res, err := oTree.AddContent(ctx, SignableChangeContent{
+				Data:        []byte("some"),
+				Key:         keys.SignKey,
+				IsSnapshot:  false,
+				IsEncrypted: true,
+				Timestamp:   someTs,
+			})
+			require.NoError(t, err)
+			require.Len(t, oTree.Heads(), 1)
+			require.Equal(t, res.Added[0].Id, oTree.Heads()[0])
+			ch, err := oTree.(*objectTree).changeBuilder.Unmarshall(res.Added[0], true)
+			require.NoError(t, err)
+			require.Equal(t, ch.Timestamp, someTs)
+		})
+	})
 
 	t.Run("add simple", func(t *testing.T) {
 		ctx := prepareTreeContext(t, aclList)
@@ -142,8 +149,8 @@ func TestObjectTree(t *testing.T) {
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("1", aclList.Head().Id, "0", false, "0"),
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
 		}
 		payload := RawChangesPayload{
 			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
@@ -187,7 +194,7 @@ func TestObjectTree(t *testing.T) {
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("0", aclList.Head().Id, "", true, ""),
+			changeCreator.CreateRaw("0", aclList.Head().Id, "", true, ""),
 		}
 		payload := RawChangesPayload{
 			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
@@ -211,7 +218,33 @@ func TestObjectTree(t *testing.T) {
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+		}
+		payload := RawChangesPayload{
+			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
+			RawChanges: rawChanges,
+		}
+		res, err := objTree.AddRawChanges(context.Background(), payload)
+		require.NoError(t, err, "adding changes should be without error")
+
+		// check result
+		assert.Equal(t, []string{"0"}, res.OldHeads)
+		assert.Equal(t, []string{"0"}, res.Heads)
+		assert.Equal(t, 0, len(res.Added))
+		assert.Equal(t, Nothing, res.Mode)
+
+		// check tree heads
+		assert.Equal(t, []string{"0"}, objTree.Heads())
+	})
+
+	t.Run("add not connected changes", func(t *testing.T) {
+		ctx := prepareTreeContext(t, aclList)
+		changeCreator := ctx.changeCreator
+		objTree := ctx.objTree
+
+		// this change could in theory replace current snapshot, we should prevent that
+		rawChanges := []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", true, "1"),
 		}
 		payload := RawChangesPayload{
 			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
@@ -237,10 +270,10 @@ func TestObjectTree(t *testing.T) {
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("1", aclList.Head().Id, "0", false, "0"),
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("3", aclList.Head().Id, "0", true, "2"),
-			changeCreator.createRaw("4", aclList.Head().Id, "3", false, "3"),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "3", false, "3"),
 		}
 		payload := RawChangesPayload{
 			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
@@ -287,9 +320,9 @@ func TestObjectTree(t *testing.T) {
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("1", aclList.Head().Id, "0", false, "0"),
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("3", aclList.Head().Id, "0", true, "2"),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
 		}
 		payload := RawChangesPayload{
 			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
@@ -305,18 +338,195 @@ func TestObjectTree(t *testing.T) {
 		assert.Equal(t, true, objTree.(*objectTree).snapshotPathIsActual())
 	})
 
+	t.Run("test empty data tree", func(t *testing.T) {
+		t.Run("empty tree add", func(t *testing.T) {
+			ctx := prepareEmptyDataTreeContext(t, aclList, nil)
+			changeCreator := ctx.changeCreator
+			objTree := ctx.objTree
+
+			rawChangesFirst := []*treechangeproto.RawTreeChangeWithId{
+				changeCreator.CreateRawWithData("1", aclList.Head().Id, "0", false, []byte("1"), "0"),
+				changeCreator.CreateRawWithData("2", aclList.Head().Id, "0", false, []byte("2"), "1"),
+				changeCreator.CreateRawWithData("3", aclList.Head().Id, "0", false, []byte("3"), "2"),
+			}
+			rawChangesSecond := []*treechangeproto.RawTreeChangeWithId{
+				changeCreator.CreateRawWithData("4", aclList.Head().Id, "0", false, []byte("4"), "2"),
+				changeCreator.CreateRawWithData("5", aclList.Head().Id, "0", false, []byte("5"), "1"),
+				changeCreator.CreateRawWithData("6", aclList.Head().Id, "0", false, []byte("6"), "3", "4", "5"),
+			}
+
+			// making them to be saved in unattached
+			_, err := objTree.AddRawChanges(context.Background(), RawChangesPayload{
+				NewHeads:   []string{"6"},
+				RawChanges: rawChangesSecond,
+			})
+			require.NoError(t, err, "adding changes should be without error")
+			// attaching them
+			res, err := objTree.AddRawChanges(context.Background(), RawChangesPayload{
+				NewHeads:   []string{"3"},
+				RawChanges: rawChangesFirst,
+			})
+
+			require.NoError(t, err, "adding changes should be without error")
+			require.Equal(t, "0", objTree.Root().Id)
+			require.Equal(t, []string{"6"}, objTree.Heads())
+			require.Equal(t, 6, len(res.Added))
+
+			// checking that added changes still have data
+			for _, ch := range res.Added {
+				unmarshallRaw := &treechangeproto.RawTreeChange{}
+				proto.Unmarshal(ch.RawChange, unmarshallRaw)
+				treeCh := &treechangeproto.TreeChange{}
+				proto.Unmarshal(unmarshallRaw.Payload, treeCh)
+				require.Equal(t, ch.Id, string(treeCh.ChangesData))
+			}
+
+			// checking that the tree doesn't have data in memory
+			err = objTree.IterateRoot(nil, func(change *Change) bool {
+				if change.Id == "0" {
+					return true
+				}
+				require.Nil(t, change.Data)
+				return true
+			})
+		})
+
+		t.Run("empty tree load", func(t *testing.T) {
+			ctx := prepareEmptyDataTreeContext(t, aclList, func(changeCreator *MockChangeCreator) RawChangesPayload {
+				rawChanges := []*treechangeproto.RawTreeChangeWithId{
+					changeCreator.CreateRawWithData("1", aclList.Head().Id, "0", false, []byte("1"), "0"),
+					changeCreator.CreateRawWithData("2", aclList.Head().Id, "0", false, []byte("2"), "1"),
+					changeCreator.CreateRawWithData("3", aclList.Head().Id, "0", false, []byte("3"), "2"),
+					changeCreator.CreateRawWithData("4", aclList.Head().Id, "0", false, []byte("4"), "2"),
+					changeCreator.CreateRawWithData("5", aclList.Head().Id, "0", false, []byte("5"), "1"),
+					changeCreator.CreateRawWithData("6", aclList.Head().Id, "0", false, []byte("6"), "3", "4", "5"),
+				}
+				return RawChangesPayload{NewHeads: []string{"6"}, RawChanges: rawChanges}
+			})
+			ctx.objTree.IterateRoot(nil, func(change *Change) bool {
+				if change.Id == "0" {
+					return true
+				}
+				require.Nil(t, change.Data)
+				return true
+			})
+			rawChanges, err := ctx.objTree.ChangesAfterCommonSnapshot([]string{"0"}, []string{"6"})
+			require.NoError(t, err)
+			for _, ch := range rawChanges {
+				unmarshallRaw := &treechangeproto.RawTreeChange{}
+				proto.Unmarshal(ch.RawChange, unmarshallRaw)
+				treeCh := &treechangeproto.TreeChange{}
+				proto.Unmarshal(unmarshallRaw.Payload, treeCh)
+				require.Equal(t, ch.Id, string(treeCh.ChangesData))
+			}
+		})
+	})
+
+	t.Run("rollback when add to storage returns error", func(t *testing.T) {
+		ctx := prepareTreeContext(t, aclList)
+		changeCreator := ctx.changeCreator
+		objTree := ctx.objTree
+		store := ctx.treeStorage.(*treestorage.InMemoryTreeStorage)
+		addErr := fmt.Errorf("error saving")
+		store.SetReturnErrorOnAdd(addErr)
+
+		rawChanges := []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", true, "0"),
+		}
+		payload := RawChangesPayload{
+			NewHeads:   []string{"1"},
+			RawChanges: rawChanges,
+		}
+		_, err := objTree.AddRawChanges(context.Background(), payload)
+		require.Error(t, err, addErr)
+		require.Equal(t, "0", objTree.Root().Id)
+	})
+
+	t.Run("their heads before common snapshot", func(t *testing.T) {
+		// checking that adding old changes did not affect the tree
+		ctx := prepareTreeContext(t, aclList)
+		changeCreator := ctx.changeCreator
+		objTree := ctx.objTree
+
+		rawChanges := []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", true, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "1", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "1", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "1", false, "2"),
+			changeCreator.CreateRaw("5", aclList.Head().Id, "1", false, "1"),
+			changeCreator.CreateRaw("6", aclList.Head().Id, "1", true, "3", "4", "5"),
+		}
+		payload := RawChangesPayload{
+			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
+			RawChanges: rawChanges,
+		}
+		_, err := objTree.AddRawChanges(context.Background(), payload)
+		require.NoError(t, err, "adding changes should be without error")
+		require.Equal(t, "6", objTree.Root().Id)
+
+		rawChangesPrevious := []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", true, "0"),
+		}
+		payload = RawChangesPayload{
+			NewHeads:   []string{"1"},
+			RawChanges: rawChangesPrevious,
+		}
+		_, err = objTree.AddRawChanges(context.Background(), payload)
+		require.NoError(t, err, "adding changes should be without error")
+		require.Equal(t, "6", objTree.Root().Id)
+	})
+
+	t.Run("stored changes will not break the pipeline if heads were not updated", func(t *testing.T) {
+		ctx := prepareTreeContext(t, aclList)
+		changeCreator := ctx.changeCreator
+		objTree := ctx.objTree
+		store := ctx.treeStorage.(*treestorage.InMemoryTreeStorage)
+
+		rawChanges := []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", true, "0"),
+		}
+		payload := RawChangesPayload{
+			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
+			RawChanges: rawChanges,
+		}
+		_, err := objTree.AddRawChanges(context.Background(), payload)
+		require.NoError(t, err, "adding changes should be without error")
+		require.Equal(t, "1", objTree.Root().Id)
+
+		// creating changes to save in the storage
+		// to imitate the condition where all changes are in the storage
+		// but the head was not updated
+		storageChanges := []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("2", aclList.Head().Id, "1", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "1", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "1", false, "2"),
+			changeCreator.CreateRaw("5", aclList.Head().Id, "1", false, "1"),
+			changeCreator.CreateRaw("6", aclList.Head().Id, "1", true, "3", "4", "5"),
+		}
+		store.AddRawChangesSetHeads(storageChanges, []string{"1"})
+
+		// updating with subset of those changes to see that everything will still work
+		payload = RawChangesPayload{
+			NewHeads:   []string{"6"},
+			RawChanges: storageChanges,
+		}
+		_, err = objTree.AddRawChanges(context.Background(), payload)
+		require.NoError(t, err, "adding changes should be without error")
+		require.Equal(t, "6", objTree.Root().Id)
+	})
+
 	t.Run("changes from tree after common snapshot complex", func(t *testing.T) {
 		ctx := prepareTreeContext(t, aclList)
 		changeCreator := ctx.changeCreator
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("1", aclList.Head().Id, "0", false, "0"),
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("3", aclList.Head().Id, "0", true, "2"),
-			changeCreator.createRaw("4", aclList.Head().Id, "0", false, "2"),
-			changeCreator.createRaw("5", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("6", aclList.Head().Id, "0", false, "3", "4", "5"),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "0", false, "2"),
+			changeCreator.CreateRaw("5", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("6", aclList.Head().Id, "0", false, "3", "4", "5"),
 		}
 
 		payload := RawChangesPayload{
@@ -390,13 +600,13 @@ func TestObjectTree(t *testing.T) {
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("1", aclList.Head().Id, "0", false, "0"),
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("3", aclList.Head().Id, "0", true, "2"),
-			changeCreator.createRaw("4", aclList.Head().Id, "0", false, "2"),
-			changeCreator.createRaw("5", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "0", false, "2"),
+			changeCreator.CreateRaw("5", aclList.Head().Id, "0", false, "1"),
 			// main difference from tree example
-			changeCreator.createRaw("6", aclList.Head().Id, "0", true, "3", "4", "5"),
+			changeCreator.CreateRaw("6", aclList.Head().Id, "0", true, "3", "4", "5"),
 		}
 
 		payload := RawChangesPayload{
@@ -471,9 +681,9 @@ func TestObjectTree(t *testing.T) {
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("1", aclList.Head().Id, "0", false, "0"),
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("3", aclList.Head().Id, "0", true, "2"),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
 		}
 		payload := RawChangesPayload{
 			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
@@ -485,9 +695,9 @@ func TestObjectTree(t *testing.T) {
 		require.Equal(t, "3", objTree.Root().Id)
 
 		rawChanges = []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("4", aclList.Head().Id, "0", false, "2"),
-			changeCreator.createRaw("5", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("6", aclList.Head().Id, "0", false, "3", "4", "5"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "0", false, "2"),
+			changeCreator.CreateRaw("5", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("6", aclList.Head().Id, "0", false, "3", "4", "5"),
 		}
 		payload = RawChangesPayload{
 			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
@@ -528,17 +738,17 @@ func TestObjectTree(t *testing.T) {
 	})
 
 	t.Run("test history tree not include", func(t *testing.T) {
-		changeCreator, deps := prepareTreeDeps(aclList)
+		changeCreator, deps := prepareHistoryTreeDeps(aclList)
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("1", aclList.Head().Id, "0", false, "0"),
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("3", aclList.Head().Id, "0", true, "2"),
-			changeCreator.createRaw("4", aclList.Head().Id, "0", false, "2"),
-			changeCreator.createRaw("5", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("6", aclList.Head().Id, "0", false, "3", "4", "5"),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "0", false, "2"),
+			changeCreator.CreateRaw("5", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("6", aclList.Head().Id, "0", false, "3", "4", "5"),
 		}
-		deps.treeStorage.TransactionAdd(rawChanges, []string{"6"})
+		deps.treeStorage.AddRawChangesSetHeads(rawChanges, []string{"6"})
 		hTree, err := buildHistoryTree(deps, HistoryTreeParams{
 			BeforeId:        "6",
 			IncludeBeforeId: false,
@@ -558,18 +768,49 @@ func TestObjectTree(t *testing.T) {
 		assert.Equal(t, "0", hTree.Root().Id)
 	})
 
+	t.Run("test history tree build full", func(t *testing.T) {
+		changeCreator, deps := prepareHistoryTreeDeps(aclList)
+
+		// sequence of snapshots: 5->1->0
+		rawChanges := []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", true, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "1", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "1", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "1", false, "2"),
+			changeCreator.CreateRaw("5", aclList.Head().Id, "1", true, "3", "4"),
+			changeCreator.CreateRaw("6", aclList.Head().Id, "5", false, "5"),
+		}
+		deps.treeStorage.AddRawChangesSetHeads(rawChanges, []string{"6"})
+		hTree, err := buildHistoryTree(deps, HistoryTreeParams{
+			BuildFullTree: true,
+		})
+		require.NoError(t, err)
+		// check tree heads
+		assert.Equal(t, []string{"6"}, hTree.Heads())
+
+		// check tree iterate
+		var iterChangesId []string
+		err = hTree.IterateFrom(hTree.Root().Id, nil, func(change *Change) bool {
+			iterChangesId = append(iterChangesId, change.Id)
+			return true
+		})
+		require.NoError(t, err, "iterate should be without error")
+		assert.Equal(t, []string{"0", "1", "2", "3", "4", "5", "6"}, iterChangesId)
+		assert.Equal(t, "0", hTree.Root().Id)
+	})
+
 	t.Run("test history tree include", func(t *testing.T) {
-		changeCreator, deps := prepareTreeDeps(aclList)
+		changeCreator, deps := prepareHistoryTreeDeps(aclList)
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			changeCreator.createRaw("1", aclList.Head().Id, "0", false, "0"),
-			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("3", aclList.Head().Id, "0", true, "2"),
-			changeCreator.createRaw("4", aclList.Head().Id, "0", false, "2"),
-			changeCreator.createRaw("5", aclList.Head().Id, "0", false, "1"),
-			changeCreator.createRaw("6", aclList.Head().Id, "0", false, "3", "4", "5"),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "0", false, "2"),
+			changeCreator.CreateRaw("5", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("6", aclList.Head().Id, "0", false, "3", "4", "5"),
 		}
-		deps.treeStorage.TransactionAdd(rawChanges, []string{"6"})
+		deps.treeStorage.AddRawChangesSetHeads(rawChanges, []string{"6"})
 		hTree, err := buildHistoryTree(deps, HistoryTreeParams{
 			BeforeId:        "6",
 			IncludeBeforeId: true,
@@ -590,7 +831,7 @@ func TestObjectTree(t *testing.T) {
 	})
 
 	t.Run("test history tree root", func(t *testing.T) {
-		_, deps := prepareTreeDeps(aclList)
+		_, deps := prepareHistoryTreeDeps(aclList)
 		hTree, err := buildHistoryTree(deps, HistoryTreeParams{
 			BeforeId:        "0",
 			IncludeBeforeId: true,
@@ -609,4 +850,40 @@ func TestObjectTree(t *testing.T) {
 		assert.Equal(t, []string{"0"}, iterChangesId)
 		assert.Equal(t, "0", hTree.Root().Id)
 	})
+
+	t.Run("validate correct tree", func(t *testing.T) {
+		ctx := prepareTreeContext(t, aclList)
+		changeCreator := ctx.changeCreator
+
+		rawChanges := []*treechangeproto.RawTreeChangeWithId{
+			ctx.objTree.Header(),
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
+		}
+		defaultObjectTreeDeps = nonVerifiableTreeDeps
+		err := ValidateRawTree(treestorage.TreeStorageCreatePayload{
+			RootRawChange: ctx.objTree.Header(),
+			Heads:         []string{"3"},
+			Changes:       rawChanges,
+		}, ctx.aclList)
+		require.NoError(t, err)
+	})
+
+	t.Run("fail to validate not connected tree", func(t *testing.T) {
+		ctx := prepareTreeContext(t, aclList)
+		changeCreator := ctx.changeCreator
+
+		rawChanges := []*treechangeproto.RawTreeChangeWithId{
+			ctx.objTree.Header(),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
+		}
+		defaultObjectTreeDeps = nonVerifiableTreeDeps
+		err := ValidateRawTree(treestorage.TreeStorageCreatePayload{
+			RootRawChange: ctx.objTree.Header(),
+			Heads:         []string{"3"},
+			Changes:       rawChanges,
+		}, ctx.aclList)
+		require.Equal(t, ErrHasInvalidChanges, err)
+	})
 }

commonspace/object/tree/objecttree/objecttreefactory.go

@@ -1,22 +1,20 @@
 package objecttree
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	"github.com/anytypeio/any-sync/commonspace/object/keychain"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
-	"github.com/anytypeio/any-sync/util/keys/symmetric"
-	"math/rand"
-	"time"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/util/crypto"
 )
 
 type ObjectTreeCreatePayload struct {
-	SignKey     signingkey.PrivKey
-	ChangeType  string
-	SpaceId     string
-	Identity    []byte
-	IsEncrypted bool
+	PrivKey       crypto.PrivKey
+	ChangeType    string
+	ChangePayload []byte
+	SpaceId       string
+	IsEncrypted   bool
+	Seed          []byte
+	Timestamp     int64
 }
 
 type HistoryTreeParams struct {
@@ -24,6 +22,7 @@ type HistoryTreeParams struct {
 	AclList         list.AclList
 	BeforeId        string
 	IncludeBeforeId bool
+	BuildFullTree   bool
 }
 
 type objectTreeDeps struct {
@@ -35,14 +34,16 @@ type objectTreeDeps struct {
 	aclList         list.AclList
 }
 
-func defaultObjectTreeDeps(
+type BuildObjectTreeFunc = func(treeStorage treestorage.TreeStorage, aclList list.AclList) (ObjectTree, error)
+
+var defaultObjectTreeDeps = verifiableTreeDeps
+
+func verifiableTreeDeps(
 	rootChange *treechangeproto.RawTreeChangeWithId,
 	treeStorage treestorage.TreeStorage,
 	aclList list.AclList) objectTreeDeps {
-
-	keychain := keychain.NewKeychain()
-	changeBuilder := NewChangeBuilder(keychain, rootChange)
-	treeBuilder := newTreeBuilder(treeStorage, changeBuilder)
+	changeBuilder := NewChangeBuilder(crypto.NewKeyStorage(), rootChange)
+	treeBuilder := newTreeBuilder(true, treeStorage, changeBuilder)
 	return objectTreeDeps{
 		changeBuilder:   changeBuilder,
 		treeBuilder:     treeBuilder,
@@ -53,12 +54,28 @@ func defaultObjectTreeDeps(
 	}
 }
 
+func emptyDataTreeDeps(
+	rootChange *treechangeproto.RawTreeChangeWithId,
+	treeStorage treestorage.TreeStorage,
+	aclList list.AclList) objectTreeDeps {
+	changeBuilder := NewChangeBuilder(crypto.NewKeyStorage(), rootChange)
+	treeBuilder := newTreeBuilder(false, treeStorage, changeBuilder)
+	return objectTreeDeps{
+		changeBuilder:   changeBuilder,
+		treeBuilder:     treeBuilder,
+		treeStorage:     treeStorage,
+		validator:       newTreeValidator(),
+		rawChangeLoader: newStorageLoader(treeStorage, changeBuilder),
+		aclList:         aclList,
+	}
+}
+
 func nonVerifiableTreeDeps(
 	rootChange *treechangeproto.RawTreeChangeWithId,
 	treeStorage treestorage.TreeStorage,
 	aclList list.AclList) objectTreeDeps {
-	changeBuilder := &nonVerifiableChangeBuilder{NewChangeBuilder(nil, rootChange)}
-	treeBuilder := newTreeBuilder(treeStorage, changeBuilder)
+	changeBuilder := &nonVerifiableChangeBuilder{NewChangeBuilder(newMockKeyStorage(), rootChange)}
+	treeBuilder := newTreeBuilder(true, treeStorage, changeBuilder)
 	return objectTreeDeps{
 		changeBuilder:   changeBuilder,
 		treeBuilder:     treeBuilder,
@@ -69,17 +86,47 @@ func nonVerifiableTreeDeps(
 	}
 }
 
-func CreateObjectTreeRoot(payload ObjectTreeCreatePayload, aclList list.AclList) (root *treechangeproto.RawTreeChangeWithId, err error) {
-	bytes := make([]byte, 32)
-	_, err = rand.Read(bytes)
+func BuildEmptyDataObjectTree(treeStorage treestorage.TreeStorage, aclList list.AclList) (ObjectTree, error) {
+	rootChange, err := treeStorage.Root()
 	if err != nil {
-		return
+		return nil, err
 	}
-	return createObjectTreeRoot(payload, time.Now().UnixNano(), bytes, aclList)
+	deps := emptyDataTreeDeps(rootChange, treeStorage, aclList)
+	return buildObjectTree(deps)
 }
 
-func DeriveObjectTreeRoot(payload ObjectTreeCreatePayload, aclList list.AclList) (root *treechangeproto.RawTreeChangeWithId, err error) {
-	return createObjectTreeRoot(payload, 0, nil, aclList)
+func BuildTestableTree(treeStorage treestorage.TreeStorage, aclList list.AclList) (ObjectTree, error) {
+	root, _ := treeStorage.Root()
+	changeBuilder := &nonVerifiableChangeBuilder{
+		ChangeBuilder: NewChangeBuilder(newMockKeyStorage(), root),
+	}
+	deps := objectTreeDeps{
+		changeBuilder:   changeBuilder,
+		treeBuilder:     newTreeBuilder(true, treeStorage, changeBuilder),
+		treeStorage:     treeStorage,
+		rawChangeLoader: newRawChangeLoader(treeStorage, changeBuilder),
+		validator:       &noOpTreeValidator{},
+		aclList:         aclList,
+	}
+
+	return buildObjectTree(deps)
+}
+
+func BuildEmptyDataTestableTree(treeStorage treestorage.TreeStorage, aclList list.AclList) (ObjectTree, error) {
+	root, _ := treeStorage.Root()
+	changeBuilder := &nonVerifiableChangeBuilder{
+		ChangeBuilder: NewChangeBuilder(newMockKeyStorage(), root),
+	}
+	deps := objectTreeDeps{
+		changeBuilder:   changeBuilder,
+		treeBuilder:     newTreeBuilder(false, treeStorage, changeBuilder),
+		treeStorage:     treeStorage,
+		rawChangeLoader: newStorageLoader(treeStorage, changeBuilder),
+		validator:       &noOpTreeValidator{},
+		aclList:         aclList,
+	}
+
+	return buildObjectTree(deps)
 }
 
 func BuildObjectTree(treeStorage treestorage.TreeStorage, aclList list.AclList) (ObjectTree, error) {
@@ -109,54 +156,7 @@ func BuildHistoryTree(params HistoryTreeParams) (HistoryTree, error) {
 	return buildHistoryTree(deps, params)
 }
 
-func CreateDerivedObjectTree(
-	payload ObjectTreeCreatePayload,
-	aclList list.AclList,
-	createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
-	return createObjectTree(payload, 0, nil, aclList, createStorage)
-}
-
-func CreateObjectTree(
-	payload ObjectTreeCreatePayload,
-	aclList list.AclList,
-	createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
-	bytes := make([]byte, 32)
-	_, err = rand.Read(bytes)
-	if err != nil {
-		return
-	}
-	return createObjectTree(payload, time.Now().UnixNano(), bytes, aclList, createStorage)
-}
-
-func createObjectTree(
-	payload ObjectTreeCreatePayload,
-	timestamp int64,
-	seed []byte,
-	aclList list.AclList,
-	createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
-	raw, err := createObjectTreeRoot(payload, timestamp, seed, aclList)
-	if err != nil {
-		return
-	}
-
-	// create storage
-	st, err := createStorage(treestorage.TreeStorageCreatePayload{
-		RootRawChange: raw,
-		Changes:       []*treechangeproto.RawTreeChangeWithId{raw},
-		Heads:         []string{raw.Id},
-	})
-	if err != nil {
-		return
-	}
-
-	return BuildObjectTree(st, aclList)
-}
-
-func createObjectTreeRoot(
-	payload ObjectTreeCreatePayload,
-	timestamp int64,
-	seed []byte,
-	aclList list.AclList) (root *treechangeproto.RawTreeChangeWithId, err error) {
+func CreateObjectTreeRoot(payload ObjectTreeCreatePayload, aclList list.AclList) (root *treechangeproto.RawTreeChangeWithId, err error) {
 	aclList.RLock()
 	aclHeadId := aclList.Head().Id
 	aclList.RUnlock()
@@ -165,16 +165,16 @@ func createObjectTreeRoot(
 		return
 	}
 	cnt := InitialContent{
-		AclHeadId:  aclHeadId,
-		Identity:   payload.Identity,
-		SigningKey: payload.SignKey,
-		SpaceId:    payload.SpaceId,
-		ChangeType: payload.ChangeType,
-		Timestamp:  timestamp,
-		Seed:       seed,
+		AclHeadId:     aclHeadId,
+		PrivKey:       payload.PrivKey,
+		SpaceId:       payload.SpaceId,
+		ChangeType:    payload.ChangeType,
+		ChangePayload: payload.ChangePayload,
+		Timestamp:     payload.Timestamp,
+		Seed:          payload.Seed,
 	}
 
-	_, root, err = NewChangeBuilder(keychain.NewKeychain(), nil).BuildRoot(cnt)
+	_, root, err = NewChangeBuilder(crypto.NewKeyStorage(), nil).BuildRoot(cnt)
 	return
 }
 
@@ -187,7 +187,7 @@ func buildObjectTree(deps objectTreeDeps) (ObjectTree, error) {
 		aclList:         deps.aclList,
 		changeBuilder:   deps.changeBuilder,
 		rawChangeLoader: deps.rawChangeLoader,
-		keys:            make(map[uint64]*symmetric.Key),
+		keys:            make(map[string]crypto.SymKey),
 		newChangesBuf:   make([]*Change, 0, 10),
 		difSnapshotBuf:  make([]*treechangeproto.RawTreeChangeWithId, 0, 10),
 		notSeenIdxBuf:   make([]int, 0, 10),
@@ -223,7 +223,7 @@ func buildHistoryTree(deps objectTreeDeps, params HistoryTreeParams) (ht History
 		aclList:         deps.aclList,
 		changeBuilder:   deps.changeBuilder,
 		rawChangeLoader: deps.rawChangeLoader,
-		keys:            make(map[uint64]*symmetric.Key),
+		keys:            make(map[string]crypto.SymKey),
 		newChangesBuf:   make([]*Change, 0, 10),
 		difSnapshotBuf:  make([]*treechangeproto.RawTreeChangeWithId, 0, 10),
 		notSeenIdxBuf:   make([]int, 0, 10),
@@ -231,7 +231,7 @@ func buildHistoryTree(deps objectTreeDeps, params HistoryTreeParams) (ht History
 	}
 
 	hTree := &historyTree{objectTree: objTree}
-	err = hTree.rebuildFromStorage(params.BeforeId, params.IncludeBeforeId)
+	err = hTree.rebuildFromStorage(params)
 	if err != nil {
 		return nil, err
 	}

commonspace/object/tree/objecttree/objecttreevalidator.go

@@ -1,10 +1,12 @@
 package objecttree
 
 import (
+	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/util/slice"
 )
 
 type ObjectTreeValidator interface {
@@ -50,16 +52,16 @@ func (v *objectTreeValidator) ValidateNewChanges(tree *Tree, aclList list.AclLis
 
 func (v *objectTreeValidator) validateChange(tree *Tree, aclList list.AclList, c *Change) (err error) {
 	var (
-		perm  list.UserPermissionPair
+		perm  list.AclUserState
 		state = aclList.AclState()
 	)
 	// checking if the user could write
-	perm, err = state.PermissionsAtRecord(c.AclHeadId, c.Identity)
+	perm, err = state.StateAtRecord(c.AclHeadId, c.Identity)
 	if err != nil {
 		return
 	}
 
-	if perm.Permission != aclrecordproto.AclUserPermissions_Writer && perm.Permission != aclrecordproto.AclUserPermissions_Admin {
+	if perm.Permissions != aclrecordproto.AclUserPermissions_Writer && perm.Permissions != aclrecordproto.AclUserPermissions_Admin {
 		err = list.ErrInsufficientPermissions
 		return
 	}
@@ -88,11 +90,23 @@ func (v *objectTreeValidator) validateChange(tree *Tree, aclList list.AclList, c
 }
 
 func ValidateRawTree(payload treestorage.TreeStorageCreatePayload, aclList list.AclList) (err error) {
-	treeStorage, err := treestorage.NewInMemoryTreeStorage(payload.RootRawChange, payload.Heads, payload.Changes)
+	treeStorage, err := treestorage.NewInMemoryTreeStorage(payload.RootRawChange, []string{payload.RootRawChange.Id}, nil)
 	if err != nil {
 		return
 	}
-
-	_, err = BuildObjectTree(treeStorage, aclList)
+	tree, err := BuildObjectTree(treeStorage, aclList)
+	if err != nil {
+		return
+	}
+	res, err := tree.AddRawChanges(context.Background(), RawChangesPayload{
+		NewHeads:   payload.Heads,
+		RawChanges: payload.Changes,
+	})
+	if err != nil {
+		return
+	}
+	if !slice.UnsortedEquals(res.Heads, payload.Heads) {
+		return ErrHasInvalidChanges
+	}
 	return
 }

commonspace/object/tree/objecttree/rawloader.go

@@ -2,15 +2,16 @@ package objecttree
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anytypeio/any-sync/util/slice"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/util/slice"
 	"time"
 )
 
 type rawChangeLoader struct {
-	treeStorage   treestorage.TreeStorage
-	changeBuilder ChangeBuilder
+	treeStorage       treestorage.TreeStorage
+	changeBuilder     ChangeBuilder
+	alwaysFromStorage bool
 
 	// buffers
 	idStack []string
@@ -23,6 +24,12 @@ type rawCacheEntry struct {
 	position  int
 }
 
+func newStorageLoader(treeStorage treestorage.TreeStorage, changeBuilder ChangeBuilder) *rawChangeLoader {
+	loader := newRawChangeLoader(treeStorage, changeBuilder)
+	loader.alwaysFromStorage = true
+	return loader
+}
+
 func newRawChangeLoader(treeStorage treestorage.TreeStorage, changeBuilder ChangeBuilder) *rawChangeLoader {
 	return &rawChangeLoader{
 		treeStorage:   treeStorage,
@@ -30,7 +37,15 @@ func newRawChangeLoader(treeStorage treestorage.TreeStorage, changeBuilder Chang
 	}
 }
 
-func (r *rawChangeLoader) LoadFromTree(t *Tree, breakpoints []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
+func (r *rawChangeLoader) Load(commonSnapshot string, t *Tree, breakpoints []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
+	if commonSnapshot == t.root.Id && !r.alwaysFromStorage {
+		return r.loadFromTree(t, breakpoints)
+	} else {
+		return r.loadFromStorage(commonSnapshot, t.Heads(), breakpoints)
+	}
+}
+
+func (r *rawChangeLoader) loadFromTree(t *Tree, breakpoints []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
 	var stack []*Change
 	for _, h := range t.headIds {
 		stack = append(stack, t.attached[h])
@@ -98,7 +113,7 @@ func (r *rawChangeLoader) LoadFromTree(t *Tree, breakpoints []string) ([]*treech
 	return convert(results)
 }
 
-func (r *rawChangeLoader) LoadFromStorage(commonSnapshot string, heads, breakpoints []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
+func (r *rawChangeLoader) loadFromStorage(commonSnapshot string, heads, breakpoints []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
 	// resetting cache
 	r.cache = make(map[string]rawCacheEntry)
 	defer func() {

commonspace/object/tree/objecttree/signablecontent.go

@@ -1,13 +1,19 @@
 package objecttree
 
 import (
-	"github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey"
+	"github.com/anyproto/any-sync/util/crypto"
 )
 
+// SignableChangeContent is a payload to be passed when we are creating change
 type SignableChangeContent struct {
-	Data        []byte
-	Key         signingkey.PrivKey
-	Identity    []byte
-	IsSnapshot  bool
+	// Data is a data provided by the client
+	Data []byte
+	// Key is the key which will be used to sign the change
+	Key crypto.PrivKey
+	// IsSnapshot tells if the change has snapshot of all previous data
+	IsSnapshot bool
+	// IsEncrypted tells if we encrypt the data with the relevant symmetric key
 	IsEncrypted bool
+	// Timestamp is a timestamp of change, if it is <= 0, then we use current timestamp
+	Timestamp int64
 }

commonspace/object/tree/objecttree/testutils.go

@@ -0,0 +1,121 @@
+package objecttree
+
+import (
+	"fmt"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/util/crypto"
+	libcrypto "github.com/libp2p/go-libp2p/core/crypto"
+)
+
+type mockPubKey struct {
+}
+
+const mockKeyValue = "mockKey"
+
+func (m mockPubKey) Equals(key crypto.Key) bool {
+	return true
+}
+
+func (m mockPubKey) Raw() ([]byte, error) {
+	return []byte(mockKeyValue), nil
+}
+
+func (m mockPubKey) Encrypt(message []byte) ([]byte, error) {
+	return message, nil
+}
+
+func (m mockPubKey) Verify(data []byte, sig []byte) (bool, error) {
+	return true, nil
+}
+
+func (m mockPubKey) Marshall() ([]byte, error) {
+	return []byte(mockKeyValue), nil
+}
+
+func (m mockPubKey) Storage() []byte {
+	return []byte(mockKeyValue)
+}
+
+func (m mockPubKey) Account() string {
+	return mockKeyValue
+}
+
+func (m mockPubKey) Network() string {
+	return mockKeyValue
+}
+
+func (m mockPubKey) PeerId() string {
+	return mockKeyValue
+}
+
+func (m mockPubKey) LibP2P() (libcrypto.PubKey, error) {
+	return nil, fmt.Errorf("can't be converted in libp2p")
+}
+
+type mockKeyStorage struct {
+}
+
+func newMockKeyStorage() mockKeyStorage {
+	return mockKeyStorage{}
+}
+
+func (m mockKeyStorage) PubKeyFromProto(protoBytes []byte) (crypto.PubKey, error) {
+	return mockPubKey{}, nil
+}
+
+type MockChangeCreator struct{}
+
+func NewMockChangeCreator() *MockChangeCreator {
+	return &MockChangeCreator{}
+}
+
+func (c *MockChangeCreator) CreateRoot(id, aclId string) *treechangeproto.RawTreeChangeWithId {
+	aclChange := &treechangeproto.RootChange{
+		AclHeadId: aclId,
+	}
+	res, _ := aclChange.Marshal()
+
+	raw := &treechangeproto.RawTreeChange{
+		Payload:   res,
+		Signature: nil,
+	}
+	rawMarshalled, _ := raw.Marshal()
+
+	return &treechangeproto.RawTreeChangeWithId{
+		RawChange: rawMarshalled,
+		Id:        id,
+	}
+}
+
+func (c *MockChangeCreator) CreateRaw(id, aclId, snapshotId string, isSnapshot bool, prevIds ...string) *treechangeproto.RawTreeChangeWithId {
+	return c.CreateRawWithData(id, aclId, snapshotId, isSnapshot, nil, prevIds...)
+}
+
+func (c *MockChangeCreator) CreateRawWithData(id, aclId, snapshotId string, isSnapshot bool, data []byte, prevIds ...string) *treechangeproto.RawTreeChangeWithId {
+	aclChange := &treechangeproto.TreeChange{
+		TreeHeadIds:    prevIds,
+		AclHeadId:      aclId,
+		SnapshotBaseId: snapshotId,
+		ChangesData:    data,
+		IsSnapshot:     isSnapshot,
+	}
+	res, _ := aclChange.Marshal()
+
+	raw := &treechangeproto.RawTreeChange{
+		Payload:   res,
+		Signature: nil,
+	}
+	rawMarshalled, _ := raw.Marshal()
+
+	return &treechangeproto.RawTreeChangeWithId{
+		RawChange: rawMarshalled,
+		Id:        id,
+	}
+}
+
+func (c *MockChangeCreator) CreateNewTreeStorage(treeId, aclHeadId string) treestorage.TreeStorage {
+	root := c.CreateRoot(treeId, aclHeadId)
+	treeStorage, _ := treestorage.NewInMemoryTreeStorage(root, []string{root.Id}, []*treechangeproto.RawTreeChangeWithId{root})
+	return treeStorage
+}

commonspace/object/tree/objecttree/tree_test.go

@@ -125,7 +125,7 @@ func TestTree_Hash(t *testing.T) {
 }
 
 func TestTree_AddFuzzy(t *testing.T) {
-	rand.Seed(time.Now().UnixNano())
+	rand.Seed(time.Now().Unix())
 	getChanges := func() []*Change {
 		changes := []*Change{
 			newChange("1", "root", "root"),

commonspace/object/tree/objecttree/treebuilder.go

@@ -4,15 +4,16 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anytypeio/any-sync/util/slice"
-	"go.uber.org/zap"
 	"time"
+
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/util/slice"
+	"go.uber.org/zap"
 )
 
 var (
-	log      = logger.NewNamed("acltree").Sugar()
+	log      = logger.NewNamedSugared("common.commonspace.objecttree")
 	ErrEmpty = errors.New("logs empty")
 )
 
@@ -20,18 +21,20 @@ type treeBuilder struct {
 	treeStorage treestorage.TreeStorage
 	builder     ChangeBuilder
 
-	cache map[string]*Change
-	tree  *Tree
+	cache            map[string]*Change
+	tree             *Tree
+	keepInMemoryData bool
 
 	// buffers
 	idStack    []string
 	loadBuffer []*Change
 }
 
-func newTreeBuilder(storage treestorage.TreeStorage, builder ChangeBuilder) *treeBuilder {
+func newTreeBuilder(keepData bool, storage treestorage.TreeStorage, builder ChangeBuilder) *treeBuilder {
 	return &treeBuilder{
-		treeStorage: storage,
-		builder:     builder,
+		treeStorage:      storage,
+		builder:          builder,
+		keepInMemoryData: keepData,
 	}
 }
 
@@ -48,7 +51,27 @@ func (tb *treeBuilder) Build(theirHeads []string, newChanges []*Change) (*Tree,
 	return tb.build(heads, theirHeads, newChanges)
 }
 
+func (tb *treeBuilder) BuildFull() (*Tree, error) {
+	defer func() {
+		tb.cache = make(map[string]*Change)
+	}()
+	tb.cache = make(map[string]*Change)
+	heads, err := tb.treeStorage.Heads()
+	if err != nil {
+		return nil, err
+	}
+	err = tb.buildTree(heads, tb.treeStorage.Id())
+	if err != nil {
+		return nil, err
+	}
+	return tb.tree, nil
+}
+
 func (tb *treeBuilder) build(heads []string, theirHeads []string, newChanges []*Change) (*Tree, error) {
+	defer func() {
+		tb.cache = make(map[string]*Change)
+	}()
+
 	var proposedHeads []string
 	tb.cache = make(map[string]*Change)
 
@@ -85,7 +108,7 @@ func (tb *treeBuilder) build(heads []string, theirHeads []string, newChanges []*
 	}
 	proposedHeads = append(proposedHeads, heads...)
 
-	log.With(zap.Strings("heads", proposedHeads)).Debug("building tree")
+	log.With(zap.Strings("heads", proposedHeads), zap.String("id", tb.treeStorage.Id())).Debug("building tree")
 	if err = tb.buildTree(proposedHeads, breakpoint); err != nil {
 		return nil, fmt.Errorf("buildTree error: %v", err)
 	}
@@ -98,8 +121,8 @@ func (tb *treeBuilder) buildTree(heads []string, breakpoint string) (err error)
 	if err != nil {
 		return
 	}
-	tb.tree.AddFast(ch)
 	changes := tb.dfs(heads, breakpoint)
+	tb.tree.AddFast(ch)
 	tb.tree.AddFast(changes...)
 	return
 }
@@ -158,6 +181,9 @@ func (tb *treeBuilder) loadChange(id string) (ch *Change, err error) {
 	if err != nil {
 		return nil, err
 	}
+	if !tb.keepInMemoryData {
+		ch.Data = nil
+	}
 
 	tb.cache[id] = ch
 	return ch, nil

commonspace/object/tree/objecttree/treegraph.go

@@ -1,5 +1,5 @@
-//go:build (!linux && !darwin) || android || ios || nographviz || windows
-// +build !linux,!darwin android ios nographviz windows
+//go:build (!linux && !darwin) || android || ios || nographviz || !cgo || windows
+// +build !linux,!darwin android ios nographviz !cgo windows
 
 package objecttree
 

commonspace/object/tree/objecttree/treegraph_nix.go

@@ -1,8 +1,9 @@
-//go:build (linux || darwin) && !android && !ios && !nographviz && (amd64 || arm64)
+//go:build (linux || darwin) && !android && !ios && !nographviz && cgo && (amd64 || arm64)
 // +build linux darwin
 // +build !android
 // +build !ios
 // +build !nographviz
+// +build cgo
 // +build amd64 arm64
 
 package objecttree
@@ -10,10 +11,11 @@ package objecttree
 import (
 	"bytes"
 	"fmt"
-	"github.com/goccy/go-graphviz"
-	"github.com/goccy/go-graphviz/cgraph"
 	"strings"
 	"time"
+
+	"github.com/goccy/go-graphviz"
+	"github.com/goccy/go-graphviz/cgraph"
 )
 
 func (t *Tree) Graph(parser DescriptionParser) (data string, err error) {

commonspace/object/tree/objecttree/util.go

@@ -1,5 +1,11 @@
 package objecttree
 
+import (
+	"fmt"
+	"github.com/anyproto/any-sync/util/crypto"
+	"math/rand"
+)
+
 func commonSnapshotForTwoPaths(ourPath []string, theirPath []string) (string, error) {
 	var i int
 	var j int
@@ -27,3 +33,24 @@ OuterLoop:
 	}
 	return ourPath[i+1], nil
 }
+
+func deriveTreeKey(key crypto.SymKey, cid string) (crypto.SymKey, error) {
+	raw, err := key.Raw()
+	if err != nil {
+		return nil, err
+	}
+	return crypto.DeriveSymmetricKey(raw, fmt.Sprintf(crypto.AnysyncTreePath, cid))
+}
+
+func DoSnapshot(treeLen int) bool {
+	if treeLen <= 100 {
+		return false
+	}
+
+	var (
+		delta    = treeLen/50 + 1
+		midPoint = 1000
+		val      = rand.Intn(midPoint * 2)
+	)
+	return midPoint-delta <= val && val <= midPoint+delta
+}

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

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/any-sync/commonspace/object/tree/synctree (interfaces: SyncClient,SyncTree,ReceiveQueue,HeadNotifiable)
+// Source: github.com/anyproto/any-sync/commonspace/object/tree/synctree (interfaces: SyncTree,ReceiveQueue,HeadNotifiable)
 
 // Package mock_synctree is a generated GoMock package.
 package mock_synctree
@@ -7,125 +7,17 @@ package mock_synctree
 import (
 	context "context"
 	reflect "reflect"
+	time "time"
 
-	list "github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	objecttree "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	updatelistener "github.com/anytypeio/any-sync/commonspace/object/tree/synctree/updatelistener"
-	treechangeproto "github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	treestorage "github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
-	spacesyncproto "github.com/anytypeio/any-sync/commonspace/spacesyncproto"
+	list "github.com/anyproto/any-sync/commonspace/object/acl/list"
+	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	updatelistener "github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener"
+	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockSyncClient is a mock of SyncClient interface.
-type MockSyncClient struct {
-	ctrl     *gomock.Controller
-	recorder *MockSyncClientMockRecorder
-}
-
-// MockSyncClientMockRecorder is the mock recorder for MockSyncClient.
-type MockSyncClientMockRecorder struct {
-	mock *MockSyncClient
-}
-
-// NewMockSyncClient creates a new mock instance.
-func NewMockSyncClient(ctrl *gomock.Controller) *MockSyncClient {
-	mock := &MockSyncClient{ctrl: ctrl}
-	mock.recorder = &MockSyncClientMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockSyncClient) EXPECT() *MockSyncClientMockRecorder {
-	return m.recorder
-}
-
-// Broadcast mocks base method.
-func (m *MockSyncClient) Broadcast(arg0 context.Context, arg1 *treechangeproto.TreeSyncMessage) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Broadcast", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Broadcast indicates an expected call of Broadcast.
-func (mr *MockSyncClientMockRecorder) Broadcast(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockSyncClient)(nil).Broadcast), arg0, arg1)
-}
-
-// CreateFullSyncRequest mocks base method.
-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)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateFullSyncRequest indicates an expected call of CreateFullSyncRequest.
-func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncRequest), arg0, arg1, arg2)
-}
-
-// CreateFullSyncResponse mocks base method.
-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)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateFullSyncResponse indicates an expected call of CreateFullSyncResponse.
-func (mr *MockSyncClientMockRecorder) CreateFullSyncResponse(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncResponse", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncResponse), arg0, arg1, arg2)
-}
-
-// CreateHeadUpdate mocks base method.
-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)
-	return ret0
-}
-
-// CreateHeadUpdate indicates an expected call of CreateHeadUpdate.
-func (mr *MockSyncClientMockRecorder) CreateHeadUpdate(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockSyncClient)(nil).CreateHeadUpdate), arg0, arg1)
-}
-
-// CreateNewTreeRequest mocks base method.
-func (m *MockSyncClient) CreateNewTreeRequest() *treechangeproto.TreeSyncMessage {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNewTreeRequest")
-	ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage)
-	return ret0
-}
-
-// CreateNewTreeRequest indicates an expected call of CreateNewTreeRequest.
-func (mr *MockSyncClientMockRecorder) CreateNewTreeRequest() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNewTreeRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateNewTreeRequest))
-}
-
-// SendWithReply mocks base method.
-func (m *MockSyncClient) SendWithReply(arg0 context.Context, arg1 string, arg2 *treechangeproto.TreeSyncMessage, arg3 string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendWithReply", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SendWithReply indicates an expected call of SendWithReply.
-func (mr *MockSyncClientMockRecorder) SendWithReply(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendWithReply", reflect.TypeOf((*MockSyncClient)(nil).SendWithReply), arg0, arg1, arg2, arg3)
-}
-
 // MockSyncTree is a mock of SyncTree interface.
 type MockSyncTree struct {
 	ctrl     *gomock.Controller
@@ -193,6 +85,20 @@ func (mr *MockSyncTreeMockRecorder) AddRawChanges(arg0, arg1 interface{}) *gomoc
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockSyncTree)(nil).AddRawChanges), arg0, arg1)
 }
 
+// ChangeInfo mocks base method.
+func (m *MockSyncTree) ChangeInfo() *treechangeproto.TreeChangeInfo {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChangeInfo")
+	ret0, _ := ret[0].(*treechangeproto.TreeChangeInfo)
+	return ret0
+}
+
+// ChangeInfo indicates an expected call of ChangeInfo.
+func (mr *MockSyncTreeMockRecorder) ChangeInfo() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeInfo", reflect.TypeOf((*MockSyncTree)(nil).ChangeInfo))
+}
+
 // ChangesAfterCommonSnapshot mocks base method.
 func (m *MockSyncTree) ChangesAfterCommonSnapshot(arg0, arg1 []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
 	m.ctrl.T.Helper()
@@ -368,6 +274,20 @@ func (mr *MockSyncTreeMockRecorder) IterateRoot(arg0, arg1 interface{}) *gomock.
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateRoot", reflect.TypeOf((*MockSyncTree)(nil).IterateRoot), arg0, arg1)
 }
 
+// Len mocks base method.
+func (m *MockSyncTree) Len() int {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Len")
+	ret0, _ := ret[0].(int)
+	return ret0
+}
+
+// Len indicates an expected call of Len.
+func (mr *MockSyncTreeMockRecorder) Len() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockSyncTree)(nil).Len))
+}
+
 // Lock mocks base method.
 func (m *MockSyncTree) Lock() {
 	m.ctrl.T.Helper()
@@ -380,6 +300,21 @@ func (mr *MockSyncTreeMockRecorder) Lock() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockSyncTree)(nil).Lock))
 }
 
+// PrepareChange mocks base method.
+func (m *MockSyncTree) PrepareChange(arg0 objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrepareChange", arg0)
+	ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PrepareChange indicates an expected call of PrepareChange.
+func (mr *MockSyncTreeMockRecorder) PrepareChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockSyncTree)(nil).PrepareChange), arg0)
+}
+
 // RLock mocks base method.
 func (m *MockSyncTree) RLock() {
 	m.ctrl.T.Helper()
@@ -472,6 +407,49 @@ func (mr *MockSyncTreeMockRecorder) SyncWithPeer(arg0, arg1 interface{}) *gomock
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWithPeer", reflect.TypeOf((*MockSyncTree)(nil).SyncWithPeer), arg0, arg1)
 }
 
+// TryClose mocks base method.
+func (m *MockSyncTree) TryClose(arg0 time.Duration) (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TryClose", arg0)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TryClose indicates an expected call of TryClose.
+func (mr *MockSyncTreeMockRecorder) TryClose(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockSyncTree)(nil).TryClose), arg0)
+}
+
+// TryLock mocks base method.
+func (m *MockSyncTree) TryLock() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TryLock")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// TryLock indicates an expected call of TryLock.
+func (mr *MockSyncTreeMockRecorder) TryLock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLock", reflect.TypeOf((*MockSyncTree)(nil).TryLock))
+}
+
+// TryRLock mocks base method.
+func (m *MockSyncTree) TryRLock() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TryRLock")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// TryRLock indicates an expected call of TryRLock.
+func (mr *MockSyncTreeMockRecorder) TryRLock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryRLock", reflect.TypeOf((*MockSyncTree)(nil).TryRLock))
+}
+
 // Unlock mocks base method.
 func (m *MockSyncTree) Unlock() {
 	m.ctrl.T.Helper()
@@ -498,6 +476,21 @@ func (mr *MockSyncTreeMockRecorder) UnmarshalledHeader() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalledHeader", reflect.TypeOf((*MockSyncTree)(nil).UnmarshalledHeader))
 }
 
+// UnpackChange mocks base method.
+func (m *MockSyncTree) UnpackChange(arg0 *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnpackChange", arg0)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UnpackChange indicates an expected call of UnpackChange.
+func (mr *MockSyncTreeMockRecorder) UnpackChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockSyncTree)(nil).UnpackChange), arg0)
+}
+
 // MockReceiveQueue is a mock of ReceiveQueue interface.
 type MockReceiveQueue struct {
 	ctrl     *gomock.Controller

commonspace/object/tree/synctree/receivequeue.go

@@ -2,7 +2,7 @@ package synctree
 
 import (
 	"errors"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
 	"sync"
 )
 

commonspace/object/tree/synctree/syncclient.go

@@ -1,66 +0,0 @@
-//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anytypeio/any-sync/commonspace/object/tree/synctree SyncClient,SyncTree,ReceiveQueue,HeadNotifiable
-package synctree
-
-import (
-	"context"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/objectsync"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
-	"github.com/anytypeio/any-sync/nodeconf"
-)
-
-type SyncClient interface {
-	RequestFactory
-	Broadcast(ctx context.Context, msg *treechangeproto.TreeSyncMessage) (err error)
-	SendWithReply(ctx context.Context, peerId string, msg *treechangeproto.TreeSyncMessage, replyId string) (err error)
-}
-
-type syncClient struct {
-	objectsync.MessagePool
-	RequestFactory
-	spaceId       string
-	configuration nodeconf.Configuration
-}
-
-func newSyncClient(
-	spaceId string,
-	pool objectsync.MessagePool,
-	factory RequestFactory,
-	configuration nodeconf.Configuration) SyncClient {
-	return &syncClient{
-		MessagePool:    pool,
-		RequestFactory: factory,
-		configuration:  configuration,
-		spaceId:        spaceId,
-	}
-}
-
-func (s *syncClient) Broadcast(ctx context.Context, msg *treechangeproto.TreeSyncMessage) (err error) {
-	objMsg, err := marshallTreeMessage(msg, s.spaceId, msg.RootChange.Id, "")
-	if err != nil {
-		return
-	}
-	return s.MessagePool.Broadcast(ctx, objMsg)
-}
-
-func (s *syncClient) SendWithReply(ctx context.Context, peerId string, msg *treechangeproto.TreeSyncMessage, replyId string) (err error) {
-	objMsg, err := marshallTreeMessage(msg, s.spaceId, msg.RootChange.Id, replyId)
-	if err != nil {
-		return
-	}
-	return s.MessagePool.SendPeer(ctx, peerId, objMsg)
-}
-
-func marshallTreeMessage(message *treechangeproto.TreeSyncMessage, spaceId, objectId, replyId string) (objMsg *spacesyncproto.ObjectSyncMessage, err error) {
-	payload, err := message.Marshal()
-	if err != nil {
-		return
-	}
-	objMsg = &spacesyncproto.ObjectSyncMessage{
-		ReplyId:  replyId,
-		Payload:  payload,
-		ObjectId: objectId,
-		SpaceId:  spaceId,
-	}
-	return
-}

commonspace/object/tree/synctree/syncprotocol_test.go

@@ -0,0 +1,361 @@
+package synctree
+
+import (
+	"context"
+	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/util/slice"
+	"github.com/gogo/protobuf/proto"
+	"github.com/stretchr/testify/require"
+	"math/rand"
+	"testing"
+	"time"
+)
+
+func TestEmptyClientGetsFullHistory(t *testing.T) {
+	treeId := "treeId"
+	spaceId := "spaceId"
+	keys, err := accountdata.NewRandom()
+	require.NoError(t, err)
+	aclList, err := list.NewTestDerivedAcl(spaceId, keys)
+	require.NoError(t, err)
+	storage := createStorage(treeId, aclList)
+	changeCreator := objecttree.NewMockChangeCreator()
+	deps := fixtureDeps{
+		aclList:     aclList,
+		initStorage: storage.(*treestorage.InMemoryTreeStorage),
+		connectionMap: map[string][]string{
+			"peer1": []string{"peer2"},
+			"peer2": []string{"peer1"},
+		},
+		emptyTrees:  []string{"peer2"},
+		treeBuilder: objecttree.BuildTestableTree,
+	}
+	fx := newProtocolFixture(t, spaceId, deps)
+	fx.run(t)
+	fx.handlers["peer1"].sendRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads: nil,
+		RawChanges: []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("1", aclList.Id(), treeId, true, treeId),
+		},
+	})
+	time.Sleep(100 * time.Millisecond)
+	fx.stop()
+	firstHeads := fx.handlers["peer1"].tree().Heads()
+	secondHeads := fx.handlers["peer2"].tree().Heads()
+	require.True(t, slice.UnsortedEquals(firstHeads, secondHeads))
+	require.Equal(t, []string{"1"}, firstHeads)
+	logMsgs := fx.log.batcher.GetAll()
+
+	var fullResponseMsg msgDescription
+	for _, msg := range logMsgs {
+		descr := msg.description()
+		if descr.name == "FullSyncResponse" {
+			fullResponseMsg = descr
+		}
+	}
+	// that means that we got not only the last snapshot, but also the first one
+	require.Len(t, fullResponseMsg.changes, 2)
+}
+
+func TestTreeFuzzyMerge(t *testing.T) {
+	testTreeFuzzyMerge(t, true)
+	testTreeFuzzyMerge(t, false)
+}
+
+func testTreeFuzzyMerge(t *testing.T, withData bool) {
+	var (
+		rnd      = rand.New(rand.NewSource(time.Now().Unix()))
+		levels   = 20
+		perLevel = 20
+		rounds   = 10
+	)
+	for i := 0; i < rounds; i++ {
+		testTreeMerge(t, levels, perLevel, withData, func() bool {
+			return true
+		})
+		testTreeMerge(t, levels, perLevel, withData, func() bool {
+			return false
+		})
+		testTreeMerge(t, levels, perLevel, withData, func() bool {
+			return rnd.Intn(10) > 8
+		})
+		levels += 2
+	}
+}
+
+func testTreeMerge(t *testing.T, levels, perLevel int, hasData bool, isSnapshot func() bool) {
+	treeId := "treeId"
+	spaceId := "spaceId"
+	keys, err := accountdata.NewRandom()
+	require.NoError(t, err)
+	aclList, err := list.NewTestDerivedAcl(spaceId, keys)
+	storage := createStorage(treeId, aclList)
+	changeCreator := objecttree.NewMockChangeCreator()
+	builder := objecttree.BuildTestableTree
+	if hasData {
+		builder = objecttree.BuildEmptyDataTestableTree
+	}
+	params := genParams{
+		prefix:     "peer1",
+		aclId:      aclList.Id(),
+		startIdx:   0,
+		levels:     levels,
+		perLevel:   perLevel,
+		snapshotId: treeId,
+		prevHeads:  []string{treeId},
+		isSnapshot: isSnapshot,
+		hasData:    hasData,
+	}
+	// generating initial tree
+	initialRes := genChanges(changeCreator, params)
+	err = storage.AddRawChangesSetHeads(initialRes.changes, initialRes.heads)
+	require.NoError(t, err)
+	deps := fixtureDeps{
+		aclList:     aclList,
+		initStorage: storage.(*treestorage.InMemoryTreeStorage),
+		connectionMap: map[string][]string{
+			"peer1": []string{"node1"},
+			"peer2": []string{"node1"},
+			"node1": []string{"peer1", "peer2"},
+		},
+		emptyTrees:  []string{"peer2", "node1"},
+		treeBuilder: builder,
+	}
+	fx := newProtocolFixture(t, spaceId, deps)
+	fx.run(t)
+	fx.handlers["peer1"].sendRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   initialRes.heads,
+		RawChanges: initialRes.changes,
+	})
+	time.Sleep(50 * time.Millisecond)
+	firstHeads := fx.handlers["peer1"].tree().Heads()
+	secondHeads := fx.handlers["peer2"].tree().Heads()
+	require.True(t, slice.UnsortedEquals(firstHeads, secondHeads))
+	params = genParams{
+		prefix:   "peer1",
+		aclId:    aclList.Id(),
+		startIdx: levels,
+		levels:   levels,
+		perLevel: perLevel,
+
+		snapshotId: initialRes.snapshotId,
+		prevHeads:  initialRes.heads,
+		isSnapshot: isSnapshot,
+		hasData:    hasData,
+	}
+	// generating different additions to the tree for different peers
+	peer1Res := genChanges(changeCreator, params)
+	params.prefix = "peer2"
+	peer2Res := genChanges(changeCreator, params)
+	fx.handlers["peer1"].sendRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   peer1Res.heads,
+		RawChanges: peer1Res.changes,
+	})
+	fx.handlers["peer2"].sendRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   peer2Res.heads,
+		RawChanges: peer2Res.changes,
+	})
+	time.Sleep(50 * time.Millisecond)
+	fx.stop()
+	firstTree := fx.handlers["peer1"].tree()
+	secondTree := fx.handlers["peer2"].tree()
+	firstHeads = firstTree.Heads()
+	secondHeads = secondTree.Heads()
+	require.True(t, slice.UnsortedEquals(firstHeads, secondHeads))
+	require.True(t, slice.UnsortedEquals(firstHeads, append(peer1Res.heads, peer2Res.heads...)))
+	firstStorage := firstTree.Storage().(*treestorage.InMemoryTreeStorage)
+	secondStorage := secondTree.Storage().(*treestorage.InMemoryTreeStorage)
+	require.True(t, firstStorage.Equal(secondStorage))
+	if hasData {
+		for _, ch := range secondStorage.Changes {
+			if ch.Id == treeId {
+				continue
+			}
+			unmarshallRaw := &treechangeproto.RawTreeChange{}
+			proto.Unmarshal(ch.RawChange, unmarshallRaw)
+			treeCh := &treechangeproto.TreeChange{}
+			proto.Unmarshal(unmarshallRaw.Payload, treeCh)
+			require.Equal(t, ch.Id, string(treeCh.ChangesData))
+		}
+	}
+}
+
+func TestTreeStorageHasExtraChanges(t *testing.T) {
+	var (
+		rnd      = rand.New(rand.NewSource(time.Now().Unix()))
+		levels   = 20
+		perLevel = 40
+	)
+
+	// simulating cases where one peer has some extra changes saved in storage
+	// and checking that this will not break the sync
+	t.Run("tree storage has extra simple", func(t *testing.T) {
+		testTreeStorageHasExtra(t, levels, perLevel, false, func() bool {
+			return false
+		})
+		testTreeStorageHasExtra(t, levels, perLevel, false, func() bool {
+			return rnd.Intn(10) > 5
+		})
+		testTreeStorageHasExtra(t, levels, perLevel, true, func() bool {
+			return false
+		})
+		testTreeStorageHasExtra(t, levels, perLevel, true, func() bool {
+			return rnd.Intn(10) > 5
+		})
+	})
+	t.Run("tree storage has extra three parts", func(t *testing.T) {
+		testTreeStorageHasExtraThreeParts(t, levels, perLevel, false, func() bool {
+			return false
+		})
+		testTreeStorageHasExtraThreeParts(t, levels, perLevel, false, func() bool {
+			return rnd.Intn(10) > 5
+		})
+		testTreeStorageHasExtraThreeParts(t, levels, perLevel, true, func() bool {
+			return false
+		})
+		testTreeStorageHasExtraThreeParts(t, levels, perLevel, true, func() bool {
+			return rnd.Intn(10) > 5
+		})
+	})
+}
+
+func testTreeStorageHasExtra(t *testing.T, levels, perLevel int, hasData bool, isSnapshot func() bool) {
+	treeId := "treeId"
+	spaceId := "spaceId"
+	keys, err := accountdata.NewRandom()
+	require.NoError(t, err)
+	aclList, err := list.NewTestDerivedAcl(spaceId, keys)
+	storage := createStorage(treeId, aclList)
+	changeCreator := objecttree.NewMockChangeCreator()
+	builder := objecttree.BuildTestableTree
+	if hasData {
+		builder = objecttree.BuildEmptyDataTestableTree
+	}
+	params := genParams{
+		prefix:     "peer1",
+		aclId:      aclList.Id(),
+		startIdx:   0,
+		levels:     levels,
+		perLevel:   perLevel,
+		snapshotId: treeId,
+		prevHeads:  []string{treeId},
+		isSnapshot: isSnapshot,
+		hasData:    hasData,
+	}
+	deps := fixtureDeps{
+		aclList:     aclList,
+		initStorage: storage.(*treestorage.InMemoryTreeStorage),
+		connectionMap: map[string][]string{
+			"peer1": []string{"peer2"},
+			"peer2": []string{"peer1"},
+		},
+		treeBuilder: builder,
+	}
+	fx := newProtocolFixture(t, spaceId, deps)
+
+	// generating initial tree
+	initialRes := genChanges(changeCreator, params)
+	fx.run(t)
+
+	// adding some changes to store, but without updating heads
+	store := fx.handlers["peer1"].tree().Storage().(*treestorage.InMemoryTreeStorage)
+	oldHeads, _ := store.Heads()
+	store.AddRawChangesSetHeads(initialRes.changes, oldHeads)
+
+	// sending those changes to other peer
+	fx.handlers["peer2"].sendRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   initialRes.heads,
+		RawChanges: initialRes.changes,
+	})
+	time.Sleep(50 * time.Millisecond)
+
+	// here we want that the saved changes in storage should not affect the sync protocol
+	firstHeads := fx.handlers["peer1"].tree().Heads()
+	secondHeads := fx.handlers["peer2"].tree().Heads()
+	require.True(t, slice.UnsortedEquals(firstHeads, secondHeads))
+	require.True(t, slice.UnsortedEquals(initialRes.heads, firstHeads))
+}
+
+func testTreeStorageHasExtraThreeParts(t *testing.T, levels, perLevel int, hasData bool, isSnapshot func() bool) {
+	treeId := "treeId"
+	spaceId := "spaceId"
+	keys, err := accountdata.NewRandom()
+	require.NoError(t, err)
+	aclList, err := list.NewTestDerivedAcl(spaceId, keys)
+	storage := createStorage(treeId, aclList)
+	changeCreator := objecttree.NewMockChangeCreator()
+	builder := objecttree.BuildTestableTree
+	if hasData {
+		builder = objecttree.BuildEmptyDataTestableTree
+	}
+	params := genParams{
+		prefix:     "peer1",
+		aclId:      aclList.Id(),
+		startIdx:   0,
+		levels:     levels,
+		perLevel:   perLevel,
+		snapshotId: treeId,
+		prevHeads:  []string{treeId},
+		isSnapshot: isSnapshot,
+		hasData:    hasData,
+	}
+	deps := fixtureDeps{
+		aclList:     aclList,
+		initStorage: storage.(*treestorage.InMemoryTreeStorage),
+		connectionMap: map[string][]string{
+			"peer1": []string{"peer2"},
+			"peer2": []string{"peer1"},
+		},
+		treeBuilder: builder,
+	}
+	fx := newProtocolFixture(t, spaceId, deps)
+
+	// generating parts
+	firstPart := genChanges(changeCreator, params)
+	params.startIdx = levels
+	params.snapshotId = firstPart.snapshotId
+	params.prevHeads = firstPart.heads
+	secondPart := genChanges(changeCreator, params)
+	params.startIdx = levels * 2
+	params.snapshotId = secondPart.snapshotId
+	params.prevHeads = secondPart.heads
+	thirdPart := genChanges(changeCreator, params)
+
+	// adding part1 to first peer and saving part2 and part3 in its storage
+	res, _ := fx.handlers["peer1"].tree().AddRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   firstPart.heads,
+		RawChanges: firstPart.changes,
+	})
+	require.True(t, slice.UnsortedEquals(res.Heads, firstPart.heads))
+	store := fx.handlers["peer1"].tree().Storage().(*treestorage.InMemoryTreeStorage)
+	oldHeads, _ := store.Heads()
+	store.AddRawChangesSetHeads(secondPart.changes, oldHeads)
+	store.AddRawChangesSetHeads(thirdPart.changes, oldHeads)
+
+	var peer2Initial []*treechangeproto.RawTreeChangeWithId
+	peer2Initial = append(peer2Initial, firstPart.changes...)
+	peer2Initial = append(peer2Initial, secondPart.changes...)
+
+	// adding part1 and part2 to second peer
+	res, _ = fx.handlers["peer2"].tree().AddRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   secondPart.heads,
+		RawChanges: peer2Initial,
+	})
+	require.True(t, slice.UnsortedEquals(res.Heads, secondPart.heads))
+	fx.run(t)
+
+	// sending part3 changes to other peer
+	fx.handlers["peer2"].sendRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   thirdPart.heads,
+		RawChanges: thirdPart.changes,
+	})
+	time.Sleep(50 * time.Millisecond)
+	firstHeads := fx.handlers["peer1"].tree().Heads()
+	secondHeads := fx.handlers["peer2"].tree().Heads()
+	require.True(t, slice.UnsortedEquals(firstHeads, secondHeads))
+	require.True(t, slice.UnsortedEquals(thirdPart.heads, firstHeads))
+}

commonspace/object/tree/synctree/synctree.go

@@ -1,21 +1,23 @@
+//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anyproto/any-sync/commonspace/object/tree/synctree SyncTree,ReceiveQueue,HeadNotifiable
 package synctree
 
 import (
 	"context"
 	"errors"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/synctree/updatelistener"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anytypeio/any-sync/commonspace/objectsync"
-	"github.com/anytypeio/any-sync/commonspace/objectsync/synchandler"
-	spacestorage "github.com/anytypeio/any-sync/commonspace/spacestorage"
-	"github.com/anytypeio/any-sync/commonspace/syncstatus"
-	"github.com/anytypeio/any-sync/net/peer"
-	"github.com/anytypeio/any-sync/nodeconf"
+	"time"
+
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/commonspace/objectsync"
+	"github.com/anyproto/any-sync/commonspace/objectsync/synchandler"
+	"github.com/anyproto/any-sync/commonspace/spacestorage"
+	"github.com/anyproto/any-sync/commonspace/syncstatus"
+	"github.com/anyproto/any-sync/net/peer"
+	"github.com/anyproto/any-sync/nodeconf"
 	"go.uber.org/zap"
-	"sync/atomic"
 )
 
 var (
@@ -42,19 +44,16 @@ type SyncTree interface {
 type syncTree struct {
 	objecttree.ObjectTree
 	synchandler.SyncHandler
-	syncClient SyncClient
+	syncClient objectsync.SyncClient
 	syncStatus syncstatus.StatusUpdater
 	notifiable HeadNotifiable
 	listener   updatelistener.UpdateListener
-	treeUsage  *atomic.Int32
+	onClose    func(id string)
 	isClosed   bool
 	isDeleted  bool
 }
 
-var log = logger.NewNamed("commonspace.synctree")
-
-var buildObjectTree = objecttree.BuildObjectTree
-var createSyncClient = newSyncClient
+var log = logger.NewNamed("common.commonspace.synctree")
 
 type ResponsiblePeersGetter interface {
 	GetResponsiblePeers(ctx context.Context) (peers []peer.Peer, err error)
@@ -62,26 +61,30 @@ type ResponsiblePeersGetter interface {
 
 type BuildDeps struct {
 	SpaceId            string
-	ObjectSync         objectsync.ObjectSync
-	Configuration      nodeconf.Configuration
+	SyncClient         objectsync.SyncClient
+	Configuration      nodeconf.NodeConf
 	HeadNotifiable     HeadNotifiable
 	Listener           updatelistener.UpdateListener
 	AclList            list.AclList
 	SpaceStorage       spacestorage.SpaceStorage
 	TreeStorage        treestorage.TreeStorage
-	TreeUsage          *atomic.Int32
+	OnClose            func(id string)
 	SyncStatus         syncstatus.StatusUpdater
 	PeerGetter         ResponsiblePeersGetter
+	BuildObjectTree    objecttree.BuildObjectTreeFunc
 	WaitTreeRemoteSync bool
 }
 
 func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t SyncTree, err error) {
-	remoteGetter := treeRemoteGetter{treeId: id, deps: deps}
-	deps.TreeStorage, err = remoteGetter.getTree(ctx)
+	var (
+		remoteGetter = treeRemoteGetter{treeId: id, deps: deps}
+		isRemote     bool
+	)
+	deps.TreeStorage, isRemote, err = remoteGetter.getTree(ctx)
 	if err != nil {
 		return
 	}
-	return buildSyncTree(ctx, true, deps)
+	return buildSyncTree(ctx, isRemote, deps)
 }
 
 func PutSyncTree(ctx context.Context, payload treestorage.TreeStorageCreatePayload, deps BuildDeps) (t SyncTree, err error) {
@@ -92,37 +95,31 @@ func PutSyncTree(ctx context.Context, payload treestorage.TreeStorageCreatePaylo
 	return buildSyncTree(ctx, true, deps)
 }
 
-func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t SyncTree, err error) {
-	objTree, err := buildObjectTree(deps.TreeStorage, deps.AclList)
+func buildSyncTree(ctx context.Context, sendUpdate bool, deps BuildDeps) (t SyncTree, err error) {
+	objTree, err := deps.BuildObjectTree(deps.TreeStorage, deps.AclList)
 	if err != nil {
 		return
 	}
-	syncClient := createSyncClient(
-		deps.SpaceId,
-		deps.ObjectSync.MessagePool(),
-		sharedFactory,
-		deps.Configuration)
+	syncClient := deps.SyncClient
 	syncTree := &syncTree{
 		ObjectTree: objTree,
 		syncClient: syncClient,
 		notifiable: deps.HeadNotifiable,
-		treeUsage:  deps.TreeUsage,
+		onClose:    deps.OnClose,
 		listener:   deps.Listener,
 		syncStatus: deps.SyncStatus,
 	}
-	syncHandler := newSyncTreeHandler(syncTree, syncClient, deps.SyncStatus)
+	syncHandler := newSyncTreeHandler(deps.SpaceId, syncTree, syncClient, deps.SyncStatus)
 	syncTree.SyncHandler = syncHandler
 	t = syncTree
 	syncTree.Lock()
 	syncTree.afterBuild()
 	syncTree.Unlock()
 
-	if isFirstBuild {
+	if sendUpdate {
 		headUpdate := syncTree.syncClient.CreateHeadUpdate(t, nil)
 		// send to everybody, because everybody should know that the node or client got new tree
-		if e := syncTree.syncClient.Broadcast(ctx, headUpdate); e != nil {
-			log.ErrorCtx(ctx, "broadcast error", zap.Error(e))
-		}
+		syncTree.syncClient.Broadcast(ctx, headUpdate)
 	}
 	return
 }
@@ -159,7 +156,7 @@ func (s *syncTree) AddContent(ctx context.Context, content objecttree.SignableCh
 	}
 	s.syncStatus.HeadsChange(s.Id(), res.Heads)
 	headUpdate := s.syncClient.CreateHeadUpdate(s, res.Added)
-	err = s.syncClient.Broadcast(ctx, headUpdate)
+	s.syncClient.Broadcast(ctx, headUpdate)
 	return
 }
 
@@ -186,13 +183,16 @@ func (s *syncTree) AddRawChanges(ctx context.Context, changesPayload objecttree.
 			s.notifiable.UpdateHeads(s.Id(), res.Heads)
 		}
 		headUpdate := s.syncClient.CreateHeadUpdate(s, res.Added)
-		err = s.syncClient.Broadcast(ctx, headUpdate)
+		s.syncClient.Broadcast(ctx, headUpdate)
 	}
 	return
 }
 
 func (s *syncTree) Delete() (err error) {
-	log.With(zap.String("id", s.Id())).Debug("deleting sync tree")
+	log.Debug("deleting sync tree", zap.String("id", s.Id()))
+	defer func() {
+		log.Debug("deleted sync tree", zap.Error(err), zap.String("id", s.Id()))
+	}()
 	s.Lock()
 	defer s.Unlock()
 	if err = s.checkAlive(); err != nil {
@@ -206,14 +206,21 @@ func (s *syncTree) Delete() (err error) {
 	return
 }
 
+func (s *syncTree) TryClose(objectTTL time.Duration) (bool, error) {
+	return true, s.Close()
+}
+
 func (s *syncTree) Close() (err error) {
-	log.With(zap.String("id", s.Id())).Debug("closing sync tree")
+	log.Debug("closing sync tree", zap.String("id", s.Id()))
+	defer func() {
+		log.Debug("closed sync tree", zap.Error(err), zap.String("id", s.Id()))
+	}()
 	s.Lock()
 	defer s.Unlock()
 	if s.isClosed {
 		return ErrSyncTreeClosed
 	}
-	s.treeUsage.Add(-1)
+	s.onClose(s.Id())
 	s.isClosed = true
 	return
 }
@@ -232,14 +239,13 @@ func (s *syncTree) SyncWithPeer(ctx context.Context, peerId string) (err error)
 	s.Lock()
 	defer s.Unlock()
 	headUpdate := s.syncClient.CreateHeadUpdate(s, nil)
-	return s.syncClient.SendWithReply(ctx, peerId, headUpdate, "")
+	return s.syncClient.SendWithReply(ctx, peerId, headUpdate.RootChange.Id, headUpdate, "")
 }
 
 func (s *syncTree) afterBuild() {
 	if s.listener != nil {
 		s.listener.Rebuild(s)
 	}
-	s.treeUsage.Add(1)
 	if s.notifiable != nil {
 		s.notifiable.UpdateHeads(s.Id(), s.Heads())
 	}

commonspace/object/tree/synctree/synctree_test.go

@@ -2,15 +2,15 @@ package synctree
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree/mock_objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/synctree/mock_synctree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/synctree/updatelistener"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/synctree/updatelistener/mock_updatelistener"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/objectsync"
-	"github.com/anytypeio/any-sync/commonspace/syncstatus"
-	"github.com/anytypeio/any-sync/nodeconf"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree/mock_objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener"
+	"github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener/mock_updatelistener"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/objectsync"
+	"github.com/anyproto/any-sync/commonspace/objectsync/mock_objectsync"
+	"github.com/anyproto/any-sync/commonspace/syncstatus"
+	"github.com/anyproto/any-sync/nodeconf"
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 	"testing"
@@ -18,7 +18,7 @@ import (
 
 type syncTreeMatcher struct {
 	objTree  objecttree.ObjectTree
-	client   SyncClient
+	client   objectsync.SyncClient
 	listener updatelistener.UpdateListener
 }
 
@@ -34,8 +34,8 @@ func (s syncTreeMatcher) String() string {
 	return ""
 }
 
-func syncClientFuncCreator(client SyncClient) func(spaceId string, factory RequestFactory, objectSync objectsync.ObjectSync, configuration nodeconf.Configuration) SyncClient {
-	return func(spaceId string, factory RequestFactory, objectSync objectsync.ObjectSync, configuration nodeconf.Configuration) SyncClient {
+func syncClientFuncCreator(client objectsync.SyncClient) func(spaceId string, factory objectsync.RequestFactory, objectSync objectsync.ObjectSync, configuration nodeconf.NodeConf) objectsync.SyncClient {
+	return func(spaceId string, factory objectsync.RequestFactory, objectSync objectsync.ObjectSync, configuration nodeconf.NodeConf) objectsync.SyncClient {
 		return client
 	}
 }
@@ -46,7 +46,7 @@ func Test_BuildSyncTree(t *testing.T) {
 	defer ctrl.Finish()
 
 	updateListenerMock := mock_updatelistener.NewMockUpdateListener(ctrl)
-	syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
+	syncClientMock := mock_objectsync.NewMockSyncClient(ctrl)
 	objTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
 	tr := &syncTree{
 		ObjectTree:  objTreeMock,
@@ -73,7 +73,7 @@ func Test_BuildSyncTree(t *testing.T) {
 		updateListenerMock.EXPECT().Update(tr)
 
 		syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), gomock.Eq(changes)).Return(headUpdate)
-		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate)).Return(nil)
+		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate))
 		res, err := tr.AddRawChanges(ctx, payload)
 		require.NoError(t, err)
 		require.Equal(t, expectedRes, res)
@@ -95,7 +95,7 @@ func Test_BuildSyncTree(t *testing.T) {
 		updateListenerMock.EXPECT().Rebuild(tr)
 
 		syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), gomock.Eq(changes)).Return(headUpdate)
-		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate)).Return(nil)
+		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate))
 		res, err := tr.AddRawChanges(ctx, payload)
 		require.NoError(t, err)
 		require.Equal(t, expectedRes, res)
@@ -133,7 +133,7 @@ func Test_BuildSyncTree(t *testing.T) {
 			Return(expectedRes, nil)
 
 		syncClientMock.EXPECT().CreateHeadUpdate(gomock.Eq(tr), gomock.Eq(changes)).Return(headUpdate)
-		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate)).Return(nil)
+		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate))
 		res, err := tr.AddContent(ctx, content)
 		require.NoError(t, err)
 		require.Equal(t, expectedRes, res)

commonspace/object/tree/synctree/synctreehandler.go

@@ -2,12 +2,13 @@ package synctree
 
 import (
 	"context"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/objectsync/synchandler"
-	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
-	"github.com/anytypeio/any-sync/commonspace/syncstatus"
-	"github.com/anytypeio/any-sync/util/slice"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/objectsync"
+	"github.com/anyproto/any-sync/commonspace/objectsync/synchandler"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/commonspace/syncstatus"
+	"github.com/anyproto/any-sync/util/slice"
 	"github.com/gogo/protobuf/proto"
 	"go.uber.org/zap"
 	"sync"
@@ -15,19 +16,21 @@ import (
 
 type syncTreeHandler struct {
 	objTree     objecttree.ObjectTree
-	syncClient  SyncClient
+	syncClient  objectsync.SyncClient
 	syncStatus  syncstatus.StatusUpdater
 	handlerLock sync.Mutex
+	spaceId     string
 	queue       ReceiveQueue
 }
 
 const maxQueueSize = 5
 
-func newSyncTreeHandler(objTree objecttree.ObjectTree, syncClient SyncClient, syncStatus syncstatus.StatusUpdater) synchandler.SyncHandler {
+func newSyncTreeHandler(spaceId string, objTree objecttree.ObjectTree, syncClient objectsync.SyncClient, syncStatus syncstatus.StatusUpdater) synchandler.SyncHandler {
 	return &syncTreeHandler{
 		objTree:    objTree,
 		syncClient: syncClient,
 		syncStatus: syncStatus,
+		spaceId:    spaceId,
 		queue:      newReceiveQueue(maxQueueSize),
 	}
 }
@@ -38,7 +41,6 @@ func (s *syncTreeHandler) HandleMessage(ctx context.Context, senderId string, ms
 	if err != nil {
 		return
 	}
-
 	s.syncStatus.HeadsReceive(senderId, msg.ObjectId, treechangeproto.GetHeads(unmarshalled))
 
 	queueFull := s.queue.AddMessage(senderId, unmarshalled, msg.RequestId)
@@ -80,15 +82,21 @@ func (s *syncTreeHandler) handleHeadUpdate(
 		fullRequest   *treechangeproto.TreeSyncMessage
 		isEmptyUpdate = len(update.Changes) == 0
 		objTree       = s.objTree
+		treeId        = objTree.Id()
 	)
-
-	log := log.With(zap.Strings("heads", objTree.Heads()), zap.String("treeId", objTree.Id()))
+	log := log.With(
+		zap.Strings("update heads", update.Heads),
+		zap.String("treeId", treeId),
+		zap.String("spaceId", s.spaceId),
+		zap.Int("len(update changes)", len(update.Changes)))
 	log.DebugCtx(ctx, "received head update message")
 
 	defer func() {
 		if err != nil {
-			log.With(zap.Error(err)).Debug("head update finished with error")
+			log.ErrorCtx(ctx, "head update finished with error", zap.Error(err))
 		} else if fullRequest != nil {
+			cnt := fullRequest.Content.GetFullSyncRequest()
+			log = log.With(zap.Strings("request heads", cnt.Heads), zap.Int("len(request changes)", len(cnt.Changes)))
 			log.DebugCtx(ctx, "sending full sync request")
 		} else {
 			if !isEmptyUpdate {
@@ -99,7 +107,6 @@ func (s *syncTreeHandler) handleHeadUpdate(
 
 	// isEmptyUpdate is sent when the tree is brought up from cache
 	if isEmptyUpdate {
-
 		headEquals := slice.UnsortedEquals(objTree.Heads(), update.Heads)
 		log.DebugCtx(ctx, "is empty update", zap.String("treeId", objTree.Id()), zap.Bool("headEquals", headEquals))
 		if headEquals {
@@ -112,7 +119,7 @@ func (s *syncTreeHandler) handleHeadUpdate(
 			return
 		}
 
-		return s.syncClient.SendWithReply(ctx, senderId, fullRequest, replyId)
+		return s.syncClient.SendWithReply(ctx, senderId, treeId, fullRequest, replyId)
 	}
 
 	if s.alreadyHasHeads(objTree, update.Heads) {
@@ -136,7 +143,7 @@ func (s *syncTreeHandler) handleHeadUpdate(
 		return
 	}
 
-	return s.syncClient.SendWithReply(ctx, senderId, fullRequest, replyId)
+	return s.syncClient.SendWithReply(ctx, senderId, treeId, fullRequest, replyId)
 }
 
 func (s *syncTreeHandler) handleFullSyncRequest(
@@ -148,18 +155,25 @@ func (s *syncTreeHandler) handleFullSyncRequest(
 		fullResponse *treechangeproto.TreeSyncMessage
 		header       = s.objTree.Header()
 		objTree      = s.objTree
+		treeId       = s.objTree.Id()
 	)
 
-	log := log.With(zap.String("senderId", senderId), zap.Strings("heads", request.Heads), zap.String("treeId", s.objTree.Id()), zap.String("replyId", replyId))
+	log := log.With(zap.String("senderId", senderId),
+		zap.Strings("request heads", request.Heads),
+		zap.String("treeId", treeId),
+		zap.String("replyId", replyId),
+		zap.String("spaceId", s.spaceId),
+		zap.Int("len(request changes)", len(request.Changes)))
 	log.DebugCtx(ctx, "received full sync request message")
 
 	defer func() {
 		if err != nil {
-			log.With(zap.Error(err)).DebugCtx(ctx, "full sync request finished with error")
-
-			s.syncClient.SendWithReply(ctx, senderId, treechangeproto.WrapError(err, header), replyId)
+			log.ErrorCtx(ctx, "full sync request finished with error", zap.Error(err))
+			s.syncClient.SendWithReply(ctx, senderId, treeId, treechangeproto.WrapError(treechangeproto.ErrFullSync, header), replyId)
 			return
 		} else if fullResponse != nil {
+			cnt := fullResponse.Content.GetFullSyncResponse()
+			log = log.With(zap.Strings("response heads", cnt.Heads), zap.Int("len(response changes)", len(cnt.Changes)))
 			log.DebugCtx(ctx, "full sync response sent")
 		}
 	}()
@@ -178,7 +192,7 @@ func (s *syncTreeHandler) handleFullSyncRequest(
 		return
 	}
 
-	return s.syncClient.SendWithReply(ctx, senderId, fullResponse, replyId)
+	return s.syncClient.SendWithReply(ctx, senderId, treeId, fullResponse, replyId)
 }
 
 func (s *syncTreeHandler) handleFullSyncResponse(
@@ -187,13 +201,18 @@ func (s *syncTreeHandler) handleFullSyncResponse(
 	response *treechangeproto.TreeFullSyncResponse) (err error) {
 	var (
 		objTree = s.objTree
+		treeId  = s.objTree.Id()
 	)
-	log := log.With(zap.Strings("heads", response.Heads), zap.String("treeId", s.objTree.Id()))
+	log := log.With(
+		zap.Strings("heads", response.Heads),
+		zap.String("treeId", treeId),
+		zap.String("spaceId", s.spaceId),
+		zap.Int("len(changes)", len(response.Changes)))
 	log.DebugCtx(ctx, "received full sync response message")
 
 	defer func() {
 		if err != nil {
-			log.With(zap.Error(err)).DebugCtx(ctx, "full sync response failed")
+			log.ErrorCtx(ctx, "full sync response failed", zap.Error(err))
 		} else {
 			log.DebugCtx(ctx, "full sync response succeeded")
 		}

commonspace/object/tree/synctree/synctreehandler_test.go

@@ -3,22 +3,24 @@ package synctree
 import (
 	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/app/logger"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree/mock_objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/synctree/mock_synctree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/syncstatus"
+	"github.com/anyproto/any-sync/commonspace/objectsync"
+	"github.com/anyproto/any-sync/commonspace/objectsync/mock_objectsync"
+	"sync"
+	"testing"
+
+	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree/mock_objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/syncstatus"
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
-	"sync"
-	"testing"
 )
 
 type testObjTreeMock struct {
 	*mock_objecttree.MockObjectTree
-	m sync.Mutex
+	m sync.RWMutex
 }
 
 func newTestObjMock(mockTree *mock_objecttree.MockObjectTree) *testObjTreeMock {
@@ -31,13 +33,29 @@ func (t *testObjTreeMock) Lock() {
 	t.m.Lock()
 }
 
+func (t *testObjTreeMock) RLock() {
+	t.m.RLock()
+}
+
 func (t *testObjTreeMock) Unlock() {
 	t.m.Unlock()
 }
 
+func (t *testObjTreeMock) RUnlock() {
+	t.m.RUnlock()
+}
+
+func (t *testObjTreeMock) TryLock() bool {
+	return t.m.TryLock()
+}
+
+func (t *testObjTreeMock) TryRLock() bool {
+	return t.m.TryRLock()
+}
+
 type syncHandlerFixture struct {
 	ctrl             *gomock.Controller
-	syncClientMock   *mock_synctree.MockSyncClient
+	syncClientMock   *mock_objectsync.MockSyncClient
 	objectTreeMock   *testObjTreeMock
 	receiveQueueMock ReceiveQueue
 
@@ -46,7 +64,7 @@ type syncHandlerFixture struct {
 
 func newSyncHandlerFixture(t *testing.T) *syncHandlerFixture {
 	ctrl := gomock.NewController(t)
-	syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
+	syncClientMock := mock_objectsync.NewMockSyncClient(ctrl)
 	objectTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
 	receiveQueue := newReceiveQueue(5)
 
@@ -72,6 +90,13 @@ func (fx *syncHandlerFixture) stop() {
 func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 	ctx := context.Background()
 	log = logger.CtxLogger{Logger: zap.NewNop()}
+	fullRequest := &treechangeproto.TreeSyncMessage{
+		Content: &treechangeproto.TreeSyncContentValue{
+			Value: &treechangeproto.TreeSyncContentValue_FullSyncRequest{
+				FullSyncRequest: &treechangeproto.TreeFullSyncRequest{},
+			},
+		},
+	}
 
 	t.Run("head update non empty all heads added", func(t *testing.T) {
 		fx := newSyncHandlerFixture(t)
@@ -85,7 +110,7 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).Times(2)
@@ -96,7 +121,6 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 				RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
 			})).
 			Return(objecttree.AddResult{}, nil)
-		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2", "h1"})
 		fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(true)
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
@@ -115,8 +139,7 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
-		fullRequest := &treechangeproto.TreeSyncMessage{}
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).AnyTimes()
@@ -131,7 +154,7 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 		fx.syncClientMock.EXPECT().
 			CreateFullSyncRequest(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
 			Return(fullRequest, nil)
-		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullRequest), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(treeId), gomock.Eq(fullRequest), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -149,7 +172,7 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h1"}).AnyTimes()
@@ -170,15 +193,14 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
-		fullRequest := &treechangeproto.TreeSyncMessage{}
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).AnyTimes()
 		fx.syncClientMock.EXPECT().
 			CreateFullSyncRequest(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
 			Return(fullRequest, nil)
-		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullRequest), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(treeId), gomock.Eq(fullRequest), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -196,7 +218,7 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h1"}).AnyTimes()
@@ -209,6 +231,13 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 	ctx := context.Background()
 	log = logger.CtxLogger{Logger: zap.NewNop()}
+	fullResponse := &treechangeproto.TreeSyncMessage{
+		Content: &treechangeproto.TreeSyncContentValue{
+			Value: &treechangeproto.TreeSyncContentValue_FullSyncResponse{
+				FullSyncResponse: &treechangeproto.TreeFullSyncResponse{},
+			},
+		},
+	}
 
 	t.Run("full sync request with change", func(t *testing.T) {
 		fx := newSyncHandlerFixture(t)
@@ -222,8 +251,7 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullRequest(fullSyncRequest, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
-		fullResponse := &treechangeproto.TreeSyncMessage{}
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Header().Return(nil)
@@ -238,7 +266,7 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 		fx.syncClientMock.EXPECT().
 			CreateFullSyncResponse(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
 			Return(fullResponse, nil)
-		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullResponse), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(treeId), gomock.Eq(fullResponse), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -256,8 +284,7 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullRequest(fullSyncRequest, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
-		fullResponse := &treechangeproto.TreeSyncMessage{}
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().
 			Id().AnyTimes().Return(treeId)
@@ -268,7 +295,7 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 		fx.syncClientMock.EXPECT().
 			CreateFullSyncResponse(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
 			Return(fullResponse, nil)
-		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullResponse), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(treeId), gomock.Eq(fullResponse), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -286,9 +313,8 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullRequest(fullSyncRequest, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 		objectMsg.RequestId = replyId
-		fullResponse := &treechangeproto.TreeSyncMessage{}
 
 		fx.objectTreeMock.EXPECT().
 			Id().AnyTimes().Return(treeId)
@@ -296,7 +322,7 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 		fx.syncClientMock.EXPECT().
 			CreateFullSyncResponse(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
 			Return(fullResponse, nil)
-		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullResponse), gomock.Eq(replyId))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(treeId), gomock.Eq(fullResponse), gomock.Eq(replyId))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -314,7 +340,7 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullRequest(fullSyncRequest, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().
 			Id().AnyTimes().Return(treeId)
@@ -331,7 +357,7 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 				RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
 			})).
 			Return(objecttree.AddResult{}, fmt.Errorf(""))
-		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Any(), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(treeId), gomock.Any(), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.Error(t, err)
@@ -355,7 +381,7 @@ func TestSyncHandler_HandleFullSyncResponse(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullResponse(fullSyncResponse, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, replyId)
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, replyId)
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().
@@ -388,7 +414,7 @@ func TestSyncHandler_HandleFullSyncResponse(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullResponse(fullSyncResponse, chWithId)
-		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, replyId)
+		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, replyId)
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().

commonspace/object/tree/synctree/treeremotegetter.go

@@ -3,11 +3,12 @@ package synctree
 import (
 	"context"
 	"fmt"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anytypeio/any-sync/commonspace/spacestorage"
-	"github.com/anytypeio/any-sync/net/peer"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/commonspace/spacestorage"
+	"github.com/anyproto/any-sync/net/peer"
+	"github.com/anyproto/any-sync/net/rpc/rpcerr"
 	"github.com/gogo/protobuf/proto"
 	"go.uber.org/zap"
 	"time"
@@ -45,13 +46,8 @@ func (t treeRemoteGetter) getPeers(ctx context.Context) (peerIds []string, err e
 }
 
 func (t treeRemoteGetter) treeRequest(ctx context.Context, peerId string) (msg *treechangeproto.TreeSyncMessage, err error) {
-	newTreeRequest := GetRequestFactory().CreateNewTreeRequest()
-	objMsg, err := marshallTreeMessage(newTreeRequest, t.deps.SpaceId, t.treeId, "")
-	if err != nil {
-		return
-	}
-
-	resp, err := t.deps.ObjectSync.MessagePool().SendSync(ctx, peerId, objMsg)
+	newTreeRequest := t.deps.SyncClient.CreateNewTreeRequest()
+	resp, err := t.deps.SyncClient.SendSync(ctx, peerId, t.treeId, newTreeRequest)
 	if err != nil {
 		return
 	}
@@ -94,12 +90,11 @@ Loop:
 	}
 }
 
-func (t treeRemoteGetter) getTree(ctx context.Context) (treeStorage treestorage.TreeStorage, err error) {
+func (t treeRemoteGetter) getTree(ctx context.Context) (treeStorage treestorage.TreeStorage, isRemote bool, err error) {
 	treeStorage, err = t.deps.SpaceStorage.TreeStorage(t.treeId)
 	if err == nil {
 		return
 	}
-
 	if err != nil && err != treestorage.ErrUnknownTreeId {
 		return
 	}
@@ -113,13 +108,21 @@ func (t treeRemoteGetter) getTree(ctx context.Context) (treeStorage treestorage.
 		return
 	}
 
+	isRemote = true
 	resp, err := t.treeRequestLoop(ctx, t.deps.WaitTreeRemoteSync)
 	if err != nil {
 		return
 	}
-	if resp.GetContent().GetFullSyncResponse() == nil {
-		err = fmt.Errorf("expected to get full sync response, but got something else")
+	switch {
+	case resp.GetContent().GetErrorResponse() != nil:
+		errResp := resp.GetContent().GetErrorResponse()
+		err = rpcerr.Err(errResp.ErrCode)
 		return
+	case resp.GetContent().GetFullSyncResponse() == nil:
+		err = treechangeproto.ErrUnexpected
+		return
+	default:
+		break
 	}
 	fullSyncResp := resp.GetContent().GetFullSyncResponse()
 
@@ -136,5 +139,6 @@ func (t treeRemoteGetter) getTree(ctx context.Context) (treeStorage treestorage.
 		return
 	}
 	// now we are sure that we can save it to the storage
-	return t.deps.SpaceStorage.CreateTreeStorage(payload)
+	treeStorage, err = t.deps.SpaceStorage.CreateTreeStorage(payload)
+	return
 }

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/any-sync/commonspace/object/tree/synctree/updatelistener (interfaces: UpdateListener)
+// Source: github.com/anyproto/any-sync/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"
 
-	objecttree "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
+	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
 	gomock "github.com/golang/mock/gomock"
 )
 

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

@@ -1,8 +1,8 @@
-//go:generate mockgen -destination mock_updatelistener/mock_updatelistener.go github.com/anytypeio/any-sync/commonspace/object/tree/synctree/updatelistener UpdateListener
+//go:generate mockgen -destination mock_updatelistener/mock_updatelistener.go github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener UpdateListener
 package updatelistener
 
 import (
-	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
 )
 
 type UpdateListener interface {

commonspace/object/tree/synctree/utils_test.go

@@ -0,0 +1,456 @@
+package synctree
+
+import (
+	"context"
+	"fmt"
+	"github.com/anyproto/any-sync/commonspace/object/acl/list"
+	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anyproto/any-sync/commonspace/objectsync"
+	"github.com/anyproto/any-sync/commonspace/objectsync/synchandler"
+	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"github.com/anyproto/any-sync/commonspace/syncstatus"
+	"github.com/anyproto/any-sync/net/peer"
+	"github.com/cheggaaa/mb/v3"
+	"github.com/gogo/protobuf/proto"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/exp/slices"
+	"math/rand"
+	"sync"
+	"testing"
+	"time"
+)
+
+// protocolMsg is a message used in sync protocol tests
+type protocolMsg struct {
+	msg        *spacesyncproto.ObjectSyncMessage
+	senderId   string
+	receiverId string
+	userMsg    *objecttree.RawChangesPayload
+}
+
+// msgDescription is a representation of message used for checking the results of the test
+type msgDescription struct {
+	name    string
+	from    string
+	to      string
+	heads   []string
+	changes []*treechangeproto.RawTreeChangeWithId
+}
+
+func (p *protocolMsg) description() (descr msgDescription) {
+	unmarshalled := &treechangeproto.TreeSyncMessage{}
+	err := proto.Unmarshal(p.msg.Payload, unmarshalled)
+	if err != nil {
+		panic(err)
+	}
+	descr = msgDescription{
+		from: p.senderId,
+		to:   p.receiverId,
+	}
+	switch {
+	case unmarshalled.GetContent().GetHeadUpdate() != nil:
+		cnt := unmarshalled.GetContent().GetHeadUpdate()
+		descr.name = "HeadUpdate"
+		descr.heads = cnt.Heads
+		descr.changes = unmarshalled.GetContent().GetHeadUpdate().Changes
+	case unmarshalled.GetContent().GetFullSyncRequest() != nil:
+		cnt := unmarshalled.GetContent().GetFullSyncRequest()
+		descr.name = "FullSyncRequest"
+		descr.heads = cnt.Heads
+		descr.changes = unmarshalled.GetContent().GetFullSyncRequest().Changes
+	case unmarshalled.GetContent().GetFullSyncResponse() != nil:
+		cnt := unmarshalled.GetContent().GetFullSyncResponse()
+		descr.name = "FullSyncResponse"
+		descr.heads = cnt.Heads
+		descr.changes = unmarshalled.GetContent().GetFullSyncResponse().Changes
+	}
+	return
+}
+
+// messageLog saves all messages that were sent during sync test
+type messageLog struct {
+	batcher *mb.MB[protocolMsg]
+}
+
+func newMessageLog() *messageLog {
+	return &messageLog{batcher: mb.New[protocolMsg](0)}
+}
+
+func (m *messageLog) addMessage(msg protocolMsg) {
+	m.batcher.Add(context.Background(), msg)
+}
+
+// testSyncHandler is the wrapper around individual tree to test sync protocol
+type testSyncHandler struct {
+	synchandler.SyncHandler
+	batcher    *mb.MB[protocolMsg]
+	peerId     string
+	aclList    list.AclList
+	log        *messageLog
+	syncClient objectsync.SyncClient
+	builder    objecttree.BuildObjectTreeFunc
+}
+
+// createSyncHandler creates a sync handler when a tree is already created
+func createSyncHandler(peerId, spaceId string, objTree objecttree.ObjectTree, log *messageLog) *testSyncHandler {
+	factory := objectsync.NewRequestFactory()
+	syncClient := objectsync.NewSyncClient(spaceId, newTestMessagePool(peerId, log), factory)
+	netTree := &broadcastTree{
+		ObjectTree: objTree,
+		SyncClient: syncClient,
+	}
+	handler := newSyncTreeHandler(spaceId, netTree, syncClient, syncstatus.NewNoOpSyncStatus())
+	return newTestSyncHandler(peerId, handler)
+}
+
+// createEmptySyncHandler creates a sync handler when the tree will be provided later (this emulates the situation when we have no tree)
+func createEmptySyncHandler(peerId, spaceId string, builder objecttree.BuildObjectTreeFunc, aclList list.AclList, log *messageLog) *testSyncHandler {
+	factory := objectsync.NewRequestFactory()
+	syncClient := objectsync.NewSyncClient(spaceId, newTestMessagePool(peerId, log), factory)
+
+	batcher := mb.New[protocolMsg](0)
+	return &testSyncHandler{
+		batcher:    batcher,
+		peerId:     peerId,
+		aclList:    aclList,
+		log:        log,
+		syncClient: syncClient,
+		builder:    builder,
+	}
+}
+
+func newTestSyncHandler(peerId string, syncHandler synchandler.SyncHandler) *testSyncHandler {
+	batcher := mb.New[protocolMsg](0)
+	return &testSyncHandler{
+		SyncHandler: syncHandler,
+		batcher:     batcher,
+		peerId:      peerId,
+	}
+}
+
+func (h *testSyncHandler) HandleMessage(ctx context.Context, senderId string, request *spacesyncproto.ObjectSyncMessage) (err error) {
+	if h.SyncHandler != nil {
+		return h.SyncHandler.HandleMessage(ctx, senderId, request)
+	}
+	unmarshalled := &treechangeproto.TreeSyncMessage{}
+	err = proto.Unmarshal(request.Payload, unmarshalled)
+	if err != nil {
+		return
+	}
+	if unmarshalled.Content.GetFullSyncResponse() == nil {
+		newTreeRequest := objectsync.NewRequestFactory().CreateNewTreeRequest()
+		var objMsg *spacesyncproto.ObjectSyncMessage
+		objMsg, err = objectsync.MarshallTreeMessage(newTreeRequest, request.SpaceId, request.ObjectId, "")
+		if err != nil {
+			return
+		}
+		return h.manager().SendPeer(context.Background(), senderId, objMsg)
+	}
+	fullSyncResponse := unmarshalled.Content.GetFullSyncResponse()
+	treeStorage, _ := treestorage.NewInMemoryTreeStorage(unmarshalled.RootChange, []string{unmarshalled.RootChange.Id}, nil)
+	tree, err := h.builder(treeStorage, h.aclList)
+	if err != nil {
+		return
+	}
+	netTree := &broadcastTree{
+		ObjectTree: tree,
+		SyncClient: h.syncClient,
+	}
+	res, err := netTree.AddRawChanges(context.Background(), objecttree.RawChangesPayload{
+		NewHeads:   fullSyncResponse.Heads,
+		RawChanges: fullSyncResponse.Changes,
+	})
+	if err != nil {
+		return
+	}
+	h.SyncHandler = newSyncTreeHandler(request.SpaceId, netTree, h.syncClient, syncstatus.NewNoOpSyncStatus())
+	var objMsg *spacesyncproto.ObjectSyncMessage
+	newTreeRequest := objectsync.NewRequestFactory().CreateHeadUpdate(netTree, res.Added)
+	objMsg, err = objectsync.MarshallTreeMessage(newTreeRequest, request.SpaceId, request.ObjectId, "")
+	if err != nil {
+		return
+	}
+	return h.manager().Broadcast(context.Background(), objMsg)
+}
+
+func (h *testSyncHandler) manager() *testMessagePool {
+	if h.SyncHandler != nil {
+		return h.SyncHandler.(*syncTreeHandler).syncClient.MessagePool().(*testMessagePool)
+	}
+	return h.syncClient.MessagePool().(*testMessagePool)
+}
+
+func (h *testSyncHandler) tree() *broadcastTree {
+	return h.SyncHandler.(*syncTreeHandler).objTree.(*broadcastTree)
+}
+
+func (h *testSyncHandler) send(ctx context.Context, msg protocolMsg) (err error) {
+	return h.batcher.Add(ctx, msg)
+}
+
+func (h *testSyncHandler) sendRawChanges(ctx context.Context, changes objecttree.RawChangesPayload) {
+	h.batcher.Add(ctx, protocolMsg{userMsg: &changes})
+}
+
+func (h *testSyncHandler) run(ctx context.Context, t *testing.T, wg *sync.WaitGroup) {
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		for {
+			res, err := h.batcher.WaitOne(ctx)
+			if err != nil {
+				return
+			}
+			if res.userMsg != nil {
+				h.tree().Lock()
+				userRes, err := h.tree().AddRawChanges(ctx, *res.userMsg)
+				require.NoError(t, err)
+				fmt.Println("user add result", userRes.Heads)
+				h.tree().Unlock()
+				continue
+			}
+			err = h.HandleMessage(ctx, res.senderId, res.msg)
+			if err != nil {
+				fmt.Println("error handling message", err.Error())
+				continue
+			}
+		}
+	}()
+}
+
+// testMessagePool captures all other handlers and sends messages to them
+type testMessagePool struct {
+	peerId   string
+	handlers map[string]*testSyncHandler
+	log      *messageLog
+}
+
+func newTestMessagePool(peerId string, log *messageLog) *testMessagePool {
+	return &testMessagePool{handlers: map[string]*testSyncHandler{}, peerId: peerId, log: log}
+}
+
+func (m *testMessagePool) addHandler(peerId string, handler *testSyncHandler) {
+	m.handlers[peerId] = handler
+}
+
+func (m *testMessagePool) SendPeer(ctx context.Context, peerId string, msg *spacesyncproto.ObjectSyncMessage) (err error) {
+	pMsg := protocolMsg{
+		msg:        msg,
+		senderId:   m.peerId,
+		receiverId: peerId,
+	}
+	m.log.addMessage(pMsg)
+	return m.handlers[peerId].send(context.Background(), pMsg)
+}
+
+func (m *testMessagePool) Broadcast(ctx context.Context, msg *spacesyncproto.ObjectSyncMessage) (err error) {
+	for _, handler := range m.handlers {
+		pMsg := protocolMsg{
+			msg:        msg,
+			senderId:   m.peerId,
+			receiverId: handler.peerId,
+		}
+		m.log.addMessage(pMsg)
+		handler.send(context.Background(), pMsg)
+	}
+	return
+}
+
+func (m *testMessagePool) GetResponsiblePeers(ctx context.Context) (peers []peer.Peer, err error) {
+	panic("should not be called")
+}
+
+func (m *testMessagePool) LastUsage() time.Time {
+	panic("should not be called")
+}
+
+func (m *testMessagePool) HandleMessage(ctx context.Context, senderId string, request *spacesyncproto.ObjectSyncMessage) (err error) {
+	panic("should not be called")
+}
+
+func (m *testMessagePool) SendSync(ctx context.Context, peerId string, message *spacesyncproto.ObjectSyncMessage) (reply *spacesyncproto.ObjectSyncMessage, err error) {
+	panic("should not be called")
+}
+
+// broadcastTree is the tree that broadcasts changes to everyone when changes are added
+// it is a simplified version of SyncTree which is easier to use in the test environment
+type broadcastTree struct {
+	objecttree.ObjectTree
+	objectsync.SyncClient
+}
+
+func (b *broadcastTree) AddRawChanges(ctx context.Context, changes objecttree.RawChangesPayload) (objecttree.AddResult, error) {
+	res, err := b.ObjectTree.AddRawChanges(ctx, changes)
+	if err != nil {
+		return objecttree.AddResult{}, err
+	}
+	upd := b.SyncClient.CreateHeadUpdate(b.ObjectTree, res.Added)
+	b.SyncClient.Broadcast(ctx, upd)
+	return res, nil
+}
+
+func createStorage(treeId string, aclList list.AclList) treestorage.TreeStorage {
+	changeCreator := objecttree.NewMockChangeCreator()
+	st := changeCreator.CreateNewTreeStorage(treeId, aclList.Head().Id)
+	return st
+}
+
+func createTestTree(aclList list.AclList, storage treestorage.TreeStorage) (objecttree.ObjectTree, error) {
+	return objecttree.BuildEmptyDataTestableTree(storage, aclList)
+}
+
+type fixtureDeps struct {
+	aclList       list.AclList
+	initStorage   *treestorage.InMemoryTreeStorage
+	connectionMap map[string][]string
+	emptyTrees    []string
+	treeBuilder   objecttree.BuildObjectTreeFunc
+}
+
+// protocolFixture is the test environment for sync protocol tests
+type protocolFixture struct {
+	handlers map[string]*testSyncHandler
+	log      *messageLog
+	wg       *sync.WaitGroup
+	ctx      context.Context
+	cancel   context.CancelFunc
+}
+
+func newProtocolFixture(t *testing.T, spaceId string, deps fixtureDeps) *protocolFixture {
+	var (
+		handlers    = map[string]*testSyncHandler{}
+		log         = newMessageLog()
+		wg          = sync.WaitGroup{}
+		ctx, cancel = context.WithCancel(context.Background())
+	)
+
+	for peerId := range deps.connectionMap {
+		var handler *testSyncHandler
+		if slices.Contains(deps.emptyTrees, peerId) {
+			handler = createEmptySyncHandler(peerId, spaceId, deps.treeBuilder, deps.aclList, log)
+		} else {
+			stCopy := deps.initStorage.Copy()
+			testTree, err := deps.treeBuilder(stCopy, deps.aclList)
+			require.NoError(t, err)
+			handler = createSyncHandler(peerId, spaceId, testTree, log)
+		}
+		handlers[peerId] = handler
+	}
+	for peerId, connectionMap := range deps.connectionMap {
+		handler := handlers[peerId]
+		manager := handler.manager()
+		for _, connectionId := range connectionMap {
+			manager.addHandler(connectionId, handlers[connectionId])
+		}
+	}
+	return &protocolFixture{
+		handlers: handlers,
+		log:      log,
+		wg:       &wg,
+		ctx:      ctx,
+		cancel:   cancel,
+	}
+}
+
+func (p *protocolFixture) run(t *testing.T) {
+	for _, handler := range p.handlers {
+		handler.run(p.ctx, t, p.wg)
+	}
+}
+
+func (p *protocolFixture) stop() {
+	p.cancel()
+	p.wg.Wait()
+}
+
+// genParams is the parameters for genChanges
+type genParams struct {
+	// prefix is the prefix which is added to change id
+	prefix     string
+	aclId      string
+	startIdx   int
+	levels     int
+	perLevel   int
+	snapshotId string
+	prevHeads  []string
+	isSnapshot func() bool
+	hasData    bool
+}
+
+// genResult is the result of genChanges
+type genResult struct {
+	changes    []*treechangeproto.RawTreeChangeWithId
+	heads      []string
+	snapshotId string
+}
+
+// genChanges generates several levels of tree changes where each level is connected only with previous one
+func genChanges(creator *objecttree.MockChangeCreator, params genParams) (res genResult) {
+	src := rand.NewSource(time.Now().Unix())
+	rnd := rand.New(src)
+	var (
+		prevHeads  []string
+		snapshotId = params.snapshotId
+	)
+	prevHeads = append(prevHeads, params.prevHeads...)
+
+	for i := 0; i < params.levels; i++ {
+		var (
+			newHeads []string
+			usedIds  = map[string]struct{}{}
+		)
+		newChange := func(isSnapshot bool, idx int, prevIds []string) string {
+			newId := fmt.Sprintf("%s.%d.%d", params.prefix, params.startIdx+i, idx)
+			var data []byte
+			if params.hasData {
+				data = []byte(newId)
+			}
+			newCh := creator.CreateRawWithData(newId, params.aclId, snapshotId, isSnapshot, data, prevIds...)
+			res.changes = append(res.changes, newCh)
+			return newId
+		}
+		if params.isSnapshot() {
+			newId := newChange(true, 0, prevHeads)
+			prevHeads = []string{newId}
+			snapshotId = newId
+			continue
+		}
+		perLevel := rnd.Intn(params.perLevel)
+		if perLevel == 0 {
+			perLevel = 1
+		}
+		for j := 0; j < perLevel; j++ {
+			prevConns := rnd.Intn(len(prevHeads))
+			if prevConns == 0 {
+				prevConns = 1
+			}
+			rnd.Shuffle(len(prevHeads), func(i, j int) {
+				prevHeads[i], prevHeads[j] = prevHeads[j], prevHeads[i]
+			})
+			// if we didn't connect with all prev ones
+			if j == perLevel-1 && len(usedIds) != len(prevHeads) {
+				var unusedIds []string
+				for _, id := range prevHeads {
+					if _, exists := usedIds[id]; !exists {
+						unusedIds = append(unusedIds, id)
+					}
+				}
+				prevHeads = unusedIds
+				prevConns = len(prevHeads)
+			}
+			var prevIds []string
+			for k := 0; k < prevConns; k++ {
+				prevIds = append(prevIds, prevHeads[k])
+				usedIds[prevHeads[k]] = struct{}{}
+			}
+			newId := newChange(false, j, prevIds)
+			newHeads = append(newHeads, newId)
+		}
+		prevHeads = newHeads
+	}
+	res.heads = prevHeads
+	res.snapshotId = snapshotId
+	return
+}

commonspace/object/tree/treechangeproto/errors.go

@@ -0,0 +1,14 @@
+package treechangeproto
+
+import (
+	"errors"
+	"github.com/anyproto/any-sync/net/rpc/rpcerr"
+)
+
+var (
+	errGroup = rpcerr.ErrGroup(ErrorCodes_ErrorOffset)
+
+	ErrUnexpected = errGroup.Register(errors.New("unexpected error"), uint64(ErrorCodes_Unexpected))
+	ErrGetTree    = errGroup.Register(errors.New("tree not found"), uint64(ErrorCodes_GetTreeError))
+	ErrFullSync   = errGroup.Register(errors.New("full sync request error"), uint64(ErrorCodes_FullSyncRequestError))
+)