diff --git a/accountservice/mock_accountservice/helper.go b/accountservice/mock_accountservice/helper.go
index cec6f34b..2dbe031e 100644
--- a/accountservice/mock_accountservice/helper.go
+++ b/accountservice/mock_accountservice/helper.go
@@ -3,7 +3,7 @@ package mock_accountservice
 import (
 	"github.com/anyproto/any-sync/accountservice"
 	"github.com/anyproto/any-sync/commonspace/object/accountdata"
-	"github.com/golang/mock/gomock"
+	"go.uber.org/mock/gomock"
 )
 
 func NewAccountServiceWithAccount(ctrl *gomock.Controller, acc *accountdata.AccountKeys) *MockService {
diff --git a/accountservice/mock_accountservice/mock_accountservice.go b/accountservice/mock_accountservice/mock_accountservice.go
index a9bbff7f..7da43f91 100644
--- a/accountservice/mock_accountservice/mock_accountservice.go
+++ b/accountservice/mock_accountservice/mock_accountservice.go
@@ -9,7 +9,7 @@ import (
 
 	app "github.com/anyproto/any-sync/app"
 	accountdata "github.com/anyproto/any-sync/commonspace/object/accountdata"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockService is a mock of Service interface.
diff --git a/app/ldiff/mock_ldiff/mock_ldiff.go b/app/ldiff/mock_ldiff/mock_ldiff.go
index 20a522b7..8e09ade9 100644
--- a/app/ldiff/mock_ldiff/mock_ldiff.go
+++ b/app/ldiff/mock_ldiff/mock_ldiff.go
@@ -9,7 +9,7 @@ import (
 	reflect "reflect"
 
 	ldiff "github.com/anyproto/any-sync/app/ldiff"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockDiff is a mock of Diff interface.
diff --git a/commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go b/commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go
index 77faf28e..18090381 100644
--- a/commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go
+++ b/commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go
@@ -10,7 +10,7 @@ import (
 
 	app "github.com/anyproto/any-sync/app"
 	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockCredentialProvider is a mock of CredentialProvider interface.
diff --git a/commonspace/deletionstate/deletionstate_test.go b/commonspace/deletionstate/deletionstate_test.go
index e5489bd8..2050fc37 100644
--- a/commonspace/deletionstate/deletionstate_test.go
+++ b/commonspace/deletionstate/deletionstate_test.go
@@ -3,8 +3,8 @@ package deletionstate
 import (
 	"github.com/anyproto/any-sync/commonspace/spacestorage"
 	"github.com/anyproto/any-sync/commonspace/spacestorage/mock_spacestorage"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"sort"
 	"testing"
 )
diff --git a/commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go b/commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go
index c4e9fefb..7706b004 100644
--- a/commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go
+++ b/commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go
@@ -9,7 +9,7 @@ import (
 
 	app "github.com/anyproto/any-sync/app"
 	deletionstate "github.com/anyproto/any-sync/commonspace/deletionstate"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockObjectDeletionState is a mock of ObjectDeletionState interface.
diff --git a/commonspace/headsync/mock_headsync/mock_headsync.go b/commonspace/headsync/mock_headsync/mock_headsync.go
index 46b16aab..b569fde4 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"
 
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockDiffSyncer is a mock of DiffSyncer interface.
diff --git a/commonspace/object/acl/list/mock_list/mock_list.go b/commonspace/object/acl/list/mock_list/mock_list.go
index 012c71c6..3e5b50be 100644
--- a/commonspace/object/acl/list/mock_list/mock_list.go
+++ b/commonspace/object/acl/list/mock_list/mock_list.go
@@ -10,7 +10,7 @@ import (
 	list "github.com/anyproto/any-sync/commonspace/object/acl/list"
 	consensusproto "github.com/anyproto/any-sync/consensus/consensusproto"
 	crypto "github.com/anyproto/any-sync/util/crypto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockAclList is a mock of AclList interface.
diff --git a/commonspace/object/acl/liststorage/mock_liststorage/mock_liststorage.go b/commonspace/object/acl/liststorage/mock_liststorage/mock_liststorage.go
index ef4781e6..52d00f50 100644
--- a/commonspace/object/acl/liststorage/mock_liststorage/mock_liststorage.go
+++ b/commonspace/object/acl/liststorage/mock_liststorage/mock_liststorage.go
@@ -9,7 +9,7 @@ import (
 	reflect "reflect"
 
 	consensusproto "github.com/anyproto/any-sync/consensus/consensusproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockListStorage is a mock of ListStorage interface.
diff --git a/commonspace/object/acl/syncacl/mock_syncacl/mock_syncacl.go b/commonspace/object/acl/syncacl/mock_syncacl/mock_syncacl.go
new file mode 100644
index 00000000..a7ca877c
--- /dev/null
+++ b/commonspace/object/acl/syncacl/mock_syncacl/mock_syncacl.go
@@ -0,0 +1,694 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anyproto/any-sync/commonspace/object/acl/syncacl (interfaces: SyncAcl,SyncClient,RequestFactory,AclSyncProtocol)
+
+// Package mock_syncacl is a generated GoMock package.
+package mock_syncacl
+
+import (
+	context "context"
+	reflect "reflect"
+
+	app "github.com/anyproto/any-sync/app"
+	list "github.com/anyproto/any-sync/commonspace/object/acl/list"
+	syncacl "github.com/anyproto/any-sync/commonspace/object/acl/syncacl"
+	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
+	consensusproto "github.com/anyproto/any-sync/consensus/consensusproto"
+	crypto "github.com/anyproto/any-sync/util/crypto"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockSyncAcl is a mock of SyncAcl interface.
+type MockSyncAcl struct {
+	ctrl     *gomock.Controller
+	recorder *MockSyncAclMockRecorder
+}
+
+// MockSyncAclMockRecorder is the mock recorder for MockSyncAcl.
+type MockSyncAclMockRecorder struct {
+	mock *MockSyncAcl
+}
+
+// NewMockSyncAcl creates a new mock instance.
+func NewMockSyncAcl(ctrl *gomock.Controller) *MockSyncAcl {
+	mock := &MockSyncAcl{ctrl: ctrl}
+	mock.recorder = &MockSyncAclMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockSyncAcl) EXPECT() *MockSyncAclMockRecorder {
+	return m.recorder
+}
+
+// AclState mocks base method.
+func (m *MockSyncAcl) AclState() *list.AclState {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AclState")
+	ret0, _ := ret[0].(*list.AclState)
+	return ret0
+}
+
+// AclState indicates an expected call of AclState.
+func (mr *MockSyncAclMockRecorder) AclState() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclState", reflect.TypeOf((*MockSyncAcl)(nil).AclState))
+}
+
+// AddRawRecord mocks base method.
+func (m *MockSyncAcl) AddRawRecord(arg0 *consensusproto.RawRecordWithId) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddRawRecord", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddRawRecord indicates an expected call of AddRawRecord.
+func (mr *MockSyncAclMockRecorder) AddRawRecord(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockSyncAcl)(nil).AddRawRecord), arg0)
+}
+
+// AddRawRecords mocks base method.
+func (m *MockSyncAcl) AddRawRecords(arg0 []*consensusproto.RawRecordWithId) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddRawRecords", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddRawRecords indicates an expected call of AddRawRecords.
+func (mr *MockSyncAclMockRecorder) AddRawRecords(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecords", reflect.TypeOf((*MockSyncAcl)(nil).AddRawRecords), arg0)
+}
+
+// Close mocks base method.
+func (m *MockSyncAcl) 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 *MockSyncAclMockRecorder) Close(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSyncAcl)(nil).Close), arg0)
+}
+
+// Get mocks base method.
+func (m *MockSyncAcl) Get(arg0 string) (*list.AclRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", arg0)
+	ret0, _ := ret[0].(*list.AclRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockSyncAclMockRecorder) Get(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSyncAcl)(nil).Get), arg0)
+}
+
+// GetIndex mocks base method.
+func (m *MockSyncAcl) GetIndex(arg0 int) (*list.AclRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetIndex", arg0)
+	ret0, _ := ret[0].(*list.AclRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetIndex indicates an expected call of GetIndex.
+func (mr *MockSyncAclMockRecorder) GetIndex(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndex", reflect.TypeOf((*MockSyncAcl)(nil).GetIndex), arg0)
+}
+
+// HandleMessage mocks base method.
+func (m *MockSyncAcl) HandleMessage(arg0 context.Context, arg1 string, arg2 *spacesyncproto.ObjectSyncMessage) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HandleMessage", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// HandleMessage indicates an expected call of HandleMessage.
+func (mr *MockSyncAclMockRecorder) HandleMessage(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockSyncAcl)(nil).HandleMessage), arg0, arg1, arg2)
+}
+
+// HandleRequest mocks base method.
+func (m *MockSyncAcl) HandleRequest(arg0 context.Context, arg1 string, arg2 *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HandleRequest", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HandleRequest indicates an expected call of HandleRequest.
+func (mr *MockSyncAclMockRecorder) HandleRequest(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRequest", reflect.TypeOf((*MockSyncAcl)(nil).HandleRequest), arg0, arg1, arg2)
+}
+
+// HasHead mocks base method.
+func (m *MockSyncAcl) HasHead(arg0 string) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HasHead", arg0)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// HasHead indicates an expected call of HasHead.
+func (mr *MockSyncAclMockRecorder) HasHead(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasHead", reflect.TypeOf((*MockSyncAcl)(nil).HasHead), arg0)
+}
+
+// Head mocks base method.
+func (m *MockSyncAcl) Head() *list.AclRecord {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Head")
+	ret0, _ := ret[0].(*list.AclRecord)
+	return ret0
+}
+
+// Head indicates an expected call of Head.
+func (mr *MockSyncAclMockRecorder) Head() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockSyncAcl)(nil).Head))
+}
+
+// Id mocks base method.
+func (m *MockSyncAcl) Id() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Id")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// Id indicates an expected call of Id.
+func (mr *MockSyncAclMockRecorder) Id() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockSyncAcl)(nil).Id))
+}
+
+// Init mocks base method.
+func (m *MockSyncAcl) 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 *MockSyncAclMockRecorder) Init(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSyncAcl)(nil).Init), arg0)
+}
+
+// IsAfter mocks base method.
+func (m *MockSyncAcl) IsAfter(arg0, arg1 string) (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsAfter", arg0, arg1)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// IsAfter indicates an expected call of IsAfter.
+func (mr *MockSyncAclMockRecorder) IsAfter(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAfter", reflect.TypeOf((*MockSyncAcl)(nil).IsAfter), arg0, arg1)
+}
+
+// Iterate mocks base method.
+func (m *MockSyncAcl) Iterate(arg0 func(*list.AclRecord) bool) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Iterate", arg0)
+}
+
+// Iterate indicates an expected call of Iterate.
+func (mr *MockSyncAclMockRecorder) Iterate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockSyncAcl)(nil).Iterate), arg0)
+}
+
+// IterateFrom mocks base method.
+func (m *MockSyncAcl) IterateFrom(arg0 string, arg1 func(*list.AclRecord) bool) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "IterateFrom", arg0, arg1)
+}
+
+// IterateFrom indicates an expected call of IterateFrom.
+func (mr *MockSyncAclMockRecorder) IterateFrom(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockSyncAcl)(nil).IterateFrom), arg0, arg1)
+}
+
+// KeyStorage mocks base method.
+func (m *MockSyncAcl) KeyStorage() crypto.KeyStorage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "KeyStorage")
+	ret0, _ := ret[0].(crypto.KeyStorage)
+	return ret0
+}
+
+// KeyStorage indicates an expected call of KeyStorage.
+func (mr *MockSyncAclMockRecorder) KeyStorage() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyStorage", reflect.TypeOf((*MockSyncAcl)(nil).KeyStorage))
+}
+
+// Lock mocks base method.
+func (m *MockSyncAcl) Lock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Lock")
+}
+
+// Lock indicates an expected call of Lock.
+func (mr *MockSyncAclMockRecorder) Lock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockSyncAcl)(nil).Lock))
+}
+
+// Name mocks base method.
+func (m *MockSyncAcl) 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 *MockSyncAclMockRecorder) Name() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockSyncAcl)(nil).Name))
+}
+
+// RLock mocks base method.
+func (m *MockSyncAcl) RLock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RLock")
+}
+
+// RLock indicates an expected call of RLock.
+func (mr *MockSyncAclMockRecorder) RLock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RLock", reflect.TypeOf((*MockSyncAcl)(nil).RLock))
+}
+
+// RUnlock mocks base method.
+func (m *MockSyncAcl) RUnlock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RUnlock")
+}
+
+// RUnlock indicates an expected call of RUnlock.
+func (mr *MockSyncAclMockRecorder) RUnlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RUnlock", reflect.TypeOf((*MockSyncAcl)(nil).RUnlock))
+}
+
+// RecordBuilder mocks base method.
+func (m *MockSyncAcl) RecordBuilder() list.AclRecordBuilder {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RecordBuilder")
+	ret0, _ := ret[0].(list.AclRecordBuilder)
+	return ret0
+}
+
+// RecordBuilder indicates an expected call of RecordBuilder.
+func (mr *MockSyncAclMockRecorder) RecordBuilder() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordBuilder", reflect.TypeOf((*MockSyncAcl)(nil).RecordBuilder))
+}
+
+// Records mocks base method.
+func (m *MockSyncAcl) Records() []*list.AclRecord {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Records")
+	ret0, _ := ret[0].([]*list.AclRecord)
+	return ret0
+}
+
+// Records indicates an expected call of Records.
+func (mr *MockSyncAclMockRecorder) Records() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Records", reflect.TypeOf((*MockSyncAcl)(nil).Records))
+}
+
+// RecordsAfter mocks base method.
+func (m *MockSyncAcl) RecordsAfter(arg0 context.Context, arg1 string) ([]*consensusproto.RawRecordWithId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RecordsAfter", arg0, arg1)
+	ret0, _ := ret[0].([]*consensusproto.RawRecordWithId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RecordsAfter indicates an expected call of RecordsAfter.
+func (mr *MockSyncAclMockRecorder) RecordsAfter(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsAfter", reflect.TypeOf((*MockSyncAcl)(nil).RecordsAfter), arg0, arg1)
+}
+
+// Root mocks base method.
+func (m *MockSyncAcl) Root() *consensusproto.RawRecordWithId {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Root")
+	ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
+	return ret0
+}
+
+// Root indicates an expected call of Root.
+func (mr *MockSyncAclMockRecorder) Root() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockSyncAcl)(nil).Root))
+}
+
+// Run mocks base method.
+func (m *MockSyncAcl) 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 *MockSyncAclMockRecorder) Run(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSyncAcl)(nil).Run), arg0)
+}
+
+// SetHeadUpdater mocks base method.
+func (m *MockSyncAcl) SetHeadUpdater(arg0 syncacl.HeadUpdater) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SetHeadUpdater", arg0)
+}
+
+// SetHeadUpdater indicates an expected call of SetHeadUpdater.
+func (mr *MockSyncAclMockRecorder) SetHeadUpdater(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeadUpdater", reflect.TypeOf((*MockSyncAcl)(nil).SetHeadUpdater), arg0)
+}
+
+// SyncWithPeer mocks base method.
+func (m *MockSyncAcl) SyncWithPeer(arg0 context.Context, arg1 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SyncWithPeer", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SyncWithPeer indicates an expected call of SyncWithPeer.
+func (mr *MockSyncAclMockRecorder) SyncWithPeer(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWithPeer", reflect.TypeOf((*MockSyncAcl)(nil).SyncWithPeer), arg0, arg1)
+}
+
+// Unlock mocks base method.
+func (m *MockSyncAcl) Unlock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Unlock")
+}
+
+// Unlock indicates an expected call of Unlock.
+func (mr *MockSyncAclMockRecorder) Unlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockSyncAcl)(nil).Unlock))
+}
+
+// ValidateRawRecord mocks base method.
+func (m *MockSyncAcl) ValidateRawRecord(arg0 *consensusproto.RawRecord) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ValidateRawRecord", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ValidateRawRecord indicates an expected call of ValidateRawRecord.
+func (mr *MockSyncAclMockRecorder) ValidateRawRecord(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRawRecord", reflect.TypeOf((*MockSyncAcl)(nil).ValidateRawRecord), arg0)
+}
+
+// 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 *consensusproto.LogSyncMessage) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Broadcast", arg0)
+}
+
+// Broadcast indicates an expected call of Broadcast.
+func (mr *MockSyncClientMockRecorder) Broadcast(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockSyncClient)(nil).Broadcast), arg0)
+}
+
+// CreateFullSyncRequest mocks base method.
+func (m *MockSyncClient) CreateFullSyncRequest(arg0 list.AclList, arg1 string) (*consensusproto.LogSyncMessage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateFullSyncRequest", arg0, arg1)
+	ret0, _ := ret[0].(*consensusproto.LogSyncMessage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateFullSyncRequest indicates an expected call of CreateFullSyncRequest.
+func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncRequest), arg0, arg1)
+}
+
+// CreateFullSyncResponse mocks base method.
+func (m *MockSyncClient) CreateFullSyncResponse(arg0 list.AclList, arg1 string) (*consensusproto.LogSyncMessage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateFullSyncResponse", arg0, arg1)
+	ret0, _ := ret[0].(*consensusproto.LogSyncMessage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateFullSyncResponse indicates an expected call of CreateFullSyncResponse.
+func (mr *MockSyncClientMockRecorder) CreateFullSyncResponse(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncResponse", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncResponse), arg0, arg1)
+}
+
+// CreateHeadUpdate mocks base method.
+func (m *MockSyncClient) CreateHeadUpdate(arg0 list.AclList, arg1 []*consensusproto.RawRecordWithId) *consensusproto.LogSyncMessage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateHeadUpdate", arg0, arg1)
+	ret0, _ := ret[0].(*consensusproto.LogSyncMessage)
+	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)
+}
+
+// QueueRequest mocks base method.
+func (m *MockSyncClient) QueueRequest(arg0 string, arg1 *consensusproto.LogSyncMessage) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "QueueRequest", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// QueueRequest indicates an expected call of QueueRequest.
+func (mr *MockSyncClientMockRecorder) QueueRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueRequest", reflect.TypeOf((*MockSyncClient)(nil).QueueRequest), arg0, arg1)
+}
+
+// SendRequest mocks base method.
+func (m *MockSyncClient) SendRequest(arg0 context.Context, arg1 string, arg2 *consensusproto.LogSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SendRequest", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SendRequest indicates an expected call of SendRequest.
+func (mr *MockSyncClientMockRecorder) SendRequest(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendRequest", reflect.TypeOf((*MockSyncClient)(nil).SendRequest), arg0, arg1, arg2)
+}
+
+// SendUpdate mocks base method.
+func (m *MockSyncClient) SendUpdate(arg0 string, arg1 *consensusproto.LogSyncMessage) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SendUpdate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SendUpdate indicates an expected call of SendUpdate.
+func (mr *MockSyncClientMockRecorder) SendUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendUpdate", reflect.TypeOf((*MockSyncClient)(nil).SendUpdate), arg0, arg1)
+}
+
+// MockRequestFactory is a mock of RequestFactory interface.
+type MockRequestFactory struct {
+	ctrl     *gomock.Controller
+	recorder *MockRequestFactoryMockRecorder
+}
+
+// MockRequestFactoryMockRecorder is the mock recorder for MockRequestFactory.
+type MockRequestFactoryMockRecorder struct {
+	mock *MockRequestFactory
+}
+
+// NewMockRequestFactory creates a new mock instance.
+func NewMockRequestFactory(ctrl *gomock.Controller) *MockRequestFactory {
+	mock := &MockRequestFactory{ctrl: ctrl}
+	mock.recorder = &MockRequestFactoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRequestFactory) EXPECT() *MockRequestFactoryMockRecorder {
+	return m.recorder
+}
+
+// CreateFullSyncRequest mocks base method.
+func (m *MockRequestFactory) CreateFullSyncRequest(arg0 list.AclList, arg1 string) (*consensusproto.LogSyncMessage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateFullSyncRequest", arg0, arg1)
+	ret0, _ := ret[0].(*consensusproto.LogSyncMessage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateFullSyncRequest indicates an expected call of CreateFullSyncRequest.
+func (mr *MockRequestFactoryMockRecorder) CreateFullSyncRequest(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockRequestFactory)(nil).CreateFullSyncRequest), arg0, arg1)
+}
+
+// CreateFullSyncResponse mocks base method.
+func (m *MockRequestFactory) CreateFullSyncResponse(arg0 list.AclList, arg1 string) (*consensusproto.LogSyncMessage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateFullSyncResponse", arg0, arg1)
+	ret0, _ := ret[0].(*consensusproto.LogSyncMessage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateFullSyncResponse indicates an expected call of CreateFullSyncResponse.
+func (mr *MockRequestFactoryMockRecorder) CreateFullSyncResponse(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncResponse", reflect.TypeOf((*MockRequestFactory)(nil).CreateFullSyncResponse), arg0, arg1)
+}
+
+// CreateHeadUpdate mocks base method.
+func (m *MockRequestFactory) CreateHeadUpdate(arg0 list.AclList, arg1 []*consensusproto.RawRecordWithId) *consensusproto.LogSyncMessage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateHeadUpdate", arg0, arg1)
+	ret0, _ := ret[0].(*consensusproto.LogSyncMessage)
+	return ret0
+}
+
+// CreateHeadUpdate indicates an expected call of CreateHeadUpdate.
+func (mr *MockRequestFactoryMockRecorder) CreateHeadUpdate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockRequestFactory)(nil).CreateHeadUpdate), arg0, arg1)
+}
+
+// MockAclSyncProtocol is a mock of AclSyncProtocol interface.
+type MockAclSyncProtocol struct {
+	ctrl     *gomock.Controller
+	recorder *MockAclSyncProtocolMockRecorder
+}
+
+// MockAclSyncProtocolMockRecorder is the mock recorder for MockAclSyncProtocol.
+type MockAclSyncProtocolMockRecorder struct {
+	mock *MockAclSyncProtocol
+}
+
+// NewMockAclSyncProtocol creates a new mock instance.
+func NewMockAclSyncProtocol(ctrl *gomock.Controller) *MockAclSyncProtocol {
+	mock := &MockAclSyncProtocol{ctrl: ctrl}
+	mock.recorder = &MockAclSyncProtocolMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockAclSyncProtocol) EXPECT() *MockAclSyncProtocolMockRecorder {
+	return m.recorder
+}
+
+// FullSyncRequest mocks base method.
+func (m *MockAclSyncProtocol) FullSyncRequest(arg0 context.Context, arg1 string, arg2 *consensusproto.LogFullSyncRequest) (*consensusproto.LogSyncMessage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FullSyncRequest", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*consensusproto.LogSyncMessage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FullSyncRequest indicates an expected call of FullSyncRequest.
+func (mr *MockAclSyncProtocolMockRecorder) FullSyncRequest(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullSyncRequest", reflect.TypeOf((*MockAclSyncProtocol)(nil).FullSyncRequest), arg0, arg1, arg2)
+}
+
+// FullSyncResponse mocks base method.
+func (m *MockAclSyncProtocol) FullSyncResponse(arg0 context.Context, arg1 string, arg2 *consensusproto.LogFullSyncResponse) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FullSyncResponse", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// FullSyncResponse indicates an expected call of FullSyncResponse.
+func (mr *MockAclSyncProtocolMockRecorder) FullSyncResponse(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FullSyncResponse", reflect.TypeOf((*MockAclSyncProtocol)(nil).FullSyncResponse), arg0, arg1, arg2)
+}
+
+// HeadUpdate mocks base method.
+func (m *MockAclSyncProtocol) HeadUpdate(arg0 context.Context, arg1 string, arg2 *consensusproto.LogHeadUpdate) (*consensusproto.LogSyncMessage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HeadUpdate", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*consensusproto.LogSyncMessage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HeadUpdate indicates an expected call of HeadUpdate.
+func (mr *MockAclSyncProtocolMockRecorder) HeadUpdate(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadUpdate", reflect.TypeOf((*MockAclSyncProtocol)(nil).HeadUpdate), arg0, arg1, arg2)
+}
diff --git a/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go b/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go
index 1f0897a5..3e349e9d 100644
--- a/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go
+++ b/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go
@@ -13,7 +13,7 @@ import (
 	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
 	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
 	treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockObjectTree is a mock of ObjectTree interface.
diff --git a/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go b/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go
index 792dbee7..3a5984ac 100644
--- a/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go
+++ b/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go
@@ -15,7 +15,7 @@ import (
 	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
 	treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
 	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockSyncTree is a mock of SyncTree interface.
diff --git a/commonspace/object/tree/synctree/synctree_test.go b/commonspace/object/tree/synctree/synctree_test.go
index 76791c59..3bba33b3 100644
--- a/commonspace/object/tree/synctree/synctree_test.go
+++ b/commonspace/object/tree/synctree/synctree_test.go
@@ -11,8 +11,8 @@ import (
 	"github.com/anyproto/any-sync/commonspace/objectsync"
 	"github.com/anyproto/any-sync/commonspace/syncstatus"
 	"github.com/anyproto/any-sync/nodeconf"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"testing"
 )
 
diff --git a/commonspace/object/tree/synctree/synctreehandler_test.go b/commonspace/object/tree/synctree/synctreehandler_test.go
index e847403d..c4ca45a5 100644
--- a/commonspace/object/tree/synctree/synctreehandler_test.go
+++ b/commonspace/object/tree/synctree/synctreehandler_test.go
@@ -9,8 +9,8 @@ import (
 	"github.com/anyproto/any-sync/commonspace/object/tree/synctree/mock_synctree"
 	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
 	"github.com/anyproto/any-sync/commonspace/syncstatus"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 )
 
 type testObjTreeMock struct {
diff --git a/commonspace/object/tree/synctree/treeremotegetter_test.go b/commonspace/object/tree/synctree/treeremotegetter_test.go
index 60452b1a..a191b678 100644
--- a/commonspace/object/tree/synctree/treeremotegetter_test.go
+++ b/commonspace/object/tree/synctree/treeremotegetter_test.go
@@ -12,8 +12,8 @@ import (
 	"github.com/anyproto/any-sync/net/peer"
 	"github.com/anyproto/any-sync/net/peer/mock_peer"
 	"github.com/gogo/protobuf/proto"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 )
 
 type treeRemoteGetterFixture struct {
diff --git a/commonspace/object/tree/synctree/treesyncprotocol_test.go b/commonspace/object/tree/synctree/treesyncprotocol_test.go
index c80dbe35..a88dd168 100644
--- a/commonspace/object/tree/synctree/treesyncprotocol_test.go
+++ b/commonspace/object/tree/synctree/treesyncprotocol_test.go
@@ -8,8 +8,8 @@ import (
 	"github.com/anyproto/any-sync/commonspace/object/tree/objecttree/mock_objecttree"
 	"github.com/anyproto/any-sync/commonspace/object/tree/synctree/mock_synctree"
 	"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"testing"
 )
 
diff --git a/commonspace/object/tree/synctree/updatelistener/mock_updatelistener/mock_updatelistener.go b/commonspace/object/tree/synctree/updatelistener/mock_updatelistener/mock_updatelistener.go
index 794b9381..050f458e 100644
--- a/commonspace/object/tree/synctree/updatelistener/mock_updatelistener/mock_updatelistener.go
+++ b/commonspace/object/tree/synctree/updatelistener/mock_updatelistener/mock_updatelistener.go
@@ -8,7 +8,7 @@ import (
 	reflect "reflect"
 
 	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockUpdateListener is a mock of UpdateListener interface.
diff --git a/commonspace/object/tree/treestorage/mock_treestorage/mock_treestorage.go b/commonspace/object/tree/treestorage/mock_treestorage/mock_treestorage.go
index 2db9a949..3a20051d 100644
--- a/commonspace/object/tree/treestorage/mock_treestorage/mock_treestorage.go
+++ b/commonspace/object/tree/treestorage/mock_treestorage/mock_treestorage.go
@@ -9,7 +9,7 @@ import (
 	reflect "reflect"
 
 	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockTreeStorage is a mock of TreeStorage interface.
diff --git a/commonspace/object/treemanager/mock_treemanager/mock_treemanager.go b/commonspace/object/treemanager/mock_treemanager/mock_treemanager.go
index ee285aac..3ef2892f 100644
--- a/commonspace/object/treemanager/mock_treemanager/mock_treemanager.go
+++ b/commonspace/object/treemanager/mock_treemanager/mock_treemanager.go
@@ -11,7 +11,7 @@ import (
 	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"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockTreeManager is a mock of TreeManager interface.
diff --git a/commonspace/objectsync/mock_objectsync/mock_objectsync.go b/commonspace/objectsync/mock_objectsync/mock_objectsync.go
index 2858c6f9..d1c4666d 100644
--- a/commonspace/objectsync/mock_objectsync/mock_objectsync.go
+++ b/commonspace/objectsync/mock_objectsync/mock_objectsync.go
@@ -12,7 +12,7 @@ import (
 	app "github.com/anyproto/any-sync/app"
 	objectsync "github.com/anyproto/any-sync/commonspace/objectsync"
 	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockObjectSync is a mock of ObjectSync interface.
diff --git a/commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go b/commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go
index d7cca965..b44d028f 100644
--- a/commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go
+++ b/commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go
@@ -12,7 +12,7 @@ import (
 	updatelistener "github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener"
 	treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
 	objecttreebuilder "github.com/anyproto/any-sync/commonspace/objecttreebuilder"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockTreeBuilder is a mock of TreeBuilder interface.
diff --git a/commonspace/peermanager/mock_peermanager/mock_peermanager.go b/commonspace/peermanager/mock_peermanager/mock_peermanager.go
index 210fb319..d7d99e32 100644
--- a/commonspace/peermanager/mock_peermanager/mock_peermanager.go
+++ b/commonspace/peermanager/mock_peermanager/mock_peermanager.go
@@ -11,7 +11,7 @@ import (
 	app "github.com/anyproto/any-sync/app"
 	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
 	peer "github.com/anyproto/any-sync/net/peer"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockPeerManager is a mock of PeerManager interface.
diff --git a/commonspace/requestmanager/requestmanager_test.go b/commonspace/requestmanager/requestmanager_test.go
index f04a4407..036d7348 100644
--- a/commonspace/requestmanager/requestmanager_test.go
+++ b/commonspace/requestmanager/requestmanager_test.go
@@ -12,8 +12,8 @@ import (
 	"github.com/anyproto/any-sync/net/peer"
 	"github.com/anyproto/any-sync/net/peer/mock_peer"
 	"github.com/anyproto/any-sync/net/pool/mock_pool"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"storj.io/drpc"
 	"storj.io/drpc/drpcconn"
 )
diff --git a/commonspace/settings/deleter_test.go b/commonspace/settings/deleter_test.go
index e4a32e84..c057207a 100644
--- a/commonspace/settings/deleter_test.go
+++ b/commonspace/settings/deleter_test.go
@@ -6,7 +6,7 @@ import (
 	"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/spacestorage/mock_spacestorage"
-	"github.com/golang/mock/gomock"
+	"go.uber.org/mock/gomock"
 	"testing"
 )
 
diff --git a/commonspace/settings/deletionmanager_test.go b/commonspace/settings/deletionmanager_test.go
index 69e8830d..fb1e7355 100644
--- a/commonspace/settings/deletionmanager_test.go
+++ b/commonspace/settings/deletionmanager_test.go
@@ -6,8 +6,8 @@ import (
 	"github.com/anyproto/any-sync/commonspace/object/treemanager/mock_treemanager"
 	"github.com/anyproto/any-sync/commonspace/settings/mock_settings"
 	"github.com/anyproto/any-sync/commonspace/settings/settingsstate"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"testing"
 )
 
diff --git a/commonspace/settings/mock_settings/mock_settings.go b/commonspace/settings/mock_settings/mock_settings.go
index 69598251..2d5da99f 100644
--- a/commonspace/settings/mock_settings/mock_settings.go
+++ b/commonspace/settings/mock_settings/mock_settings.go
@@ -9,7 +9,7 @@ import (
 	reflect "reflect"
 
 	settingsstate "github.com/anyproto/any-sync/commonspace/settings/settingsstate"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockDeletionManager is a mock of DeletionManager interface.
diff --git a/commonspace/settings/settingsobject_test.go b/commonspace/settings/settingsobject_test.go
index 9d83d9cd..7d2f4eaa 100644
--- a/commonspace/settings/settingsobject_test.go
+++ b/commonspace/settings/settingsobject_test.go
@@ -16,8 +16,8 @@ import (
 	"github.com/anyproto/any-sync/commonspace/settings/settingsstate"
 	"github.com/anyproto/any-sync/commonspace/settings/settingsstate/mock_settingsstate"
 	"github.com/anyproto/any-sync/commonspace/spacestorage/mock_spacestorage"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"sync"
 	"testing"
 	"time"
diff --git a/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go b/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go
index 2bb898cf..091c3ea8 100644
--- a/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go
+++ b/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go
@@ -9,7 +9,7 @@ import (
 
 	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
 	settingsstate "github.com/anyproto/any-sync/commonspace/settings/settingsstate"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockStateBuilder is a mock of StateBuilder interface.
diff --git a/commonspace/settings/settingsstate/statebuilder_test.go b/commonspace/settings/settingsstate/statebuilder_test.go
index a2cf3072..c2d1d4ed 100644
--- a/commonspace/settings/settingsstate/statebuilder_test.go
+++ b/commonspace/settings/settingsstate/statebuilder_test.go
@@ -4,8 +4,8 @@ import (
 	"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/spacesyncproto"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"testing"
 )
 
diff --git a/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go b/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go
index bc7f448c..a81d0a93 100644
--- a/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go
+++ b/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go
@@ -13,7 +13,7 @@ import (
 	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
 	treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
 	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockSpaceStorage is a mock of SpaceStorage interface.
diff --git a/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go b/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go
index 8d8a1111..a04f5e11 100644
--- a/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go
+++ b/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go
@@ -9,7 +9,7 @@ import (
 	reflect "reflect"
 
 	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 	drpc "storj.io/drpc"
 )
 
diff --git a/consensus/consensusclient/client.go b/consensus/consensusclient/client.go
index 6bf5e8ab..d745bef6 100644
--- a/consensus/consensusclient/client.go
+++ b/consensus/consensusclient/client.go
@@ -36,9 +36,9 @@ type Watcher interface {
 
 type Service interface {
 	// AddLog adds new log to consensus servers
-	AddLog(ctx context.Context, clog *consensusproto.Log) (err error)
+	AddLog(ctx context.Context, rec *consensusproto.RawRecordWithId) (err error)
 	// AddRecord adds new record to consensus servers
-	AddRecord(ctx context.Context, logId string, clog *consensusproto.RawRecord) (record *consensusproto.RawRecordWithId, err error)
+	AddRecord(ctx context.Context, logId string, rec *consensusproto.RawRecord) (record *consensusproto.RawRecordWithId, err error)
 	// Watch starts watching to given logId and calls watcher when any relative event received
 	Watch(logId string, w Watcher) (err error)
 	// UnWatch stops watching given logId and removes watcher
@@ -86,10 +86,10 @@ func (s *service) doClient(ctx context.Context, fn func(cl consensusproto.DRPCCo
 	return fn(consensusproto.NewDRPCConsensusClient(dc))
 }
 
-func (s *service) AddLog(ctx context.Context, clog *consensusproto.Log) (err error) {
+func (s *service) AddLog(ctx context.Context, rec *consensusproto.RawRecordWithId) (err error) {
 	return s.doClient(ctx, func(cl consensusproto.DRPCConsensusClient) error {
 		if _, err = cl.LogAdd(ctx, &consensusproto.LogAddRequest{
-			Log: clog,
+			Record: rec,
 		}); err != nil {
 			return rpcerr.Unwrap(err)
 		}
@@ -97,11 +97,11 @@ func (s *service) AddLog(ctx context.Context, clog *consensusproto.Log) (err err
 	})
 }
 
-func (s *service) AddRecord(ctx context.Context, logId string, clog *consensusproto.RawRecord) (record *consensusproto.RawRecordWithId, err error) {
+func (s *service) AddRecord(ctx context.Context, logId string, rec *consensusproto.RawRecord) (record *consensusproto.RawRecordWithId, err error) {
 	err = s.doClient(ctx, func(cl consensusproto.DRPCConsensusClient) error {
 		if record, err = cl.RecordAdd(ctx, &consensusproto.RecordAddRequest{
 			LogId:  logId,
-			Record: clog,
+			Record: rec,
 		}); err != nil {
 			return rpcerr.Unwrap(err)
 		}
@@ -212,6 +212,7 @@ func (s *service) streamReader() error {
 		if len(events) == 0 {
 			return s.stream.Err()
 		}
+		s.mu.Lock()
 		for _, e := range events {
 			if w, ok := s.watchers[e.LogId]; ok {
 				if e.Error == nil {
@@ -223,6 +224,7 @@ func (s *service) streamReader() error {
 				log.Warn("received unexpected log id", zap.String("logId", e.LogId))
 			}
 		}
+		s.mu.Unlock()
 	}
 }
 
diff --git a/consensus/consensusclient/client_test.go b/consensus/consensusclient/client_test.go
index f4b8f2cc..ea47c50a 100644
--- a/consensus/consensusclient/client_test.go
+++ b/consensus/consensusclient/client_test.go
@@ -12,9 +12,9 @@ import (
 	"github.com/anyproto/any-sync/nodeconf/mock_nodeconf"
 	"github.com/anyproto/any-sync/testutil/accounttest"
 	"github.com/anyproto/any-sync/util/cidutil"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"sync"
 	"testing"
 	"time"
@@ -113,7 +113,7 @@ func TestService_Init(t *testing.T) {
 func TestService_AddLog(t *testing.T) {
 	fx := newFixture(t).run(t)
 	defer fx.Finish()
-	assert.NoError(t, fx.AddLog(ctx, &consensusproto.Log{}))
+	assert.NoError(t, fx.AddLog(ctx, &consensusproto.RawRecordWithId{}))
 }
 
 func TestService_AddRecord(t *testing.T) {
diff --git a/consensus/consensusclient/mock_consensusclient/mock_consensusclient.go b/consensus/consensusclient/mock_consensusclient/mock_consensusclient.go
index 95087515..242bd645 100644
--- a/consensus/consensusclient/mock_consensusclient/mock_consensusclient.go
+++ b/consensus/consensusclient/mock_consensusclient/mock_consensusclient.go
@@ -11,7 +11,7 @@ import (
 	app "github.com/anyproto/any-sync/app"
 	consensusclient "github.com/anyproto/any-sync/consensus/consensusclient"
 	consensusproto "github.com/anyproto/any-sync/consensus/consensusproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockService is a mock of Service interface.
@@ -38,7 +38,7 @@ func (m *MockService) EXPECT() *MockServiceMockRecorder {
 }
 
 // AddLog mocks base method.
-func (m *MockService) AddLog(arg0 context.Context, arg1 *consensusproto.Log) error {
+func (m *MockService) AddLog(arg0 context.Context, arg1 *consensusproto.RawRecordWithId) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddLog", arg0, arg1)
 	ret0, _ := ret[0].(error)
@@ -52,7 +52,7 @@ func (mr *MockServiceMockRecorder) AddLog(arg0, arg1 interface{}) *gomock.Call {
 }
 
 // AddRecord mocks base method.
-func (m *MockService) AddRecord(arg0 context.Context, arg1 []byte, arg2 *consensusproto.RawRecord) (*consensusproto.RawRecordWithId, error) {
+func (m *MockService) AddRecord(arg0 context.Context, arg1 string, arg2 *consensusproto.RawRecord) (*consensusproto.RawRecordWithId, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddRecord", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
@@ -123,7 +123,7 @@ func (mr *MockServiceMockRecorder) Run(arg0 interface{}) *gomock.Call {
 }
 
 // UnWatch mocks base method.
-func (m *MockService) UnWatch(arg0 []byte) error {
+func (m *MockService) UnWatch(arg0 string) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "UnWatch", arg0)
 	ret0, _ := ret[0].(error)
@@ -137,7 +137,7 @@ func (mr *MockServiceMockRecorder) UnWatch(arg0 interface{}) *gomock.Call {
 }
 
 // Watch mocks base method.
-func (m *MockService) Watch(arg0 []byte, arg1 consensusclient.Watcher) error {
+func (m *MockService) Watch(arg0 string, arg1 consensusclient.Watcher) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Watch", arg0, arg1)
 	ret0, _ := ret[0].(error)
diff --git a/consensus/consensusproto/consensus.pb.go b/consensus/consensusproto/consensus.pb.go
index cafc4723..dbee9248 100644
--- a/consensus/consensusproto/consensus.pb.go
+++ b/consensus/consensusproto/consensus.pb.go
@@ -29,6 +29,8 @@ const (
 	ErrCodes_LogExists      ErrCodes = 1
 	ErrCodes_LogNotFound    ErrCodes = 2
 	ErrCodes_RecordConflict ErrCodes = 3
+	ErrCodes_Forbidden      ErrCodes = 4
+	ErrCodes_InvalidPayload ErrCodes = 5
 	ErrCodes_ErrorOffset    ErrCodes = 500
 )
 
@@ -37,6 +39,8 @@ var ErrCodes_name = map[int32]string{
 	1:   "LogExists",
 	2:   "LogNotFound",
 	3:   "RecordConflict",
+	4:   "Forbidden",
+	5:   "InvalidPayload",
 	500: "ErrorOffset",
 }
 
@@ -45,6 +49,8 @@ var ErrCodes_value = map[string]int32{
 	"LogExists":      1,
 	"LogNotFound":    2,
 	"RecordConflict": 3,
+	"Forbidden":      4,
+	"InvalidPayload": 5,
 	"ErrorOffset":    500,
 }
 
@@ -58,7 +64,6 @@ func (ErrCodes) EnumDescriptor() ([]byte, []int) {
 
 type Log struct {
 	Id      string             `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
-	Payload []byte             `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
 	Records []*RawRecordWithId `protobuf:"bytes,3,rep,name=records,proto3" json:"records,omitempty"`
 }
 
@@ -102,13 +107,6 @@ func (m *Log) GetId() string {
 	return ""
 }
 
-func (m *Log) GetPayload() []byte {
-	if m != nil {
-		return m.Payload
-	}
-	return nil
-}
-
 func (m *Log) GetRecords() []*RawRecordWithId {
 	if m != nil {
 		return m.Records
@@ -344,7 +342,8 @@ func (m *Ok) XXX_DiscardUnknown() {
 var xxx_messageInfo_Ok proto.InternalMessageInfo
 
 type LogAddRequest struct {
-	Log *Log `protobuf:"bytes,1,opt,name=log,proto3" json:"log,omitempty"`
+	// first record in the log, consensus node not sign it
+	Record *RawRecordWithId `protobuf:"bytes,1,opt,name=record,proto3" json:"record,omitempty"`
 }
 
 func (m *LogAddRequest) Reset()         { *m = LogAddRequest{} }
@@ -380,9 +379,9 @@ func (m *LogAddRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_LogAddRequest proto.InternalMessageInfo
 
-func (m *LogAddRequest) GetLog() *Log {
+func (m *LogAddRequest) GetRecord() *RawRecordWithId {
 	if m != nil {
-		return m.Log
+		return m.Record
 	}
 	return nil
 }
@@ -939,56 +938,57 @@ func init() {
 }
 
 var fileDescriptor_b8d7f1c16b400059 = []byte{
-	// 778 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x5f, 0x4f, 0xdb, 0x56,
-	0x14, 0x8f, 0x6d, 0xc8, 0x9f, 0x93, 0x91, 0x78, 0x87, 0x69, 0xf2, 0xa2, 0x11, 0x22, 0x4f, 0x93,
-	0x32, 0x34, 0x85, 0x2d, 0xd3, 0x26, 0x4d, 0x68, 0x9a, 0x46, 0x14, 0x94, 0x48, 0x21, 0x6c, 0x46,
-	0x0c, 0xa9, 0x95, 0xaa, 0xba, 0xbe, 0x37, 0xc6, 0x25, 0xf8, 0xba, 0xf6, 0x0d, 0x90, 0xd7, 0xbe,
-	0xf6, 0xa5, 0x5f, 0xa0, 0xdf, 0xa7, 0x8f, 0x3c, 0xf6, 0xb1, 0x82, 0x97, 0x7e, 0x80, 0x7e, 0x80,
-	0xca, 0xd7, 0x7f, 0x12, 0xf2, 0x87, 0x0a, 0x95, 0x17, 0xb8, 0xe7, 0xff, 0xef, 0xfc, 0xce, 0xf1,
-	0x09, 0x6c, 0x5b, 0xcc, 0x0d, 0xa8, 0x1b, 0x8c, 0x82, 0xc9, 0xcb, 0xf3, 0x19, 0x67, 0xdb, 0xe2,
-	0xef, 0x94, 0xb6, 0x21, 0x14, 0x58, 0x4a, 0x15, 0xff, 0x86, 0xb2, 0xfe, 0x1c, 0x94, 0x1e, 0xb3,
-	0xb1, 0x04, 0xb2, 0x43, 0x34, 0xa9, 0x26, 0xd5, 0x0b, 0x86, 0xec, 0x10, 0xd4, 0x20, 0xe7, 0x99,
-	0xe3, 0x21, 0x33, 0x89, 0x26, 0xd7, 0xa4, 0xfa, 0x57, 0x46, 0x22, 0xe2, 0x9f, 0x90, 0xf3, 0xa9,
-	0xc5, 0x7c, 0x12, 0x68, 0x4a, 0x4d, 0xa9, 0x17, 0x9b, 0x9b, 0x8d, 0xdb, 0x29, 0x1b, 0x86, 0x79,
-	0x61, 0x08, 0x8f, 0x63, 0x87, 0x9f, 0x74, 0x89, 0x91, 0xf8, 0xeb, 0x6f, 0x24, 0x28, 0xa4, 0xc6,
-	0xe9, 0x12, 0xd2, 0xed, 0x12, 0xdf, 0x43, 0x21, 0x70, 0x6c, 0xd7, 0xe4, 0x23, 0x9f, 0xc6, 0xe5,
-	0x27, 0x0a, 0xdc, 0x02, 0xd5, 0xb4, 0x2c, 0xea, 0x71, 0xe6, 0x77, 0x09, 0x75, 0xb9, 0xc3, 0xc7,
-	0x9a, 0x22, 0x9c, 0xe6, 0xf4, 0xf8, 0x33, 0x7c, 0x9d, 0xe8, 0x0e, 0xd3, 0x8c, 0x2b, 0xc2, 0x79,
-	0xde, 0xa0, 0xef, 0x40, 0x79, 0x06, 0xfb, 0x1d, 0x20, 0x23, 0xc6, 0xe4, 0x84, 0x31, 0xdd, 0x85,
-	0x6c, 0xdc, 0xd8, 0xb7, 0x90, 0xf5, 0x7c, 0x7a, 0xde, 0x4d, 0xf8, 0x8c, 0x25, 0xac, 0x40, 0xde,
-	0x49, 0x00, 0x47, 0x5d, 0xa5, 0x32, 0x22, 0xac, 0x10, 0x93, 0x9b, 0x71, 0x23, 0xe2, 0x1d, 0xd2,
-	0xc0, 0x9d, 0x33, 0x1a, 0x70, 0xf3, 0xcc, 0x13, 0xa0, 0x15, 0x63, 0xa2, 0xd0, 0x57, 0x40, 0x3e,
-	0x38, 0xd5, 0xff, 0x80, 0xb5, 0x1e, 0xb3, 0xff, 0x21, 0xc4, 0xa0, 0x2f, 0x46, 0x34, 0xe0, 0xf8,
-	0x23, 0x28, 0x43, 0x66, 0x8b, 0xca, 0xc5, 0xe6, 0xfa, 0xec, 0x68, 0x7a, 0xcc, 0x36, 0x42, 0xbb,
-	0xfe, 0x18, 0xd4, 0x08, 0xed, 0x54, 0xe8, 0x37, 0xb0, 0x3a, 0x64, 0x76, 0x0a, 0x3b, 0x12, 0xf0,
-	0x57, 0xc8, 0x46, 0xf3, 0x13, 0x98, 0x8b, 0xcd, 0xef, 0x96, 0x8e, 0xdb, 0x88, 0x1d, 0xf5, 0x7d,
-	0x28, 0xf7, 0x98, 0x7d, 0x6c, 0x72, 0xeb, 0x24, 0xc9, 0x5d, 0x81, 0xfc, 0x45, 0x28, 0x77, 0x49,
-	0xa0, 0x49, 0x35, 0xa5, 0x5e, 0x30, 0x52, 0x19, 0xab, 0x00, 0x23, 0x37, 0xb5, 0xca, 0xc2, 0x3a,
-	0xa5, 0xd1, 0x5f, 0x49, 0xa2, 0x49, 0x91, 0xaf, 0x7d, 0x4e, 0xdd, 0x65, 0x48, 0xa7, 0x36, 0x53,
-	0xbe, 0xdf, 0x66, 0xe2, 0x4f, 0xb0, 0x4a, 0x7d, 0x9f, 0xf9, 0x82, 0xff, 0x05, 0xbc, 0xb5, 0x7d,
-	0xdf, 0x88, 0x3c, 0xf4, 0xdf, 0x41, 0x69, 0xfb, 0x3e, 0x36, 0x92, 0x88, 0x10, 0x42, 0xa9, 0xa9,
-	0x2d, 0x88, 0x68, 0x31, 0x42, 0x83, 0x24, 0xec, 0xa5, 0x0c, 0xeb, 0x3d, 0x66, 0x1f, 0x8e, 0x5d,
-	0xab, 0xc5, 0x5c, 0x4e, 0x5d, 0xfe, 0xbf, 0x39, 0x1c, 0x51, 0xfc, 0x1b, 0xe0, 0x84, 0x9a, 0xe4,
-	0xc8, 0x23, 0x26, 0xa7, 0xf1, 0xd8, 0x36, 0x16, 0x8c, 0xad, 0x93, 0x3a, 0x75, 0x32, 0xc6, 0x54,
-	0x08, 0xf6, 0xa1, 0x3c, 0x18, 0x0d, 0x87, 0x61, 0xe2, 0x98, 0xec, 0x78, 0x50, 0xfa, 0x82, 0x2c,
-	0x7b, 0xb7, 0x3d, 0x3b, 0x19, 0x63, 0x36, 0x18, 0xff, 0x03, 0x75, 0xa2, 0x0a, 0xbc, 0x30, 0x45,
-	0xcc, 0xca, 0x0f, 0x77, 0x26, 0x8c, 0x5c, 0x3b, 0x19, 0x63, 0x2e, 0x7c, 0x37, 0x07, 0xab, 0xe7,
-	0x61, 0xb3, 0xfa, 0x18, 0x4a, 0x31, 0x07, 0xfb, 0x34, 0x08, 0x4c, 0x9b, 0xde, 0xe3, 0xee, 0xfc,
-	0x05, 0x39, 0x2b, 0x22, 0xee, 0x0e, 0x38, 0xb3, 0xf4, 0x1a, 0x49, 0x8c, 0xfe, 0x44, 0xec, 0xd0,
-	0x84, 0xc5, 0xf0, 0x8b, 0x0b, 0x59, 0x8c, 0x6b, 0x8b, 0xf7, 0x17, 0x6c, 0x90, 0x6e, 0x01, 0xce,
-	0xf3, 0xfb, 0xd0, 0x45, 0x88, 0xd8, 0xa1, 0x59, 0xce, 0x1f, 0xb8, 0xca, 0xd6, 0x53, 0xc8, 0x27,
-	0xdb, 0x8b, 0x25, 0x80, 0x23, 0x97, 0x5e, 0x7a, 0xd4, 0xe2, 0x94, 0xa8, 0x19, 0x5c, 0x83, 0x42,
-	0x8f, 0xd9, 0xed, 0x4b, 0x27, 0xe0, 0x81, 0x2a, 0x61, 0x19, 0x8a, 0x3d, 0x66, 0xf7, 0x19, 0xdf,
-	0x63, 0x23, 0x97, 0xa8, 0x32, 0x22, 0x94, 0xa2, 0xa4, 0x2d, 0xe6, 0x0e, 0x86, 0x8e, 0xc5, 0x55,
-	0x05, 0x55, 0x28, 0xb6, 0xc3, 0x6f, 0xe0, 0x60, 0x30, 0x08, 0x28, 0x57, 0x3f, 0x2a, 0xcd, 0x0f,
-	0x12, 0x14, 0x5a, 0x09, 0x1a, 0xdc, 0x81, 0x6c, 0x74, 0xc3, 0x70, 0xd1, 0xe2, 0x4f, 0x0e, 0x54,
-	0x05, 0x67, 0xcd, 0x07, 0xa7, 0xd8, 0x87, 0x42, 0x7a, 0xc8, 0xb0, 0x36, 0xd7, 0xe3, 0xcc, 0x8d,
-	0xab, 0x7c, 0x8e, 0x05, 0xec, 0x43, 0x3e, 0xb9, 0x35, 0xb8, 0xb9, 0x00, 0xce, 0xf4, 0x55, 0xab,
-	0x6c, 0x2c, 0x73, 0x10, 0x67, 0xaa, 0x2e, 0xfd, 0x22, 0xed, 0x36, 0xdf, 0x5e, 0x57, 0xa5, 0xab,
-	0xeb, 0xaa, 0xf4, 0xfe, 0xba, 0x2a, 0xbd, 0xbe, 0xa9, 0x66, 0xae, 0x6e, 0xaa, 0x99, 0x77, 0x37,
-	0xd5, 0xcc, 0x23, 0x6d, 0xd9, 0x4f, 0xf7, 0xb3, 0xac, 0xf8, 0xf7, 0xdb, 0xa7, 0x00, 0x00, 0x00,
-	0xff, 0xff, 0x9e, 0x4a, 0x75, 0x11, 0xdd, 0x07, 0x00, 0x00,
+	// 792 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x4d, 0x6f, 0xf3, 0x44,
+	0x10, 0x8e, 0xed, 0x7c, 0x4e, 0x78, 0x13, 0x33, 0x2f, 0x42, 0x26, 0xa2, 0x69, 0x64, 0x2e, 0xa1,
+	0x42, 0x29, 0x04, 0x21, 0x84, 0x2a, 0x84, 0x68, 0x94, 0x2a, 0x91, 0xd2, 0xb4, 0xb8, 0x2a, 0x95,
+	0x40, 0x42, 0x72, 0xbd, 0x1b, 0xd7, 0x6a, 0xea, 0x35, 0xf6, 0x26, 0x6d, 0xae, 0x70, 0xe4, 0xc2,
+	0x1f, 0xe0, 0xff, 0x70, 0xec, 0x91, 0x23, 0x6a, 0x2f, 0xfc, 0x00, 0x7e, 0x00, 0xf2, 0xfa, 0x23,
+	0xa9, 0x93, 0x14, 0xd0, 0xdb, 0x4b, 0xb2, 0xf3, 0xf5, 0xcc, 0xcc, 0xb3, 0xb3, 0x63, 0xd8, 0xb7,
+	0x98, 0x1b, 0x50, 0x37, 0x98, 0x05, 0xcb, 0x93, 0xe7, 0x33, 0xce, 0xf6, 0xc5, 0xef, 0x8a, 0xb6,
+	0x23, 0x14, 0x58, 0x4b, 0x15, 0xa7, 0xa1, 0xac, 0x9f, 0x82, 0x32, 0x62, 0x36, 0xd6, 0x40, 0x76,
+	0x88, 0x26, 0xb5, 0xa4, 0x76, 0xc5, 0x90, 0x1d, 0x82, 0x5f, 0x40, 0xc9, 0xa7, 0x16, 0xf3, 0x49,
+	0xa0, 0x29, 0x2d, 0xa5, 0x5d, 0xed, 0xee, 0x76, 0x9e, 0x06, 0x76, 0x0c, 0xf3, 0xd6, 0x10, 0x1e,
+	0x17, 0x0e, 0xbf, 0x1a, 0x12, 0x23, 0xf1, 0xd7, 0x7f, 0x93, 0xa0, 0x92, 0x1a, 0x51, 0x83, 0x92,
+	0x67, 0x2e, 0xa6, 0xcc, 0x8c, 0xd0, 0xdf, 0x32, 0x12, 0x11, 0xdf, 0x87, 0x4a, 0xe0, 0xd8, 0xae,
+	0xc9, 0x67, 0x3e, 0xd5, 0x64, 0x61, 0x5b, 0x2a, 0x70, 0x0f, 0x54, 0xd3, 0xb2, 0xa8, 0xc7, 0x99,
+	0x3f, 0x24, 0xd4, 0xe5, 0x0e, 0x5f, 0x68, 0x8a, 0x70, 0x5a, 0xd3, 0xe3, 0x47, 0xf0, 0x76, 0xa2,
+	0x3b, 0x4b, 0x11, 0xf3, 0xc2, 0x79, 0xdd, 0xa0, 0x1f, 0x40, 0x3d, 0x53, 0xfb, 0x33, 0x45, 0x46,
+	0xbc, 0xc8, 0x09, 0x2f, 0xba, 0x0b, 0xc5, 0xb8, 0xb1, 0x77, 0xa1, 0xe8, 0xf9, 0x74, 0x3e, 0x4c,
+	0x58, 0x8b, 0x25, 0x6c, 0x40, 0xd9, 0x49, 0x0a, 0x8e, 0xba, 0x4a, 0x65, 0x44, 0xc8, 0x13, 0x93,
+	0x9b, 0x71, 0x23, 0xe2, 0x1c, 0xd2, 0xc0, 0x9d, 0x1b, 0x1a, 0x70, 0xf3, 0xc6, 0x13, 0x45, 0x2b,
+	0xc6, 0x52, 0xa1, 0xe7, 0x41, 0x3e, 0xb9, 0xd6, 0x07, 0xf0, 0x6a, 0xc4, 0xec, 0xaf, 0x09, 0x31,
+	0xe8, 0x8f, 0x33, 0x1a, 0x70, 0xfc, 0x1c, 0x8a, 0x11, 0xdd, 0x22, 0xf9, 0x7f, 0xb8, 0x9d, 0xd8,
+	0x5d, 0xff, 0x1e, 0xd4, 0x48, 0xbf, 0x02, 0xf6, 0x0e, 0x14, 0xa6, 0xcc, 0x4e, 0x1b, 0x89, 0x04,
+	0xfc, 0x24, 0x4d, 0x21, 0x8b, 0x14, 0xef, 0x6d, 0x4d, 0x91, 0x82, 0x1f, 0x43, 0x7d, 0xc4, 0xec,
+	0x0b, 0x93, 0x5b, 0x57, 0x09, 0x76, 0x03, 0xca, 0xb7, 0xa1, 0x3c, 0x24, 0x81, 0x26, 0xb5, 0x94,
+	0x76, 0xc5, 0x48, 0x65, 0x6c, 0x02, 0xcc, 0xdc, 0xd4, 0x2a, 0x0b, 0xeb, 0x8a, 0x46, 0xff, 0x45,
+	0x12, 0x6d, 0x0b, 0xbc, 0xfe, 0x9c, 0xba, 0xdb, 0x2a, 0x5d, 0x99, 0x55, 0xf9, 0xff, 0xcd, 0x2a,
+	0x7e, 0x08, 0x05, 0xea, 0xfb, 0xcc, 0x17, 0x37, 0x52, 0xed, 0xbe, 0xce, 0x06, 0xf6, 0x7d, 0xdf,
+	0x88, 0x3c, 0xf4, 0xcf, 0x40, 0xe9, 0xfb, 0x3e, 0x76, 0x92, 0x88, 0xb0, 0x84, 0x5a, 0x57, 0xdb,
+	0x10, 0xd1, 0x63, 0x84, 0x06, 0x49, 0xd8, 0x4f, 0x32, 0xbc, 0x1e, 0x31, 0xfb, 0x6c, 0xe1, 0x5a,
+	0x3d, 0xe6, 0x72, 0xea, 0xf2, 0x6f, 0xcd, 0xe9, 0x8c, 0xe2, 0x57, 0x00, 0x57, 0xd4, 0x24, 0xe7,
+	0x1e, 0x31, 0x39, 0x8d, 0x6f, 0x71, 0x27, 0x0b, 0x36, 0x62, 0xf6, 0x20, 0x75, 0x1a, 0xe4, 0x8c,
+	0x95, 0x10, 0x1c, 0x43, 0x7d, 0x32, 0x9b, 0x4e, 0x43, 0xe0, 0x98, 0xec, 0xf8, 0xa2, 0xf4, 0x0d,
+	0x28, 0x47, 0x4f, 0x3d, 0x07, 0x39, 0x23, 0x1b, 0x8c, 0xdf, 0x80, 0xba, 0x54, 0x05, 0x5e, 0x08,
+	0x11, 0xb3, 0xf2, 0xc1, 0xb3, 0x80, 0x91, 0xeb, 0x20, 0x67, 0xac, 0x85, 0x1f, 0x96, 0xa0, 0x30,
+	0x0f, 0x9b, 0xd5, 0x17, 0x50, 0x8b, 0x39, 0x38, 0xa6, 0x41, 0x60, 0xda, 0x74, 0x6d, 0xdf, 0xac,
+	0xbc, 0x40, 0xf9, 0xe9, 0x0b, 0xfc, 0x12, 0x4a, 0x56, 0x44, 0xdc, 0x33, 0xe5, 0x64, 0xe9, 0x35,
+	0x92, 0x18, 0xfd, 0x07, 0x31, 0x43, 0x4b, 0x16, 0xc3, 0x37, 0x18, 0xb2, 0x18, 0xe7, 0x16, 0xe7,
+	0x37, 0x98, 0x20, 0xdd, 0x02, 0x5c, 0xe7, 0xf7, 0xa5, 0x93, 0x10, 0x31, 0x43, 0x59, 0xce, 0x5f,
+	0x38, 0xcb, 0xde, 0xcf, 0x12, 0x94, 0x93, 0xf1, 0xc5, 0x1a, 0xc0, 0xb9, 0x4b, 0xef, 0x3c, 0x6a,
+	0x71, 0x4a, 0xd4, 0x1c, 0xbe, 0x82, 0xca, 0x88, 0xd9, 0xfd, 0x3b, 0x27, 0xe0, 0x81, 0x2a, 0x61,
+	0x1d, 0xaa, 0x23, 0x66, 0x8f, 0x19, 0x3f, 0x62, 0x33, 0x97, 0xa8, 0x32, 0x22, 0xd4, 0x22, 0xd4,
+	0x1e, 0x73, 0x27, 0x53, 0xc7, 0xe2, 0xaa, 0x12, 0xc6, 0x1c, 0x31, 0xff, 0xd2, 0x21, 0x84, 0xba,
+	0x6a, 0x3e, 0x74, 0x19, 0xba, 0x73, 0x73, 0xea, 0x90, 0xd3, 0xe8, 0x6e, 0xd5, 0x02, 0xaa, 0x50,
+	0xed, 0x87, 0xef, 0xe4, 0x64, 0x32, 0x09, 0x28, 0x57, 0xff, 0x56, 0xba, 0x7f, 0x49, 0x50, 0xe9,
+	0x25, 0x15, 0xe3, 0x01, 0x14, 0xa3, 0xcd, 0x87, 0x9b, 0x1e, 0xc7, 0x72, 0x89, 0x35, 0x30, 0x6b,
+	0x3e, 0xb9, 0xc6, 0x31, 0x54, 0xd2, 0x65, 0x87, 0xad, 0x35, 0x1e, 0x32, 0x7b, 0xb0, 0xf1, 0x6f,
+	0x4c, 0xe1, 0x18, 0xca, 0xc9, 0x3e, 0xc2, 0xdd, 0x0d, 0xe5, 0xac, 0x6e, 0xbe, 0xc6, 0xce, 0x36,
+	0x07, 0xb1, 0xca, 0xda, 0xd2, 0xc7, 0xd2, 0x61, 0xf7, 0xf7, 0x87, 0xa6, 0x74, 0xff, 0xd0, 0x94,
+	0xfe, 0x7c, 0x68, 0x4a, 0xbf, 0x3e, 0x36, 0x73, 0xf7, 0x8f, 0xcd, 0xdc, 0x1f, 0x8f, 0xcd, 0xdc,
+	0x77, 0xda, 0xb6, 0xcf, 0xfa, 0x65, 0x51, 0xfc, 0x7d, 0xfa, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0x3a, 0xf6, 0x39, 0x2c, 0xf9, 0x07, 0x00, 0x00,
 }
 
 func (m *Log) Marshal() (dAtA []byte, err error) {
@@ -1025,13 +1025,6 @@ func (m *Log) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA[i] = 0x1a
 		}
 	}
-	if len(m.Payload) > 0 {
-		i -= len(m.Payload)
-		copy(dAtA[i:], m.Payload)
-		i = encodeVarintConsensus(dAtA, i, uint64(len(m.Payload)))
-		i--
-		dAtA[i] = 0x12
-	}
 	if len(m.Id) > 0 {
 		i -= len(m.Id)
 		copy(dAtA[i:], m.Id)
@@ -1222,9 +1215,9 @@ func (m *LogAddRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.Log != nil {
+	if m.Record != nil {
 		{
-			size, err := m.Log.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.Record.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -1701,10 +1694,6 @@ func (m *Log) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovConsensus(uint64(l))
 	}
-	l = len(m.Payload)
-	if l > 0 {
-		n += 1 + l + sovConsensus(uint64(l))
-	}
 	if len(m.Records) > 0 {
 		for _, e := range m.Records {
 			l = e.Size()
@@ -1795,8 +1784,8 @@ func (m *LogAddRequest) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.Log != nil {
-		l = m.Log.Size()
+	if m.Record != nil {
+		l = m.Record.Size()
 		n += 1 + l + sovConsensus(uint64(l))
 	}
 	return n
@@ -2068,40 +2057,6 @@ func (m *Log) Unmarshal(dAtA []byte) error {
 			}
 			m.Id = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowConsensus
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthConsensus
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthConsensus
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
-			if m.Payload == nil {
-				m.Payload = []byte{}
-			}
-			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Records", wireType)
@@ -2709,7 +2664,7 @@ func (m *LogAddRequest) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Record", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -2736,10 +2691,10 @@ func (m *LogAddRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Log == nil {
-				m.Log = &Log{}
+			if m.Record == nil {
+				m.Record = &RawRecordWithId{}
 			}
-			if err := m.Log.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Record.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/consensus/consensusproto/consensuserr/errors.go b/consensus/consensusproto/consensuserr/errors.go
index a7ba9f96..4bc59139 100644
--- a/consensus/consensusproto/consensuserr/errors.go
+++ b/consensus/consensusproto/consensuserr/errors.go
@@ -9,8 +9,10 @@ import (
 var (
 	errGroup = rpcerr.ErrGroup(consensusproto.ErrCodes_ErrorOffset)
 
-	ErrUnexpected  = errGroup.Register(fmt.Errorf("unexpected consensus error"), uint64(consensusproto.ErrCodes_Unexpected))
-	ErrConflict    = errGroup.Register(fmt.Errorf("records conflict"), uint64(consensusproto.ErrCodes_RecordConflict))
-	ErrLogExists   = errGroup.Register(fmt.Errorf("log exists"), uint64(consensusproto.ErrCodes_LogExists))
-	ErrLogNotFound = errGroup.Register(fmt.Errorf("log not found"), uint64(consensusproto.ErrCodes_LogNotFound))
+	ErrUnexpected     = errGroup.Register(fmt.Errorf("unexpected consensus error"), uint64(consensusproto.ErrCodes_Unexpected))
+	ErrConflict       = errGroup.Register(fmt.Errorf("records conflict"), uint64(consensusproto.ErrCodes_RecordConflict))
+	ErrLogExists      = errGroup.Register(fmt.Errorf("log exists"), uint64(consensusproto.ErrCodes_LogExists))
+	ErrLogNotFound    = errGroup.Register(fmt.Errorf("log not found"), uint64(consensusproto.ErrCodes_LogNotFound))
+	ErrForbidden      = errGroup.Register(fmt.Errorf("forbidden"), uint64(consensusproto.ErrCodes_Forbidden))
+	ErrInvalidPayload = errGroup.Register(fmt.Errorf("invalid payload"), uint64(consensusproto.ErrCodes_InvalidPayload))
 )
diff --git a/consensus/consensusproto/protos/consensus.proto b/consensus/consensusproto/protos/consensus.proto
index e7fa086d..7af9316f 100644
--- a/consensus/consensusproto/protos/consensus.proto
+++ b/consensus/consensusproto/protos/consensus.proto
@@ -8,13 +8,14 @@ enum ErrCodes {
     LogExists = 1;
     LogNotFound = 2;
     RecordConflict = 3;
+    Forbidden = 4;
+    InvalidPayload = 5;
     ErrorOffset = 500;
 }
 
 
 message Log {
     string id = 1;
-    bytes payload = 2;
     repeated RawRecordWithId records = 3;
 }
 
@@ -53,7 +54,8 @@ service Consensus {
 message Ok {}
 
 message LogAddRequest {
-    Log log = 1;
+    // first record in the log, consensus node not sign it
+    RawRecordWithId record = 1;
 }
 
 message RecordAddRequest {
diff --git a/coordinator/coordinatorclient/mock_coordinatorclient/mock_coordinatorclient.go b/coordinator/coordinatorclient/mock_coordinatorclient/mock_coordinatorclient.go
index d2d83159..c94189e9 100644
--- a/coordinator/coordinatorclient/mock_coordinatorclient/mock_coordinatorclient.go
+++ b/coordinator/coordinatorclient/mock_coordinatorclient/mock_coordinatorclient.go
@@ -12,7 +12,7 @@ import (
 	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
 	coordinatorclient "github.com/anyproto/any-sync/coordinator/coordinatorclient"
 	coordinatorproto "github.com/anyproto/any-sync/coordinator/coordinatorproto"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockCoordinatorClient is a mock of CoordinatorClient interface.
diff --git a/go.mod b/go.mod
index 925e5cd6..2a10036c 100644
--- a/go.mod
+++ b/go.mod
@@ -12,7 +12,6 @@ require (
 	github.com/gobwas/glob v0.2.3
 	github.com/goccy/go-graphviz v0.1.1
 	github.com/gogo/protobuf v1.3.2
-	github.com/golang/mock v1.6.0
 	github.com/google/uuid v1.3.0
 	github.com/hashicorp/yamux v0.1.1
 	github.com/huandu/skiplist v1.2.0
@@ -34,6 +33,7 @@ require (
 	github.com/tyler-smith/go-bip39 v1.1.0
 	github.com/zeebo/blake3 v0.2.3
 	go.uber.org/atomic v1.11.0
+	go.uber.org/mock v0.2.0
 	go.uber.org/zap v1.24.0
 	golang.org/x/crypto v0.10.0
 	golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1
diff --git a/go.sum b/go.sum
index e36885d7..8afce3ca 100644
--- a/go.sum
+++ b/go.sum
@@ -54,7 +54,6 @@ github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
 github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
-github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
@@ -281,6 +280,8 @@ go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
 go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA=
+go.uber.org/mock v0.2.0 h1:TaP3xedm7JaAgScZO7tlvlKrqT0p7I6OsdGB5YNSMDU=
+go.uber.org/mock v0.2.0/go.mod h1:J0y0rp9L3xiff1+ZBfKxlC1fz2+aO16tw0tsDOixfuM=
 go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
@@ -365,7 +366,6 @@ golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
diff --git a/net/peer/mock_peer/mock_peer.go b/net/peer/mock_peer/mock_peer.go
index dc0a5b6a..5d6531b4 100644
--- a/net/peer/mock_peer/mock_peer.go
+++ b/net/peer/mock_peer/mock_peer.go
@@ -9,7 +9,7 @@ import (
 	reflect "reflect"
 	time "time"
 
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 	drpc "storj.io/drpc"
 )
 
diff --git a/net/peer/peer_test.go b/net/peer/peer_test.go
index 7aa8428c..a5275876 100644
--- a/net/peer/peer_test.go
+++ b/net/peer/peer_test.go
@@ -6,9 +6,9 @@ import (
 	"github.com/anyproto/any-sync/net/secureservice/handshake"
 	"github.com/anyproto/any-sync/net/secureservice/handshake/handshakeproto"
 	"github.com/anyproto/any-sync/net/transport/mock_transport"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"io"
 	"net"
 	_ "net/http/pprof"
diff --git a/net/pool/mock_pool/mock_pool.go b/net/pool/mock_pool/mock_pool.go
index be884903..7a304053 100644
--- a/net/pool/mock_pool/mock_pool.go
+++ b/net/pool/mock_pool/mock_pool.go
@@ -9,7 +9,7 @@ import (
 	reflect "reflect"
 
 	peer "github.com/anyproto/any-sync/net/peer"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockPool is a mock of Pool interface.
diff --git a/net/secureservice/secureservice_test.go b/net/secureservice/secureservice_test.go
index 86735f66..0a6675dd 100644
--- a/net/secureservice/secureservice_test.go
+++ b/net/secureservice/secureservice_test.go
@@ -9,9 +9,9 @@ import (
 	"github.com/anyproto/any-sync/nodeconf"
 	"github.com/anyproto/any-sync/nodeconf/mock_nodeconf"
 	"github.com/anyproto/any-sync/testutil/testnodeconf"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"net"
 	"testing"
 )
diff --git a/net/transport/mock_transport/mock_transport.go b/net/transport/mock_transport/mock_transport.go
index e0428014..ddc13ea4 100644
--- a/net/transport/mock_transport/mock_transport.go
+++ b/net/transport/mock_transport/mock_transport.go
@@ -10,7 +10,7 @@ import (
 	reflect "reflect"
 
 	transport "github.com/anyproto/any-sync/net/transport"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockTransport is a mock of Transport interface.
diff --git a/net/transport/yamux/yamux_test.go b/net/transport/yamux/yamux_test.go
index 9b209054..1fd6ba3a 100644
--- a/net/transport/yamux/yamux_test.go
+++ b/net/transport/yamux/yamux_test.go
@@ -10,9 +10,9 @@ import (
 	"github.com/anyproto/any-sync/nodeconf/mock_nodeconf"
 	"github.com/anyproto/any-sync/testutil/accounttest"
 	"github.com/anyproto/any-sync/testutil/testnodeconf"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"io"
 	"net"
 	"sync"
diff --git a/nodeconf/mock_nodeconf/mock_nodeconf.go b/nodeconf/mock_nodeconf/mock_nodeconf.go
index 353bf921..9b4c7d58 100644
--- a/nodeconf/mock_nodeconf/mock_nodeconf.go
+++ b/nodeconf/mock_nodeconf/mock_nodeconf.go
@@ -11,7 +11,7 @@ import (
 	app "github.com/anyproto/any-sync/app"
 	nodeconf "github.com/anyproto/any-sync/nodeconf"
 	chash "github.com/anyproto/go-chash"
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockService is a mock of Service interface.
diff --git a/util/periodicsync/mock_periodicsync/mock_periodicsync.go b/util/periodicsync/mock_periodicsync/mock_periodicsync.go
index d34d6162..909b32e1 100644
--- a/util/periodicsync/mock_periodicsync/mock_periodicsync.go
+++ b/util/periodicsync/mock_periodicsync/mock_periodicsync.go
@@ -7,7 +7,7 @@ package mock_periodicsync
 import (
 	reflect "reflect"
 
-	gomock "github.com/golang/mock/gomock"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockPeriodicSync is a mock of PeriodicSync interface.
diff --git a/util/periodicsync/periodicsync_test.go b/util/periodicsync/periodicsync_test.go
index 35dd848c..f45a940b 100644
--- a/util/periodicsync/periodicsync_test.go
+++ b/util/periodicsync/periodicsync_test.go
@@ -3,8 +3,8 @@ package periodicsync
 import (
 	"context"
 	"github.com/anyproto/any-sync/app/logger"
-	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 	"testing"
 	"time"
 )