Merge pull request #66 from anytypeio/add-master-key

Bump github.com/goccy/go-graphviz from 0.1.0 to 0.1.1

.github/dependabot.yml

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

.github/workflows/coverage.yml

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

LICENSE

@@ -1,21 +0,0 @@
-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/anyproto
+export GOPRIVATE=github.com/anytypeio
 export PATH:=deps:$(PATH)
 
 proto:
@@ -8,8 +8,8 @@ proto:
 	@$(eval P_ACL_RECORDS_PATH_PB := commonspace/object/acl/aclrecordproto)
 	@$(eval P_TREE_CHANGES_PATH_PB := commonspace/object/tree/treechangeproto)
 	@$(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))
+	@$(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))
 
 	protoc --gogofaster_out=:. $(P_ACL_RECORDS_PATH_PB)/protos/*.proto
 	protoc --gogofaster_out=:. $(P_TREE_CHANGES_PATH_PB)/protos/*.proto

accountservice/accountservice.go

@@ -1,9 +1,9 @@
-//go:generate mockgen -destination mock_accountservice/mock_accountservice.go github.com/anyproto/any-sync/accountservice Service
+//go:generate mockgen -destination mock_accountservice/mock_accountservice.go github.com/anytypeio/any-sync/accountservice Service
 package accountservice
 
 import (
-	"github.com/anyproto/any-sync/app"
-	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anytypeio/any-sync/app"
+	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
 )
 
 const CName = "common.accountservice"

accountservice/mock_accountservice/helper.go

@@ -1,8 +1,8 @@
 package mock_accountservice
 
 import (
-	"github.com/anyproto/any-sync/accountservice"
-	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anytypeio/any-sync/accountservice"
+	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
 	"github.com/golang/mock/gomock"
 )
 

accountservice/mock_accountservice/mock_accountservice.go

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

app/app.go

@@ -4,11 +4,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anytypeio/any-sync/app/logger"
 	"go.uber.org/zap"
 	"os"
 	"runtime"
-	"runtime/debug"
 	"strings"
 	"sync"
 	"time"
@@ -16,8 +15,8 @@ import (
 
 var (
 	// values of this vars will be defined while compilation
-	AppName, GitCommit, GitBranch, GitState, GitSummary, BuildDate string
-	name                                                           string
+	GitCommit, GitBranch, GitState, GitSummary, BuildDate string
+	name                                                  string
 )
 
 var (
@@ -55,12 +54,11 @@ 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      Stat
-	stopStat       Stat
-	deviceState    int
-	anySyncVersion string
+	components  []Component
+	mu          sync.RWMutex
+	startStat   Stat
+	stopStat    Stat
+	deviceState int
 }
 
 // Name returns app name
@@ -68,10 +66,6 @@ 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
@@ -263,7 +257,7 @@ func (app *App) Close(ctx context.Context) error {
 		case <-time.After(StopWarningAfter):
 			statLogger(app.stopStat, log).
 				With(zap.String("in_progress", currentComponentStopping)).
-				Warn("components close in progress")
+			 	Warn("components close in progress")
 		}
 	}()
 	go func() {
@@ -317,20 +311,3 @@ 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/anyproto/any-sync/app/ldiff Diff,Remote
+//go:generate mockgen -destination mock_ldiff/mock_ldiff.go github.com/anytypeio/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 := uuid.NewString()
+			head := bson.NewObjectId().Hex()
 			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: uuid.NewString(),
+				Head: bson.NewObjectId().Hex(),
 			})
 		}
 
@@ -108,7 +108,7 @@ func TestDiff_Diff(t *testing.T) {
 		for i := 0; i < 10; i++ {
 			d2.Set(Element{
 				Id:   fmt.Sprint(i),
-				Head: uuid.NewString(),
+				Head: bson.NewObjectId().Hex(),
 			})
 		}
 		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 := uuid.NewString()
+		head := bson.NewObjectId().Hex()
 		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/anyproto/any-sync/app/ldiff (interfaces: Diff,Remote)
+// Source: github.com/anytypeio/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/anyproto/any-sync/app/ldiff"
+	ldiff "github.com/anytypeio/any-sync/app/ldiff"
 	gomock "github.com/golang/mock/gomock"
 )
 

app/logger/config.go

@@ -1,13 +1,10 @@
 package logger
 
 import (
-	"fmt"
-	"strings"
-
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 
-	"github.com/anyproto/any-sync/util/slice"
+	"github.com/anytypeio/any-sync/util/slice"
 )
 
 type LogFormat int
@@ -18,19 +15,14 @@ const (
 	JSONOutput
 )
 
-type NamedLevel struct {
-	Name  string `yaml:"name"`
-	Level string `yaml:"level"`
-}
-
 type Config struct {
-	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
+	Production     bool              `yaml:"production"`
+	DefaultLevel   string            `yaml:"defaultLevel"`
+	NamedLevels    map[string]string `yaml:"namedLevels"`
+	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() {
@@ -76,49 +68,20 @@ func (l Config) ApplyGlobal() {
 			conf.Level = defaultLevel
 		}
 	}
-	for _, v := range l.Levels {
-		if lev, err := zap.ParseAtomicLevel(v.Level); err == nil {
+	var lvl = make(map[string]zap.AtomicLevel)
+	for k, v := range l.NamedLevels {
+		if lev, err := zap.ParseAtomicLevel(v); err == nil {
+			lvl[k] = lev
 			// 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(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
+	SetNamedLevels(lvl)
 }

app/logger/log.go

@@ -11,17 +11,12 @@ var (
 	mu                sync.Mutex
 	logger            *zap.Logger
 	loggerConfig      zap.Config
-	namedLevels       []namedLevel
+	namedLevels       = make(map[string]zap.AtomicLevel)
 	namedGlobs        = make(map[string]glob.Glob)
 	namedLoggers      = make(map[string]CtxLogger)
 	namedSugarLoggers = make(map[string]*zap.SugaredLogger)
 )
 
-type namedLevel struct {
-	name  string
-	level zap.AtomicLevel
-}
-
 func init() {
 	loggerConfig = zap.NewDevelopmentConfig()
 	logger, _ = loggerConfig.Build()
@@ -40,23 +35,18 @@ func SetDefault(l *zap.Logger) {
 // 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) {
+func SetNamedLevels(l map[string]zap.AtomicLevel) {
 	mu.Lock()
 	defer mu.Unlock()
-	namedLevels = namedLevels[:0]
+	namedLevels = l
 
 	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)
+	for k, l := range namedLevels {
+		g, err := glob.Compile(k)
 		if err == nil {
-			namedGlobs[nl.Name] = g
+			namedGlobs[k] = g
 		}
-
+		namedLevels[k] = l
 		if l.Level() < minLevel {
 			minLevel = l.Level()
 		}
@@ -91,18 +81,23 @@ func Default() *zap.Logger {
 	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
+	level, ok := namedLevels[name]
+	if !ok {
+		var found bool
+		for globName, glob := range namedGlobs {
+			if glob.Match(name) {
+				found = true
+				level, _ = namedLevels[globName]
+				// no need to check ok, because we know that globName exists
+				break
+			}
 		}
-		if g, ok := namedGlobs[nl.name]; ok && g.Match(name) {
-			return nl.level
+		if !found {
+			level = loggerConfig.Level
 		}
 	}
-	return zap.NewAtomicLevelAt(logger.Level())
+	return level
 }
 
 func NewNamed(name string, fields ...zap.Field) CtxLogger {

app/logger/log_test.go

@@ -1,150 +0,0 @@
-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/ocache.go

@@ -3,7 +3,7 @@ package ocache
 import (
 	"context"
 	"errors"
-	"github.com/anyproto/any-sync/app/logger"
+	"github.com/anytypeio/any-sync/app/logger"
 	"go.uber.org/zap"
 	"sync"
 	"time"

commonfile/fileblockstore/fileblockstore.go

@@ -2,8 +2,8 @@ package fileblockstore
 
 import (
 	"context"
-	"github.com/anyproto/any-sync/app/logger"
-	"github.com/anyproto/any-sync/commonfile/fileproto/fileprotoerr"
+	"github.com/anytypeio/any-sync/app/logger"
+	"github.com/anytypeio/any-sync/commonfile/fileproto/fileprotoerr"
 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 )

commonfile/fileproto/file.pb.go

@@ -298,6 +298,94 @@ func (m *BlockPushResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_BlockPushResponse proto.InternalMessageInfo
 
+type BlocksDeleteRequest struct {
+	SpaceId string   `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
+	Cids    [][]byte `protobuf:"bytes,2,rep,name=cids,proto3" json:"cids,omitempty"`
+}
+
+func (m *BlocksDeleteRequest) Reset()         { *m = BlocksDeleteRequest{} }
+func (m *BlocksDeleteRequest) String() string { return proto.CompactTextString(m) }
+func (*BlocksDeleteRequest) ProtoMessage()    {}
+func (*BlocksDeleteRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_fd665a7e11c833d5, []int{4}
+}
+func (m *BlocksDeleteRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BlocksDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BlocksDeleteRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *BlocksDeleteRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlocksDeleteRequest.Merge(m, src)
+}
+func (m *BlocksDeleteRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *BlocksDeleteRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_BlocksDeleteRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BlocksDeleteRequest proto.InternalMessageInfo
+
+func (m *BlocksDeleteRequest) GetSpaceId() string {
+	if m != nil {
+		return m.SpaceId
+	}
+	return ""
+}
+
+func (m *BlocksDeleteRequest) GetCids() [][]byte {
+	if m != nil {
+		return m.Cids
+	}
+	return nil
+}
+
+type BlocksDeleteResponse struct {
+}
+
+func (m *BlocksDeleteResponse) Reset()         { *m = BlocksDeleteResponse{} }
+func (m *BlocksDeleteResponse) String() string { return proto.CompactTextString(m) }
+func (*BlocksDeleteResponse) ProtoMessage()    {}
+func (*BlocksDeleteResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_fd665a7e11c833d5, []int{5}
+}
+func (m *BlocksDeleteResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *BlocksDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_BlocksDeleteResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *BlocksDeleteResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BlocksDeleteResponse.Merge(m, src)
+}
+func (m *BlocksDeleteResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *BlocksDeleteResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_BlocksDeleteResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BlocksDeleteResponse proto.InternalMessageInfo
+
 type BlocksCheckRequest struct {
 	SpaceId string   `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
 	Cids    [][]byte `protobuf:"bytes,2,rep,name=cids,proto3" json:"cids,omitempty"`
@@ -307,7 +395,7 @@ func (m *BlocksCheckRequest) Reset()         { *m = BlocksCheckRequest{} }
 func (m *BlocksCheckRequest) String() string { return proto.CompactTextString(m) }
 func (*BlocksCheckRequest) ProtoMessage()    {}
 func (*BlocksCheckRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{4}
+	return fileDescriptor_fd665a7e11c833d5, []int{6}
 }
 func (m *BlocksCheckRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -358,7 +446,7 @@ func (m *BlocksCheckResponse) Reset()         { *m = BlocksCheckResponse{} }
 func (m *BlocksCheckResponse) String() string { return proto.CompactTextString(m) }
 func (*BlocksCheckResponse) ProtoMessage()    {}
 func (*BlocksCheckResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{5}
+	return fileDescriptor_fd665a7e11c833d5, []int{7}
 }
 func (m *BlocksCheckResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -403,7 +491,7 @@ func (m *BlockAvailability) Reset()         { *m = BlockAvailability{} }
 func (m *BlockAvailability) String() string { return proto.CompactTextString(m) }
 func (*BlockAvailability) ProtoMessage()    {}
 func (*BlockAvailability) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{6}
+	return fileDescriptor_fd665a7e11c833d5, []int{8}
 }
 func (m *BlockAvailability) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -456,7 +544,7 @@ func (m *BlocksBindRequest) Reset()         { *m = BlocksBindRequest{} }
 func (m *BlocksBindRequest) String() string { return proto.CompactTextString(m) }
 func (*BlocksBindRequest) ProtoMessage()    {}
 func (*BlocksBindRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{7}
+	return fileDescriptor_fd665a7e11c833d5, []int{9}
 }
 func (m *BlocksBindRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -513,7 +601,7 @@ func (m *BlocksBindResponse) Reset()         { *m = BlocksBindResponse{} }
 func (m *BlocksBindResponse) String() string { return proto.CompactTextString(m) }
 func (*BlocksBindResponse) ProtoMessage()    {}
 func (*BlocksBindResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{8}
+	return fileDescriptor_fd665a7e11c833d5, []int{10}
 }
 func (m *BlocksBindResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -551,7 +639,7 @@ func (m *FilesDeleteRequest) Reset()         { *m = FilesDeleteRequest{} }
 func (m *FilesDeleteRequest) String() string { return proto.CompactTextString(m) }
 func (*FilesDeleteRequest) ProtoMessage()    {}
 func (*FilesDeleteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{9}
+	return fileDescriptor_fd665a7e11c833d5, []int{11}
 }
 func (m *FilesDeleteRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -601,7 +689,7 @@ func (m *FilesDeleteResponse) Reset()         { *m = FilesDeleteResponse{} }
 func (m *FilesDeleteResponse) String() string { return proto.CompactTextString(m) }
 func (*FilesDeleteResponse) ProtoMessage()    {}
 func (*FilesDeleteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{10}
+	return fileDescriptor_fd665a7e11c833d5, []int{12}
 }
 func (m *FilesDeleteResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -639,7 +727,7 @@ func (m *FilesInfoRequest) Reset()         { *m = FilesInfoRequest{} }
 func (m *FilesInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*FilesInfoRequest) ProtoMessage()    {}
 func (*FilesInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{11}
+	return fileDescriptor_fd665a7e11c833d5, []int{13}
 }
 func (m *FilesInfoRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -690,7 +778,7 @@ func (m *FilesInfoResponse) Reset()         { *m = FilesInfoResponse{} }
 func (m *FilesInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*FilesInfoResponse) ProtoMessage()    {}
 func (*FilesInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{12}
+	return fileDescriptor_fd665a7e11c833d5, []int{14}
 }
 func (m *FilesInfoResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -736,7 +824,7 @@ func (m *FileInfo) Reset()         { *m = FileInfo{} }
 func (m *FileInfo) String() string { return proto.CompactTextString(m) }
 func (*FileInfo) ProtoMessage()    {}
 func (*FileInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{13}
+	return fileDescriptor_fd665a7e11c833d5, []int{15}
 }
 func (m *FileInfo) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -793,7 +881,7 @@ func (m *CheckRequest) Reset()         { *m = CheckRequest{} }
 func (m *CheckRequest) String() string { return proto.CompactTextString(m) }
 func (*CheckRequest) ProtoMessage()    {}
 func (*CheckRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{14}
+	return fileDescriptor_fd665a7e11c833d5, []int{16}
 }
 func (m *CheckRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -831,7 +919,7 @@ func (m *CheckResponse) Reset()         { *m = CheckResponse{} }
 func (m *CheckResponse) String() string { return proto.CompactTextString(m) }
 func (*CheckResponse) ProtoMessage()    {}
 func (*CheckResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{15}
+	return fileDescriptor_fd665a7e11c833d5, []int{17}
 }
 func (m *CheckResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -882,7 +970,7 @@ func (m *SpaceInfoRequest) Reset()         { *m = SpaceInfoRequest{} }
 func (m *SpaceInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*SpaceInfoRequest) ProtoMessage()    {}
 func (*SpaceInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{16}
+	return fileDescriptor_fd665a7e11c833d5, []int{18}
 }
 func (m *SpaceInfoRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -929,7 +1017,7 @@ func (m *SpaceInfoResponse) Reset()         { *m = SpaceInfoResponse{} }
 func (m *SpaceInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*SpaceInfoResponse) ProtoMessage()    {}
 func (*SpaceInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd665a7e11c833d5, []int{17}
+	return fileDescriptor_fd665a7e11c833d5, []int{19}
 }
 func (m *SpaceInfoResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -993,6 +1081,8 @@ func init() {
 	proto.RegisterType((*BlockGetResponse)(nil), "filesync.BlockGetResponse")
 	proto.RegisterType((*BlockPushRequest)(nil), "filesync.BlockPushRequest")
 	proto.RegisterType((*BlockPushResponse)(nil), "filesync.BlockPushResponse")
+	proto.RegisterType((*BlocksDeleteRequest)(nil), "filesync.BlocksDeleteRequest")
+	proto.RegisterType((*BlocksDeleteResponse)(nil), "filesync.BlocksDeleteResponse")
 	proto.RegisterType((*BlocksCheckRequest)(nil), "filesync.BlocksCheckRequest")
 	proto.RegisterType((*BlocksCheckResponse)(nil), "filesync.BlocksCheckResponse")
 	proto.RegisterType((*BlockAvailability)(nil), "filesync.BlockAvailability")
@@ -1014,58 +1104,59 @@ func init() {
 }
 
 var fileDescriptor_fd665a7e11c833d5 = []byte{
-	// 805 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcd, 0x52, 0xeb, 0x36,
-	0x14, 0x8e, 0x13, 0x13, 0xe2, 0x13, 0x02, 0x8e, 0xf8, 0x69, 0x1a, 0x52, 0x4f, 0xc6, 0x8b, 0x0e,
-	0xc3, 0x74, 0x42, 0x87, 0x76, 0xc1, 0xa6, 0x0b, 0x12, 0x12, 0x48, 0xe9, 0xd0, 0xd6, 0x4c, 0x87,
-	0x69, 0xbb, 0xa9, 0x63, 0x2b, 0xe0, 0x62, 0xac, 0xd4, 0x52, 0x5a, 0xd2, 0x47, 0xe8, 0xaa, 0x7d,
-	0x99, 0x3e, 0x03, 0x4b, 0x96, 0x77, 0x79, 0x07, 0x5e, 0xe4, 0x8e, 0x64, 0x39, 0x56, 0x7e, 0xee,
-	0x70, 0x7f, 0x36, 0x8e, 0xf4, 0xe9, 0x9c, 0xf3, 0x1d, 0x7d, 0x92, 0xbe, 0x09, 0x7c, 0xee, 0x91,
-	0xbb, 0x3b, 0x12, 0x0d, 0x83, 0x10, 0x1f, 0xf0, 0xcf, 0x28, 0x26, 0x8c, 0x1c, 0x88, 0x2f, 0x15,
-	0x40, 0x4b, 0x8c, 0x51, 0x89, 0x8f, 0xe9, 0x24, 0xf2, 0xec, 0x6f, 0x60, 0xa3, 0x1d, 0x12, 0xef,
-	0xf6, 0x14, 0x33, 0x07, 0xff, 0x31, 0xc6, 0x94, 0xa1, 0x1a, 0xac, 0xd2, 0x91, 0xeb, 0xe1, 0xbe,
-	0x5f, 0xd3, 0x9a, 0xda, 0x9e, 0xe1, 0xa4, 0x53, 0x64, 0x42, 0xc1, 0x0b, 0xfc, 0x5a, 0xbe, 0xa9,
-	0xed, 0xad, 0x39, 0x7c, 0x68, 0x1f, 0x81, 0x99, 0xa5, 0xd3, 0x11, 0x89, 0x28, 0x4e, 0xa3, 0xb4,
-	0x69, 0x14, 0x42, 0xa0, 0xfb, 0x2e, 0x73, 0x65, 0xa2, 0x18, 0xdb, 0xbf, 0xcb, 0xcc, 0x1f, 0xc6,
-	0xf4, 0xe6, 0x65, 0xe6, 0x1d, 0x28, 0xf2, 0x96, 0xfb, 0x09, 0xb9, 0xe1, 0xc8, 0x59, 0xca, 0x55,
-	0x58, 0xe4, 0xd2, 0x15, 0xae, 0x4d, 0xa8, 0x2a, 0x5c, 0x49, 0x9b, 0x76, 0x1b, 0x90, 0x00, 0x69,
-	0xe7, 0x06, 0x7b, 0xb7, 0x2f, 0xb7, 0x80, 0x40, 0xf7, 0x02, 0x9f, 0xd6, 0xf2, 0xcd, 0x02, 0x2f,
-	0xcc, 0xc7, 0xf6, 0x00, 0x36, 0x67, 0x6a, 0x48, 0x05, 0xce, 0x01, 0x0d, 0x04, 0x7c, 0xfc, 0xa7,
-	0x1b, 0x84, 0xee, 0x20, 0x08, 0x03, 0x36, 0xa9, 0x69, 0xcd, 0xc2, 0x5e, 0xf9, 0x70, 0xb7, 0x95,
-	0x6a, 0xdf, 0x12, 0xa9, 0x6a, 0x88, 0xb3, 0x24, 0xcd, 0xfe, 0x55, 0x36, 0xaf, 0x82, 0x4b, 0x34,
-	0xfe, 0x1a, 0x8a, 0x94, 0xb9, 0x6c, 0x4c, 0x85, 0x42, 0xeb, 0x87, 0x8d, 0x8c, 0x47, 0xcd, 0xbc,
-	0x14, 0x31, 0x8e, 0x8c, 0xb5, 0x7f, 0x96, 0xc5, 0x69, 0x3b, 0x88, 0xfc, 0x0f, 0x3f, 0x86, 0x54,
-	0x9b, 0x82, 0xa2, 0xcd, 0x56, 0xaa, 0x6f, 0x52, 0x5a, 0xaa, 0x7e, 0x06, 0xa8, 0xc7, 0xfb, 0x3a,
-	0xc1, 0x21, 0x66, 0xf8, 0x65, 0xc6, 0x1a, 0xac, 0x26, 0x1c, 0x89, 0xf0, 0x86, 0x93, 0x4e, 0xed,
-	0x6d, 0xd8, 0x9c, 0xa9, 0x24, 0x09, 0x7a, 0x60, 0x0a, 0xb8, 0x1f, 0x0d, 0xc9, 0xc7, 0x94, 0xef,
-	0x42, 0x55, 0xa9, 0x23, 0x0f, 0xf6, 0x4b, 0x30, 0x86, 0x29, 0x28, 0xcf, 0x13, 0x65, 0x3a, 0xf3,
-	0x78, 0x11, 0x9e, 0x05, 0xd9, 0xbf, 0x41, 0x29, 0x85, 0x15, 0xf5, 0xb4, 0x19, 0xf5, 0x2c, 0x80,
-	0x31, 0x75, 0xaf, 0x71, 0x7b, 0xc2, 0x70, 0x72, 0x7c, 0xba, 0xa3, 0x20, 0xa8, 0x01, 0x06, 0x57,
-	0xb4, 0x43, 0xc6, 0x11, 0x13, 0x57, 0xbd, 0xe2, 0x64, 0x80, 0xbd, 0x0e, 0x6b, 0xea, 0x0d, 0xb6,
-	0xcf, 0xa1, 0x32, 0x7b, 0x1b, 0xeb, 0x50, 0x92, 0xdb, 0xa5, 0xa2, 0x67, 0xc3, 0x99, 0xce, 0x39,
-	0xb5, 0x1b, 0x86, 0xe4, 0xaf, 0xab, 0x38, 0x60, 0x58, 0x50, 0x97, 0x1c, 0x05, 0xb1, 0xbf, 0x00,
-	0xf3, 0x52, 0xc4, 0xbe, 0x8b, 0x9a, 0xf6, 0x7f, 0x1a, 0x54, 0x95, 0x70, 0xc9, 0x6f, 0x01, 0x84,
-	0xc1, 0x5d, 0xc0, 0x92, 0xed, 0x69, 0xc9, 0xf6, 0x32, 0xe4, 0xfd, 0xb7, 0xaf, 0x2b, 0xdb, 0xe7,
-	0xd9, 0x42, 0xed, 0x64, 0x59, 0x4f, 0xb2, 0x33, 0x64, 0xff, 0x1f, 0x0d, 0x4a, 0xdd, 0x38, 0xee,
-	0x10, 0x1f, 0x53, 0xb4, 0x0e, 0xf0, 0x53, 0x84, 0xef, 0x47, 0xd8, 0x63, 0xd8, 0x37, 0x73, 0x68,
-	0x03, 0xca, 0x9d, 0xfe, 0xc9, 0x05, 0x61, 0x3d, 0x32, 0x8e, 0x7c, 0x53, 0x43, 0x15, 0x30, 0x7a,
-	0x24, 0x1e, 0x04, 0xbe, 0x8f, 0x23, 0x33, 0x8f, 0x76, 0x00, 0x89, 0xfd, 0x7c, 0xc7, 0xbb, 0xed,
-	0xde, 0x7b, 0x18, 0xfb, 0xd8, 0x37, 0x0b, 0x68, 0x1b, 0xaa, 0x3f, 0x8e, 0x71, 0x3c, 0xb9, 0x0c,
-	0xfe, 0xc6, 0x53, 0x58, 0xe7, 0xd9, 0x57, 0x31, 0x89, 0xae, 0xcf, 0x5c, 0x7a, 0x63, 0xae, 0x20,
-	0x13, 0xca, 0xdd, 0x38, 0x26, 0xf1, 0xf7, 0xc3, 0x21, 0xc5, 0xcc, 0x7c, 0xd0, 0xf6, 0xdb, 0x80,
-	0x16, 0x1f, 0x23, 0x4f, 0xbb, 0x20, 0xac, 0x7b, 0x1f, 0x50, 0x46, 0xcd, 0x1c, 0x02, 0x28, 0xca,
-	0xb1, 0x86, 0xaa, 0x50, 0x49, 0xc6, 0xfd, 0x48, 0x34, 0x62, 0xe6, 0x0f, 0xff, 0xd7, 0x41, 0xe7,
-	0x57, 0x0a, 0x1d, 0x43, 0x29, 0xf5, 0x5e, 0xf4, 0xe9, 0x9c, 0xab, 0x64, 0x76, 0x5e, 0xaf, 0x2f,
-	0x5b, 0x92, 0x47, 0x73, 0x02, 0xc6, 0xd4, 0x18, 0xd1, 0x7c, 0xa0, 0xe2, 0xcc, 0xf5, 0xdd, 0xa5,
-	0x6b, 0xb2, 0xca, 0xb7, 0x50, 0x56, 0x5c, 0x10, 0x35, 0xe6, 0x62, 0x67, 0x0c, 0xb6, 0xfe, 0xd9,
-	0x5b, 0x56, 0x65, 0xad, 0x53, 0x80, 0xcc, 0x35, 0xd0, 0x3c, 0xad, 0x6a, 0x53, 0xf5, 0xc6, 0xf2,
-	0xc5, 0xac, 0x29, 0xc5, 0x1e, 0xd4, 0xa6, 0x16, 0xfd, 0x47, 0x6d, 0x6a, 0x89, 0xa7, 0x70, 0x99,
-	0xa6, 0x5e, 0xa0, 0xca, 0x34, 0x6f, 0x34, 0xaa, 0x4c, 0x8b, 0xe6, 0x71, 0x04, 0x2b, 0x89, 0x40,
-	0x3b, 0x59, 0xd4, 0x8c, 0x34, 0x9f, 0x2c, 0xe0, 0x19, 0xff, 0xf4, 0x59, 0xa9, 0xfc, 0xf3, 0x4f,
-	0x53, 0xe5, 0x5f, 0x78, 0x87, 0xed, 0xd6, 0xc3, 0x93, 0xa5, 0x3d, 0x3e, 0x59, 0xda, 0xeb, 0x27,
-	0x4b, 0xfb, 0xf7, 0xd9, 0xca, 0x3d, 0x3e, 0x5b, 0xb9, 0x57, 0xcf, 0x56, 0xee, 0x97, 0xad, 0x65,
-	0x7f, 0x1b, 0x06, 0x45, 0xf1, 0xf3, 0xd5, 0x9b, 0x00, 0x00, 0x00, 0xff, 0xff, 0x45, 0x87, 0x27,
-	0x98, 0x55, 0x08, 0x00, 0x00,
+	// 817 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4f, 0x53, 0xfb, 0x44,
+	0x18, 0x6e, 0xda, 0xfc, 0x4a, 0xf3, 0x96, 0x42, 0xba, 0x40, 0xad, 0xa5, 0x66, 0x3a, 0x39, 0x38,
+	0x0c, 0xe3, 0x14, 0x07, 0x3d, 0x70, 0xf1, 0x40, 0x4b, 0x0b, 0x15, 0x07, 0x35, 0x8c, 0xc3, 0xa8,
+	0x17, 0xd3, 0x64, 0x0b, 0x91, 0x90, 0xad, 0xd9, 0xad, 0x52, 0x3f, 0x82, 0x27, 0xfd, 0x32, 0x7e,
+	0x06, 0x8e, 0x1c, 0x3d, 0x3a, 0xf0, 0x45, 0x9c, 0xdd, 0x6c, 0x9a, 0xed, 0x1f, 0x07, 0xc4, 0x4b,
+	0xd8, 0x3c, 0xfb, 0xbe, 0xef, 0xf3, 0xee, 0xf3, 0x66, 0x1f, 0x0a, 0x1f, 0x7a, 0xe4, 0xee, 0x8e,
+	0x44, 0xa3, 0x20, 0xc4, 0x07, 0xfc, 0x31, 0x8e, 0x09, 0x23, 0x07, 0xe2, 0x49, 0x05, 0xd0, 0x16,
+	0x6b, 0x54, 0xe2, 0x6b, 0x3a, 0x8d, 0x3c, 0xfb, 0x33, 0xd8, 0xec, 0x84, 0xc4, 0xbb, 0x3d, 0xc5,
+	0xcc, 0xc1, 0x3f, 0x4d, 0x30, 0x65, 0xa8, 0x0e, 0x6b, 0x74, 0xec, 0x7a, 0x78, 0xe0, 0xd7, 0xb5,
+	0x96, 0xb6, 0x67, 0x38, 0xe9, 0x2b, 0x32, 0xa1, 0xe0, 0x05, 0x7e, 0x3d, 0xdf, 0xd2, 0xf6, 0xd6,
+	0x1d, 0xbe, 0xb4, 0x8f, 0xc0, 0xcc, 0xd2, 0xe9, 0x98, 0x44, 0x14, 0xa7, 0x51, 0xda, 0x2c, 0x0a,
+	0x21, 0xd0, 0x7d, 0x97, 0xb9, 0x32, 0x51, 0xac, 0xed, 0x1f, 0x65, 0xe6, 0x57, 0x13, 0x7a, 0xf3,
+	0x32, 0x73, 0x0d, 0x8a, 0xbc, 0xe5, 0x41, 0x42, 0x6e, 0x38, 0xf2, 0x2d, 0xe5, 0x2a, 0x2c, 0x73,
+	0xe9, 0x0a, 0xd7, 0x16, 0x54, 0x15, 0xae, 0xa4, 0x4d, 0xbb, 0x0b, 0x5b, 0x02, 0xa4, 0x27, 0x38,
+	0xc4, 0x0c, 0xbf, 0xdc, 0x03, 0x02, 0xdd, 0x0b, 0x7c, 0x5a, 0xcf, 0xb7, 0x0a, 0xbc, 0x32, 0x5f,
+	0xdb, 0x35, 0xd8, 0x9e, 0x2f, 0x22, 0x8b, 0x77, 0x00, 0x25, 0x78, 0xf7, 0x06, 0x7b, 0xb7, 0x6f,
+	0xab, 0x3d, 0x4c, 0x1b, 0x94, 0x35, 0xa4, 0xbc, 0xe7, 0x80, 0x86, 0x02, 0x3e, 0xfe, 0xd9, 0x0d,
+	0x42, 0x77, 0x18, 0x84, 0x01, 0x9b, 0xd6, 0xb5, 0x56, 0x61, 0xaf, 0x7c, 0xb8, 0xdb, 0x4e, 0x07,
+	0xdb, 0x16, 0xa9, 0x6a, 0x88, 0xb3, 0x22, 0xcd, 0xfe, 0x5e, 0x2a, 0xa3, 0x82, 0x2b, 0x06, 0xf8,
+	0x29, 0x14, 0x29, 0x73, 0xd9, 0x84, 0x0a, 0xf9, 0x37, 0x0e, 0x9b, 0x19, 0x8f, 0x9a, 0x79, 0x29,
+	0x62, 0x1c, 0x19, 0x6b, 0x7f, 0x2b, 0x8b, 0xd3, 0x4e, 0x10, 0xf9, 0x6f, 0x9f, 0x71, 0xaa, 0x4d,
+	0x41, 0xd1, 0x66, 0x3b, 0xd5, 0x37, 0x29, 0x2d, 0x55, 0x3f, 0x03, 0xd4, 0xe7, 0x7d, 0xbd, 0x76,
+	0xa2, 0x75, 0x58, 0x4b, 0x38, 0x12, 0xe1, 0x0d, 0x27, 0x7d, 0xb5, 0x77, 0x60, 0x6b, 0xae, 0x92,
+	0x24, 0xe8, 0x83, 0x29, 0xe0, 0x41, 0x34, 0x22, 0xff, 0xa7, 0x7c, 0x0f, 0xaa, 0x4a, 0x1d, 0x39,
+	0xd8, 0x8f, 0xc1, 0x18, 0xa5, 0xa0, 0x9c, 0x27, 0xca, 0x74, 0xe6, 0xf1, 0x22, 0x3c, 0x0b, 0xb2,
+	0x7f, 0x80, 0x52, 0x0a, 0x2b, 0xea, 0x69, 0x73, 0xea, 0x59, 0x00, 0x13, 0xea, 0x5e, 0xe3, 0xce,
+	0x94, 0xe1, 0x64, 0x7c, 0xba, 0xa3, 0x20, 0xa8, 0x09, 0x06, 0x57, 0xb4, 0x4b, 0x26, 0x11, 0x13,
+	0xf7, 0xa8, 0xe2, 0x64, 0x80, 0xbd, 0x01, 0xeb, 0xea, 0x17, 0x6c, 0x9f, 0x43, 0x65, 0xfe, 0x6b,
+	0x6c, 0x40, 0x49, 0x1e, 0x97, 0x8a, 0x9e, 0x0d, 0x67, 0xf6, 0xce, 0xa9, 0xdd, 0x30, 0x24, 0xbf,
+	0x5c, 0xc5, 0x01, 0xc3, 0x82, 0xba, 0xe4, 0x28, 0x88, 0xfd, 0x11, 0x98, 0x97, 0x22, 0xf6, 0x35,
+	0x6a, 0xda, 0x7f, 0x68, 0x50, 0x55, 0xc2, 0x25, 0xbf, 0x05, 0x10, 0x06, 0x77, 0x01, 0x4b, 0x8e,
+	0xa7, 0x25, 0xc7, 0xcb, 0x90, 0xff, 0x7e, 0x7c, 0x5d, 0x39, 0x3e, 0xcf, 0x16, 0x6a, 0x27, 0xdb,
+	0x7a, 0x92, 0x9d, 0x21, 0xfb, 0xbf, 0x69, 0x50, 0xea, 0xc5, 0x71, 0x97, 0xf8, 0x98, 0xa2, 0x0d,
+	0x80, 0x6f, 0x22, 0x7c, 0x3f, 0xc6, 0x1e, 0xc3, 0xbe, 0x99, 0x43, 0x9b, 0x50, 0xee, 0x0e, 0x4e,
+	0x2e, 0x08, 0xeb, 0x93, 0x49, 0xe4, 0x9b, 0x1a, 0xaa, 0x80, 0xd1, 0x27, 0xf1, 0x30, 0xf0, 0x7d,
+	0x1c, 0x99, 0x79, 0x54, 0x03, 0x24, 0xce, 0xf3, 0x05, 0xef, 0xb6, 0x77, 0xef, 0x61, 0xec, 0x63,
+	0xdf, 0x2c, 0xa0, 0x1d, 0xa8, 0x7e, 0x3d, 0xc1, 0xf1, 0xf4, 0x32, 0xf8, 0x15, 0xcf, 0x60, 0x9d,
+	0x67, 0x5f, 0xc5, 0x24, 0xba, 0x3e, 0x73, 0xe9, 0x8d, 0xf9, 0x0e, 0x99, 0x50, 0xee, 0xc5, 0x31,
+	0x89, 0xbf, 0x1c, 0x8d, 0x28, 0x66, 0xe6, 0x83, 0xb6, 0xdf, 0x01, 0xb4, 0x7c, 0x19, 0x79, 0xda,
+	0x05, 0x61, 0xbd, 0xfb, 0x80, 0x32, 0x6a, 0xe6, 0x10, 0x40, 0x51, 0xae, 0x35, 0x54, 0x85, 0x4a,
+	0xb2, 0x1e, 0x44, 0xa2, 0x11, 0x33, 0x7f, 0xf8, 0xa7, 0x0e, 0x3a, 0xff, 0xa4, 0xd0, 0x31, 0x94,
+	0x52, 0x63, 0x47, 0xef, 0x2f, 0xb8, 0x4a, 0xf6, 0xbf, 0xa2, 0xd1, 0x58, 0xb5, 0x25, 0x47, 0x73,
+	0x02, 0xc6, 0xcc, 0x75, 0xd1, 0x62, 0xa0, 0x62, 0xfb, 0x8d, 0xdd, 0x95, 0x7b, 0xb2, 0xca, 0xe7,
+	0x50, 0x56, 0x5c, 0x10, 0x35, 0x17, 0x62, 0xe7, 0x0c, 0xb6, 0xf1, 0xc1, 0xbf, 0xec, 0xca, 0x5a,
+	0xa7, 0x00, 0x99, 0x6b, 0xa0, 0x45, 0x5a, 0xd5, 0xa6, 0x1a, 0xcd, 0xd5, 0x9b, 0x59, 0x53, 0x8a,
+	0x3d, 0xa8, 0x4d, 0x2d, 0xfb, 0x8f, 0xda, 0xd4, 0x0a, 0x4f, 0xe1, 0x32, 0xcd, 0xbc, 0x40, 0x95,
+	0x69, 0xd1, 0x68, 0x54, 0x99, 0x96, 0xcd, 0xe3, 0x08, 0xde, 0x25, 0x02, 0xd5, 0xb2, 0xa8, 0x39,
+	0x69, 0xde, 0x5b, 0xc2, 0x33, 0xfe, 0xd9, 0xb5, 0x52, 0xf9, 0x17, 0xaf, 0xa6, 0xca, 0xbf, 0x74,
+	0x0f, 0x3b, 0xed, 0x87, 0x27, 0x4b, 0x7b, 0x7c, 0xb2, 0xb4, 0xbf, 0x9f, 0x2c, 0xed, 0xf7, 0x67,
+	0x2b, 0xf7, 0xf8, 0x6c, 0xe5, 0xfe, 0x7a, 0xb6, 0x72, 0xdf, 0x6d, 0xaf, 0xfa, 0x4d, 0x32, 0x2c,
+	0x8a, 0x3f, 0x9f, 0xfc, 0x13, 0x00, 0x00, 0xff, 0xff, 0x26, 0x23, 0x7f, 0x83, 0xb2, 0x08, 0x00,
+	0x00,
 }
 
 func (m *BlockGetRequest) Marshal() (dAtA []byte, err error) {
@@ -1216,6 +1307,68 @@ func (m *BlockPushResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *BlocksDeleteRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BlocksDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BlocksDeleteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Cids) > 0 {
+		for iNdEx := len(m.Cids) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Cids[iNdEx])
+			copy(dAtA[i:], m.Cids[iNdEx])
+			i = encodeVarintFile(dAtA, i, uint64(len(m.Cids[iNdEx])))
+			i--
+			dAtA[i] = 0x12
+		}
+	}
+	if len(m.SpaceId) > 0 {
+		i -= len(m.SpaceId)
+		copy(dAtA[i:], m.SpaceId)
+		i = encodeVarintFile(dAtA, i, uint64(len(m.SpaceId)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *BlocksDeleteResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BlocksDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BlocksDeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func (m *BlocksCheckRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1791,6 +1944,34 @@ func (m *BlockPushResponse) Size() (n int) {
 	return n
 }
 
+func (m *BlocksDeleteRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.SpaceId)
+	if l > 0 {
+		n += 1 + l + sovFile(uint64(l))
+	}
+	if len(m.Cids) > 0 {
+		for _, b := range m.Cids {
+			l = len(b)
+			n += 1 + l + sovFile(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *BlocksDeleteResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func (m *BlocksCheckRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -2487,6 +2668,170 @@ func (m *BlockPushResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *BlocksDeleteRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowFile
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: BlocksDeleteRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: BlocksDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFile
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthFile
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthFile
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SpaceId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Cids", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFile
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthFile
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthFile
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Cids = append(m.Cids, make([]byte, postIndex-iNdEx))
+			copy(m.Cids[len(m.Cids)-1], dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFile(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFile
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *BlocksDeleteResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowFile
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: BlocksDeleteResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: BlocksDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFile(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFile
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *BlocksCheckRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

commonfile/fileproto/fileprotoerr/fileprotoerr.go

@@ -2,8 +2,8 @@ package fileprotoerr
 
 import (
 	"fmt"
-	"github.com/anyproto/any-sync/commonfile/fileproto"
-	"github.com/anyproto/any-sync/net/rpc/rpcerr"
+	"github.com/anytypeio/any-sync/commonfile/fileproto"
+	"github.com/anytypeio/any-sync/net/rpc/rpcerr"
 )
 
 var (

commonfile/fileproto/protos/file.proto

@@ -51,6 +51,13 @@ message BlockPushRequest {
 
 message BlockPushResponse {}
 
+message BlocksDeleteRequest {
+    string spaceId = 1;
+    repeated bytes cids = 2;
+}
+
+message BlocksDeleteResponse {}
+
 
 message BlocksCheckRequest {
     string spaceId = 1;

commonfile/fileservice/blockservice.go

@@ -2,7 +2,7 @@ package fileservice
 
 import (
 	"context"
-	"github.com/anyproto/any-sync/commonfile/fileblockstore"
+	"github.com/anytypeio/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/anyproto/any-sync/app"
-	"github.com/anyproto/any-sync/app/logger"
-	"github.com/anyproto/any-sync/commonfile/fileblockstore"
+	"github.com/anytypeio/any-sync/app"
+	"github.com/anytypeio/any-sync/app/logger"
+	"github.com/anytypeio/any-sync/commonfile/fileblockstore"
 	"github.com/ipfs/go-cid"
 	chunker "github.com/ipfs/go-ipfs-chunker"
 	ipld "github.com/ipfs/go-ipld-format"

commonspace/commongetter.go

@@ -2,22 +2,22 @@ package commonspace
 
 import (
 	"context"
-	"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"
+	"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"
 	"sync/atomic"
 )
 
 type commonGetter struct {
-	treemanager.TreeManager
+	treegetter.TreeGetter
 	spaceId         string
 	reservedObjects []syncobjectgetter.SyncObject
 	spaceIsClosed   *atomic.Bool
 }
 
-func newCommonGetter(spaceId string, getter treemanager.TreeManager, spaceIsClosed *atomic.Bool) *commonGetter {
+func newCommonGetter(spaceId string, getter treegetter.TreeGetter, spaceIsClosed *atomic.Bool) *commonGetter {
 	return &commonGetter{
-		TreeManager:   getter,
+		TreeGetter:    getter,
 		spaceId:       spaceId,
 		spaceIsClosed: spaceIsClosed,
 	}
@@ -34,7 +34,7 @@ func (c *commonGetter) GetTree(ctx context.Context, spaceId, treeId string) (obj
 	if obj := c.getReservedObject(treeId); obj != nil {
 		return obj.(objecttree.ObjectTree), nil
 	}
-	return c.TreeManager.GetTree(ctx, spaceId, treeId)
+	return c.TreeGetter.GetTree(ctx, spaceId, treeId)
 }
 
 func (c *commonGetter) getReservedObject(id string) syncobjectgetter.SyncObject {
@@ -53,7 +53,7 @@ func (c *commonGetter) GetObject(ctx context.Context, objectId string) (obj sync
 	if obj := c.getReservedObject(objectId); obj != nil {
 		return obj, nil
 	}
-	t, err := c.TreeManager.GetTree(ctx, c.spaceId, objectId)
+	t, err := c.TreeGetter.GetTree(ctx, c.spaceId, objectId)
 	if err != nil {
 		return
 	}

commonspace/commonstorage.go

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

commonspace/config.go

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

commonspace/credentialprovider/credentialprovider.go

@@ -1,9 +1,9 @@
-//go:generate mockgen -destination mock_credentialprovider/mock_credentialprovider.go github.com/anyproto/any-sync/commonspace/credentialprovider CredentialProvider
+//go:generate mockgen -destination mock_credentialprovider/mock_credentialprovider.go github.com/anytypeio/any-sync/commonspace/credentialprovider CredentialProvider
 package credentialprovider
 
 import (
 	"context"
-	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
 )
 
 const CName = "common.commonspace.credentialprovider"

commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go

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

commonspace/deletion_test.go

@@ -1,271 +0,0 @@
-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,18 @@ package headsync
 import (
 	"context"
 	"fmt"
-	"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"
+	"github.com/anytypeio/any-sync/app/ldiff"
+	"github.com/anytypeio/any-sync/app/logger"
+	"github.com/anytypeio/any-sync/commonspace/credentialprovider"
+	"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/settingsstate"
+	"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"
 	"go.uber.org/zap"
 	"time"
 )
@@ -23,14 +24,13 @@ type DiffSyncer interface {
 	RemoveObjects(ids []string)
 	UpdateHeads(id string, heads []string)
 	Init(deletionState settingsstate.ObjectDeletionState)
-	Close() error
 }
 
 func newDiffSyncer(
 	spaceId string,
 	diff ldiff.Diff,
 	peerManager peermanager.PeerManager,
-	cache treemanager.TreeManager,
+	cache treegetter.TreeGetter,
 	storage spacestorage.SpaceStorage,
 	clientFactory spacesyncproto.ClientFactory,
 	syncStatus syncstatus.StatusUpdater,
@@ -39,7 +39,7 @@ func newDiffSyncer(
 	return &diffSyncer{
 		diff:               diff,
 		spaceId:            spaceId,
-		treeManager:        cache,
+		cache:              cache,
 		storage:            storage,
 		peerManager:        peerManager,
 		clientFactory:      clientFactory,
@@ -53,20 +53,18 @@ type diffSyncer struct {
 	spaceId            string
 	diff               ldiff.Diff
 	peerManager        peermanager.PeerManager
-	treeManager        treemanager.TreeManager
+	cache              treegetter.TreeGetter
 	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 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) {
@@ -126,7 +124,7 @@ func (d *diffSyncer) syncWithPeer(ctx context.Context, p peer.Peer) (err error)
 	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.syncTrees(ctx, p.Id(), []string{d.storage.SpaceSettingsId()})
 		}
 		d.syncStatus.SetNodesOnline(p.Id(), false)
 		return fmt.Errorf("diff error: %v", err)
@@ -139,24 +137,45 @@ func (d *diffSyncer) syncWithPeer(ctx context.Context, p peer.Peer) (err error)
 
 	totalLen := len(newIds) + len(changedIds) + len(removedIds)
 	// not syncing ids which were removed through settings document
-	missingIds := d.deletionState.Filter(newIds)
-	existingIds := append(d.deletionState.Filter(removedIds), d.deletionState.Filter(changedIds)...)
+	filteredIds := d.deletionState.FilterJoin(newIds, changedIds, removedIds)
 
-	d.syncStatus.RemoveAllExcept(p.Id(), existingIds, stateCounter)
+	d.syncStatus.RemoveAllExcept(p.Id(), filteredIds, stateCounter)
+
+	d.syncTrees(ctx, p.Id(), filteredIds)
 
-	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(existingIds)-len(missingIds)),
+		zap.Int("already deleted ids", totalLen-len(filteredIds)),
 		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, peerId string, cl spacesyncproto.DRPCSpaceSyncClient) (err error) {
 	aclStorage, err := d.storage.AclStorage()
 	if err != nil {
@@ -219,7 +238,3 @@ func (d *diffSyncer) subscribe(ctx context.Context, peerId string) (err error) {
 		Payload: payload,
 	})
 }
-
-func (d *diffSyncer) Close() error {
-	return d.treeSyncer.Close()
-}

commonspace/headsync/diffsyncer_test.go

@@ -4,22 +4,22 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"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/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/credentialprovider/mock_credentialprovider"
+	"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/settingsstate/mock_settingsstate"
+	"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/golang/mock/gomock"
 	"github.com/libp2p/go-libp2p/core/sec"
 	"github.com/stretchr/testify/require"
@@ -51,10 +51,6 @@ 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()
 }
@@ -113,13 +109,12 @@ func TestDiffSyncer_Sync(t *testing.T) {
 
 	diffMock := mock_ldiff.NewMockDiff(ctrl)
 	peerManagerMock := mock_peermanager.NewMockPeerManager(ctrl)
-	cacheMock := mock_treemanager.NewMockTreeManager(ctrl)
+	cacheMock := mock_treegetter.NewMockTreeGetter(ctrl)
 	stMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
 	clientMock := mock_spacesyncproto.NewMockDRPCSpaceSyncClient(ctrl)
 	factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceSyncClient {
 		return clientMock
 	})
-	treeSyncerMock := mock_treemanager.NewMockTreeSyncer(ctrl)
 	credentialProvider := mock_credentialprovider.NewMockCredentialProvider(ctrl)
 	delState := mock_settingsstate.NewMockObjectDeletionState(ctrl)
 	spaceId := "spaceId"
@@ -127,21 +122,21 @@ func TestDiffSyncer_Sync(t *testing.T) {
 	l := logger.NewNamed(spaceId)
 	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{mPeer}, nil)
+			Return([]peer.Peer{mockPeer{}}, nil)
 		diffMock.EXPECT().
 			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
 			Return([]string{"new"}, []string{"changed"}, 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)
+		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)
+		}
 		require.NoError(t, diffSyncer.Sync(ctx))
 	})
 
@@ -228,15 +223,16 @@ func TestDiffSyncer_Sync(t *testing.T) {
 	})
 
 	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)
+			Return([]peer.Peer{mockPeer{}}, 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)
+		cacheMock.EXPECT().
+			GetTree(gomock.Any(), spaceId, "settingsId").
+			Return(nil, nil)
 
 		require.NoError(t, diffSyncer.Sync(ctx))
 	})

commonspace/headsync/headsync.go

@@ -1,20 +1,20 @@
-//go:generate mockgen -destination mock_headsync/mock_headsync.go github.com/anyproto/any-sync/commonspace/headsync DiffSyncer
+//go:generate mockgen -destination mock_headsync/mock_headsync.go github.com/anytypeio/any-sync/commonspace/headsync DiffSyncer
 package headsync
 
 import (
 	"context"
-	"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"
+	"github.com/anytypeio/any-sync/app/ldiff"
+	"github.com/anytypeio/any-sync/app/logger"
+	"github.com/anytypeio/any-sync/commonspace/credentialprovider"
+	"github.com/anytypeio/any-sync/commonspace/object/treegetter"
+	"github.com/anytypeio/any-sync/commonspace/peermanager"
+	"github.com/anytypeio/any-sync/commonspace/settings/settingsstate"
+	"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/nodeconf"
+	"github.com/anytypeio/any-sync/util/periodicsync"
 	"go.uber.org/zap"
 	"golang.org/x/exp/slices"
 	"strings"
@@ -46,7 +46,7 @@ type headSync struct {
 	diff           ldiff.Diff
 	log            logger.CtxLogger
 	syncer         DiffSyncer
-	configuration  nodeconf.NodeConf
+	configuration  nodeconf.Configuration
 	spaceIsDeleted *atomic.Bool
 
 	syncPeriod int
@@ -56,10 +56,10 @@ func NewHeadSync(
 	spaceId string,
 	spaceIsDeleted *atomic.Bool,
 	syncPeriod int,
-	configuration nodeconf.NodeConf,
+	configuration nodeconf.Configuration,
 	storage spacestorage.SpaceStorage,
 	peerManager peermanager.PeerManager,
-	cache treemanager.TreeManager,
+	cache treegetter.TreeGetter,
 	syncStatus syncstatus.StatusUpdater,
 	credentialProvider credentialprovider.CredentialProvider,
 	log logger.CtxLogger) HeadSync {
@@ -136,7 +136,7 @@ func (d *headSync) RemoveObjects(ids []string) {
 
 func (d *headSync) Close() (err error) {
 	d.periodicSync.Close()
-	return d.syncer.Close()
+	return nil
 }
 
 func (d *headSync) fillDiff(objectIds []string) {

commonspace/headsync/headsync_test.go

@@ -1,14 +1,14 @@
 package headsync
 
 import (
-	"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/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/settingsstate/mock_settingsstate"
+	"github.com/anytypeio/any-sync/commonspace/spacestorage/mock_spacestorage"
+	"github.com/anytypeio/any-sync/util/periodicsync/mock_periodicsync"
 	"github.com/golang/mock/gomock"
 	"testing"
 )
@@ -65,7 +65,6 @@ 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/anyproto/any-sync/commonspace/headsync (interfaces: DiffSyncer)
+// Source: github.com/anytypeio/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"
 
-	settingsstate "github.com/anyproto/any-sync/commonspace/settings/settingsstate"
+	settingsstate "github.com/anytypeio/any-sync/commonspace/settings/settingsstate"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -35,20 +35,6 @@ 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 settingsstate.ObjectDeletionState) {
 	m.ctrl.T.Helper()

commonspace/headsync/remotediff.go

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

commonspace/headsync/remotediff_test.go

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

commonspace/object/accountdata/accountdata.go

@@ -2,7 +2,7 @@ package accountdata
 
 import (
 	"crypto/rand"
-	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/anytypeio/any-sync/util/crypto"
 )
 
 type AccountKeys struct {

commonspace/object/acl/list/aclrecordbuilder.go

@@ -1,9 +1,9 @@
 package list
 
 import (
-	"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/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anytypeio/any-sync/util/cidutil"
+	"github.com/anytypeio/any-sync/util/crypto"
 	"github.com/gogo/protobuf/proto"
 	"time"
 )

commonspace/object/acl/list/aclstate.go

@@ -3,9 +3,9 @@ package list
 import (
 	"errors"
 	"fmt"
-	"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/anytypeio/any-sync/app/logger"
+	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anytypeio/any-sync/util/crypto"
 	"github.com/gogo/protobuf/proto"
 	"go.uber.org/zap"
 )

commonspace/object/acl/list/aclstatebuilder.go

@@ -1,8 +1,8 @@
 package list
 
 import (
-	"github.com/anyproto/any-sync/commonspace/object/accountdata"
-	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
+	"github.com/anytypeio/any-sync/util/crypto"
 )
 
 type aclStateBuilder struct {

commonspace/object/acl/list/list.go

@@ -1,14 +1,14 @@
-//go:generate mockgen -destination mock_list/mock_list.go github.com/anyproto/any-sync/commonspace/object/acl/list AclList
+//go:generate mockgen -destination mock_list/mock_list.go github.com/anytypeio/any-sync/commonspace/object/acl/list AclList
 package list
 
 import (
 	"context"
 	"errors"
 	"fmt"
-	"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"
+	"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/util/crypto"
 	"sync"
 )
 

commonspace/object/acl/list/list_test.go

@@ -2,7 +2,7 @@ package list
 
 import (
 	"fmt"
-	"github.com/anyproto/any-sync/commonspace/object/accountdata"
+	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
 	"github.com/stretchr/testify/require"
 	"testing"
 )

commonspace/object/acl/list/listutils.go

@@ -1,10 +1,10 @@
 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"
+	"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/util/crypto"
 )
 
 func NewTestDerivedAcl(spaceId string, keys *accountdata.AccountKeys) (AclList, error) {

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

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anyproto/any-sync/commonspace/object/acl/list (interfaces: AclList)
+// Source: github.com/anytypeio/any-sync/commonspace/object/acl/list (interfaces: AclList)
 
 // Package mock_list is a generated GoMock package.
 package mock_list
@@ -7,9 +7,9 @@ package mock_list
 import (
 	reflect "reflect"
 
-	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"
+	aclrecordproto "github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
+	list "github.com/anytypeio/any-sync/commonspace/object/acl/list"
+	crypto "github.com/anytypeio/any-sync/util/crypto"
 	gomock "github.com/golang/mock/gomock"
 )
 

commonspace/object/acl/list/models.go

@@ -1,8 +1,8 @@
 package list
 
 import (
-	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/anytypeio/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anytypeio/any-sync/util/crypto"
 )
 
 type AclRecord struct {

commonspace/object/acl/liststorage/inmemory.go

@@ -3,7 +3,7 @@ package liststorage
 import (
 	"context"
 	"fmt"
-	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anytypeio/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/anyproto/any-sync/commonspace/object/acl/liststorage ListStorage
+//go:generate mockgen -destination mock_liststorage/mock_liststorage.go github.com/anytypeio/any-sync/commonspace/object/acl/liststorage ListStorage
 package liststorage
 
 import (
 	"context"
 	"errors"
-	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	"github.com/anytypeio/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/anyproto/any-sync/commonspace/object/acl/liststorage (interfaces: ListStorage)
+// Source: github.com/anytypeio/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/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
+	aclrecordproto "github.com/anytypeio/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/anyproto/any-sync/commonspace/object/acl/list"
-	"github.com/anyproto/any-sync/commonspace/objectsync"
-	"github.com/anyproto/any-sync/commonspace/objectsync/synchandler"
+	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
+	"github.com/anytypeio/any-sync/commonspace/objectsync"
+	"github.com/anytypeio/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/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anyproto/any-sync/commonspace/object/acl/list"
-	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"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"
 )
 
 type syncAclHandler struct {

commonspace/object/syncobjectgetter/syncobjectgetter.go

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

commonspace/object/tree/exporter/treeexporter.go

@@ -1,11 +1,11 @@
 package exporter
 
 import (
-	"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"
+	"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/treechangeproto"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anytypeio/any-sync/util/crypto"
 )
 
 type DataConverter interface {

commonspace/object/tree/exporter/treeimport.go

@@ -1,10 +1,10 @@
 package exporter
 
 import (
-	"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"
+	"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"
 )
 
 type TreeImportParams struct {

commonspace/object/tree/objecttree/change.go

@@ -2,8 +2,8 @@ package objecttree
 
 import (
 	"errors"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/any-sync/util/crypto"
 	"github.com/gogo/protobuf/proto"
 )
 

commonspace/object/tree/objecttree/changebuilder.go

@@ -2,10 +2,11 @@ package objecttree
 
 import (
 	"errors"
-	"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/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/any-sync/util/cidutil"
+	"github.com/anytypeio/any-sync/util/crypto"
 	"github.com/gogo/protobuf/proto"
+	"time"
 )
 
 var ErrEmptyChange = errors.New("change payload should not be empty")
@@ -19,7 +20,6 @@ type BuilderContent struct {
 	PrivKey        crypto.PrivKey
 	ReadKey        crypto.SymKey
 	Content        []byte
-	Timestamp      int64
 }
 
 type InitialContent struct {
@@ -59,16 +59,13 @@ 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       crypto.KeyStorage
-	newChange  newChangeFunc
 }
 
 func NewChangeBuilder(keys crypto.KeyStorage, rootChange *treechangeproto.RawTreeChangeWithId) ChangeBuilder {
-	return &changeBuilder{keys: keys, rootChange: rootChange, newChange: NewChange}
+	return &changeBuilder{keys: keys, rootChange: rootChange}
 }
 
 func (c *changeBuilder) Unmarshall(rawIdChange *treechangeproto.RawTreeChangeWithId, verify bool) (ch *Change, err error) {
@@ -166,7 +163,7 @@ func (c *changeBuilder) Build(payload BuilderContent) (ch *Change, rawIdChange *
 		AclHeadId:      payload.AclHeadId,
 		SnapshotBaseId: payload.SnapshotBaseId,
 		ReadKeyId:      payload.ReadKeyId,
-		Timestamp:      payload.Timestamp,
+		Timestamp:      time.Now().Unix(),
 		Identity:       identity,
 		IsSnapshot:     payload.IsSnapshot,
 	}
@@ -200,7 +197,7 @@ func (c *changeBuilder) Build(payload BuilderContent) (ch *Change, rawIdChange *
 	if err != nil {
 		return
 	}
-	ch = c.newChange(id, payload.PrivKey.GetPublic(), change, signature)
+	ch = NewChange(id, payload.PrivKey.GetPublic(), change, signature)
 	rawIdChange = &treechangeproto.RawTreeChangeWithId{
 		RawChange: marshalledRawChange,
 		Id:        id,
@@ -271,7 +268,7 @@ func (c *changeBuilder) unmarshallRawChange(raw *treechangeproto.RawTreeChange,
 	if err != nil {
 		return
 	}
-	ch = c.newChange(id, key, unmarshalled, raw.Signature)
+	ch = NewChange(id, key, unmarshalled, raw.Signature)
 	return
 }
 

commonspace/object/tree/objecttree/historytree.go

@@ -14,47 +14,34 @@ type historyTree struct {
 	*objectTree
 }
 
-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 {
+func (h *historyTree) rebuildFromStorage(beforeId string, include bool) (err error) {
+	ot := h.objectTree
+	ot.treeBuilder.Reset()
+	if beforeId == ot.Id() && !include {
 		return ErrLoadBeforeRoot
 	}
 
 	heads := []string{beforeId}
 	if beforeId == "" {
-		heads, err = h.treeStorage.Heads()
+		heads, err = ot.treeStorage.Heads()
 		if err != nil {
 			return
 		}
 	} else if !include {
-		beforeChange, err := h.treeBuilder.loadChange(beforeId)
+		beforeChange, err := ot.treeBuilder.loadChange(beforeId)
 		if err != nil {
 			return err
 		}
 		heads = beforeChange.PreviousIds
 	}
 
-	h.tree, err = h.treeBuilder.build(heads, nil, nil)
-	return
+	ot.tree, err = ot.treeBuilder.build(heads, nil, nil)
+	if err != nil {
+		return
+	}
+	ot.aclList.RLock()
+	defer ot.aclList.RUnlock()
+	state := ot.aclList.AclState()
+
+	return ot.readKeysFromAclState(state)
 }

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

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anyproto/any-sync/commonspace/object/tree/objecttree (interfaces: ObjectTree)
+// Source: github.com/anytypeio/any-sync/commonspace/object/tree/objecttree (interfaces: ObjectTree)
 
 // Package mock_objecttree is a generated GoMock package.
 package mock_objecttree
@@ -9,10 +9,10 @@ import (
 	reflect "reflect"
 	time "time"
 
-	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"
+	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"
 	gomock "github.com/golang/mock/gomock"
 )
 

commonspace/object/tree/objecttree/objecttree.go

@@ -1,18 +1,18 @@
-//go:generate mockgen -destination mock_objecttree/mock_objecttree.go github.com/anyproto/any-sync/commonspace/object/tree/objecttree ObjectTree
+//go:generate mockgen -destination mock_objecttree/mock_objecttree.go github.com/anytypeio/any-sync/commonspace/object/tree/objecttree ObjectTree
 package objecttree
 
 import (
 	"context"
 	"errors"
-	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/anytypeio/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"
+	"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/treechangeproto"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anytypeio/any-sync/util/slice"
 )
 
 type RWLocker interface {
@@ -116,25 +116,13 @@ 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()
@@ -199,7 +187,7 @@ func (ot *objectTree) AddContent(ctx context.Context, content SignableChangeCont
 		panic(err)
 	}
 
-	err = ot.treeStorage.AddRawChangesSetHeads([]*treechangeproto.RawTreeChangeWithId{rawChange}, []string{objChange.Id})
+	err = ot.treeStorage.TransactionAdd([]*treechangeproto.RawTreeChangeWithId{rawChange}, []string{objChange.Id})
 	if err != nil {
 		return
 	}
@@ -263,10 +251,6 @@ func (ot *objectTree) prepareBuilderContent(content SignableChangeContent) (cnt
 		}
 		readKey = ot.currentReadKey
 	}
-	timestamp := content.Timestamp
-	if timestamp <= 0 {
-		timestamp = time.Now().Unix()
-	}
 	cnt = BuilderContent{
 		TreeHeadIds:    ot.tree.Heads(),
 		AclHeadId:      ot.aclList.Head().Id,
@@ -276,7 +260,6 @@ func (ot *objectTree) prepareBuilderContent(content SignableChangeContent) (cnt
 		PrivKey:        content.Key,
 		ReadKey:        readKey,
 		Content:        content.Data,
-		Timestamp:      timestamp,
 	}
 	return
 }
@@ -296,11 +279,7 @@ func (ot *objectTree) AddRawChanges(ctx context.Context, changesPayload RawChang
 		addResult.Mode = Rebuild
 	}
 
-	err = ot.treeStorage.AddRawChangesSetHeads(addResult.Added, addResult.Heads)
-	if err != nil {
-		// rolling back all changes made to inmemory state
-		ot.rebuildFromStorage(nil, nil)
-	}
+	err = ot.treeStorage.TransactionAdd(addResult.Added, addResult.Heads)
 	return
 }
 
@@ -363,7 +342,7 @@ func (ot *objectTree) addRawChanges(ctx context.Context, changesPayload RawChang
 	}
 
 	// checks if we need to go to database
-	snapshotNotInTree := func(ch *Change) bool {
+	isOldSnapshot := func(ch *Change) bool {
 		if ch.SnapshotId == ot.tree.RootId() {
 			return false
 		}
@@ -378,12 +357,26 @@ func (ot *objectTree) addRawChanges(ctx context.Context, changesPayload RawChang
 
 	shouldRebuildFromStorage := false
 	// checking if we have some changes with different snapshot and then rebuilding
-	for _, ch := range ot.newChangesBuf {
-		if snapshotNotInTree(ch) {
+	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
 			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)
@@ -480,11 +473,6 @@ 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
 	}
@@ -551,8 +539,22 @@ 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 _, attachedExists := ot.tree.attached[ch]; !attachedExists {
+		if !hasChange(ch) {
 			return false
 		}
 	}
@@ -619,7 +621,19 @@ func (ot *objectTree) ChangesAfterCommonSnapshot(theirPath, theirHeads []string)
 		}
 	}
 
-	return ot.rawChangeLoader.Load(commonSnapshot, ot.tree, theirHeads)
+	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)
 }
 
 func (ot *objectTree) snapshotPathIsActual() bool {

commonspace/object/tree/objecttree/objecttree_test.go

@@ -2,44 +2,105 @@ package objecttree
 
 import (
 	"context"
-	"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"
+	"crypto/rand"
+	"github.com/anytypeio/any-sync/commonspace/object/accountdata"
+	"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/crypto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"testing"
-	"time"
 )
 
+type mockKeyStorage struct {
+	key crypto.PubKey
+}
+
+func newKeyStorage() mockKeyStorage {
+	_, pk, _ := crypto.GenerateEd25519Key(rand.Reader)
+	return mockKeyStorage{pk}
+}
+
+func (m mockKeyStorage) PubKeyFromProto(protoBytes []byte) (crypto.PubKey, error) {
+	return m.key, nil
+}
+
+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
-	changeCreator *MockChangeCreator
+	changeBuilder ChangeBuilder
+	changeCreator *mockChangeCreator
 	objTree       ObjectTree
 }
 
-func prepareAclList(t *testing.T) (list.AclList, *accountdata.AccountKeys) {
+func prepareAclList(t *testing.T) list.AclList {
 	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, randKeys
+	return aclList
 }
 
-func prepareHistoryTreeDeps(aclList list.AclList) (*MockChangeCreator, objectTreeDeps) {
-	changeCreator := NewMockChangeCreator()
-	treeStorage := changeCreator.CreateNewTreeStorage("0", aclList.Head().Id)
+func prepareTreeDeps(aclList list.AclList) (*mockChangeCreator, objectTreeDeps) {
+	changeCreator := &mockChangeCreator{}
+	treeStorage := changeCreator.createNewTreeStorage("0", aclList.Head().Id)
 	root, _ := treeStorage.Root()
 	changeBuilder := &nonVerifiableChangeBuilder{
-		ChangeBuilder: NewChangeBuilder(newMockKeyStorage(), root),
+		ChangeBuilder: NewChangeBuilder(newKeyStorage(), root),
 	}
 	deps := objectTreeDeps{
 		changeBuilder:   changeBuilder,
-		treeBuilder:     newTreeBuilder(true, treeStorage, changeBuilder),
+		treeBuilder:     newTreeBuilder(treeStorage, changeBuilder),
 		treeStorage:     treeStorage,
 		rawChangeLoader: newRawChangeLoader(treeStorage, changeBuilder),
 		validator:       &noOpTreeValidator{},
@@ -49,26 +110,23 @@ func prepareHistoryTreeDeps(aclList list.AclList) (*MockChangeCreator, objectTre
 }
 
 func prepareTreeContext(t *testing.T, aclList list.AclList) testTreeContext {
-	return prepareContext(t, aclList, BuildTestableTree, nil)
-}
-
-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)
+	changeCreator := &mockChangeCreator{}
+	treeStorage := changeCreator.createNewTreeStorage("0", aclList.Head().Id)
+	root, _ := treeStorage.Root()
+	changeBuilder := &nonVerifiableChangeBuilder{
+		ChangeBuilder: NewChangeBuilder(newKeyStorage(), root),
 	}
-	objTree, err := objTreeBuilder(treeStorage, aclList)
+	deps := objectTreeDeps{
+		changeBuilder:   changeBuilder,
+		treeBuilder:     newTreeBuilder(treeStorage, changeBuilder),
+		treeStorage:     treeStorage,
+		rawChangeLoader: newRawChangeLoader(treeStorage, changeBuilder),
+		validator:       &noOpTreeValidator{},
+		aclList:         aclList,
+	}
+
+	// check build
+	objTree, err := buildObjectTree(deps)
 	require.NoError(t, err, "building tree should be without error")
 
 	// check tree iterate
@@ -78,69 +136,18 @@ func prepareContext(
 		return true
 	})
 	require.NoError(t, err, "iterate should be without error")
-	if additionalChanges == nil {
-		assert.Equal(t, []string{"0"}, iterChangesId)
-	}
+	assert.Equal(t, []string{"0"}, iterChangesId)
 	return testTreeContext{
 		aclList:       aclList,
 		treeStorage:   treeStorage,
+		changeBuilder: changeBuilder,
 		changeCreator: changeCreator,
 		objTree:       objTree,
 	}
 }
 
 func TestObjectTree(t *testing.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)
-		})
-	})
+	aclList := prepareAclList(t)
 
 	t.Run("add simple", func(t *testing.T) {
 		ctx := prepareTreeContext(t, aclList)
@@ -149,8 +156,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},
@@ -194,7 +201,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},
@@ -218,33 +225,7 @@ func TestObjectTree(t *testing.T) {
 		objTree := ctx.objTree
 
 		rawChanges := []*treechangeproto.RawTreeChangeWithId{
-			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"),
+			changeCreator.createRaw("2", aclList.Head().Id, "0", false, "1"),
 		}
 		payload := RawChangesPayload{
 			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
@@ -270,10 +251,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},
@@ -320,9 +301,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},
@@ -338,195 +319,18 @@ 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{
@@ -600,13 +404,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{
@@ -681,9 +485,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},
@@ -695,9 +499,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},
@@ -738,17 +542,17 @@ func TestObjectTree(t *testing.T) {
 	})
 
 	t.Run("test history tree not include", func(t *testing.T) {
-		changeCreator, deps := prepareHistoryTreeDeps(aclList)
+		changeCreator, deps := prepareTreeDeps(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.AddRawChangesSetHeads(rawChanges, []string{"6"})
+		deps.treeStorage.TransactionAdd(rawChanges, []string{"6"})
 		hTree, err := buildHistoryTree(deps, HistoryTreeParams{
 			BeforeId:        "6",
 			IncludeBeforeId: false,
@@ -768,49 +572,18 @@ 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 := prepareHistoryTreeDeps(aclList)
+		changeCreator, deps := prepareTreeDeps(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.AddRawChangesSetHeads(rawChanges, []string{"6"})
+		deps.treeStorage.TransactionAdd(rawChanges, []string{"6"})
 		hTree, err := buildHistoryTree(deps, HistoryTreeParams{
 			BeforeId:        "6",
 			IncludeBeforeId: true,
@@ -831,7 +604,7 @@ func TestObjectTree(t *testing.T) {
 	})
 
 	t.Run("test history tree root", func(t *testing.T) {
-		_, deps := prepareHistoryTreeDeps(aclList)
+		_, deps := prepareTreeDeps(aclList)
 		hTree, err := buildHistoryTree(deps, HistoryTreeParams{
 			BeforeId:        "0",
 			IncludeBeforeId: true,
@@ -850,40 +623,4 @@ 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,10 +1,12 @@
 package objecttree
 
 import (
-	"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"
+	"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/crypto"
+	"math/rand"
+	"time"
 )
 
 type ObjectTreeCreatePayload struct {
@@ -13,8 +15,6 @@ type ObjectTreeCreatePayload struct {
 	ChangePayload []byte
 	SpaceId       string
 	IsEncrypted   bool
-	Seed          []byte
-	Timestamp     int64
 }
 
 type HistoryTreeParams struct {
@@ -22,7 +22,6 @@ type HistoryTreeParams struct {
 	AclList         list.AclList
 	BeforeId        string
 	IncludeBeforeId bool
-	BuildFullTree   bool
 }
 
 type objectTreeDeps struct {
@@ -34,16 +33,12 @@ type objectTreeDeps struct {
 	aclList         list.AclList
 }
 
-type BuildObjectTreeFunc = func(treeStorage treestorage.TreeStorage, aclList list.AclList) (ObjectTree, error)
-
-var defaultObjectTreeDeps = verifiableTreeDeps
-
-func verifiableTreeDeps(
+func defaultObjectTreeDeps(
 	rootChange *treechangeproto.RawTreeChangeWithId,
 	treeStorage treestorage.TreeStorage,
 	aclList list.AclList) objectTreeDeps {
 	changeBuilder := NewChangeBuilder(crypto.NewKeyStorage(), rootChange)
-	treeBuilder := newTreeBuilder(true, treeStorage, changeBuilder)
+	treeBuilder := newTreeBuilder(treeStorage, changeBuilder)
 	return objectTreeDeps{
 		changeBuilder:   changeBuilder,
 		treeBuilder:     treeBuilder,
@@ -54,28 +49,12 @@ func verifiableTreeDeps(
 	}
 }
 
-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(newMockKeyStorage(), rootChange)}
-	treeBuilder := newTreeBuilder(true, treeStorage, changeBuilder)
+	changeBuilder := &nonVerifiableChangeBuilder{NewChangeBuilder(nil, rootChange)}
+	treeBuilder := newTreeBuilder(treeStorage, changeBuilder)
 	return objectTreeDeps{
 		changeBuilder:   changeBuilder,
 		treeBuilder:     treeBuilder,
@@ -86,47 +65,17 @@ func nonVerifiableTreeDeps(
 	}
 }
 
-func BuildEmptyDataObjectTree(treeStorage treestorage.TreeStorage, aclList list.AclList) (ObjectTree, error) {
-	rootChange, err := treeStorage.Root()
+func CreateObjectTreeRoot(payload ObjectTreeCreatePayload, aclList list.AclList) (root *treechangeproto.RawTreeChangeWithId, err error) {
+	bytes := make([]byte, 32)
+	_, err = rand.Read(bytes)
 	if err != nil {
-		return nil, err
+		return
 	}
-	deps := emptyDataTreeDeps(rootChange, treeStorage, aclList)
-	return buildObjectTree(deps)
+	return createObjectTreeRoot(payload, time.Now().Unix(), bytes, 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 DeriveObjectTreeRoot(payload ObjectTreeCreatePayload, aclList list.AclList) (root *treechangeproto.RawTreeChangeWithId, err error) {
+	return createObjectTreeRoot(payload, 0, nil, aclList)
 }
 
 func BuildObjectTree(treeStorage treestorage.TreeStorage, aclList list.AclList) (ObjectTree, error) {
@@ -156,7 +105,54 @@ func BuildHistoryTree(params HistoryTreeParams) (HistoryTree, error) {
 	return buildHistoryTree(deps, params)
 }
 
-func CreateObjectTreeRoot(payload ObjectTreeCreatePayload, aclList list.AclList) (root *treechangeproto.RawTreeChangeWithId, err error) {
+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().Unix(), 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) {
 	aclList.RLock()
 	aclHeadId := aclList.Head().Id
 	aclList.RUnlock()
@@ -170,8 +166,8 @@ func CreateObjectTreeRoot(payload ObjectTreeCreatePayload, aclList list.AclList)
 		SpaceId:       payload.SpaceId,
 		ChangeType:    payload.ChangeType,
 		ChangePayload: payload.ChangePayload,
-		Timestamp:     payload.Timestamp,
-		Seed:          payload.Seed,
+		Timestamp:     timestamp,
+		Seed:          seed,
 	}
 
 	_, root, err = NewChangeBuilder(crypto.NewKeyStorage(), nil).BuildRoot(cnt)
@@ -231,7 +227,7 @@ func buildHistoryTree(deps objectTreeDeps, params HistoryTreeParams) (ht History
 	}
 
 	hTree := &historyTree{objectTree: objTree}
-	err = hTree.rebuildFromStorage(params)
+	err = hTree.rebuildFromStorage(params.BeforeId, params.IncludeBeforeId)
 	if err != nil {
 		return nil, err
 	}

commonspace/object/tree/objecttree/objecttreevalidator.go

@@ -1,12 +1,10 @@
 package objecttree
 
 import (
-	"context"
 	"fmt"
-	"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"
+	"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"
 )
 
 type ObjectTreeValidator interface {
@@ -90,23 +88,11 @@ 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, []string{payload.RootRawChange.Id}, nil)
+	treeStorage, err := treestorage.NewInMemoryTreeStorage(payload.RootRawChange, payload.Heads, payload.Changes)
 	if err != nil {
 		return
 	}
-	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
-	}
+
+	_, err = BuildObjectTree(treeStorage, aclList)
 	return
 }

commonspace/object/tree/objecttree/rawloader.go

@@ -2,16 +2,15 @@ package objecttree
 
 import (
 	"context"
-	"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/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/treestorage"
+	"github.com/anytypeio/any-sync/util/slice"
 	"time"
 )
 
 type rawChangeLoader struct {
-	treeStorage       treestorage.TreeStorage
-	changeBuilder     ChangeBuilder
-	alwaysFromStorage bool
+	treeStorage   treestorage.TreeStorage
+	changeBuilder ChangeBuilder
 
 	// buffers
 	idStack []string
@@ -24,12 +23,6 @@ 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,
@@ -37,15 +30,7 @@ func newRawChangeLoader(treeStorage treestorage.TreeStorage, changeBuilder Chang
 	}
 }
 
-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) {
+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])
@@ -113,7 +98,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,19 +1,12 @@
 package objecttree
 
 import (
-	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/anytypeio/any-sync/util/crypto"
 )
 
-// SignableChangeContent is a payload to be passed when we are creating change
 type SignableChangeContent struct {
-	// 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
+	Data        []byte
+	Key         crypto.PrivKey
+	IsSnapshot  bool
 	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

@@ -1,121 +0,0 @@
-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/treebuilder.go

@@ -6,9 +6,9 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/anyproto/any-sync/app/logger"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anyproto/any-sync/util/slice"
+	"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"
 )
 
@@ -21,20 +21,18 @@ type treeBuilder struct {
 	treeStorage treestorage.TreeStorage
 	builder     ChangeBuilder
 
-	cache            map[string]*Change
-	tree             *Tree
-	keepInMemoryData bool
+	cache map[string]*Change
+	tree  *Tree
 
 	// buffers
 	idStack    []string
 	loadBuffer []*Change
 }
 
-func newTreeBuilder(keepData bool, storage treestorage.TreeStorage, builder ChangeBuilder) *treeBuilder {
+func newTreeBuilder(storage treestorage.TreeStorage, builder ChangeBuilder) *treeBuilder {
 	return &treeBuilder{
-		treeStorage:      storage,
-		builder:          builder,
-		keepInMemoryData: keepData,
+		treeStorage: storage,
+		builder:     builder,
 	}
 }
 
@@ -51,27 +49,7 @@ 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)
 
@@ -121,8 +99,8 @@ func (tb *treeBuilder) buildTree(heads []string, breakpoint string) (err error)
 	if err != nil {
 		return
 	}
-	changes := tb.dfs(heads, breakpoint)
 	tb.tree.AddFast(ch)
+	changes := tb.dfs(heads, breakpoint)
 	tb.tree.AddFast(changes...)
 	return
 }
@@ -181,9 +159,6 @@ 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/util.go

@@ -2,7 +2,7 @@ package objecttree
 
 import (
 	"fmt"
-	"github.com/anyproto/any-sync/util/crypto"
+	"github.com/anytypeio/any-sync/util/crypto"
 	"math/rand"
 )
 

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

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anyproto/any-sync/commonspace/object/tree/synctree (interfaces: SyncTree,ReceiveQueue,HeadNotifiable)
+// Source: github.com/anytypeio/any-sync/commonspace/object/tree/synctree (interfaces: SyncClient,SyncTree,ReceiveQueue,HeadNotifiable)
 
 // Package mock_synctree is a generated GoMock package.
 package mock_synctree
@@ -9,15 +9,124 @@ import (
 	reflect "reflect"
 	time "time"
 
-	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"
+	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"
 	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

commonspace/object/tree/synctree/receivequeue.go

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

commonspace/object/tree/synctree/requestfactory.go

@@ -1,10 +1,10 @@
-package objectsync
+package synctree
 
 import (
 	"fmt"
-	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anyproto/any-sync/util/slice"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/any-sync/util/slice"
 )
 
 type RequestFactory interface {
@@ -14,8 +14,10 @@ type RequestFactory interface {
 	CreateFullSyncResponse(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (*treechangeproto.TreeSyncMessage, error)
 }
 
-func NewRequestFactory() RequestFactory {
-	return &requestFactory{}
+var sharedFactory = &requestFactory{}
+
+func GetRequestFactory() RequestFactory {
+	return sharedFactory
 }
 
 type requestFactory struct{}

commonspace/object/tree/synctree/syncclient.go

@@ -0,0 +1,66 @@
+//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

@@ -1,361 +0,0 @@
-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,4 +1,3 @@
-//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anyproto/any-sync/commonspace/object/tree/synctree SyncTree,ReceiveQueue,HeadNotifiable
 package synctree
 
 import (
@@ -6,17 +5,17 @@ import (
 	"errors"
 	"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"
+	"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"
+	"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"
 	"go.uber.org/zap"
 )
 
@@ -44,7 +43,7 @@ type SyncTree interface {
 type syncTree struct {
 	objecttree.ObjectTree
 	synchandler.SyncHandler
-	syncClient objectsync.SyncClient
+	syncClient SyncClient
 	syncStatus syncstatus.StatusUpdater
 	notifiable HeadNotifiable
 	listener   updatelistener.UpdateListener
@@ -55,14 +54,17 @@ type syncTree struct {
 
 var log = logger.NewNamed("common.commonspace.synctree")
 
+var buildObjectTree = objecttree.BuildObjectTree
+var createSyncClient = newSyncClient
+
 type ResponsiblePeersGetter interface {
 	GetResponsiblePeers(ctx context.Context) (peers []peer.Peer, err error)
 }
 
 type BuildDeps struct {
 	SpaceId            string
-	SyncClient         objectsync.SyncClient
-	Configuration      nodeconf.NodeConf
+	ObjectSync         objectsync.ObjectSync
+	Configuration      nodeconf.Configuration
 	HeadNotifiable     HeadNotifiable
 	Listener           updatelistener.UpdateListener
 	AclList            list.AclList
@@ -71,20 +73,16 @@ type BuildDeps struct {
 	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) {
-	var (
-		remoteGetter = treeRemoteGetter{treeId: id, deps: deps}
-		isRemote     bool
-	)
-	deps.TreeStorage, isRemote, err = remoteGetter.getTree(ctx)
+	remoteGetter := treeRemoteGetter{treeId: id, deps: deps}
+	deps.TreeStorage, err = remoteGetter.getTree(ctx)
 	if err != nil {
 		return
 	}
-	return buildSyncTree(ctx, isRemote, deps)
+	return buildSyncTree(ctx, true, deps)
 }
 
 func PutSyncTree(ctx context.Context, payload treestorage.TreeStorageCreatePayload, deps BuildDeps) (t SyncTree, err error) {
@@ -95,12 +93,16 @@ func PutSyncTree(ctx context.Context, payload treestorage.TreeStorageCreatePaylo
 	return buildSyncTree(ctx, true, deps)
 }
 
-func buildSyncTree(ctx context.Context, sendUpdate bool, deps BuildDeps) (t SyncTree, err error) {
-	objTree, err := deps.BuildObjectTree(deps.TreeStorage, deps.AclList)
+func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t SyncTree, err error) {
+	objTree, err := buildObjectTree(deps.TreeStorage, deps.AclList)
 	if err != nil {
 		return
 	}
-	syncClient := deps.SyncClient
+	syncClient := createSyncClient(
+		deps.SpaceId,
+		deps.ObjectSync.MessagePool(),
+		sharedFactory,
+		deps.Configuration)
 	syncTree := &syncTree{
 		ObjectTree: objTree,
 		syncClient: syncClient,
@@ -116,10 +118,12 @@ func buildSyncTree(ctx context.Context, sendUpdate bool, deps BuildDeps) (t Sync
 	syncTree.afterBuild()
 	syncTree.Unlock()
 
-	if sendUpdate {
+	if isFirstBuild {
 		headUpdate := syncTree.syncClient.CreateHeadUpdate(t, nil)
 		// send to everybody, because everybody should know that the node or client got new tree
-		syncTree.syncClient.Broadcast(ctx, headUpdate)
+		if e := syncTree.syncClient.Broadcast(ctx, headUpdate); e != nil {
+			log.ErrorCtx(ctx, "broadcast error", zap.Error(e))
+		}
 	}
 	return
 }
@@ -156,7 +160,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)
-	s.syncClient.Broadcast(ctx, headUpdate)
+	err = s.syncClient.Broadcast(ctx, headUpdate)
 	return
 }
 
@@ -183,7 +187,7 @@ func (s *syncTree) AddRawChanges(ctx context.Context, changesPayload objecttree.
 			s.notifiable.UpdateHeads(s.Id(), res.Heads)
 		}
 		headUpdate := s.syncClient.CreateHeadUpdate(s, res.Added)
-		s.syncClient.Broadcast(ctx, headUpdate)
+		err = s.syncClient.Broadcast(ctx, headUpdate)
 	}
 	return
 }
@@ -239,7 +243,7 @@ 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.RootChange.Id, headUpdate, "")
+	return s.syncClient.SendWithReply(ctx, peerId, headUpdate, "")
 }
 
 func (s *syncTree) afterBuild() {

commonspace/object/tree/synctree/synctree_test.go

@@ -2,15 +2,15 @@ package synctree
 
 import (
 	"context"
-	"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/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/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 	"testing"
@@ -18,7 +18,7 @@ import (
 
 type syncTreeMatcher struct {
 	objTree  objecttree.ObjectTree
-	client   objectsync.SyncClient
+	client   SyncClient
 	listener updatelistener.UpdateListener
 }
 
@@ -34,8 +34,8 @@ func (s syncTreeMatcher) String() string {
 	return ""
 }
 
-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 {
+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 {
 		return client
 	}
 }
@@ -46,7 +46,7 @@ func Test_BuildSyncTree(t *testing.T) {
 	defer ctrl.Finish()
 
 	updateListenerMock := mock_updatelistener.NewMockUpdateListener(ctrl)
-	syncClientMock := mock_objectsync.NewMockSyncClient(ctrl)
+	syncClientMock := mock_synctree.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))
+		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate)).Return(nil)
 		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))
+		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate)).Return(nil)
 		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))
+		syncClientMock.EXPECT().Broadcast(gomock.Any(), gomock.Eq(headUpdate)).Return(nil)
 		res, err := tr.AddContent(ctx, content)
 		require.NoError(t, err)
 		require.Equal(t, expectedRes, res)

commonspace/object/tree/synctree/synctreehandler.go

@@ -2,13 +2,12 @@ package synctree
 
 import (
 	"context"
-	"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/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/gogo/protobuf/proto"
 	"go.uber.org/zap"
 	"sync"
@@ -16,7 +15,7 @@ import (
 
 type syncTreeHandler struct {
 	objTree     objecttree.ObjectTree
-	syncClient  objectsync.SyncClient
+	syncClient  SyncClient
 	syncStatus  syncstatus.StatusUpdater
 	handlerLock sync.Mutex
 	spaceId     string
@@ -25,7 +24,7 @@ type syncTreeHandler struct {
 
 const maxQueueSize = 5
 
-func newSyncTreeHandler(spaceId string, objTree objecttree.ObjectTree, syncClient objectsync.SyncClient, syncStatus syncstatus.StatusUpdater) synchandler.SyncHandler {
+func newSyncTreeHandler(spaceId string, objTree objecttree.ObjectTree, syncClient SyncClient, syncStatus syncstatus.StatusUpdater) synchandler.SyncHandler {
 	return &syncTreeHandler{
 		objTree:    objTree,
 		syncClient: syncClient,
@@ -82,21 +81,15 @@ func (s *syncTreeHandler) handleHeadUpdate(
 		fullRequest   *treechangeproto.TreeSyncMessage
 		isEmptyUpdate = len(update.Changes) == 0
 		objTree       = s.objTree
-		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 := log.With(zap.Strings("heads", objTree.Heads()), zap.String("treeId", objTree.Id()), zap.String("spaceId", s.spaceId))
 	log.DebugCtx(ctx, "received head update message")
 
 	defer func() {
 		if err != nil {
-			log.ErrorCtx(ctx, "head update finished with error", zap.Error(err))
+			log.With(zap.Error(err)).Debug("head update finished with error")
 		} 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 {
@@ -119,7 +112,7 @@ func (s *syncTreeHandler) handleHeadUpdate(
 			return
 		}
 
-		return s.syncClient.SendWithReply(ctx, senderId, treeId, fullRequest, replyId)
+		return s.syncClient.SendWithReply(ctx, senderId, fullRequest, replyId)
 	}
 
 	if s.alreadyHasHeads(objTree, update.Heads) {
@@ -143,7 +136,7 @@ func (s *syncTreeHandler) handleHeadUpdate(
 		return
 	}
 
-	return s.syncClient.SendWithReply(ctx, senderId, treeId, fullRequest, replyId)
+	return s.syncClient.SendWithReply(ctx, senderId, fullRequest, replyId)
 }
 
 func (s *syncTreeHandler) handleFullSyncRequest(
@@ -155,25 +148,22 @@ 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("request heads", request.Heads),
-		zap.String("treeId", treeId),
+		zap.Strings("heads", request.Heads),
+		zap.String("treeId", s.objTree.Id()),
 		zap.String("replyId", replyId),
-		zap.String("spaceId", s.spaceId),
-		zap.Int("len(request changes)", len(request.Changes)))
+		zap.String("spaceId", s.spaceId))
 	log.DebugCtx(ctx, "received full sync request message")
 
 	defer func() {
 		if err != nil {
-			log.ErrorCtx(ctx, "full sync request finished with error", zap.Error(err))
-			s.syncClient.SendWithReply(ctx, senderId, treeId, treechangeproto.WrapError(treechangeproto.ErrFullSync, header), replyId)
+			log.With(zap.Error(err)).DebugCtx(ctx, "full sync request finished with error")
+
+			s.syncClient.SendWithReply(ctx, senderId, treechangeproto.WrapError(err, 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")
 		}
 	}()
@@ -192,7 +182,7 @@ func (s *syncTreeHandler) handleFullSyncRequest(
 		return
 	}
 
-	return s.syncClient.SendWithReply(ctx, senderId, treeId, fullResponse, replyId)
+	return s.syncClient.SendWithReply(ctx, senderId, fullResponse, replyId)
 }
 
 func (s *syncTreeHandler) handleFullSyncResponse(
@@ -201,18 +191,13 @@ 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", treeId),
-		zap.String("spaceId", s.spaceId),
-		zap.Int("len(changes)", len(response.Changes)))
+	log := log.With(zap.Strings("heads", response.Heads), zap.String("treeId", s.objTree.Id()), zap.String("spaceId", s.spaceId))
 	log.DebugCtx(ctx, "received full sync response message")
 
 	defer func() {
 		if err != nil {
-			log.ErrorCtx(ctx, "full sync response failed", zap.Error(err))
+			log.With(zap.Error(err)).DebugCtx(ctx, "full sync response failed")
 		} else {
 			log.DebugCtx(ctx, "full sync response succeeded")
 		}

commonspace/object/tree/synctree/synctreehandler_test.go

@@ -3,16 +3,15 @@ package synctree
 import (
 	"context"
 	"fmt"
-	"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/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/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
@@ -55,7 +54,7 @@ func (t *testObjTreeMock) TryRLock() bool {
 
 type syncHandlerFixture struct {
 	ctrl             *gomock.Controller
-	syncClientMock   *mock_objectsync.MockSyncClient
+	syncClientMock   *mock_synctree.MockSyncClient
 	objectTreeMock   *testObjTreeMock
 	receiveQueueMock ReceiveQueue
 
@@ -64,7 +63,7 @@ type syncHandlerFixture struct {
 
 func newSyncHandlerFixture(t *testing.T) *syncHandlerFixture {
 	ctrl := gomock.NewController(t)
-	syncClientMock := mock_objectsync.NewMockSyncClient(ctrl)
+	syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
 	objectTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
 	receiveQueue := newReceiveQueue(5)
 
@@ -90,13 +89,6 @@ 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)
@@ -110,7 +102,7 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).Times(2)
@@ -121,6 +113,7 @@ 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)
@@ -139,7 +132,8 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		fullRequest := &treechangeproto.TreeSyncMessage{}
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).AnyTimes()
@@ -154,7 +148,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(treeId), gomock.Eq(fullRequest), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullRequest), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -172,7 +166,7 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h1"}).AnyTimes()
@@ -193,14 +187,15 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		fullRequest := &treechangeproto.TreeSyncMessage{}
 
 		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(treeId), gomock.Eq(fullRequest), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullRequest), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -218,7 +213,7 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapHeadUpdate(headUpdate, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Heads().Return([]string{"h1"}).AnyTimes()
@@ -231,13 +226,6 @@ 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)
@@ -251,7 +239,8 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullRequest(fullSyncRequest, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		fullResponse := &treechangeproto.TreeSyncMessage{}
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().Header().Return(nil)
@@ -266,7 +255,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(treeId), gomock.Eq(fullResponse), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullResponse), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -284,7 +273,8 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullRequest(fullSyncRequest, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		fullResponse := &treechangeproto.TreeSyncMessage{}
 
 		fx.objectTreeMock.EXPECT().
 			Id().AnyTimes().Return(treeId)
@@ -295,7 +285,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(treeId), gomock.Eq(fullResponse), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullResponse), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -313,8 +303,9 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullRequest(fullSyncRequest, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
 		objectMsg.RequestId = replyId
+		fullResponse := &treechangeproto.TreeSyncMessage{}
 
 		fx.objectTreeMock.EXPECT().
 			Id().AnyTimes().Return(treeId)
@@ -322,7 +313,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(treeId), gomock.Eq(fullResponse), gomock.Eq(replyId))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Eq(fullResponse), gomock.Eq(replyId))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.NoError(t, err)
@@ -340,7 +331,7 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullRequest(fullSyncRequest, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, "")
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, "")
 
 		fx.objectTreeMock.EXPECT().
 			Id().AnyTimes().Return(treeId)
@@ -357,7 +348,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.Eq(treeId), gomock.Any(), gomock.Eq(""))
+		fx.syncClientMock.EXPECT().SendWithReply(gomock.Any(), gomock.Eq(senderId), gomock.Any(), gomock.Eq(""))
 
 		err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)
 		require.Error(t, err)
@@ -381,7 +372,7 @@ func TestSyncHandler_HandleFullSyncResponse(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullResponse(fullSyncResponse, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, replyId)
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, replyId)
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().
@@ -414,7 +405,7 @@ func TestSyncHandler_HandleFullSyncResponse(t *testing.T) {
 			SnapshotPath: []string{"h1"},
 		}
 		treeMsg := treechangeproto.WrapFullResponse(fullSyncResponse, chWithId)
-		objectMsg, _ := objectsync.MarshallTreeMessage(treeMsg, "spaceId", treeId, replyId)
+		objectMsg, _ := marshallTreeMessage(treeMsg, "spaceId", treeId, replyId)
 
 		fx.objectTreeMock.EXPECT().Id().AnyTimes().Return(treeId)
 		fx.objectTreeMock.EXPECT().

commonspace/object/tree/synctree/treeremotegetter.go

@@ -3,12 +3,11 @@ package synctree
 import (
 	"context"
 	"fmt"
-	"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/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/gogo/protobuf/proto"
 	"go.uber.org/zap"
 	"time"
@@ -46,8 +45,13 @@ 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 := t.deps.SyncClient.CreateNewTreeRequest()
-	resp, err := t.deps.SyncClient.SendSync(ctx, peerId, t.treeId, newTreeRequest)
+	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)
 	if err != nil {
 		return
 	}
@@ -90,11 +94,12 @@ Loop:
 	}
 }
 
-func (t treeRemoteGetter) getTree(ctx context.Context) (treeStorage treestorage.TreeStorage, isRemote bool, err error) {
+func (t treeRemoteGetter) getTree(ctx context.Context) (treeStorage treestorage.TreeStorage, err error) {
 	treeStorage, err = t.deps.SpaceStorage.TreeStorage(t.treeId)
 	if err == nil {
 		return
 	}
+
 	if err != nil && err != treestorage.ErrUnknownTreeId {
 		return
 	}
@@ -108,21 +113,13 @@ func (t treeRemoteGetter) getTree(ctx context.Context) (treeStorage treestorage.
 		return
 	}
 
-	isRemote = true
 	resp, err := t.treeRequestLoop(ctx, t.deps.WaitTreeRemoteSync)
 	if err != nil {
 		return
 	}
-	switch {
-	case resp.GetContent().GetErrorResponse() != nil:
-		errResp := resp.GetContent().GetErrorResponse()
-		err = rpcerr.Err(errResp.ErrCode)
+	if resp.GetContent().GetFullSyncResponse() == nil {
+		err = fmt.Errorf("expected to get full sync response, but got something else")
 		return
-	case resp.GetContent().GetFullSyncResponse() == nil:
-		err = treechangeproto.ErrUnexpected
-		return
-	default:
-		break
 	}
 	fullSyncResp := resp.GetContent().GetFullSyncResponse()
 
@@ -139,6 +136,5 @@ func (t treeRemoteGetter) getTree(ctx context.Context) (treeStorage treestorage.
 		return
 	}
 	// now we are sure that we can save it to the storage
-	treeStorage, err = t.deps.SpaceStorage.CreateTreeStorage(payload)
-	return
+	return t.deps.SpaceStorage.CreateTreeStorage(payload)
 }

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

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener (interfaces: UpdateListener)
+// Source: github.com/anytypeio/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/anyproto/any-sync/commonspace/object/tree/objecttree"
+	objecttree "github.com/anytypeio/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/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener UpdateListener
+//go:generate mockgen -destination mock_updatelistener/mock_updatelistener.go github.com/anytypeio/any-sync/commonspace/object/tree/synctree/updatelistener UpdateListener
 package updatelistener
 
 import (
-	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
 )
 
 type UpdateListener interface {

commonspace/object/tree/synctree/utils_test.go

@@ -1,456 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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))
-)

commonspace/object/tree/treechangeproto/protos/treechange.proto

@@ -56,13 +56,6 @@ message RawTreeChangeWithId {
   string id = 2;
 }
 
-enum ErrorCodes {
-  Unexpected = 0;
-  GetTreeError = 1;
-  FullSyncRequestError = 2;
-  ErrorOffset = 400;
-}
-
 message TreeSyncMessage {
   TreeSyncContentValue content = 1;
   RawTreeChangeWithId rootChange = 2;
@@ -102,7 +95,6 @@ message TreeFullSyncResponse {
 // TreeErrorResponse is an error sent as a response for a full sync request
 message TreeErrorResponse {
   string error = 1;
-  uint64 errCode = 2;
 }
 
 // TreeChangeInfo is used internally in Tree implementation for ease of marshalling

commonspace/object/tree/treechangeproto/treechange.go

@@ -1,7 +1,5 @@
 package treechangeproto
 
-import "github.com/anyproto/any-sync/net/rpc/rpcerr"
-
 func WrapHeadUpdate(update *TreeHeadUpdate, rootChange *RawTreeChangeWithId) *TreeSyncMessage {
 	return &TreeSyncMessage{
 		Content: &TreeSyncContentValue{
@@ -32,7 +30,7 @@ func WrapFullResponse(response *TreeFullSyncResponse, rootChange *RawTreeChangeW
 func WrapError(err error, rootChange *RawTreeChangeWithId) *TreeSyncMessage {
 	return &TreeSyncMessage{
 		Content: &TreeSyncContentValue{
-			Value: &TreeSyncContentValue_ErrorResponse{ErrorResponse: &TreeErrorResponse{ErrCode: rpcerr.Code(err)}},
+			Value: &TreeSyncContentValue_ErrorResponse{ErrorResponse: &TreeErrorResponse{Error: err.Error()}},
 		},
 		RootChange: rootChange,
 	}

commonspace/object/tree/treechangeproto/treechange.pb.go

@@ -22,37 +22,6 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
-type ErrorCodes int32
-
-const (
-	ErrorCodes_Unexpected           ErrorCodes = 0
-	ErrorCodes_GetTreeError         ErrorCodes = 1
-	ErrorCodes_FullSyncRequestError ErrorCodes = 2
-	ErrorCodes_ErrorOffset          ErrorCodes = 400
-)
-
-var ErrorCodes_name = map[int32]string{
-	0:   "Unexpected",
-	1:   "GetTreeError",
-	2:   "FullSyncRequestError",
-	400: "ErrorOffset",
-}
-
-var ErrorCodes_value = map[string]int32{
-	"Unexpected":           0,
-	"GetTreeError":         1,
-	"FullSyncRequestError": 2,
-	"ErrorOffset":          400,
-}
-
-func (x ErrorCodes) String() string {
-	return proto.EnumName(ErrorCodes_name, int32(x))
-}
-
-func (ErrorCodes) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_5033f0301ef9b772, []int{0}
-}
-
 // RootChange is a root of a tree
 type RootChange struct {
 	// AclHeadId is a cid of latest acl record at the time of tree creation
@@ -722,8 +691,7 @@ func (m *TreeFullSyncResponse) GetSnapshotPath() []string {
 
 // TreeErrorResponse is an error sent as a response for a full sync request
 type TreeErrorResponse struct {
-	Error   string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
-	ErrCode uint64 `protobuf:"varint,2,opt,name=errCode,proto3" json:"errCode,omitempty"`
+	Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
 }
 
 func (m *TreeErrorResponse) Reset()         { *m = TreeErrorResponse{} }
@@ -766,13 +734,6 @@ func (m *TreeErrorResponse) GetError() string {
 	return ""
 }
 
-func (m *TreeErrorResponse) GetErrCode() uint64 {
-	if m != nil {
-		return m.ErrCode
-	}
-	return 0
-}
-
 // TreeChangeInfo is used internally in Tree implementation for ease of marshalling
 type TreeChangeInfo struct {
 	ChangeType    string `protobuf:"bytes,1,opt,name=changeType,proto3" json:"changeType,omitempty"`
@@ -827,7 +788,6 @@ func (m *TreeChangeInfo) GetChangePayload() []byte {
 }
 
 func init() {
-	proto.RegisterEnum("treechange.ErrorCodes", ErrorCodes_name, ErrorCodes_value)
 	proto.RegisterType((*RootChange)(nil), "treechange.RootChange")
 	proto.RegisterType((*TreeChange)(nil), "treechange.TreeChange")
 	proto.RegisterType((*RawTreeChange)(nil), "treechange.RawTreeChange")
@@ -846,54 +806,50 @@ func init() {
 }
 
 var fileDescriptor_5033f0301ef9b772 = []byte{
-	// 741 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x55, 0x4f, 0x4f, 0xfb, 0x46,
-	0x10, 0xf5, 0x3a, 0x81, 0x90, 0x49, 0x08, 0xe9, 0xc2, 0xc1, 0x42, 0xad, 0x6b, 0x59, 0x55, 0x1b,
-	0xf5, 0x00, 0x12, 0x3d, 0xb5, 0xaa, 0x84, 0x4a, 0x0a, 0x24, 0x42, 0x6d, 0xd1, 0xf2, 0xa7, 0x12,
-	0xb7, 0xc5, 0x9e, 0x10, 0x57, 0x89, 0xed, 0x7a, 0x37, 0xa5, 0xf9, 0x00, 0xbd, 0xb4, 0x12, 0xe2,
-	0x2b, 0xf5, 0xf6, 0x3b, 0x72, 0xe4, 0xf8, 0x13, 0x7c, 0x91, 0x9f, 0xbc, 0x1b, 0x27, 0xb6, 0x93,
-	0x03, 0x37, 0x2e, 0x89, 0xe7, 0x79, 0xe6, 0xed, 0x9b, 0x37, 0xde, 0x5d, 0x38, 0xf4, 0xa2, 0xf1,
-	0x38, 0x0a, 0x45, 0xcc, 0x3d, 0xdc, 0x8f, 0x6e, 0xff, 0x40, 0x4f, 0xee, 0xcb, 0x04, 0x51, 0xfd,
-	0x78, 0x43, 0x1e, 0xde, 0x61, 0x9c, 0x44, 0x32, 0xda, 0x57, 0xbf, 0x22, 0x07, 0xef, 0x29, 0x84,
-	0xc2, 0x02, 0x71, 0x9f, 0x09, 0x00, 0x8b, 0x22, 0xd9, 0x55, 0x21, 0xfd, 0x1c, 0xea, 0xdc, 0x1b,
-	0xf5, 0x90, 0xfb, 0x7d, 0xdf, 0x22, 0x0e, 0xe9, 0xd4, 0xd9, 0x02, 0xa0, 0x16, 0xd4, 0xd4, 0xaa,
-	0x7d, 0xdf, 0x32, 0xd5, 0xbb, 0x2c, 0xa4, 0x36, 0x80, 0x26, 0xbc, 0x9c, 0xc6, 0x68, 0x55, 0xd4,
-	0xcb, 0x1c, 0x92, 0xf2, 0xca, 0x60, 0x8c, 0x42, 0xf2, 0x71, 0x6c, 0x55, 0x1d, 0xd2, 0xa9, 0xb0,
-	0x05, 0x40, 0x29, 0x54, 0x05, 0xa2, 0x6f, 0xad, 0x39, 0xa4, 0xd3, 0x64, 0xea, 0x99, 0xee, 0xc2,
-	0x46, 0xe0, 0x63, 0x28, 0x03, 0x39, 0xb5, 0xd6, 0x15, 0x3e, 0x8f, 0xe9, 0x57, 0xb0, 0xa9, 0xb9,
-	0xcf, 0xf9, 0x74, 0x14, 0x71, 0xdf, 0xaa, 0xa9, 0x84, 0x22, 0xe8, 0x3e, 0x98, 0x00, 0x97, 0x09,
-	0xe2, 0xac, 0x35, 0x07, 0x1a, 0x69, 0xdf, 0xba, 0x15, 0x61, 0x11, 0xa7, 0xd2, 0xa9, 0xb3, 0x3c,
-	0x54, 0x6c, 0xde, 0x2c, 0x37, 0xff, 0x35, 0xb4, 0x44, 0xc8, 0x63, 0x31, 0x8c, 0xe4, 0x11, 0x17,
-	0xa9, 0x07, 0xba, 0xcd, 0x12, 0x9a, 0xae, 0xa3, 0x75, 0x88, 0x9f, 0xb9, 0xe4, 0xaa, 0xd9, 0x26,
-	0xcb, 0x43, 0xe9, 0x3a, 0x09, 0x72, 0xff, 0x0c, 0xa7, 0x7d, 0xdd, 0x73, 0x9d, 0x2d, 0x80, 0xa2,
-	0x55, 0xeb, 0x65, 0xab, 0xf2, 0xb6, 0xd4, 0x4a, 0xb6, 0xd8, 0x00, 0x81, 0xb8, 0x98, 0xa9, 0xb1,
-	0x36, 0x1c, 0xd2, 0xd9, 0x60, 0x39, 0xc4, 0x3d, 0x85, 0x4d, 0xc6, 0xef, 0x73, 0x96, 0x58, 0x50,
-	0x8b, 0x67, 0x0e, 0x12, 0xc5, 0x95, 0x85, 0xa9, 0x08, 0x11, 0xdc, 0x85, 0x5c, 0x4e, 0x12, 0x54,
-	0x56, 0x34, 0xd9, 0x02, 0x70, 0xbb, 0xb0, 0x5d, 0x20, 0xfa, 0x3d, 0x90, 0x43, 0xad, 0x3c, 0xe1,
-	0xf7, 0x1a, 0x9a, 0x11, 0x2e, 0x00, 0xda, 0x02, 0x33, 0xc8, 0x6c, 0x35, 0x03, 0xdf, 0x7d, 0x20,
-	0xb0, 0x95, 0x52, 0x5c, 0x4c, 0x43, 0xef, 0x17, 0x14, 0x82, 0xdf, 0x21, 0xfd, 0x01, 0x6a, 0x5e,
-	0x14, 0x4a, 0x0c, 0xa5, 0xaa, 0x6f, 0x1c, 0x38, 0x7b, 0xb9, 0xaf, 0x37, 0xcb, 0xee, 0xea, 0x94,
-	0x6b, 0x3e, 0x9a, 0x20, 0xcb, 0x0a, 0xe8, 0x21, 0x40, 0x32, 0xff, 0x90, 0xd5, 0x3a, 0x8d, 0x83,
-	0x2f, 0xf3, 0xe5, 0x2b, 0x24, 0xb3, 0x5c, 0x89, 0xfb, 0xbf, 0x09, 0x3b, 0xab, 0x96, 0xa0, 0x3f,
-	0x02, 0x0c, 0x91, 0xfb, 0x57, 0xb1, 0xcf, 0x25, 0xce, 0x84, 0xed, 0x96, 0x85, 0xf5, 0xe6, 0x19,
-	0x3d, 0x83, 0xe5, 0xf2, 0xe9, 0x19, 0x6c, 0x0d, 0x26, 0xa3, 0x51, 0xca, 0xca, 0xf0, 0xcf, 0x09,
-	0x0a, 0xb9, 0x4a, 0x5c, 0x4a, 0x71, 0x52, 0x4c, 0xeb, 0x19, 0xac, 0x5c, 0x49, 0x7f, 0x85, 0xf6,
-	0x02, 0x12, 0x71, 0x14, 0x0a, 0xbd, 0xdb, 0x56, 0x38, 0x75, 0x52, 0xca, 0xeb, 0x19, 0x6c, 0xa9,
-	0x96, 0x1e, 0xc3, 0x26, 0x26, 0x49, 0x94, 0xcc, 0xc9, 0xaa, 0x8a, 0xec, 0x8b, 0x32, 0xd9, 0x71,
-	0x3e, 0xa9, 0x67, 0xb0, 0x62, 0xd5, 0x51, 0x0d, 0xd6, 0xfe, 0x4a, 0xad, 0x72, 0xff, 0x21, 0xd0,
-	0x2a, 0xba, 0x41, 0x77, 0x60, 0x2d, 0x75, 0x23, 0xdb, 0x71, 0x3a, 0xa0, 0xdf, 0x43, 0x6d, 0xb6,
-	0x25, 0x2c, 0xd3, 0xa9, 0xbc, 0x65, 0x54, 0x59, 0x3e, 0x75, 0xa1, 0x99, 0x6d, 0xb9, 0x73, 0x2e,
-	0x87, 0x56, 0x45, 0xf1, 0x16, 0x30, 0xf7, 0x5f, 0x02, 0xdb, 0x2b, 0x2c, 0x7d, 0x1f, 0x31, 0xff,
-	0x11, 0xfd, 0x61, 0x95, 0x27, 0xf2, 0x3e, 0x6a, 0xba, 0xf0, 0xd9, 0xd2, 0x44, 0x53, 0x25, 0x6a,
-	0xa2, 0xb3, 0x33, 0x5f, 0x07, 0xe9, 0xf9, 0x80, 0x49, 0xd2, 0x8d, 0x7c, 0xbd, 0x9f, 0xaa, 0x2c,
-	0x0b, 0xdd, 0x6b, 0x3d, 0x66, 0xad, 0xa2, 0x1f, 0x0e, 0xa2, 0xd2, 0x0d, 0x40, 0x96, 0x6e, 0x80,
-	0xa5, 0x33, 0xdb, 0x5c, 0x71, 0x66, 0x7f, 0x7b, 0x03, 0xa0, 0x84, 0xa5, 0x8b, 0x08, 0xda, 0x02,
-	0xb8, 0x0a, 0xf1, 0xef, 0x18, 0x3d, 0x89, 0x7e, 0xdb, 0xa0, 0x6d, 0x68, 0x9e, 0xa2, 0x9c, 0xab,
-	0x6f, 0x13, 0x6a, 0xc1, 0x4e, 0x69, 0xc4, 0xfa, 0x8d, 0x49, 0xdb, 0xd0, 0x50, 0x8f, 0xbf, 0x0d,
-	0x06, 0x02, 0x65, 0xfb, 0xb1, 0x72, 0xf4, 0xd3, 0x87, 0x17, 0x9b, 0x3c, 0xbd, 0xd8, 0xe4, 0xe3,
-	0x8b, 0x4d, 0x1e, 0x5f, 0x6d, 0xe3, 0xe9, 0xd5, 0x36, 0x9e, 0x5f, 0x6d, 0xe3, 0xe6, 0x9b, 0x37,
-	0xde, 0xa8, 0xb7, 0xeb, 0xea, 0xef, 0xbb, 0x4f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x1b, 0x35, 0x02,
-	0x10, 0x83, 0x07, 0x00, 0x00,
+	// 677 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x55, 0xcf, 0x4f, 0xd4, 0x40,
+	0x14, 0xee, 0x74, 0x81, 0xb2, 0x8f, 0x05, 0x74, 0xe0, 0xd0, 0x10, 0xad, 0x4d, 0x63, 0x74, 0xbd,
+	0x40, 0x82, 0x27, 0x8d, 0x09, 0x11, 0x04, 0x77, 0x43, 0x34, 0x64, 0x40, 0x4c, 0xbc, 0x0d, 0xed,
+	0xc0, 0xd6, 0xec, 0x76, 0x6a, 0x67, 0x56, 0xb2, 0x7f, 0x80, 0x17, 0x4d, 0x88, 0xff, 0x92, 0x37,
+	0x8f, 0x1c, 0x39, 0x1a, 0xf6, 0x1f, 0x31, 0x9d, 0x69, 0xb7, 0x3f, 0x76, 0x0f, 0xdc, 0xb8, 0x74,
+	0xf7, 0x7d, 0x7d, 0xef, 0x7b, 0xdf, 0xfb, 0xe6, 0x47, 0x61, 0xc7, 0xe7, 0x83, 0x01, 0x8f, 0x44,
+	0x4c, 0x7d, 0xb6, 0xc5, 0xcf, 0xbe, 0x32, 0x5f, 0x6e, 0xc9, 0x84, 0x31, 0xf5, 0xf0, 0x7b, 0x34,
+	0xba, 0x60, 0x71, 0xc2, 0x25, 0xdf, 0x52, 0x4f, 0x51, 0x82, 0x37, 0x15, 0x82, 0xa1, 0x40, 0xbc,
+	0x1b, 0x04, 0x40, 0x38, 0x97, 0x7b, 0x2a, 0xc4, 0x8f, 0xa0, 0x49, 0xfd, 0x7e, 0x87, 0xd1, 0xa0,
+	0x1b, 0xd8, 0xc8, 0x45, 0xed, 0x26, 0x29, 0x00, 0x6c, 0x83, 0xa5, 0xba, 0x76, 0x03, 0xdb, 0x54,
+	0xef, 0xf2, 0x10, 0x3b, 0x00, 0x9a, 0xf0, 0x64, 0x14, 0x33, 0xbb, 0xa1, 0x5e, 0x96, 0x90, 0x94,
+	0x57, 0x86, 0x03, 0x26, 0x24, 0x1d, 0xc4, 0xf6, 0x9c, 0x8b, 0xda, 0x0d, 0x52, 0x00, 0x18, 0xc3,
+	0x9c, 0x60, 0x2c, 0xb0, 0xe7, 0x5d, 0xd4, 0x6e, 0x11, 0xf5, 0x1f, 0x6f, 0xc0, 0x62, 0x18, 0xb0,
+	0x48, 0x86, 0x72, 0x64, 0x2f, 0x28, 0x7c, 0x12, 0xe3, 0xa7, 0xb0, 0xac, 0xb9, 0x8f, 0xe8, 0xa8,
+	0xcf, 0x69, 0x60, 0x5b, 0x2a, 0xa1, 0x0a, 0x7a, 0x57, 0x26, 0xc0, 0x49, 0xc2, 0x58, 0x36, 0x9a,
+	0x0b, 0x4b, 0xe9, 0xdc, 0x7a, 0x14, 0x61, 0x23, 0xb7, 0xd1, 0x6e, 0x92, 0x32, 0x54, 0x1d, 0xde,
+	0xac, 0x0f, 0xff, 0x0c, 0x56, 0x44, 0x44, 0x63, 0xd1, 0xe3, 0x72, 0x97, 0x8a, 0xd4, 0x03, 0x3d,
+	0x66, 0x0d, 0x4d, 0xfb, 0x68, 0x1d, 0xe2, 0x1d, 0x95, 0x54, 0x0d, 0xdb, 0x22, 0x65, 0x28, 0xed,
+	0x93, 0x30, 0x1a, 0x1c, 0xb2, 0x51, 0x57, 0xcf, 0xdc, 0x24, 0x05, 0x50, 0xb5, 0x6a, 0xa1, 0x6e,
+	0x55, 0xd9, 0x16, 0xab, 0x66, 0x8b, 0x03, 0x10, 0x8a, 0xe3, 0x4c, 0x8d, 0xbd, 0xe8, 0xa2, 0xf6,
+	0x22, 0x29, 0x21, 0xde, 0x7b, 0x58, 0x26, 0xf4, 0xb2, 0x64, 0x89, 0x0d, 0x56, 0x9c, 0x39, 0x88,
+	0x14, 0x57, 0x1e, 0xa6, 0x22, 0x44, 0x78, 0x11, 0x51, 0x39, 0x4c, 0x98, 0xb2, 0xa2, 0x45, 0x0a,
+	0xc0, 0xdb, 0x83, 0xb5, 0x0a, 0xd1, 0xe7, 0x50, 0xf6, 0xb4, 0xf2, 0x84, 0x5e, 0x6a, 0x28, 0x23,
+	0x2c, 0x00, 0xbc, 0x02, 0x66, 0x98, 0xdb, 0x6a, 0x86, 0x81, 0x77, 0x85, 0x60, 0x35, 0xa5, 0x38,
+	0x1e, 0x45, 0xfe, 0x07, 0x26, 0x04, 0xbd, 0x60, 0xf8, 0x35, 0x58, 0x3e, 0x8f, 0x24, 0x8b, 0xa4,
+	0xaa, 0x5f, 0xda, 0x76, 0x37, 0x4b, 0xbb, 0x37, 0xcf, 0xde, 0xd3, 0x29, 0xa7, 0xb4, 0x3f, 0x64,
+	0x24, 0x2f, 0xc0, 0x3b, 0x00, 0xc9, 0x64, 0x23, 0xab, 0x3e, 0x4b, 0xdb, 0x4f, 0xca, 0xe5, 0x33,
+	0x24, 0x93, 0x52, 0x89, 0xf7, 0xc7, 0x84, 0xf5, 0x59, 0x2d, 0xf0, 0x1b, 0x80, 0x1e, 0xa3, 0xc1,
+	0xa7, 0x38, 0xa0, 0x92, 0x65, 0xc2, 0x36, 0xea, 0xc2, 0x3a, 0x93, 0x8c, 0x8e, 0x41, 0x4a, 0xf9,
+	0xf8, 0x10, 0x56, 0xcf, 0x87, 0xfd, 0x7e, 0xca, 0x4a, 0xd8, 0xb7, 0x21, 0x13, 0x72, 0x96, 0xb8,
+	0x94, 0xe2, 0xa0, 0x9a, 0xd6, 0x31, 0x48, 0xbd, 0x12, 0x7f, 0x84, 0x07, 0x05, 0x24, 0x62, 0x1e,
+	0x09, 0x7d, 0xda, 0x66, 0x38, 0x75, 0x50, 0xcb, 0xeb, 0x18, 0x64, 0xaa, 0x16, 0xef, 0xc3, 0x32,
+	0x4b, 0x12, 0x9e, 0x4c, 0xc8, 0xe6, 0x14, 0xd9, 0xe3, 0x3a, 0xd9, 0x7e, 0x39, 0xa9, 0x63, 0x90,
+	0x6a, 0xd5, 0xae, 0x05, 0xf3, 0xdf, 0x53, 0xab, 0xbc, 0x1f, 0x08, 0x56, 0xaa, 0x6e, 0xe0, 0x75,
+	0x98, 0x4f, 0xdd, 0xc8, 0x4f, 0x9c, 0x0e, 0xf0, 0x2b, 0xb0, 0xb2, 0x23, 0x61, 0x9b, 0x6e, 0xe3,
+	0x2e, 0x4b, 0x95, 0xe7, 0x63, 0x0f, 0x5a, 0xf9, 0x91, 0x3b, 0xa2, 0xb2, 0x67, 0x37, 0x14, 0x6f,
+	0x05, 0xf3, 0x7e, 0x22, 0x58, 0x9b, 0x61, 0xe9, 0xfd, 0x88, 0xf9, 0x85, 0xf4, 0xc6, 0xaa, 0xaf,
+	0xc8, 0xfd, 0xa8, 0x79, 0x01, 0x0f, 0xa7, 0x56, 0x34, 0x55, 0xa2, 0x56, 0x34, 0xbb, 0xf3, 0x75,
+	0xe0, 0x9d, 0xea, 0xc5, 0xd4, 0xbd, 0xba, 0xd1, 0x39, 0xaf, 0xdd, 0xf3, 0x68, 0xea, 0x9e, 0x9f,
+	0xba, 0x99, 0xcd, 0x19, 0x37, 0xf3, 0xee, 0xdb, 0xbf, 0xb7, 0x0e, 0xba, 0xbe, 0x75, 0xd0, 0xbf,
+	0x5b, 0x07, 0xfd, 0x1e, 0x3b, 0xc6, 0xf5, 0xd8, 0x31, 0x6e, 0xc6, 0x8e, 0xf1, 0xe5, 0xf9, 0x1d,
+	0xbf, 0x6d, 0x67, 0x0b, 0xea, 0xe7, 0xe5, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbc, 0xc0, 0xf7,
+	0x30, 0x0d, 0x07, 0x00, 0x00,
 }
 
 func (m *RootChange) Marshal() (dAtA []byte, err error) {
@@ -1470,11 +1426,6 @@ func (m *TreeErrorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.ErrCode != 0 {
-		i = encodeVarintTreechange(dAtA, i, uint64(m.ErrCode))
-		i--
-		dAtA[i] = 0x10
-	}
 	if len(m.Error) > 0 {
 		i -= len(m.Error)
 		copy(dAtA[i:], m.Error)
@@ -1812,9 +1763,6 @@ func (m *TreeErrorResponse) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTreechange(uint64(l))
 	}
-	if m.ErrCode != 0 {
-		n += 1 + sovTreechange(uint64(m.ErrCode))
-	}
 	return n
 }
 
@@ -3444,25 +3392,6 @@ func (m *TreeErrorResponse) Unmarshal(dAtA []byte) error {
 			}
 			m.Error = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ErrCode", wireType)
-			}
-			m.ErrCode = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTreechange
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.ErrCode |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTreechange(dAtA[iNdEx:])

commonspace/object/tree/treestorage/inmemory.go

@@ -3,34 +3,25 @@ package treestorage
 import (
 	"context"
 	"fmt"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anyproto/any-sync/util/slice"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
 	"sync"
 )
 
-type InMemoryTreeStorage struct {
+type inMemoryTreeStorage struct {
 	id      string
 	root    *treechangeproto.RawTreeChangeWithId
 	heads   []string
-	Changes map[string]*treechangeproto.RawTreeChangeWithId
-	addErr  error
+	changes map[string]*treechangeproto.RawTreeChangeWithId
 
 	sync.RWMutex
 }
 
-func (t *InMemoryTreeStorage) SetReturnErrorOnAdd(err error) {
-	t.addErr = err
-}
-
-func (t *InMemoryTreeStorage) AddRawChangesSetHeads(changes []*treechangeproto.RawTreeChangeWithId, heads []string) error {
+func (t *inMemoryTreeStorage) TransactionAdd(changes []*treechangeproto.RawTreeChangeWithId, heads []string) error {
 	t.RLock()
 	defer t.RUnlock()
-	if t.addErr != nil {
-		return t.addErr
-	}
 
 	for _, ch := range changes {
-		t.Changes[ch.Id] = ch
+		t.changes[ch.Id] = ch
 	}
 	t.heads = append(t.heads[:0], heads...)
 	return nil
@@ -46,89 +37,62 @@ func NewInMemoryTreeStorage(
 	}
 	allChanges[root.Id] = root
 
-	return &InMemoryTreeStorage{
+	return &inMemoryTreeStorage{
 		id:      root.Id,
 		root:    root,
-		heads:   append([]string(nil), heads...),
-		Changes: allChanges,
+		heads:   heads,
+		changes: allChanges,
 		RWMutex: sync.RWMutex{},
 	}, nil
 }
 
-func (t *InMemoryTreeStorage) HasChange(ctx context.Context, id string) (bool, error) {
-	_, exists := t.Changes[id]
+func (t *inMemoryTreeStorage) HasChange(ctx context.Context, id string) (bool, error) {
+	_, exists := t.changes[id]
 	return exists, nil
 }
 
-func (t *InMemoryTreeStorage) Id() string {
+func (t *inMemoryTreeStorage) Id() string {
 	t.RLock()
 	defer t.RUnlock()
 	return t.id
 }
 
-func (t *InMemoryTreeStorage) Root() (*treechangeproto.RawTreeChangeWithId, error) {
+func (t *inMemoryTreeStorage) Root() (*treechangeproto.RawTreeChangeWithId, error) {
 	t.RLock()
 	defer t.RUnlock()
 	return t.root, nil
 }
 
-func (t *InMemoryTreeStorage) Heads() ([]string, error) {
+func (t *inMemoryTreeStorage) Heads() ([]string, error) {
 	t.RLock()
 	defer t.RUnlock()
 	return t.heads, nil
 }
 
-func (t *InMemoryTreeStorage) SetHeads(heads []string) error {
+func (t *inMemoryTreeStorage) SetHeads(heads []string) error {
 	t.Lock()
 	defer t.Unlock()
 	t.heads = append(t.heads[:0], heads...)
 	return nil
 }
 
-func (t *InMemoryTreeStorage) AddRawChange(change *treechangeproto.RawTreeChangeWithId) error {
+func (t *inMemoryTreeStorage) AddRawChange(change *treechangeproto.RawTreeChangeWithId) error {
 	t.Lock()
 	defer t.Unlock()
 	// TODO: better to do deep copy
-	t.Changes[change.Id] = change
+	t.changes[change.Id] = change
 	return nil
 }
 
-func (t *InMemoryTreeStorage) GetRawChange(ctx context.Context, changeId string) (*treechangeproto.RawTreeChangeWithId, error) {
+func (t *inMemoryTreeStorage) GetRawChange(ctx context.Context, changeId string) (*treechangeproto.RawTreeChangeWithId, error) {
 	t.RLock()
 	defer t.RUnlock()
-	if res, exists := t.Changes[changeId]; exists {
+	if res, exists := t.changes[changeId]; exists {
 		return res, nil
 	}
 	return nil, fmt.Errorf("could not get change with id: %s", changeId)
 }
 
-func (t *InMemoryTreeStorage) Delete() error {
+func (t *inMemoryTreeStorage) Delete() error {
 	return nil
 }
-
-func (t *InMemoryTreeStorage) Copy() *InMemoryTreeStorage {
-	var changes []*treechangeproto.RawTreeChangeWithId
-	for _, ch := range t.Changes {
-		changes = append(changes, ch)
-	}
-	other, _ := NewInMemoryTreeStorage(t.root, t.heads, changes)
-	return other.(*InMemoryTreeStorage)
-}
-
-func (t *InMemoryTreeStorage) Equal(other *InMemoryTreeStorage) bool {
-	if !slice.UnsortedEquals(t.heads, other.heads) {
-		return false
-	}
-	if len(t.Changes) != len(other.Changes) {
-		return false
-	}
-	for k, v := range t.Changes {
-		if otherV, exists := other.Changes[k]; exists {
-			if otherV.Id == v.Id {
-				continue
-			}
-		}
-		return false
-	}
-	return true
-}

commonspace/object/tree/treestorage/mock_treestorage/mock_treestorage.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anyproto/any-sync/commonspace/object/tree/treestorage (interfaces: TreeStorage)
+// Source: github.com/anytypeio/any-sync/commonspace/object/tree/treestorage (interfaces: TreeStorage)
 
 // Package mock_treestorage is a generated GoMock package.
 package mock_treestorage
@@ -8,7 +8,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	treechangeproto "github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -49,20 +49,6 @@ func (mr *MockTreeStorageMockRecorder) AddRawChange(arg0 interface{}) *gomock.Ca
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChange", reflect.TypeOf((*MockTreeStorage)(nil).AddRawChange), arg0)
 }
 
-// AddRawChangesSetHeads mocks base method.
-func (m *MockTreeStorage) AddRawChangesSetHeads(arg0 []*treechangeproto.RawTreeChangeWithId, arg1 []string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "AddRawChangesSetHeads", arg0, arg1)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// AddRawChangesSetHeads indicates an expected call of AddRawChangesSetHeads.
-func (mr *MockTreeStorageMockRecorder) AddRawChangesSetHeads(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesSetHeads", reflect.TypeOf((*MockTreeStorage)(nil).AddRawChangesSetHeads), arg0, arg1)
-}
-
 // Delete mocks base method.
 func (m *MockTreeStorage) Delete() error {
 	m.ctrl.T.Helper()
@@ -164,3 +150,17 @@ func (mr *MockTreeStorageMockRecorder) SetHeads(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeads", reflect.TypeOf((*MockTreeStorage)(nil).SetHeads), arg0)
 }
+
+// TransactionAdd mocks base method.
+func (m *MockTreeStorage) TransactionAdd(arg0 []*treechangeproto.RawTreeChangeWithId, arg1 []string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TransactionAdd", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// TransactionAdd indicates an expected call of TransactionAdd.
+func (mr *MockTreeStorageMockRecorder) TransactionAdd(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionAdd", reflect.TypeOf((*MockTreeStorage)(nil).TransactionAdd), arg0, arg1)
+}

commonspace/object/tree/treestorage/treestorage.go

@@ -1,10 +1,10 @@
-//go:generate mockgen -destination mock_treestorage/mock_treestorage.go github.com/anyproto/any-sync/commonspace/object/tree/treestorage TreeStorage
+//go:generate mockgen -destination mock_treestorage/mock_treestorage.go github.com/anytypeio/any-sync/commonspace/object/tree/treestorage TreeStorage
 package treestorage
 
 import (
 	"context"
 	"errors"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto"
 )
 
 var (
@@ -31,7 +31,7 @@ type TreeStorage interface {
 	Heads() ([]string, error)
 	SetHeads(heads []string) error
 	AddRawChange(change *treechangeproto.RawTreeChangeWithId) error
-	AddRawChangesSetHeads(changes []*treechangeproto.RawTreeChangeWithId, heads []string) error
+	TransactionAdd(changes []*treechangeproto.RawTreeChangeWithId, heads []string) error
 
 	GetRawChange(ctx context.Context, id string) (*treechangeproto.RawTreeChangeWithId, error)
 	HasChange(ctx context.Context, id string) (bool, error)

commonspace/object/treegetter/mock_treegetter/mock_treegetter.go

@@ -0,0 +1,136 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/any-sync/commonspace/object/treegetter (interfaces: TreeGetter)
+
+// Package mock_treegetter is a generated GoMock package.
+package mock_treegetter
+
+import (
+	context "context"
+	reflect "reflect"
+
+	app "github.com/anytypeio/any-sync/app"
+	objecttree "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockTreeGetter is a mock of TreeGetter interface.
+type MockTreeGetter struct {
+	ctrl     *gomock.Controller
+	recorder *MockTreeGetterMockRecorder
+}
+
+// MockTreeGetterMockRecorder is the mock recorder for MockTreeGetter.
+type MockTreeGetterMockRecorder struct {
+	mock *MockTreeGetter
+}
+
+// NewMockTreeGetter creates a new mock instance.
+func NewMockTreeGetter(ctrl *gomock.Controller) *MockTreeGetter {
+	mock := &MockTreeGetter{ctrl: ctrl}
+	mock.recorder = &MockTreeGetterMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockTreeGetter) EXPECT() *MockTreeGetterMockRecorder {
+	return m.recorder
+}
+
+// Close mocks base method.
+func (m *MockTreeGetter) Close(arg0 context.Context) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Close", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Close indicates an expected call of Close.
+func (mr *MockTreeGetterMockRecorder) Close(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTreeGetter)(nil).Close), arg0)
+}
+
+// DeleteSpace mocks base method.
+func (m *MockTreeGetter) DeleteSpace(arg0 context.Context, arg1 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteSpace", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteSpace indicates an expected call of DeleteSpace.
+func (mr *MockTreeGetterMockRecorder) DeleteSpace(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpace", reflect.TypeOf((*MockTreeGetter)(nil).DeleteSpace), arg0, arg1)
+}
+
+// DeleteTree mocks base method.
+func (m *MockTreeGetter) DeleteTree(arg0 context.Context, arg1, arg2 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteTree", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteTree indicates an expected call of DeleteTree.
+func (mr *MockTreeGetterMockRecorder) DeleteTree(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockTreeGetter)(nil).DeleteTree), arg0, arg1, arg2)
+}
+
+// GetTree mocks base method.
+func (m *MockTreeGetter) GetTree(arg0 context.Context, arg1, arg2 string) (objecttree.ObjectTree, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTree", arg0, arg1, arg2)
+	ret0, _ := ret[0].(objecttree.ObjectTree)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTree indicates an expected call of GetTree.
+func (mr *MockTreeGetterMockRecorder) GetTree(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockTreeGetter)(nil).GetTree), arg0, arg1, arg2)
+}
+
+// Init mocks base method.
+func (m *MockTreeGetter) Init(arg0 *app.App) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Init", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Init indicates an expected call of Init.
+func (mr *MockTreeGetterMockRecorder) Init(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTreeGetter)(nil).Init), arg0)
+}
+
+// Name mocks base method.
+func (m *MockTreeGetter) Name() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Name")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Name indicates an expected call of Name.
+func (mr *MockTreeGetterMockRecorder) Name() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockTreeGetter)(nil).Name))
+}
+
+// Run mocks base method.
+func (m *MockTreeGetter) Run(arg0 context.Context) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Run", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Run indicates an expected call of Run.
+func (mr *MockTreeGetterMockRecorder) Run(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTreeGetter)(nil).Run), arg0)
+}

commonspace/object/treegetter/treegetter.go

@@ -0,0 +1,17 @@
+//go:generate mockgen -destination mock_treegetter/mock_treegetter.go github.com/anytypeio/any-sync/commonspace/object/treegetter TreeGetter
+package treegetter
+
+import (
+	"context"
+	"github.com/anytypeio/any-sync/app"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
+)
+
+const CName = "common.object.treegetter"
+
+type TreeGetter interface {
+	app.ComponentRunnable
+	GetTree(ctx context.Context, spaceId, treeId string) (objecttree.ObjectTree, error)
+	DeleteTree(ctx context.Context, spaceId, treeId string) error
+	DeleteSpace(ctx context.Context, spaceId string) error
+}

commonspace/object/treemanager/mock_treemanager/mock_treemanager.go

@@ -1,214 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anyproto/any-sync/commonspace/object/treemanager (interfaces: TreeManager,TreeSyncer)
-
-// Package mock_treemanager is a generated GoMock package.
-package mock_treemanager
-
-import (
-	context "context"
-	reflect "reflect"
-
-	app "github.com/anyproto/any-sync/app"
-	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
-	treemanager "github.com/anyproto/any-sync/commonspace/object/treemanager"
-	gomock "github.com/golang/mock/gomock"
-)
-
-// MockTreeManager is a mock of TreeManager interface.
-type MockTreeManager struct {
-	ctrl     *gomock.Controller
-	recorder *MockTreeManagerMockRecorder
-}
-
-// MockTreeManagerMockRecorder is the mock recorder for MockTreeManager.
-type MockTreeManagerMockRecorder struct {
-	mock *MockTreeManager
-}
-
-// NewMockTreeManager creates a new mock instance.
-func NewMockTreeManager(ctrl *gomock.Controller) *MockTreeManager {
-	mock := &MockTreeManager{ctrl: ctrl}
-	mock.recorder = &MockTreeManagerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockTreeManager) EXPECT() *MockTreeManagerMockRecorder {
-	return m.recorder
-}
-
-// Close mocks base method.
-func (m *MockTreeManager) Close(arg0 context.Context) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Close", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Close indicates an expected call of Close.
-func (mr *MockTreeManagerMockRecorder) Close(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTreeManager)(nil).Close), arg0)
-}
-
-// DeleteTree mocks base method.
-func (m *MockTreeManager) DeleteTree(arg0 context.Context, arg1, arg2 string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DeleteTree", arg0, arg1, arg2)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// DeleteTree indicates an expected call of DeleteTree.
-func (mr *MockTreeManagerMockRecorder) DeleteTree(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockTreeManager)(nil).DeleteTree), arg0, arg1, arg2)
-}
-
-// GetTree mocks base method.
-func (m *MockTreeManager) GetTree(arg0 context.Context, arg1, arg2 string) (objecttree.ObjectTree, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTree", arg0, arg1, arg2)
-	ret0, _ := ret[0].(objecttree.ObjectTree)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetTree indicates an expected call of GetTree.
-func (mr *MockTreeManagerMockRecorder) GetTree(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockTreeManager)(nil).GetTree), arg0, arg1, arg2)
-}
-
-// Init mocks base method.
-func (m *MockTreeManager) Init(arg0 *app.App) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Init", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Init indicates an expected call of Init.
-func (mr *MockTreeManagerMockRecorder) Init(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTreeManager)(nil).Init), arg0)
-}
-
-// MarkTreeDeleted mocks base method.
-func (m *MockTreeManager) MarkTreeDeleted(arg0 context.Context, arg1, arg2 string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MarkTreeDeleted", arg0, arg1, arg2)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// MarkTreeDeleted indicates an expected call of MarkTreeDeleted.
-func (mr *MockTreeManagerMockRecorder) MarkTreeDeleted(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkTreeDeleted", reflect.TypeOf((*MockTreeManager)(nil).MarkTreeDeleted), arg0, arg1, arg2)
-}
-
-// Name mocks base method.
-func (m *MockTreeManager) Name() string {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Name")
-	ret0, _ := ret[0].(string)
-	return ret0
-}
-
-// Name indicates an expected call of Name.
-func (mr *MockTreeManagerMockRecorder) Name() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockTreeManager)(nil).Name))
-}
-
-// NewTreeSyncer mocks base method.
-func (m *MockTreeManager) NewTreeSyncer(arg0 string, arg1 treemanager.TreeManager) treemanager.TreeSyncer {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "NewTreeSyncer", arg0, arg1)
-	ret0, _ := ret[0].(treemanager.TreeSyncer)
-	return ret0
-}
-
-// NewTreeSyncer indicates an expected call of NewTreeSyncer.
-func (mr *MockTreeManagerMockRecorder) NewTreeSyncer(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewTreeSyncer", reflect.TypeOf((*MockTreeManager)(nil).NewTreeSyncer), arg0, arg1)
-}
-
-// Run mocks base method.
-func (m *MockTreeManager) Run(arg0 context.Context) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Run", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Run indicates an expected call of Run.
-func (mr *MockTreeManagerMockRecorder) Run(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTreeManager)(nil).Run), arg0)
-}
-
-// MockTreeSyncer is a mock of TreeSyncer interface.
-type MockTreeSyncer struct {
-	ctrl     *gomock.Controller
-	recorder *MockTreeSyncerMockRecorder
-}
-
-// MockTreeSyncerMockRecorder is the mock recorder for MockTreeSyncer.
-type MockTreeSyncerMockRecorder struct {
-	mock *MockTreeSyncer
-}
-
-// NewMockTreeSyncer creates a new mock instance.
-func NewMockTreeSyncer(ctrl *gomock.Controller) *MockTreeSyncer {
-	mock := &MockTreeSyncer{ctrl: ctrl}
-	mock.recorder = &MockTreeSyncerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockTreeSyncer) EXPECT() *MockTreeSyncerMockRecorder {
-	return m.recorder
-}
-
-// Close mocks base method.
-func (m *MockTreeSyncer) 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 *MockTreeSyncerMockRecorder) Close() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTreeSyncer)(nil).Close))
-}
-
-// Init mocks base method.
-func (m *MockTreeSyncer) Init() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "Init")
-}
-
-// Init indicates an expected call of Init.
-func (mr *MockTreeSyncerMockRecorder) Init() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTreeSyncer)(nil).Init))
-}
-
-// SyncAll mocks base method.
-func (m *MockTreeSyncer) SyncAll(arg0 context.Context, arg1 string, arg2, arg3 []string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SyncAll", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SyncAll indicates an expected call of SyncAll.
-func (mr *MockTreeSyncerMockRecorder) SyncAll(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncAll", reflect.TypeOf((*MockTreeSyncer)(nil).SyncAll), arg0, arg1, arg2, arg3)
-}

commonspace/object/treemanager/treemanager.go

@@ -1,24 +0,0 @@
-//go:generate mockgen -destination mock_treemanager/mock_treemanager.go github.com/anyproto/any-sync/commonspace/object/treemanager TreeManager,TreeSyncer
-package treemanager
-
-import (
-	"context"
-	"github.com/anyproto/any-sync/app"
-	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
-)
-
-const CName = "common.object.treemanager"
-
-type TreeManager interface {
-	app.ComponentRunnable
-	GetTree(ctx context.Context, spaceId, treeId string) (objecttree.ObjectTree, error)
-	MarkTreeDeleted(ctx context.Context, spaceId, treeId string) error
-	DeleteTree(ctx context.Context, spaceId, treeId string) error
-	NewTreeSyncer(spaceId string, treeManager TreeManager) TreeSyncer
-}
-
-type TreeSyncer interface {
-	Init()
-	SyncAll(ctx context.Context, peerId string, existing, missing []string) error
-	Close() error
-}

commonspace/objectsync/mock_objectsync/mock_objectsync.go

@@ -1,152 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anyproto/any-sync/commonspace/objectsync (interfaces: SyncClient)
-
-// Package mock_objectsync is a generated GoMock package.
-package mock_objectsync
-
-import (
-	context "context"
-	reflect "reflect"
-
-	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
-	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	objectsync "github.com/anyproto/any-sync/commonspace/objectsync"
-	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) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "Broadcast", arg0, arg1)
-}
-
-// 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))
-}
-
-// MessagePool mocks base method.
-func (m *MockSyncClient) MessagePool() objectsync.MessagePool {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "MessagePool")
-	ret0, _ := ret[0].(objectsync.MessagePool)
-	return ret0
-}
-
-// MessagePool indicates an expected call of MessagePool.
-func (mr *MockSyncClientMockRecorder) MessagePool() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MessagePool", reflect.TypeOf((*MockSyncClient)(nil).MessagePool))
-}
-
-// SendSync mocks base method.
-func (m *MockSyncClient) SendSync(arg0 context.Context, arg1, arg2 string, arg3 *treechangeproto.TreeSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendSync", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SendSync indicates an expected call of SendSync.
-func (mr *MockSyncClientMockRecorder) SendSync(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendSync", reflect.TypeOf((*MockSyncClient)(nil).SendSync), arg0, arg1, arg2, arg3)
-}
-
-// SendWithReply mocks base method.
-func (m *MockSyncClient) SendWithReply(arg0 context.Context, arg1, arg2 string, arg3 *treechangeproto.TreeSyncMessage, arg4 string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SendWithReply", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// SendWithReply indicates an expected call of SendWithReply.
-func (mr *MockSyncClientMockRecorder) SendWithReply(arg0, arg1, arg2, arg3, arg4 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, arg4)
-}

commonspace/objectsync/msgpool.go

@@ -3,9 +3,9 @@ package objectsync
 import (
 	"context"
 	"fmt"
-	"github.com/anyproto/any-sync/commonspace/objectsync/synchandler"
-	"github.com/anyproto/any-sync/commonspace/peermanager"
-	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	"github.com/anytypeio/any-sync/commonspace/objectsync/synchandler"
+	"github.com/anytypeio/any-sync/commonspace/peermanager"
+	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
 	"go.uber.org/zap"
 	"strconv"
 	"strings"
@@ -53,11 +53,9 @@ func newMessagePool(peerManager peermanager.PeerManager, messageHandler MessageH
 
 func (s *messagePool) SendSync(ctx context.Context, peerId string, msg *spacesyncproto.ObjectSyncMessage) (reply *spacesyncproto.ObjectSyncMessage, err error) {
 	s.updateLastUsage()
-	if _, ok := ctx.Deadline(); !ok {
-		var cancel context.CancelFunc
-		ctx, cancel = context.WithTimeout(ctx, time.Minute)
-		defer cancel()
-	}
+	var cancel context.CancelFunc
+	ctx, cancel = context.WithTimeout(ctx, time.Second*10)
+	defer cancel()
 	newCounter := s.counter.Add(1)
 	msg.RequestId = genReplyKey(peerId, msg.ObjectId, newCounter)
 	log.InfoCtx(ctx, "mpool sendSync", zap.String("requestId", msg.RequestId))
@@ -105,7 +103,6 @@ func (s *messagePool) HandleMessage(ctx context.Context, senderId string, msg *s
 			return
 		}
 		log.WarnCtx(ctx, "reply id does not exist", zap.String("replyId", msg.ReplyId))
-		return
 	}
 	return s.messageHandler(ctx, senderId, msg)
 }

commonspace/objectsync/objectsync.go

@@ -1,21 +1,17 @@
-//go:generate mockgen -destination mock_objectsync/mock_objectsync.go github.com/anyproto/any-sync/commonspace/objectsync SyncClient
 package objectsync
 
 import (
 	"context"
-	"fmt"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/gogo/protobuf/proto"
 	"sync/atomic"
 	"time"
 
-	"github.com/anyproto/any-sync/app/logger"
-	"github.com/anyproto/any-sync/commonspace/object/syncobjectgetter"
-	"github.com/anyproto/any-sync/commonspace/objectsync/synchandler"
-	"github.com/anyproto/any-sync/commonspace/peermanager"
-	"github.com/anyproto/any-sync/commonspace/spacestorage"
-	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	"github.com/anyproto/any-sync/nodeconf"
+	"github.com/anytypeio/any-sync/app/logger"
+	"github.com/anytypeio/any-sync/commonspace/object/syncobjectgetter"
+	"github.com/anytypeio/any-sync/commonspace/objectsync/synchandler"
+	"github.com/anytypeio/any-sync/commonspace/peermanager"
+	"github.com/anytypeio/any-sync/commonspace/spacestorage"
+	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
+	"github.com/anytypeio/any-sync/nodeconf"
 	"go.uber.org/zap"
 	"golang.org/x/exp/slices"
 )
@@ -25,8 +21,9 @@ var log = logger.NewNamed("common.commonspace.objectsync")
 type ObjectSync interface {
 	LastUsage
 	synchandler.SyncHandler
-	SyncClient() SyncClient
+	MessagePool() MessagePool
 
+	Init()
 	Close() (err error)
 }
 
@@ -34,9 +31,8 @@ type objectSync struct {
 	spaceId string
 
 	messagePool   MessagePool
-	syncClient    SyncClient
 	objectGetter  syncobjectgetter.SyncObjectGetter
-	configuration nodeconf.NodeConf
+	configuration nodeconf.Configuration
 	spaceStorage  spacestorage.SpaceStorage
 
 	syncCtx        context.Context
@@ -47,23 +43,45 @@ type objectSync struct {
 func NewObjectSync(
 	spaceId string,
 	spaceIsDeleted *atomic.Bool,
-	configuration nodeconf.NodeConf,
+	configuration nodeconf.Configuration,
 	peerManager peermanager.PeerManager,
 	objectGetter syncobjectgetter.SyncObjectGetter,
 	storage spacestorage.SpaceStorage) ObjectSync {
 	syncCtx, cancel := context.WithCancel(context.Background())
-	os := &objectSync{
+	os := newObjectSync(
+		spaceId,
+		spaceIsDeleted,
+		configuration,
+		objectGetter,
+		storage,
+		syncCtx,
+		cancel)
+	msgPool := newMessagePool(peerManager, os.handleMessage)
+	os.messagePool = msgPool
+	return os
+}
+
+func newObjectSync(
+	spaceId string,
+	spaceIsDeleted *atomic.Bool,
+	configuration nodeconf.Configuration,
+	objectGetter syncobjectgetter.SyncObjectGetter,
+	spaceStorage spacestorage.SpaceStorage,
+	syncCtx context.Context,
+	cancel context.CancelFunc,
+) *objectSync {
+	return &objectSync{
 		objectGetter:   objectGetter,
-		spaceStorage:   storage,
+		spaceStorage:   spaceStorage,
 		spaceId:        spaceId,
 		syncCtx:        syncCtx,
 		cancelSync:     cancel,
 		spaceIsDeleted: spaceIsDeleted,
 		configuration:  configuration,
 	}
-	os.messagePool = newMessagePool(peerManager, os.handleMessage)
-	os.syncClient = NewSyncClient(spaceId, os.messagePool, NewRequestFactory())
-	return os
+}
+
+func (s *objectSync) Init() {
 }
 
 func (s *objectSync) Close() (err error) {
@@ -80,78 +98,22 @@ func (s *objectSync) HandleMessage(ctx context.Context, senderId string, message
 }
 
 func (s *objectSync) handleMessage(ctx context.Context, senderId string, msg *spacesyncproto.ObjectSyncMessage) (err error) {
-	log := log.With(
-		zap.String("objectId", msg.ObjectId),
-		zap.String("requestId", msg.RequestId),
-		zap.String("replyId", msg.ReplyId))
+	log := log.With(zap.String("objectId", msg.ObjectId), zap.String("replyId", msg.ReplyId))
 	if s.spaceIsDeleted.Load() {
 		log = log.With(zap.Bool("isDeleted", true))
 		// preventing sync with other clients if they are not just syncing the settings tree
 		if !slices.Contains(s.configuration.NodeIds(s.spaceId), senderId) && msg.ObjectId != s.spaceStorage.SpaceSettingsId() {
-			s.unmarshallSendError(ctx, msg, spacesyncproto.ErrUnexpected, senderId, msg.ObjectId)
-			return fmt.Errorf("can't perform operation with object, space is deleted")
-		}
-	}
-	log.DebugCtx(ctx, "handling message")
-	hasTree, err := s.spaceStorage.HasTree(msg.ObjectId)
-	if err != nil {
-		s.unmarshallSendError(ctx, msg, spacesyncproto.ErrUnexpected, senderId, msg.ObjectId)
-		return fmt.Errorf("falied to execute get operation on storage has tree: %w", err)
-	}
-	// in this case we will try to get it from remote, unless the sender also sent us the same request :-)
-	if !hasTree {
-		treeMsg := &treechangeproto.TreeSyncMessage{}
-		err = proto.Unmarshal(msg.Payload, treeMsg)
-		if err != nil {
-			s.sendError(ctx, nil, spacesyncproto.ErrUnexpected, senderId, msg.ObjectId, msg.RequestId)
-			return fmt.Errorf("failed to unmarshall tree sync message: %w", err)
-		}
-		// this means that we don't have the tree locally and therefore can't return it
-		if s.isEmptyFullSyncRequest(treeMsg) {
-			err = treechangeproto.ErrGetTree
-			s.sendError(ctx, nil, treechangeproto.ErrGetTree, senderId, msg.ObjectId, msg.RequestId)
-			return fmt.Errorf("failed to get tree from storage on full sync: %w", err)
+			return spacesyncproto.ErrSpaceIsDeleted
 		}
 	}
+	log.With(zap.String("objectId", msg.ObjectId), zap.String("replyId", msg.ReplyId)).DebugCtx(ctx, "handling message")
 	obj, err := s.objectGetter.GetObject(ctx, msg.ObjectId)
-	if err != nil {
-		// TODO: write tests for object sync https://linear.app/anytype/issue/GO-1299/write-tests-for-commonspaceobjectsync
-		s.unmarshallSendError(ctx, msg, spacesyncproto.ErrUnexpected, senderId, msg.ObjectId)
-		return fmt.Errorf("failed to get object from cache: %w", err)
-	}
-	// TODO: unmarshall earlier
-	err = obj.HandleMessage(ctx, senderId, msg)
-	if err != nil {
-		s.unmarshallSendError(ctx, msg, spacesyncproto.ErrUnexpected, senderId, msg.ObjectId)
-		return fmt.Errorf("failed to handle message: %w", err)
-	}
-	return
-}
-
-func (s *objectSync) SyncClient() SyncClient {
-	return s.syncClient
-}
-
-func (s *objectSync) unmarshallSendError(ctx context.Context, msg *spacesyncproto.ObjectSyncMessage, respErr error, senderId, objectId string) {
-	unmarshalled := &treechangeproto.TreeSyncMessage{}
-	err := proto.Unmarshal(msg.Payload, unmarshalled)
 	if err != nil {
 		return
 	}
-	s.sendError(ctx, unmarshalled.RootChange, respErr, senderId, objectId, msg.RequestId)
+	return obj.HandleMessage(ctx, senderId, msg)
 }
 
-func (s *objectSync) sendError(ctx context.Context, root *treechangeproto.RawTreeChangeWithId, respErr error, senderId, objectId, replyId string) {
-	// we don't send errors if have no reply id, this can lead to bugs and also nobody needs this error
-	if replyId == "" {
-		return
-	}
-	resp := treechangeproto.WrapError(respErr, root)
-	if err := s.syncClient.SendWithReply(ctx, senderId, objectId, resp, replyId); err != nil {
-		log.InfoCtx(ctx, "failed to send error to client")
-	}
-}
-
-func (s *objectSync) isEmptyFullSyncRequest(msg *treechangeproto.TreeSyncMessage) bool {
-	return msg.GetContent().GetFullSyncRequest() != nil && len(msg.GetContent().GetFullSyncRequest().GetHeads()) == 0
+func (s *objectSync) MessagePool() MessagePool {
+	return s.messagePool
 }

commonspace/objectsync/syncclient.go

@@ -1,78 +0,0 @@
-package objectsync
-
-import (
-	"context"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	"go.uber.org/zap"
-)
-
-type SyncClient interface {
-	RequestFactory
-	Broadcast(ctx context.Context, msg *treechangeproto.TreeSyncMessage)
-	SendWithReply(ctx context.Context, peerId, objectId string, msg *treechangeproto.TreeSyncMessage, replyId string) (err error)
-	SendSync(ctx context.Context, peerId, objectId string, msg *treechangeproto.TreeSyncMessage) (reply *spacesyncproto.ObjectSyncMessage, err error)
-	MessagePool() MessagePool
-}
-
-type syncClient struct {
-	RequestFactory
-	spaceId     string
-	messagePool MessagePool
-}
-
-func NewSyncClient(
-	spaceId string,
-	messagePool MessagePool,
-	factory RequestFactory) SyncClient {
-	return &syncClient{
-		messagePool:    messagePool,
-		RequestFactory: factory,
-		spaceId:        spaceId,
-	}
-}
-
-func (s *syncClient) Broadcast(ctx context.Context, msg *treechangeproto.TreeSyncMessage) {
-	objMsg, err := MarshallTreeMessage(msg, s.spaceId, msg.RootChange.Id, "")
-	if err != nil {
-		return
-	}
-	err = s.messagePool.Broadcast(ctx, objMsg)
-	if err != nil {
-		log.DebugCtx(ctx, "broadcast error", zap.Error(err))
-	}
-}
-
-func (s *syncClient) SendSync(ctx context.Context, peerId, objectId string, msg *treechangeproto.TreeSyncMessage) (reply *spacesyncproto.ObjectSyncMessage, err error) {
-	objMsg, err := MarshallTreeMessage(msg, s.spaceId, objectId, "")
-	if err != nil {
-		return
-	}
-	return s.messagePool.SendSync(ctx, peerId, objMsg)
-}
-
-func (s *syncClient) SendWithReply(ctx context.Context, peerId, objectId string, msg *treechangeproto.TreeSyncMessage, replyId string) (err error) {
-	objMsg, err := MarshallTreeMessage(msg, s.spaceId, objectId, replyId)
-	if err != nil {
-		return
-	}
-	return s.messagePool.SendPeer(ctx, peerId, objMsg)
-}
-
-func (s *syncClient) MessagePool() MessagePool {
-	return s.messagePool
-}
-
-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/objectsync/synchandler/synchhandler.go

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

commonspace/payloads.go

@@ -1,20 +1,14 @@
 package commonspace
 
 import (
-	"errors"
-	"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/objecttree"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anyproto/any-sync/commonspace/spacestorage"
-	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	"github.com/anyproto/any-sync/util/cidutil"
-	"github.com/anyproto/any-sync/util/crypto"
-	"github.com/gogo/protobuf/proto"
+	"github.com/anytypeio/any-sync/commonspace/object/acl/list"
+	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
+	"github.com/anytypeio/any-sync/commonspace/spacestorage"
+	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
+	"github.com/anytypeio/any-sync/util/cidutil"
+	"github.com/anytypeio/any-sync/util/crypto"
 	"hash/fnv"
 	"math/rand"
-	"strconv"
-	"strings"
 	"time"
 )
 
@@ -22,8 +16,6 @@ const (
 	SpaceReserved = "any-sync.space"
 )
 
-var ErrIncorrectIdentity = errors.New("incorrect identity")
-
 func storagePayloadForSpaceCreate(payload SpaceCreatePayload) (storagePayload spacestorage.SpaceStorageCreatePayload, err error) {
 	// marshalling keys
 	identity, err := payload.SigningKey.GetPublic().Marshall()
@@ -188,142 +180,3 @@ func storagePayloadForSpaceDerive(payload SpaceDerivePayload) (storagePayload sp
 	}
 	return
 }
-
-func validateSpaceStorageCreatePayload(payload spacestorage.SpaceStorageCreatePayload) (err error) {
-	err = ValidateSpaceHeader(payload.SpaceHeaderWithId, nil)
-	if err != nil {
-		return
-	}
-	aclSpaceId, err := validateCreateSpaceAclPayload(payload.AclWithId)
-	if err != nil {
-		return
-	}
-	aclHeadId, settingsSpaceId, err := validateCreateSpaceSettingsPayload(payload.SpaceSettingsWithId)
-	if err != nil {
-		return
-	}
-	if aclSpaceId != payload.SpaceHeaderWithId.Id || aclSpaceId != settingsSpaceId {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	if aclHeadId != payload.AclWithId.Id {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	return
-}
-
-func ValidateSpaceHeader(rawHeaderWithId *spacesyncproto.RawSpaceHeaderWithId, identity crypto.PubKey) (err error) {
-	sepIdx := strings.Index(rawHeaderWithId.Id, ".")
-	if sepIdx == -1 {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	if !cidutil.VerifyCid(rawHeaderWithId.RawHeader, rawHeaderWithId.Id[:sepIdx]) {
-		err = objecttree.ErrIncorrectCid
-		return
-	}
-	var rawSpaceHeader spacesyncproto.RawSpaceHeader
-	err = proto.Unmarshal(rawHeaderWithId.RawHeader, &rawSpaceHeader)
-	if err != nil {
-		return
-	}
-	var header spacesyncproto.SpaceHeader
-	err = proto.Unmarshal(rawSpaceHeader.SpaceHeader, &header)
-	if err != nil {
-		return
-	}
-	payloadIdentity, err := crypto.UnmarshalEd25519PublicKeyProto(header.Identity)
-	if err != nil {
-		return
-	}
-	res, err := payloadIdentity.Verify(rawSpaceHeader.SpaceHeader, rawSpaceHeader.Signature)
-	if err != nil || !res {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	if rawHeaderWithId.Id[sepIdx+1:] != strconv.FormatUint(header.ReplicationKey, 36) {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	if identity == nil {
-		return
-	}
-	if !payloadIdentity.Equals(identity) {
-		err = ErrIncorrectIdentity
-		return
-	}
-	return
-}
-
-func validateCreateSpaceAclPayload(rawWithId *aclrecordproto.RawAclRecordWithId) (spaceId string, err error) {
-	if !cidutil.VerifyCid(rawWithId.Payload, rawWithId.Id) {
-		err = objecttree.ErrIncorrectCid
-		return
-	}
-	var rawAcl aclrecordproto.RawAclRecord
-	err = proto.Unmarshal(rawWithId.Payload, &rawAcl)
-	if err != nil {
-		return
-	}
-	var aclRoot aclrecordproto.AclRoot
-	err = proto.Unmarshal(rawAcl.Payload, &aclRoot)
-	if err != nil {
-		return
-	}
-	payloadIdentity, err := crypto.UnmarshalEd25519PublicKeyProto(aclRoot.Identity)
-	if err != nil {
-		return
-	}
-	res, err := payloadIdentity.Verify(rawAcl.Payload, rawAcl.Signature)
-	if err != nil || !res {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	masterKey, err := crypto.UnmarshalEd25519PublicKeyProto(aclRoot.MasterKey)
-	if err != nil {
-		return
-	}
-	rawIdentity, err := payloadIdentity.Raw()
-	if err != nil {
-		return
-	}
-	res, err = masterKey.Verify(rawIdentity, aclRoot.IdentitySignature)
-	if err != nil || !res {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	spaceId = aclRoot.SpaceId
-
-	return
-}
-
-func validateCreateSpaceSettingsPayload(rawWithId *treechangeproto.RawTreeChangeWithId) (aclHeadId string, spaceId string, err error) {
-	if !cidutil.VerifyCid(rawWithId.RawChange, rawWithId.Id) {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	var raw treechangeproto.RawTreeChange
-	err = proto.Unmarshal(rawWithId.RawChange, &raw)
-	if err != nil {
-		return
-	}
-	var rootChange treechangeproto.RootChange
-	err = proto.Unmarshal(raw.Payload, &rootChange)
-	if err != nil {
-		return
-	}
-	payloadIdentity, err := crypto.UnmarshalEd25519PublicKeyProto(rootChange.Identity)
-	if err != nil {
-		return
-	}
-	res, err := payloadIdentity.Verify(raw.Payload, raw.Signature)
-	if err != nil || !res {
-		err = spacestorage.ErrIncorrectSpaceHeader
-		return
-	}
-	spaceId = rootChange.SpaceId
-	aclHeadId = rootChange.AclHeadId
-
-	return
-}

commonspace/payloads_test.go

@@ -1,657 +0,0 @@
-package commonspace
-
-import (
-	"fmt"
-	"github.com/anyproto/any-sync/commonspace/object/accountdata"
-	"github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto"
-	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/anyproto/any-sync/commonspace/spacestorage"
-	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	"github.com/anyproto/any-sync/util/cidutil"
-	"github.com/anyproto/any-sync/util/crypto"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"math/rand"
-	"strconv"
-	"testing"
-	"time"
-)
-
-func TestSuccessHeaderPayloadForSpaceCreate(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	_, rawHeaderWithId, err := rawHeaderWithId(accountKeys)
-	require.NoError(t, err)
-	err = ValidateSpaceHeader(rawHeaderWithId, nil)
-	require.NoError(t, err)
-}
-
-func TestFailedHeaderPayloadForSpaceCreate_InvalidFormatSpaceId(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	require.NoError(t, err)
-	spaceHeaderSeed := make([]byte, 32)
-	_, err = rand.Read(spaceHeaderSeed)
-	require.NoError(t, err)
-	spaceHeaderPayload := make([]byte, 32)
-	_, err = rand.Read(spaceHeaderPayload)
-	require.NoError(t, err)
-	replicationKey := rand.Uint64()
-	header := &spacesyncproto.SpaceHeader{
-		Identity:           identity,
-		Timestamp:          time.Now().Unix(),
-		SpaceType:          "SpaceType",
-		ReplicationKey:     replicationKey,
-		Seed:               spaceHeaderSeed,
-		SpaceHeaderPayload: spaceHeaderPayload,
-	}
-	marhalled, err := header.Marshal()
-	require.NoError(t, err)
-	signature, err := accountKeys.SignKey.Sign(marhalled)
-	require.NoError(t, err)
-	rawHeader := &spacesyncproto.RawSpaceHeader{
-		SpaceHeader: marhalled,
-		Signature:   signature,
-	}
-	marhalledRawHeader, err := rawHeader.Marshal()
-	require.NoError(t, err)
-	id, err := cidutil.NewCidFromBytes(marhalled)
-	require.NoError(t, err)
-	spaceId := fmt.Sprintf("%s%s", id, strconv.FormatUint(replicationKey, 36))
-	rawHeaderWithId := &spacesyncproto.RawSpaceHeaderWithId{
-		RawHeader: marhalledRawHeader,
-		Id:        spaceId,
-	}
-	err = ValidateSpaceHeader(rawHeaderWithId, nil)
-	assert.EqualErrorf(t, err, spacestorage.ErrIncorrectSpaceHeader.Error(), "Error should be: %v, got: %v", spacestorage.ErrIncorrectSpaceHeader, err)
-}
-
-func TestFailedHeaderPayloadForSpaceCreate_CidIsWrong(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	require.NoError(t, err)
-	spaceHeaderSeed := make([]byte, 32)
-	_, err = rand.Read(spaceHeaderSeed)
-	require.NoError(t, err)
-	spaceHeaderPayload := make([]byte, 32)
-	_, err = rand.Read(spaceHeaderPayload)
-	require.NoError(t, err)
-	replicationKey := rand.Uint64()
-	header := &spacesyncproto.SpaceHeader{
-		Identity:           identity,
-		Timestamp:          time.Now().Unix(),
-		SpaceType:          "SpaceType",
-		ReplicationKey:     replicationKey,
-		Seed:               spaceHeaderSeed,
-		SpaceHeaderPayload: spaceHeaderPayload,
-	}
-	marhalled, err := header.Marshal()
-	require.NoError(t, err)
-	signature, err := accountKeys.SignKey.Sign(marhalled)
-	require.NoError(t, err)
-	rawHeader := &spacesyncproto.RawSpaceHeader{
-		SpaceHeader: marhalled,
-		Signature:   signature,
-	}
-	marhalledRawHeader, err := rawHeader.Marshal()
-	require.NoError(t, err)
-	id := "faisdfjpiocpoakopkop34"
-	spaceId := fmt.Sprintf("%s.%s", id, strconv.FormatUint(replicationKey, 36))
-	rawHeaderWithId := &spacesyncproto.RawSpaceHeaderWithId{
-		RawHeader: marhalledRawHeader,
-		Id:        spaceId,
-	}
-	err = ValidateSpaceHeader(rawHeaderWithId, nil)
-	assert.EqualErrorf(t, err, objecttree.ErrIncorrectCid.Error(), "Error should be: %v, got: %v", objecttree.ErrIncorrectCid, err)
-}
-
-func TestFailedHeaderPayloadForSpaceCreate_SignedWithAnotherIdentity(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	require.NoError(t, err)
-	spaceHeaderSeed := make([]byte, 32)
-	_, err = rand.Read(spaceHeaderSeed)
-	require.NoError(t, err)
-	spaceHeaderPayload := make([]byte, 32)
-	_, err = rand.Read(spaceHeaderPayload)
-	require.NoError(t, err)
-	replicationKey := rand.Uint64()
-	header := &spacesyncproto.SpaceHeader{
-		Identity:           identity,
-		Timestamp:          time.Now().Unix(),
-		SpaceType:          "SpaceType",
-		ReplicationKey:     replicationKey,
-		Seed:               spaceHeaderSeed,
-		SpaceHeaderPayload: spaceHeaderPayload,
-	}
-	marhalled, err := header.Marshal()
-	require.NoError(t, err)
-	anotherAccountKeys, err := accountdata.NewRandom()
-	signature, err := anotherAccountKeys.SignKey.Sign(marhalled)
-	require.NoError(t, err)
-	rawHeader := &spacesyncproto.RawSpaceHeader{
-		SpaceHeader: marhalled,
-		Signature:   signature,
-	}
-	marhalledRawHeader, err := rawHeader.Marshal()
-	require.NoError(t, err)
-	id := "faisdfjpiocpoakopkop34"
-	spaceId := fmt.Sprintf("%s.%s", id, strconv.FormatUint(replicationKey, 36))
-	rawHeaderWithId := &spacesyncproto.RawSpaceHeaderWithId{
-		RawHeader: marhalledRawHeader,
-		Id:        spaceId,
-	}
-	err = ValidateSpaceHeader(rawHeaderWithId, nil)
-	assert.EqualErrorf(t, err, objecttree.ErrIncorrectCid.Error(), "Error should be: %v, got: %v", objecttree.ErrIncorrectCid, err)
-}
-
-func TestSuccessAclPayloadSpace(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	spaceId := "AnySpaceId"
-	_, rawWithId, err := rawAclWithId(accountKeys, spaceId)
-	require.NoError(t, err)
-	validationSpaceId, err := validateCreateSpaceAclPayload(rawWithId)
-	require.Equal(t, validationSpaceId, spaceId)
-	require.NoError(t, err)
-}
-
-func TestFailAclPayloadSpace_IncorrectCid(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	require.NoError(t, err)
-	readKeyBytes := make([]byte, 32)
-	_, err = rand.Read(readKeyBytes)
-	require.NoError(t, err)
-	readKey, err := accountKeys.SignKey.GetPublic().Encrypt(readKeyBytes)
-	require.NoError(t, err)
-	masterKey, _, err := crypto.GenerateRandomEd25519KeyPair()
-	require.NoError(t, err)
-	rawIdentity, err := accountKeys.SignKey.GetPublic().Raw()
-	require.NoError(t, err)
-	identitySignature, err := masterKey.Sign(rawIdentity)
-	require.NoError(t, err)
-	rawMasterKey, err := masterKey.GetPublic().Marshall()
-	require.NoError(t, err)
-	aclRoot := aclrecordproto.AclRoot{
-		Identity:          identity,
-		MasterKey:         rawMasterKey,
-		SpaceId:           "SpaceId",
-		EncryptedReadKey:  readKey,
-		Timestamp:         time.Now().Unix(),
-		IdentitySignature: identitySignature,
-	}
-	marshalled, err := aclRoot.Marshal()
-	require.NoError(t, err)
-	signature, err := accountKeys.SignKey.Sign(marshalled)
-	rawAclRecord := &aclrecordproto.RawAclRecord{
-		Payload:   marshalled,
-		Signature: signature,
-	}
-	marshalledRaw, err := rawAclRecord.Marshal()
-	require.NoError(t, err)
-	aclHeadId := "rand"
-	rawWithId := &aclrecordproto.RawAclRecordWithId{
-		Payload: marshalledRaw,
-		Id:      aclHeadId,
-	}
-	_, err = validateCreateSpaceAclPayload(rawWithId)
-	assert.EqualErrorf(t, err, objecttree.ErrIncorrectCid.Error(), "Error should be: %v, got: %v", objecttree.ErrIncorrectCid, err)
-}
-
-func TestFailedAclPayloadSpace_IncorrectSignature(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	readKeyBytes := make([]byte, 32)
-	_, err = rand.Read(readKeyBytes)
-	require.NoError(t, err)
-	readKey, err := accountKeys.SignKey.GetPublic().Encrypt(readKeyBytes)
-	require.NoError(t, err)
-	masterKey, _, err := crypto.GenerateRandomEd25519KeyPair()
-	require.NoError(t, err)
-	rawIdentity, err := accountKeys.SignKey.GetPublic().Raw()
-	require.NoError(t, err)
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	identitySignature, err := masterKey.Sign(rawIdentity)
-	require.NoError(t, err)
-	rawMasterKey, err := masterKey.GetPublic().Raw()
-	require.NoError(t, err)
-	aclRoot := aclrecordproto.AclRoot{
-		Identity:          identity,
-		MasterKey:         rawMasterKey,
-		SpaceId:           "SpaceId",
-		EncryptedReadKey:  readKey,
-		Timestamp:         time.Now().Unix(),
-		IdentitySignature: identitySignature,
-	}
-	marshalled, err := aclRoot.Marshal()
-	require.NoError(t, err)
-	rawAclRecord := &aclrecordproto.RawAclRecord{
-		Payload:   marshalled,
-		Signature: marshalled,
-	}
-	marshalledRaw, err := rawAclRecord.Marshal()
-	require.NoError(t, err)
-	aclHeadId, err := cidutil.NewCidFromBytes(marshalledRaw)
-	require.NoError(t, err)
-	rawWithId := &aclrecordproto.RawAclRecordWithId{
-		Payload: marshalledRaw,
-		Id:      aclHeadId,
-	}
-	_, err = validateCreateSpaceAclPayload(rawWithId)
-	assert.NotNil(t, err)
-	assert.EqualErrorf(t, err, spacestorage.ErrIncorrectSpaceHeader.Error(), "Error should be: %v, got: %v", spacestorage.ErrIncorrectSpaceHeader, err)
-}
-
-func TestFailedAclPayloadSpace_IncorrectIdentitySignature(t *testing.T) {
-	spaceId := "AnySpaceId"
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	readKeyBytes := make([]byte, 32)
-	_, err = rand.Read(readKeyBytes)
-	if err != nil {
-		return
-	}
-	readKey, err := accountKeys.SignKey.GetPublic().Encrypt(readKeyBytes)
-	if err != nil {
-		return
-	}
-	masterKey, _, err := crypto.GenerateRandomEd25519KeyPair()
-	if err != nil {
-		return
-	}
-	masterPubKey := masterKey.GetPublic()
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	if err != nil {
-		return
-	}
-	rawMasterKey, err := masterPubKey.Marshall()
-	if err != nil {
-		return
-	}
-	aclRoot := aclrecordproto.AclRoot{
-		Identity:          identity,
-		MasterKey:         rawMasterKey,
-		SpaceId:           spaceId,
-		EncryptedReadKey:  readKey,
-		Timestamp:         time.Now().Unix(),
-		IdentitySignature: identity,
-	}
-	marshalled, err := aclRoot.Marshal()
-	if err != nil {
-		return
-	}
-	signature, err := accountKeys.SignKey.Sign(marshalled)
-	rawAclRecord := &aclrecordproto.RawAclRecord{
-		Payload:   marshalled,
-		Signature: signature,
-	}
-	marshalledRaw, err := rawAclRecord.Marshal()
-	if err != nil {
-		return
-	}
-	aclHeadId, err := cidutil.NewCidFromBytes(marshalledRaw)
-	if err != nil {
-		return
-	}
-	rawWithId := &aclrecordproto.RawAclRecordWithId{
-		Payload: marshalledRaw,
-		Id:      aclHeadId,
-	}
-	_, err = validateCreateSpaceAclPayload(rawWithId)
-	assert.EqualErrorf(t, err, spacestorage.ErrIncorrectSpaceHeader.Error(), "Error should be: %v, got: %v", spacestorage.ErrIncorrectSpaceHeader, err)
-}
-
-func TestSuccessSettingsPayloadSpace(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	require.NoError(t, err)
-	spaceSettingsSeed := make([]byte, 32)
-	_, err = rand.Read(spaceSettingsSeed)
-	require.NoError(t, err)
-	changePayload := make([]byte, 32)
-	_, err = rand.Read(changePayload)
-	require.NoError(t, err)
-	spaceId := "SpaceId"
-	rootChange := &treechangeproto.RootChange{
-		AclHeadId:     "AclHeadId",
-		SpaceId:       spaceId,
-		ChangeType:    "ChangeType",
-		Timestamp:     time.Now().Unix(),
-		Seed:          spaceSettingsSeed,
-		Identity:      identity,
-		ChangePayload: changePayload,
-	}
-	marshalledChange, err := rootChange.Marshal()
-	require.NoError(t, err)
-	signature, err := accountKeys.SignKey.Sign(marshalledChange)
-	require.NoError(t, err)
-	raw := &treechangeproto.RawTreeChange{
-		Payload:   marshalledChange,
-		Signature: signature,
-	}
-	marshalledRawChange, err := raw.Marshal()
-	id, err := cidutil.NewCidFromBytes(marshalledRawChange)
-	require.NoError(t, err)
-	rawIdChange := &treechangeproto.RawTreeChangeWithId{
-		RawChange: marshalledRawChange,
-		Id:        id,
-	}
-	_, validationSpaceId, err := validateCreateSpaceSettingsPayload(rawIdChange)
-	require.Equal(t, validationSpaceId, spaceId)
-	require.NoError(t, err)
-}
-
-func TestFailSettingsPayloadSpace_InvalidSignature(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	require.NoError(t, err)
-	spaceSettingsSeed := make([]byte, 32)
-	_, err = rand.Read(spaceSettingsSeed)
-	require.NoError(t, err)
-	changePayload := make([]byte, 32)
-	_, err = rand.Read(changePayload)
-	require.NoError(t, err)
-	rootChange := &treechangeproto.RootChange{
-		AclHeadId:     "AclHeadId",
-		SpaceId:       "SpaceId",
-		ChangeType:    "ChangeType",
-		Timestamp:     time.Now().Unix(),
-		Seed:          spaceSettingsSeed,
-		Identity:      identity,
-		ChangePayload: changePayload,
-	}
-	marshalledChange, err := rootChange.Marshal()
-	require.NoError(t, err)
-	raw := &treechangeproto.RawTreeChange{
-		Payload:   marshalledChange,
-		Signature: marshalledChange,
-	}
-	marshalledRawChange, err := raw.Marshal()
-	id, err := cidutil.NewCidFromBytes(marshalledRawChange)
-	require.NoError(t, err)
-	rawIdChange := &treechangeproto.RawTreeChangeWithId{
-		RawChange: marshalledRawChange,
-		Id:        id,
-	}
-	_, _, err = validateCreateSpaceSettingsPayload(rawIdChange)
-	assert.EqualErrorf(t, err, spacestorage.ErrIncorrectSpaceHeader.Error(), "Error should be: %v, got: %v", spacestorage.ErrIncorrectSpaceHeader, err)
-}
-
-func TestFailSettingsPayloadSpace_InvalidCid(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	require.NoError(t, err)
-	spaceSettingsSeed := make([]byte, 32)
-	_, err = rand.Read(spaceSettingsSeed)
-	require.NoError(t, err)
-	changePayload := make([]byte, 32)
-	_, err = rand.Read(changePayload)
-	require.NoError(t, err)
-	rootChange := &treechangeproto.RootChange{
-		AclHeadId:     "AclHeadId",
-		SpaceId:       "SpaceId",
-		ChangeType:    "ChangeType",
-		Timestamp:     time.Now().Unix(),
-		Seed:          spaceSettingsSeed,
-		Identity:      identity,
-		ChangePayload: changePayload,
-	}
-	marshalledChange, err := rootChange.Marshal()
-	require.NoError(t, err)
-	signature, err := accountKeys.SignKey.Sign(marshalledChange)
-	require.NoError(t, err)
-	raw := &treechangeproto.RawTreeChange{
-		Payload:   marshalledChange,
-		Signature: signature,
-	}
-	marshalledRawChange, err := raw.Marshal()
-	id := "id"
-	require.NoError(t, err)
-	rawIdChange := &treechangeproto.RawTreeChangeWithId{
-		RawChange: marshalledRawChange,
-		Id:        id,
-	}
-	_, _, err = validateCreateSpaceSettingsPayload(rawIdChange)
-	assert.EqualErrorf(t, err, spacestorage.ErrIncorrectSpaceHeader.Error(), "Error should be: %v, got: %v", spacestorage.ErrIncorrectSpaceHeader, err)
-}
-
-func TestSuccessSameIds(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	spaceId, rawHeaderWithId, err := rawHeaderWithId(accountKeys)
-	require.NoError(t, err)
-	aclHeadId, rawAclWithId, err := rawAclWithId(accountKeys, spaceId)
-	require.NoError(t, err)
-	rawSettingsPayload, err := rawSettingsPayload(accountKeys, spaceId, aclHeadId)
-	spacePayload := spacestorage.SpaceStorageCreatePayload{
-		AclWithId:           rawAclWithId,
-		SpaceHeaderWithId:   rawHeaderWithId,
-		SpaceSettingsWithId: rawSettingsPayload,
-	}
-	err = validateSpaceStorageCreatePayload(spacePayload)
-	require.NoError(t, err)
-}
-
-func TestFailWithAclWrongSpaceId(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	spaceId, rawHeaderWithId, err := rawHeaderWithId(accountKeys)
-	require.NoError(t, err)
-	aclHeadId, rawAclWithId, err := rawAclWithId(accountKeys, "spaceId")
-	require.NoError(t, err)
-	rawSettingsPayload, err := rawSettingsPayload(accountKeys, spaceId, aclHeadId)
-	spacePayload := spacestorage.SpaceStorageCreatePayload{
-		AclWithId:           rawAclWithId,
-		SpaceHeaderWithId:   rawHeaderWithId,
-		SpaceSettingsWithId: rawSettingsPayload,
-	}
-	err = validateSpaceStorageCreatePayload(spacePayload)
-	assert.EqualErrorf(t, err, spacestorage.ErrIncorrectSpaceHeader.Error(), "Error should be: %v, got: %v", spacestorage.ErrIncorrectSpaceHeader, err)
-}
-
-func TestFailWithSettingsWrongSpaceId(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	spaceId, rawHeaderWithId, err := rawHeaderWithId(accountKeys)
-	require.NoError(t, err)
-	aclHeadId, rawAclWithId, err := rawAclWithId(accountKeys, spaceId)
-	require.NoError(t, err)
-	rawSettingsPayload, err := rawSettingsPayload(accountKeys, "spaceId", aclHeadId)
-	spacePayload := spacestorage.SpaceStorageCreatePayload{
-		AclWithId:           rawAclWithId,
-		SpaceHeaderWithId:   rawHeaderWithId,
-		SpaceSettingsWithId: rawSettingsPayload,
-	}
-	err = validateSpaceStorageCreatePayload(spacePayload)
-	assert.EqualErrorf(t, err, spacestorage.ErrIncorrectSpaceHeader.Error(), "Error should be: %v, got: %v", spacestorage.ErrIncorrectSpaceHeader, err)
-}
-
-func TestFailWithWrongAclHeadIdInSettingsPayload(t *testing.T) {
-	accountKeys, err := accountdata.NewRandom()
-	require.NoError(t, err)
-	spaceId, rawHeaderWithId, err := rawHeaderWithId(accountKeys)
-	require.NoError(t, err)
-	_, rawAclWithId, err := rawAclWithId(accountKeys, spaceId)
-	require.NoError(t, err)
-	rawSettingsPayload, err := rawSettingsPayload(accountKeys, spaceId, "aclHeadId")
-	spacePayload := spacestorage.SpaceStorageCreatePayload{
-		AclWithId:           rawAclWithId,
-		SpaceHeaderWithId:   rawHeaderWithId,
-		SpaceSettingsWithId: rawSettingsPayload,
-	}
-	err = validateSpaceStorageCreatePayload(spacePayload)
-	assert.EqualErrorf(t, err, spacestorage.ErrIncorrectSpaceHeader.Error(), "Error should be: %v, got: %v", spacestorage.ErrIncorrectSpaceHeader, err)
-}
-
-func rawSettingsPayload(accountKeys *accountdata.AccountKeys, spaceId, aclHeadId string) (rawIdChange *treechangeproto.RawTreeChangeWithId, err error) {
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	if err != nil {
-		return
-	}
-	spaceSettingsSeed := make([]byte, 32)
-	_, err = rand.Read(spaceSettingsSeed)
-	if err != nil {
-		return
-	}
-	changePayload := make([]byte, 32)
-	_, err = rand.Read(changePayload)
-	if err != nil {
-		return
-	}
-	rootChange := &treechangeproto.RootChange{
-		AclHeadId:     aclHeadId,
-		SpaceId:       spaceId,
-		ChangeType:    "ChangeType",
-		Timestamp:     time.Now().Unix(),
-		Seed:          spaceSettingsSeed,
-		Identity:      identity,
-		ChangePayload: changePayload,
-	}
-	marshalledChange, err := rootChange.Marshal()
-	if err != nil {
-		return
-	}
-	signature, err := accountKeys.SignKey.Sign(marshalledChange)
-	if err != nil {
-		return
-	}
-	raw := &treechangeproto.RawTreeChange{
-		Payload:   marshalledChange,
-		Signature: signature,
-	}
-	marshalledRawChange, err := raw.Marshal()
-	id, err := cidutil.NewCidFromBytes(marshalledRawChange)
-	if err != nil {
-		return
-	}
-	rawIdChange = &treechangeproto.RawTreeChangeWithId{
-		RawChange: marshalledRawChange,
-		Id:        id,
-	}
-
-	return
-}
-
-func rawAclWithId(accountKeys *accountdata.AccountKeys, spaceId string) (aclHeadId string, rawWithId *aclrecordproto.RawAclRecordWithId, err error) {
-	// TODO: use same storage creation methods as we use in spaces
-	readKeyBytes := make([]byte, 32)
-	_, err = rand.Read(readKeyBytes)
-	if err != nil {
-		return
-	}
-	readKey, err := accountKeys.SignKey.GetPublic().Encrypt(readKeyBytes)
-	if err != nil {
-		return
-	}
-	masterKey, _, err := crypto.GenerateRandomEd25519KeyPair()
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	if err != nil {
-		return
-	}
-	masterPubKey := masterKey.GetPublic()
-	rawIdentity, err := accountKeys.SignKey.GetPublic().Raw()
-	if err != nil {
-		return
-	}
-	identitySignature, err := masterKey.Sign(rawIdentity)
-	if err != nil {
-		return
-	}
-	rawMasterKey, err := masterPubKey.Marshall()
-	if err != nil {
-		return
-	}
-	aclRoot := aclrecordproto.AclRoot{
-		Identity:          identity,
-		MasterKey:         rawMasterKey,
-		SpaceId:           spaceId,
-		EncryptedReadKey:  readKey,
-		Timestamp:         time.Now().Unix(),
-		IdentitySignature: identitySignature,
-	}
-	marshalled, err := aclRoot.Marshal()
-	if err != nil {
-		return
-	}
-	signature, err := accountKeys.SignKey.Sign(marshalled)
-	rawAclRecord := &aclrecordproto.RawAclRecord{
-		Payload:   marshalled,
-		Signature: signature,
-	}
-	marshalledRaw, err := rawAclRecord.Marshal()
-	if err != nil {
-		return
-	}
-	aclHeadId, err = cidutil.NewCidFromBytes(marshalledRaw)
-	if err != nil {
-		return
-	}
-	rawWithId = &aclrecordproto.RawAclRecordWithId{
-		Payload: marshalledRaw,
-		Id:      aclHeadId,
-	}
-
-	return
-}
-
-func rawHeaderWithId(accountKeys *accountdata.AccountKeys) (spaceId string, rawWithId *spacesyncproto.RawSpaceHeaderWithId, err error) {
-	// TODO: use same storage creation methods as we use in spaces
-	identity, err := accountKeys.SignKey.GetPublic().Marshall()
-	if err != nil {
-		return
-	}
-	spaceHeaderSeed := make([]byte, 32)
-	_, err = rand.Read(spaceHeaderSeed)
-	if err != nil {
-		return
-	}
-	spaceHeaderPayload := make([]byte, 32)
-	_, err = rand.Read(spaceHeaderPayload)
-	if err != nil {
-		return
-	}
-	replicationKey := rand.Uint64()
-	header := &spacesyncproto.SpaceHeader{
-		Identity:           identity,
-		Timestamp:          time.Now().Unix(),
-		SpaceType:          "SpaceType",
-		ReplicationKey:     replicationKey,
-		Seed:               spaceHeaderSeed,
-		SpaceHeaderPayload: spaceHeaderPayload,
-	}
-	marhalled, err := header.Marshal()
-	if err != nil {
-		return
-	}
-	signature, err := accountKeys.SignKey.Sign(marhalled)
-	if err != nil {
-		return
-	}
-	rawHeader := &spacesyncproto.RawSpaceHeader{
-		SpaceHeader: marhalled,
-		Signature:   signature,
-	}
-	marshalledRawHeader, err := rawHeader.Marshal()
-	if err != nil {
-		return
-	}
-	id, err := cidutil.NewCidFromBytes(marshalledRawHeader)
-	if err != nil {
-		return
-	}
-	spaceId = fmt.Sprintf("%s.%s", id, strconv.FormatUint(replicationKey, 36))
-	rawWithId = &spacesyncproto.RawSpaceHeaderWithId{
-		RawHeader: marshalledRawHeader,
-		Id:        spaceId,
-	}
-
-	return
-}

commonspace/peermanager/mock_peermanager/mock_peermanager.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anyproto/any-sync/commonspace/peermanager (interfaces: PeerManager)
+// Source: github.com/anytypeio/any-sync/commonspace/peermanager (interfaces: PeerManager)
 
 // Package mock_peermanager is a generated GoMock package.
 package mock_peermanager
@@ -8,8 +8,8 @@ import (
 	context "context"
 	reflect "reflect"
 
-	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	peer "github.com/anyproto/any-sync/net/peer"
+	spacesyncproto "github.com/anytypeio/any-sync/commonspace/spacesyncproto"
+	peer "github.com/anytypeio/any-sync/net/peer"
 	gomock "github.com/golang/mock/gomock"
 )
 

commonspace/peermanager/peermanager.go

@@ -1,11 +1,11 @@
-//go:generate mockgen -destination mock_peermanager/mock_peermanager.go github.com/anyproto/any-sync/commonspace/peermanager PeerManager
+//go:generate mockgen -destination mock_peermanager/mock_peermanager.go github.com/anytypeio/any-sync/commonspace/peermanager PeerManager
 package peermanager
 
 import (
 	"context"
-	"github.com/anyproto/any-sync/app"
-	"github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	"github.com/anyproto/any-sync/net/peer"
+	"github.com/anytypeio/any-sync/app"
+	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
+	"github.com/anytypeio/any-sync/net/peer"
 )
 
 const CName = "common.commonspace.peermanager"

commonspace/settings/deleter.go

@@ -2,10 +2,9 @@ package settings
 
 import (
 	"context"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anyproto/any-sync/commonspace/object/treemanager"
-	"github.com/anyproto/any-sync/commonspace/settings/settingsstate"
-	"github.com/anyproto/any-sync/commonspace/spacestorage"
+	"github.com/anytypeio/any-sync/commonspace/object/treegetter"
+	"github.com/anytypeio/any-sync/commonspace/settings/settingsstate"
+	"github.com/anytypeio/any-sync/commonspace/spacestorage"
 	"go.uber.org/zap"
 )
 
@@ -16,48 +15,25 @@ type Deleter interface {
 type deleter struct {
 	st     spacestorage.SpaceStorage
 	state  settingsstate.ObjectDeletionState
-	getter treemanager.TreeManager
+	getter treegetter.TreeGetter
 }
 
-func newDeleter(st spacestorage.SpaceStorage, state settingsstate.ObjectDeletionState, getter treemanager.TreeManager) Deleter {
+func newDeleter(st spacestorage.SpaceStorage, state settingsstate.ObjectDeletionState, getter treegetter.TreeGetter) Deleter {
 	return &deleter{st, state, getter}
 }
 
 func (d *deleter) Delete() {
-	var (
-		allQueued = d.state.GetQueued()
-		spaceId   = d.st.Id()
-	)
+	allQueued := d.state.GetQueued()
 	for _, id := range allQueued {
-		log := log.With(zap.String("treeId", id), zap.String("spaceId", spaceId))
-		shouldDelete, err := d.tryMarkDeleted(spaceId, id)
-		if !shouldDelete {
-			if err != nil {
-				log.Error("failed to mark object as deleted", zap.Error(err))
-				continue
-			}
-		} else {
-			err = d.getter.DeleteTree(context.Background(), spaceId, id)
-			if err != nil && err != spacestorage.ErrTreeStorageAlreadyDeleted {
-				log.Error("failed to delete object", zap.Error(err))
-				continue
-			}
+		err := d.getter.DeleteTree(context.Background(), d.st.Id(), id)
+		if err != nil && err != spacestorage.ErrTreeStorageAlreadyDeleted {
+			log.With(zap.String("id", id), zap.Error(err)).Error("failed to delete object")
+			continue
 		}
 		err = d.state.Delete(id)
 		if err != nil {
-			log.Error("failed to mark object as deleted", zap.Error(err))
+			log.With(zap.String("id", id), zap.Error(err)).Error("failed to mark object as deleted")
 		}
-		log.Debug("object successfully deleted", zap.Error(err))
+		log.With(zap.String("id", id), zap.Error(err)).Debug("object successfully deleted")
 	}
 }
-
-func (d *deleter) tryMarkDeleted(spaceId, treeId string) (bool, error) {
-	_, err := d.st.TreeStorage(treeId)
-	if err == nil {
-		return true, nil
-	}
-	if err != treestorage.ErrUnknownTreeId {
-		return false, err
-	}
-	return false, d.getter.MarkTreeDeleted(context.Background(), spaceId, treeId)
-}

commonspace/settings/deleter_test.go

@@ -2,62 +2,39 @@ package settings
 
 import (
 	"fmt"
-	"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
-	"github.com/anyproto/any-sync/commonspace/object/treemanager/mock_treemanager"
-	"github.com/anyproto/any-sync/commonspace/settings/settingsstate/mock_settingsstate"
-	"github.com/anyproto/any-sync/commonspace/spacestorage/mock_spacestorage"
+	"github.com/anytypeio/any-sync/commonspace/object/treegetter/mock_treegetter"
+	"github.com/anytypeio/any-sync/commonspace/settings/settingsstate/mock_settingsstate"
+	"github.com/anytypeio/any-sync/commonspace/spacestorage"
+	"github.com/anytypeio/any-sync/commonspace/spacestorage/mock_spacestorage"
 	"github.com/golang/mock/gomock"
 	"testing"
 )
 
 func TestDeleter_Delete(t *testing.T) {
 	ctrl := gomock.NewController(t)
-	treeManager := mock_treemanager.NewMockTreeManager(ctrl)
+	treeGetter := mock_treegetter.NewMockTreeGetter(ctrl)
 	st := mock_spacestorage.NewMockSpaceStorage(ctrl)
 	delState := mock_settingsstate.NewMockObjectDeletionState(ctrl)
 
-	deleter := newDeleter(st, delState, treeManager)
+	deleter := newDeleter(st, delState, treeGetter)
 
-	t.Run("deleter delete mark deleted success", func(t *testing.T) {
+	t.Run("deleter delete queued", func(t *testing.T) {
 		id := "id"
 		spaceId := "spaceId"
 		delState.EXPECT().GetQueued().Return([]string{id})
 		st.EXPECT().Id().Return(spaceId)
-		st.EXPECT().TreeStorage(id).Return(nil, treestorage.ErrUnknownTreeId)
-		treeManager.EXPECT().MarkTreeDeleted(gomock.Any(), spaceId, id).Return(nil)
+		treeGetter.EXPECT().DeleteTree(gomock.Any(), spaceId, id).Return(nil)
 		delState.EXPECT().Delete(id).Return(nil)
 
 		deleter.Delete()
 	})
 
-	t.Run("deleter delete mark deleted other error", func(t *testing.T) {
+	t.Run("deleter delete already deleted", func(t *testing.T) {
 		id := "id"
 		spaceId := "spaceId"
 		delState.EXPECT().GetQueued().Return([]string{id})
 		st.EXPECT().Id().Return(spaceId)
-		st.EXPECT().TreeStorage(id).Return(nil, fmt.Errorf("unknown error"))
-
-		deleter.Delete()
-	})
-
-	t.Run("deleter delete mark deleted fail", func(t *testing.T) {
-		id := "id"
-		spaceId := "spaceId"
-		delState.EXPECT().GetQueued().Return([]string{id})
-		st.EXPECT().Id().Return(spaceId)
-		st.EXPECT().TreeStorage(id).Return(nil, treestorage.ErrUnknownTreeId)
-		treeManager.EXPECT().MarkTreeDeleted(gomock.Any(), spaceId, id).Return(fmt.Errorf("mark error"))
-
-		deleter.Delete()
-	})
-	//treeManager.EXPECT().DeleteTree(gomock.Any(), spaceId, id).Return(spacestorage.ErrTreeStorageAlreadyDeleted)
-	t.Run("deleter delete success", func(t *testing.T) {
-		id := "id"
-		spaceId := "spaceId"
-		delState.EXPECT().GetQueued().Return([]string{id})
-		st.EXPECT().Id().Return(spaceId)
-		st.EXPECT().TreeStorage(id).Return(nil, nil)
-		treeManager.EXPECT().DeleteTree(gomock.Any(), spaceId, id).Return(nil)
+		treeGetter.EXPECT().DeleteTree(gomock.Any(), spaceId, id).Return(spacestorage.ErrTreeStorageAlreadyDeleted)
 		delState.EXPECT().Delete(id).Return(nil)
 
 		deleter.Delete()
@@ -68,8 +45,7 @@ func TestDeleter_Delete(t *testing.T) {
 		spaceId := "spaceId"
 		delState.EXPECT().GetQueued().Return([]string{id})
 		st.EXPECT().Id().Return(spaceId)
-		st.EXPECT().TreeStorage(id).Return(nil, nil)
-		treeManager.EXPECT().DeleteTree(gomock.Any(), spaceId, id).Return(fmt.Errorf("some error"))
+		treeGetter.EXPECT().DeleteTree(gomock.Any(), spaceId, id).Return(fmt.Errorf("some error"))
 
 		deleter.Delete()
 	})

commonspace/settings/deletionmanager.go

@@ -2,8 +2,9 @@ package settings
 
 import (
 	"context"
-	"github.com/anyproto/any-sync/commonspace/object/treemanager"
-	"github.com/anyproto/any-sync/commonspace/settings/settingsstate"
+	"github.com/anytypeio/any-sync/commonspace/object/treegetter"
+	"github.com/anytypeio/any-sync/commonspace/settings/settingsstate"
+	"github.com/anytypeio/any-sync/util/slice"
 	"go.uber.org/zap"
 )
 
@@ -19,12 +20,12 @@ func newDeletionManager(
 	spaceId string,
 	settingsId string,
 	isResponsible bool,
-	treeManager treemanager.TreeManager,
+	treeGetter treegetter.TreeGetter,
 	deletionState settingsstate.ObjectDeletionState,
 	provider SpaceIdsProvider,
 	onSpaceDelete func()) DeletionManager {
 	return &deletionManager{
-		treeManager:   treeManager,
+		treeGetter:    treeGetter,
 		isResponsible: isResponsible,
 		spaceId:       spaceId,
 		settingsId:    settingsId,
@@ -37,7 +38,7 @@ func newDeletionManager(
 type deletionManager struct {
 	deletionState settingsstate.ObjectDeletionState
 	provider      SpaceIdsProvider
-	treeManager   treemanager.TreeManager
+	treeGetter    treegetter.TreeGetter
 	spaceId       string
 	settingsId    string
 	isResponsible bool
@@ -46,20 +47,26 @@ type deletionManager struct {
 
 func (d *deletionManager) UpdateState(ctx context.Context, state *settingsstate.State) error {
 	log := log.With(zap.String("spaceId", d.spaceId))
-	d.deletionState.Add(state.DeletedIds)
+	err := d.deletionState.Add(state.DeletedIds)
+	if err != nil {
+		log.Debug("failed to add deleted ids to deletion state")
+	}
 	if state.DeleterId == "" {
 		return nil
 	}
-	// we should delete space
 	log.Debug("deleting space")
+	err = d.treeGetter.DeleteSpace(ctx, d.spaceId)
+	if err != nil {
+		log.Debug("failed to notify on space deletion", zap.Error(err))
+	}
 	if d.isResponsible {
-		mapIds := map[string]struct{}{}
-		for _, id := range d.provider.AllIds() {
-			if id != d.settingsId {
-				mapIds[id] = struct{}{}
-			}
+		allIds := slice.DiscardFromSlice(d.provider.AllIds(), func(id string) bool {
+			return id == d.settingsId
+		})
+		err := d.deletionState.Add(allIds)
+		if err != nil {
+			log.Debug("failed to add all ids to deletion state")
 		}
-		d.deletionState.Add(mapIds)
 	}
 	d.onSpaceDelete()
 	return nil