diff --git a/commonspace/headsync/mock_headsync/mock_headsync.go b/commonspace/headsync/mock_headsync/mock_headsync.go
index b0781825..8a2f74dc 100644
--- a/commonspace/headsync/mock_headsync/mock_headsync.go
+++ b/commonspace/headsync/mock_headsync/mock_headsync.go
@@ -8,7 +8,7 @@ import (
 	context "context"
 	reflect "reflect"
 
-	deletionstate "github.com/anytypeio/any-sync/commonspace/settings/settingsstate"
+	settingsstate "github.com/anytypeio/any-sync/commonspace/settings/settingsstate"
 	gomock "github.com/golang/mock/gomock"
 )
 
@@ -36,7 +36,7 @@ func (m *MockDiffSyncer) EXPECT() *MockDiffSyncerMockRecorder {
 }
 
 // Init mocks base method.
-func (m *MockDiffSyncer) Init(arg0 deletionstate.ObjectDeletionState) {
+func (m *MockDiffSyncer) Init(arg0 settingsstate.ObjectDeletionState) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Init", arg0)
 }
diff --git a/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go b/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go
index 95dd7a00..541fa779 100644
--- a/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go
+++ b/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go
@@ -255,6 +255,21 @@ func (mr *MockObjectTreeMockRecorder) Lock() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockObjectTree)(nil).Lock))
 }
 
+// PrepareChange mocks base method.
+func (m *MockObjectTree) PrepareChange(arg0 objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrepareChange", arg0)
+	ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PrepareChange indicates an expected call of PrepareChange.
+func (mr *MockObjectTreeMockRecorder) PrepareChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockObjectTree)(nil).PrepareChange), arg0)
+}
+
 // RLock mocks base method.
 func (m *MockObjectTree) RLock() {
 	m.ctrl.T.Helper()
@@ -374,3 +389,18 @@ func (mr *MockObjectTreeMockRecorder) UnmarshalledHeader() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalledHeader", reflect.TypeOf((*MockObjectTree)(nil).UnmarshalledHeader))
 }
+
+// UnpackChange mocks base method.
+func (m *MockObjectTree) UnpackChange(arg0 *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnpackChange", arg0)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UnpackChange indicates an expected call of UnpackChange.
+func (mr *MockObjectTreeMockRecorder) UnpackChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockObjectTree)(nil).UnpackChange), arg0)
+}
diff --git a/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go b/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go
index 1928e62d..d7fe181f 100644
--- a/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go
+++ b/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go
@@ -380,6 +380,21 @@ func (mr *MockSyncTreeMockRecorder) Lock() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockSyncTree)(nil).Lock))
 }
 
+// PrepareChange mocks base method.
+func (m *MockSyncTree) PrepareChange(arg0 objecttree.SignableChangeContent) (*treechangeproto.RawTreeChangeWithId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PrepareChange", arg0)
+	ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PrepareChange indicates an expected call of PrepareChange.
+func (mr *MockSyncTreeMockRecorder) PrepareChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareChange", reflect.TypeOf((*MockSyncTree)(nil).PrepareChange), arg0)
+}
+
 // RLock mocks base method.
 func (m *MockSyncTree) RLock() {
 	m.ctrl.T.Helper()
@@ -526,6 +541,21 @@ func (mr *MockSyncTreeMockRecorder) UnmarshalledHeader() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalledHeader", reflect.TypeOf((*MockSyncTree)(nil).UnmarshalledHeader))
 }
 
+// UnpackChange mocks base method.
+func (m *MockSyncTree) UnpackChange(arg0 *treechangeproto.RawTreeChangeWithId) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnpackChange", arg0)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UnpackChange indicates an expected call of UnpackChange.
+func (mr *MockSyncTreeMockRecorder) UnpackChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackChange", reflect.TypeOf((*MockSyncTree)(nil).UnpackChange), arg0)
+}
+
 // MockReceiveQueue is a mock of ReceiveQueue interface.
 type MockReceiveQueue struct {
 	ctrl     *gomock.Controller
diff --git a/commonspace/object/treegetter/mock_treegetter/mock_treegetter.go b/commonspace/object/treegetter/mock_treegetter/mock_treegetter.go
index b984ea1b..6aee2208 100644
--- a/commonspace/object/treegetter/mock_treegetter/mock_treegetter.go
+++ b/commonspace/object/treegetter/mock_treegetter/mock_treegetter.go
@@ -50,6 +50,20 @@ func (mr *MockTreeGetterMockRecorder) Close(arg0 interface{}) *gomock.Call {
 	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()
diff --git a/commonspace/settings/settings.go b/commonspace/settings/settings.go
index effd3ac0..ef51bc4f 100644
--- a/commonspace/settings/settings.go
+++ b/commonspace/settings/settings.go
@@ -134,7 +134,7 @@ func NewSettingsObject(deps Deps, spaceId string) (obj SettingsObject) {
 	return
 }
 
-func (s *settingsObject) updateIds(tr objecttree.ObjectTree, isUpdate bool) {
+func (s *settingsObject) updateIds(tr objecttree.ObjectTree) {
 	var err error
 	s.state, err = s.builder.Build(tr, s.state, isUpdate)
 	if err != nil {
@@ -149,13 +149,14 @@ func (s *settingsObject) updateIds(tr objecttree.ObjectTree, isUpdate bool) {
 
 // Update is called as part of UpdateListener interface
 func (s *settingsObject) Update(tr objecttree.ObjectTree) {
-	s.updateIds(tr, true)
+	s.updateIds(tr)
 }
 
 // Rebuild is called as part of UpdateListener interface (including when the object is built for the first time, e.g. on Init call)
 func (s *settingsObject) Rebuild(tr objecttree.ObjectTree) {
 	// at initial build "s" may not contain the object tree, so it is safer to provide it from the function parameter
-	s.updateIds(tr, false)
+	s.state = nil
+	s.updateIds(tr)
 }
 
 func (s *settingsObject) Init(ctx context.Context) (err error) {
diff --git a/commonspace/settings/settingsstate/deletionstate.go b/commonspace/settings/settingsstate/deletionstate.go
index 16de7486..c28dca63 100644
--- a/commonspace/settings/settingsstate/deletionstate.go
+++ b/commonspace/settings/settingsstate/deletionstate.go
@@ -1,4 +1,4 @@
-//go:generate mockgen -destination mock_deletionstate/mock_deletionstate.go github.com/anytypeio/any-sync/commonspace/settings/deletionstate DeletionState
+//go:generate mockgen -destination mock_settingsstate/mock_settingsstate.go github.com/anytypeio/any-sync/commonspace/settings/settingsstate ObjectDeletionState,StateBuilder
 package settingsstate
 
 import (
diff --git a/commonspace/settings/settingsstate/mock_settingsstate/mock_deletionstate.go b/commonspace/settings/settingsstate/mock_settingsstate/mock_deletionstate.go
deleted file mode 100644
index 0e9aa0c0..00000000
--- a/commonspace/settings/settingsstate/mock_settingsstate/mock_deletionstate.go
+++ /dev/null
@@ -1,136 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/any-sync/commonspace/settings/deletionstate (interfaces: ObjectDeletionState)
-
-// Package mock_deletionstate is a generated GoMock package.
-package mock_settingsstate
-
-import (
-	reflect "reflect"
-
-	deletionstate "github.com/anytypeio/any-sync/commonspace/settings/settingsstate"
-	gomock "github.com/golang/mock/gomock"
-)
-
-// MockDeletionState is a mock of ObjectDeletionState interface.
-type MockDeletionState struct {
-	ctrl     *gomock.Controller
-	recorder *MockDeletionStateMockRecorder
-}
-
-// MockDeletionStateMockRecorder is the mock recorder for MockDeletionState.
-type MockDeletionStateMockRecorder struct {
-	mock *MockDeletionState
-}
-
-// NewMockDeletionState creates a new mock instance.
-func NewMockDeletionState(ctrl *gomock.Controller) *MockDeletionState {
-	mock := &MockDeletionState{ctrl: ctrl}
-	mock.recorder = &MockDeletionStateMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockDeletionState) EXPECT() *MockDeletionStateMockRecorder {
-	return m.recorder
-}
-
-// Add mocks base method.
-func (m *MockDeletionState) Add(arg0 []string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Add", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Add indicates an expected call of Add.
-func (mr *MockDeletionStateMockRecorder) Add(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockDeletionState)(nil).Add), arg0)
-}
-
-// AddObserver mocks base method.
-func (m *MockDeletionState) AddObserver(arg0 deletionstate.StateUpdateObserver) {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "AddObserver", arg0)
-}
-
-// AddObserver indicates an expected call of AddObserver.
-func (mr *MockDeletionStateMockRecorder) AddObserver(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObserver", reflect.TypeOf((*MockDeletionState)(nil).AddObserver), arg0)
-}
-
-// CreateDeleteChange mocks base method.
-func (m *MockDeletionState) CreateObjectDeleteChange(arg0 string, arg1 bool) ([]byte, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateDeleteChange", arg0, arg1)
-	ret0, _ := ret[0].([]byte)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CreateDeleteChange indicates an expected call of CreateDeleteChange.
-func (mr *MockDeletionStateMockRecorder) CreateDeleteChange(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDeleteChange", reflect.TypeOf((*MockDeletionState)(nil).CreateObjectDeleteChange), arg0, arg1)
-}
-
-// Delete mocks base method.
-func (m *MockDeletionState) Delete(arg0 string) error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Delete", arg0)
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// Delete indicates an expected call of Delete.
-func (mr *MockDeletionStateMockRecorder) Delete(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDeletionState)(nil).Delete), arg0)
-}
-
-// Exists mocks base method.
-func (m *MockDeletionState) Exists(arg0 string) bool {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Exists", arg0)
-	ret0, _ := ret[0].(bool)
-	return ret0
-}
-
-// Exists indicates an expected call of Exists.
-func (mr *MockDeletionStateMockRecorder) Exists(arg0 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockDeletionState)(nil).Exists), arg0)
-}
-
-// FilterJoin mocks base method.
-func (m *MockDeletionState) FilterJoin(arg0 ...[]string) []string {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{}
-	for _, a := range arg0 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "FilterJoin", varargs...)
-	ret0, _ := ret[0].([]string)
-	return ret0
-}
-
-// FilterJoin indicates an expected call of FilterJoin.
-func (mr *MockDeletionStateMockRecorder) FilterJoin(arg0 ...interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterJoin", reflect.TypeOf((*MockDeletionState)(nil).FilterJoin), arg0...)
-}
-
-// GetQueued mocks base method.
-func (m *MockDeletionState) GetQueued() []string {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetQueued")
-	ret0, _ := ret[0].([]string)
-	return ret0
-}
-
-// GetQueued indicates an expected call of GetQueued.
-func (mr *MockDeletionStateMockRecorder) GetQueued() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueued", reflect.TypeOf((*MockDeletionState)(nil).GetQueued))
-}
diff --git a/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go b/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go
new file mode 100644
index 00000000..65e72c96
--- /dev/null
+++ b/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go
@@ -0,0 +1,160 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/any-sync/commonspace/settings/settingsstate (interfaces: ObjectDeletionState,StateBuilder)
+
+// Package mock_settingsstate is a generated GoMock package.
+package mock_settingsstate
+
+import (
+	reflect "reflect"
+
+	objecttree "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
+	settingsstate "github.com/anytypeio/any-sync/commonspace/settings/settingsstate"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockObjectDeletionState is a mock of ObjectDeletionState interface.
+type MockObjectDeletionState struct {
+	ctrl     *gomock.Controller
+	recorder *MockObjectDeletionStateMockRecorder
+}
+
+// MockObjectDeletionStateMockRecorder is the mock recorder for MockObjectDeletionState.
+type MockObjectDeletionStateMockRecorder struct {
+	mock *MockObjectDeletionState
+}
+
+// NewMockObjectDeletionState creates a new mock instance.
+func NewMockObjectDeletionState(ctrl *gomock.Controller) *MockObjectDeletionState {
+	mock := &MockObjectDeletionState{ctrl: ctrl}
+	mock.recorder = &MockObjectDeletionStateMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockObjectDeletionState) EXPECT() *MockObjectDeletionStateMockRecorder {
+	return m.recorder
+}
+
+// Add mocks base method.
+func (m *MockObjectDeletionState) Add(arg0 []string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Add", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Add indicates an expected call of Add.
+func (mr *MockObjectDeletionStateMockRecorder) Add(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockObjectDeletionState)(nil).Add), arg0)
+}
+
+// AddObserver mocks base method.
+func (m *MockObjectDeletionState) AddObserver(arg0 settingsstate.StateUpdateObserver) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "AddObserver", arg0)
+}
+
+// AddObserver indicates an expected call of AddObserver.
+func (mr *MockObjectDeletionStateMockRecorder) AddObserver(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObserver", reflect.TypeOf((*MockObjectDeletionState)(nil).AddObserver), arg0)
+}
+
+// Delete mocks base method.
+func (m *MockObjectDeletionState) Delete(arg0 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Delete indicates an expected call of Delete.
+func (mr *MockObjectDeletionStateMockRecorder) Delete(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockObjectDeletionState)(nil).Delete), arg0)
+}
+
+// Exists mocks base method.
+func (m *MockObjectDeletionState) Exists(arg0 string) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Exists", arg0)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// Exists indicates an expected call of Exists.
+func (mr *MockObjectDeletionStateMockRecorder) Exists(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockObjectDeletionState)(nil).Exists), arg0)
+}
+
+// FilterJoin mocks base method.
+func (m *MockObjectDeletionState) FilterJoin(arg0 ...[]string) []string {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{}
+	for _, a := range arg0 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "FilterJoin", varargs...)
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// FilterJoin indicates an expected call of FilterJoin.
+func (mr *MockObjectDeletionStateMockRecorder) FilterJoin(arg0 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterJoin", reflect.TypeOf((*MockObjectDeletionState)(nil).FilterJoin), arg0...)
+}
+
+// GetQueued mocks base method.
+func (m *MockObjectDeletionState) GetQueued() []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetQueued")
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// GetQueued indicates an expected call of GetQueued.
+func (mr *MockObjectDeletionStateMockRecorder) GetQueued() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueued", reflect.TypeOf((*MockObjectDeletionState)(nil).GetQueued))
+}
+
+// MockStateBuilder is a mock of StateBuilder interface.
+type MockStateBuilder struct {
+	ctrl     *gomock.Controller
+	recorder *MockStateBuilderMockRecorder
+}
+
+// MockStateBuilderMockRecorder is the mock recorder for MockStateBuilder.
+type MockStateBuilderMockRecorder struct {
+	mock *MockStateBuilder
+}
+
+// NewMockStateBuilder creates a new mock instance.
+func NewMockStateBuilder(ctrl *gomock.Controller) *MockStateBuilder {
+	mock := &MockStateBuilder{ctrl: ctrl}
+	mock.recorder = &MockStateBuilderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStateBuilder) EXPECT() *MockStateBuilderMockRecorder {
+	return m.recorder
+}
+
+// Build mocks base method.
+func (m *MockStateBuilder) Build(arg0 objecttree.ObjectTree, arg1 *settingsstate.State) (*settingsstate.State, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Build", arg0, arg1)
+	ret0, _ := ret[0].(*settingsstate.State)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Build indicates an expected call of Build.
+func (mr *MockStateBuilderMockRecorder) Build(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockStateBuilder)(nil).Build), arg0, arg1)
+}
diff --git a/commonspace/settings/settingsstate/statebuilder.go b/commonspace/settings/settingsstate/statebuilder.go
index dab6b32f..1fb43f53 100644
--- a/commonspace/settings/settingsstate/statebuilder.go
+++ b/commonspace/settings/settingsstate/statebuilder.go
@@ -1,13 +1,14 @@
 package settingsstate
 
 import (
+	"fmt"
 	"github.com/anytypeio/any-sync/commonspace/object/tree/objecttree"
 	"github.com/anytypeio/any-sync/commonspace/spacesyncproto"
 	"github.com/gogo/protobuf/proto"
 )
 
 type StateBuilder interface {
-	Build(tree objecttree.ObjectTree, state *State, isUpdate bool) (*State, error)
+	Build(tree objecttree.ObjectTree, state *State) (*State, error)
 }
 
 func NewStateBuilder() StateBuilder {
@@ -17,19 +18,21 @@ func NewStateBuilder() StateBuilder {
 type stateBuilder struct {
 }
 
-func (s *stateBuilder) Build(tr objecttree.ObjectTree, oldState *State, isUpdate bool) (state *State, err error) {
-	state = oldState
-
-	if !isUpdate || state == nil {
-		state = &State{}
-	}
+func (s *stateBuilder) Build(tr objecttree.ObjectTree, oldState *State) (state *State, err error) {
 	var (
 		rootId  = tr.Root().Id
-		startId = state.LastIteratedId
+		startId = rootId
 	)
+	state = oldState
+	if state == nil {
+		state = &State{}
+	} else if state.LastIteratedId != "" {
+		startId = state.LastIteratedId
+	}
+
 	process := func(change *objecttree.Change) bool {
-		state.LastIteratedId = change.Id
 		state = s.processChange(change, rootId, startId, state)
+		state.LastIteratedId = change.Id
 		return true
 	}
 	convert := func(decrypted []byte) (res any, err error) {
@@ -41,16 +44,13 @@ func (s *stateBuilder) Build(tr objecttree.ObjectTree, oldState *State, isUpdate
 		return deleteChange, nil
 	}
 
-	if startId == "" {
-		startId = rootId
-	}
 	err = tr.IterateFrom(startId, convert, process)
 	return
 }
 
 func (s *stateBuilder) processChange(change *objecttree.Change, rootId, startId string, state *State) *State {
 	// ignoring root change which has empty model or startId change
-	if change.Model == nil || (change.Id == startId && startId != "") {
+	if change.Model == nil || state.LastIteratedId == startId {
 		return state
 	}
 
@@ -67,10 +67,12 @@ func (s *stateBuilder) processChange(change *objecttree.Change, rootId, startId
 
 	// otherwise getting data from content
 	for _, cnt := range deleteChange.Content {
+		fmt.Println(cnt.GetSpaceDelete() != nil)
 		switch {
 		case cnt.GetObjectDelete() != nil:
 			state.DeletedIds = append(state.DeletedIds, cnt.GetObjectDelete().GetId())
 		case cnt.GetSpaceDelete() != nil:
+			fmt.Println(cnt.GetSpaceDelete().GetDeleterPeerId())
 			state.DeleterId = cnt.GetSpaceDelete().GetDeleterPeerId()
 		}
 	}
diff --git a/commonspace/settings/settingsstate/statebuilder_test.go b/commonspace/settings/settingsstate/statebuilder_test.go
new file mode 100644
index 00000000..3069d23d
--- /dev/null
+++ b/commonspace/settings/settingsstate/statebuilder_test.go
@@ -0,0 +1,95 @@
+package settingsstate
+
+import (
+	"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/spacesyncproto"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func TestStateBuilder_ProcessChange(t *testing.T) {
+	sb := &stateBuilder{}
+	rootId := "rootId"
+	deletedId := "deletedId"
+
+	t.Run("empty model", func(t *testing.T) {
+		ch := &objecttree.Change{}
+		startId := "startId"
+		newSt := sb.processChange(ch, rootId, startId, &State{
+			DeletedIds: []string{deletedId},
+		})
+		require.Equal(t, []string{deletedId}, newSt.DeletedIds)
+	})
+
+	t.Run("changeId is equal to startId, LastIteratedId is equal to startId", func(t *testing.T) {
+		ch := &objecttree.Change{}
+		ch.Model = &spacesyncproto.SettingsData{
+			Content: []*spacesyncproto.SpaceSettingsContent{
+				{Value: &spacesyncproto.SpaceSettingsContent_ObjectDelete{
+					ObjectDelete: &spacesyncproto.ObjectDelete{Id: deletedId},
+				}},
+			},
+		}
+		ch.Id = "startId"
+		startId := "startId"
+		newSt := sb.processChange(ch, rootId, startId, &State{
+			DeletedIds:     []string{deletedId},
+			LastIteratedId: startId,
+		})
+		require.Equal(t, []string{deletedId}, newSt.DeletedIds)
+	})
+
+	t.Run("changeId is equal to rootId", func(t *testing.T) {
+		ch := &objecttree.Change{}
+		ch.Model = &spacesyncproto.SettingsData{
+			Snapshot: &spacesyncproto.SpaceSettingsSnapshot{
+				DeletedIds:    []string{"id1", "id2"},
+				DeleterPeerId: "peerId",
+			},
+		}
+		ch.Id = "rootId"
+		newSt := sb.processChange(ch, rootId, rootId, &State{})
+		require.Equal(t, []string{"id1", "id2"}, newSt.DeletedIds)
+		require.Equal(t, "peerId", newSt.DeleterId)
+	})
+
+	t.Run("changeId is not equal to lastIteratedId or rootId", func(t *testing.T) {
+		ch := &objecttree.Change{}
+		ch.Model = &spacesyncproto.SettingsData{
+			Content: []*spacesyncproto.SpaceSettingsContent{
+				{Value: &spacesyncproto.SpaceSettingsContent_ObjectDelete{
+					ObjectDelete: &spacesyncproto.ObjectDelete{Id: deletedId},
+				}},
+			},
+		}
+		ch.Id = "someId"
+		startId := "startId"
+		newSt := sb.processChange(ch, rootId, startId, &State{})
+		require.Equal(t, []string{deletedId}, newSt.DeletedIds)
+	})
+}
+
+func TestStateBuilder_Build(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	objTree := mock_objecttree.NewMockObjectTree(ctrl)
+	sb := &stateBuilder{}
+	defer ctrl.Finish()
+
+	t.Run("state is nil", func(t *testing.T) {
+		ch := &objecttree.Change{Id: "rootId"}
+		objTree.EXPECT().Root().Return(ch)
+		objTree.EXPECT().IterateFrom("rootId", gomock.Any(), gomock.Any()).Return(nil)
+		_, err := sb.Build(objTree, nil)
+		require.NoError(t, err)
+	})
+
+	t.Run("state is non-empty", func(t *testing.T) {
+		ch := &objecttree.Change{Id: "rootId"}
+		objTree.EXPECT().Root().Return(ch)
+		objTree.EXPECT().IterateFrom("someId", gomock.Any(), gomock.Any()).Return(nil)
+		_, err := sb.Build(objTree, &State{LastIteratedId: "someId"})
+		require.NoError(t, err)
+	})
+}
diff --git a/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go b/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go
index 26f6bb30..82a14be2 100644
--- a/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go
+++ b/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go
@@ -95,6 +95,21 @@ func (mr *MockSpaceStorageMockRecorder) Id() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockSpaceStorage)(nil).Id))
 }
 
+// IsSpaceDeleted mocks base method.
+func (m *MockSpaceStorage) IsSpaceDeleted() (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsSpaceDeleted")
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// IsSpaceDeleted indicates an expected call of IsSpaceDeleted.
+func (mr *MockSpaceStorageMockRecorder) IsSpaceDeleted() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSpaceDeleted", reflect.TypeOf((*MockSpaceStorage)(nil).IsSpaceDeleted))
+}
+
 // ReadSpaceHash mocks base method.
 func (m *MockSpaceStorage) ReadSpaceHash() (string, error) {
 	m.ctrl.T.Helper()
@@ -110,6 +125,20 @@ func (mr *MockSpaceStorageMockRecorder) ReadSpaceHash() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSpaceHash", reflect.TypeOf((*MockSpaceStorage)(nil).ReadSpaceHash))
 }
 
+// SetSpaceDeleted mocks base method.
+func (m *MockSpaceStorage) SetSpaceDeleted() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetSpaceDeleted")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SetSpaceDeleted indicates an expected call of SetSpaceDeleted.
+func (mr *MockSpaceStorageMockRecorder) SetSpaceDeleted() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSpaceDeleted", reflect.TypeOf((*MockSpaceStorage)(nil).SetSpaceDeleted))
+}
+
 // SetTreeDeletedStatus mocks base method.
 func (m *MockSpaceStorage) SetTreeDeletedStatus(arg0, arg1 string) error {
 	m.ctrl.T.Helper()
diff --git a/nodeconf/mock_nodeconf/mock_nodeconf.go b/nodeconf/mock_nodeconf/mock_nodeconf.go
index 5d9e65e2..a403da04 100644
--- a/nodeconf/mock_nodeconf/mock_nodeconf.go
+++ b/nodeconf/mock_nodeconf/mock_nodeconf.go
@@ -213,6 +213,20 @@ func (mr *MockConfigurationMockRecorder) NodeIds(arg0 interface{}) *gomock.Call
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeIds", reflect.TypeOf((*MockConfiguration)(nil).NodeIds), arg0)
 }
 
+// NodeTypes mocks base method.
+func (m *MockConfiguration) NodeTypes(arg0 string) []nodeconf.NodeType {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NodeTypes", arg0)
+	ret0, _ := ret[0].([]nodeconf.NodeType)
+	return ret0
+}
+
+// NodeTypes indicates an expected call of NodeTypes.
+func (mr *MockConfigurationMockRecorder) NodeTypes(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeTypes", reflect.TypeOf((*MockConfiguration)(nil).NodeTypes), arg0)
+}
+
 // Partition mocks base method.
 func (m *MockConfiguration) Partition(arg0 string) int {
 	m.ctrl.T.Helper()