Update to marshal append

commonfile/fileproto/file.pb.go

@@ -117,6 +117,14 @@ func (m *Ok) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Ok) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Ok) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Ok.Merge(m, src)
 }
@@ -156,6 +164,14 @@ func (m *BlockGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *BlockGetRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BlockGetRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BlockGetRequest.Merge(m, src)
 }
@@ -215,6 +231,14 @@ func (m *BlockGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *BlockGetResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BlockGetResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BlockGetResponse.Merge(m, src)
 }
@@ -269,6 +293,14 @@ func (m *BlockPushRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *BlockPushRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BlockPushRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BlockPushRequest.Merge(m, src)
 }
@@ -335,6 +367,14 @@ func (m *BlocksCheckRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *BlocksCheckRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BlocksCheckRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BlocksCheckRequest.Merge(m, src)
 }
@@ -386,6 +426,14 @@ func (m *BlocksCheckResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *BlocksCheckResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BlocksCheckResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BlocksCheckResponse.Merge(m, src)
 }
@@ -431,6 +479,14 @@ func (m *BlockAvailability) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *BlockAvailability) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BlockAvailability) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BlockAvailability.Merge(m, src)
 }
@@ -484,6 +540,14 @@ func (m *BlocksBindRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *BlocksBindRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BlocksBindRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BlocksBindRequest.Merge(m, src)
 }
@@ -543,6 +607,14 @@ func (m *FilesDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *FilesDeleteRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FilesDeleteRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FilesDeleteRequest.Merge(m, src)
 }
@@ -593,6 +665,14 @@ func (m *FilesDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *FilesDeleteResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FilesDeleteResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FilesDeleteResponse.Merge(m, src)
 }
@@ -631,6 +711,14 @@ func (m *FilesInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *FilesInfoRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FilesInfoRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FilesInfoRequest.Merge(m, src)
 }
@@ -682,6 +770,14 @@ func (m *FilesInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *FilesInfoResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FilesInfoResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FilesInfoResponse.Merge(m, src)
 }
@@ -728,6 +824,14 @@ func (m *FileInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *FileInfo) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FileInfo) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FileInfo.Merge(m, src)
 }
@@ -786,6 +890,14 @@ func (m *FilesGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *FilesGetRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FilesGetRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FilesGetRequest.Merge(m, src)
 }
@@ -830,6 +942,14 @@ func (m *FilesGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *FilesGetResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FilesGetResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FilesGetResponse.Merge(m, src)
 }
@@ -873,6 +993,14 @@ func (m *CheckRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *CheckRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *CheckRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CheckRequest.Merge(m, src)
 }
@@ -911,6 +1039,14 @@ func (m *CheckResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *CheckResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *CheckResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CheckResponse.Merge(m, src)
 }
@@ -962,6 +1098,14 @@ func (m *SpaceInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *SpaceInfoRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceInfoRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceInfoRequest.Merge(m, src)
 }
@@ -1011,6 +1155,14 @@ func (m *SpaceInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *SpaceInfoResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceInfoResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceInfoResponse.Merge(m, src)
 }
@@ -1089,6 +1241,14 @@ func (m *AccountInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *AccountInfoRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountInfoRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountInfoRequest.Merge(m, src)
 }
@@ -1132,6 +1292,14 @@ func (m *AccountInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *AccountInfoResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountInfoResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountInfoResponse.Merge(m, src)
 }
@@ -1205,6 +1373,14 @@ func (m *AccountLimitSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]by
 		return b[:n], nil
 	}
 }
+func (m *AccountLimitSetRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountLimitSetRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountLimitSetRequest.Merge(m, src)
 }
@@ -1257,6 +1433,14 @@ func (m *SpaceLimitSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *SpaceLimitSetRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceLimitSetRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceLimitSetRequest.Merge(m, src)
 }

commonspace/object/acl/aclrecordproto/aclrecord.pb.go

@@ -91,6 +91,14 @@ func (m *AclRoot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *AclRoot) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclRoot) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclRoot.Merge(m, src)
 }
@@ -192,6 +200,14 @@ func (m *AclAccountInvite) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *AclAccountInvite) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountInvite) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountInvite.Merge(m, src)
 }
@@ -241,6 +257,14 @@ func (m *AclAccountRequestJoin) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *AclAccountRequestJoin) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountRequestJoin) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountRequestJoin.Merge(m, src)
 }
@@ -310,6 +334,14 @@ func (m *AclAccountRequestAccept) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return b[:n], nil
 	}
 }
+func (m *AclAccountRequestAccept) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountRequestAccept) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountRequestAccept.Merge(m, src)
 }
@@ -376,6 +408,14 @@ func (m *AclAccountRequestDecline) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
+func (m *AclAccountRequestDecline) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountRequestDecline) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountRequestDecline.Merge(m, src)
 }
@@ -421,6 +461,14 @@ func (m *AclAccountInviteRevoke) XXX_Marshal(b []byte, deterministic bool) ([]by
 		return b[:n], nil
 	}
 }
+func (m *AclAccountInviteRevoke) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountInviteRevoke) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountInviteRevoke.Merge(m, src)
 }
@@ -467,6 +515,14 @@ func (m *AclEncryptedReadKey) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *AclEncryptedReadKey) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclEncryptedReadKey) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclEncryptedReadKey.Merge(m, src)
 }
@@ -519,6 +575,14 @@ func (m *AclAccountPermissionChanges) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *AclAccountPermissionChanges) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountPermissionChanges) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountPermissionChanges.Merge(m, src)
 }
@@ -564,6 +628,14 @@ func (m *AclAccountsAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
+func (m *AclAccountsAdd) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountsAdd) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountsAdd.Merge(m, src)
 }
@@ -612,6 +684,14 @@ func (m *AclAccountAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *AclAccountAdd) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountAdd) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountAdd.Merge(m, src)
 }
@@ -678,6 +758,14 @@ func (m *AclAccountRequestCancel) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return b[:n], nil
 	}
 }
+func (m *AclAccountRequestCancel) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountRequestCancel) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountRequestCancel.Merge(m, src)
 }
@@ -724,6 +812,14 @@ func (m *AclAccountPermissionChange) XXX_Marshal(b []byte, deterministic bool) (
 		return b[:n], nil
 	}
 }
+func (m *AclAccountPermissionChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountPermissionChange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountPermissionChange.Merge(m, src)
 }
@@ -781,6 +877,14 @@ func (m *AclReadKeyChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *AclReadKeyChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclReadKeyChange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclReadKeyChange.Merge(m, src)
 }
@@ -848,6 +952,14 @@ func (m *AclAccountRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *AclAccountRemove) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountRemove) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountRemove.Merge(m, src)
 }
@@ -899,6 +1011,14 @@ func (m *AclAccountRequestRemove) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return b[:n], nil
 	}
 }
+func (m *AclAccountRequestRemove) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAccountRequestRemove) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAccountRequestRemove.Merge(m, src)
 }
@@ -927,7 +1047,7 @@ type AclContentValue struct {
 	//	*AclContentValue_PermissionChanges
 	//	*AclContentValue_AccountsAdd
 	//	*AclContentValue_RequestCancel
-	Value isAclContentValue_Value `protobuf_oneof:"value"`
+	Value isAclContentValueValue `protobuf_oneof:"value"`
 }
 
 func (m *AclContentValue) Reset()         { *m = AclContentValue{} }
@@ -951,6 +1071,14 @@ func (m *AclContentValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *AclContentValue) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclContentValue) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclContentValue.Merge(m, src)
 }
@@ -963,8 +1091,8 @@ func (m *AclContentValue) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_AclContentValue proto.InternalMessageInfo
 
-type isAclContentValue_Value interface {
+type isAclContentValueValue interface {
-	isAclContentValue_Value()
+	isAclContentValueValue()
 	MarshalTo([]byte) (int, error)
 	Size() int
 }
@@ -1006,20 +1134,20 @@ type AclContentValue_RequestCancel struct {
 	RequestCancel *AclAccountRequestCancel `protobuf:"bytes,12,opt,name=requestCancel,proto3,oneof" json:"requestCancel,omitempty"`
 }
 
-func (*AclContentValue_Invite) isAclContentValue_Value()               {}
+func (*AclContentValue_Invite) isAclContentValueValue()               {}
-func (*AclContentValue_InviteRevoke) isAclContentValue_Value()         {}
+func (*AclContentValue_InviteRevoke) isAclContentValueValue()         {}
-func (*AclContentValue_RequestJoin) isAclContentValue_Value()          {}
+func (*AclContentValue_RequestJoin) isAclContentValueValue()          {}
-func (*AclContentValue_RequestAccept) isAclContentValue_Value()        {}
+func (*AclContentValue_RequestAccept) isAclContentValueValue()        {}
-func (*AclContentValue_PermissionChange) isAclContentValue_Value()     {}
+func (*AclContentValue_PermissionChange) isAclContentValueValue()     {}
-func (*AclContentValue_AccountRemove) isAclContentValue_Value()        {}
+func (*AclContentValue_AccountRemove) isAclContentValueValue()        {}
-func (*AclContentValue_ReadKeyChange) isAclContentValue_Value()        {}
+func (*AclContentValue_ReadKeyChange) isAclContentValueValue()        {}
-func (*AclContentValue_RequestDecline) isAclContentValue_Value()       {}
+func (*AclContentValue_RequestDecline) isAclContentValueValue()       {}
-func (*AclContentValue_AccountRequestRemove) isAclContentValue_Value() {}
+func (*AclContentValue_AccountRequestRemove) isAclContentValueValue() {}
-func (*AclContentValue_PermissionChanges) isAclContentValue_Value()    {}
+func (*AclContentValue_PermissionChanges) isAclContentValueValue()    {}
-func (*AclContentValue_AccountsAdd) isAclContentValue_Value()          {}
+func (*AclContentValue_AccountsAdd) isAclContentValueValue()          {}
-func (*AclContentValue_RequestCancel) isAclContentValue_Value()        {}
+func (*AclContentValue_RequestCancel) isAclContentValueValue()        {}
 
-func (m *AclContentValue) GetValue() isAclContentValue_Value {
+func (m *AclContentValue) GetValue() isAclContentValueValue {
 	if m != nil {
 		return m.Value
 	}
@@ -1154,6 +1282,14 @@ func (m *AclData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *AclData) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclData) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclData.Merge(m, src)
 }

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

@@ -94,6 +94,14 @@ func (m *RootChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *RootChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *RootChange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_RootChange.Merge(m, src)
 }
@@ -205,6 +213,14 @@ func (m *TreeChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *TreeChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TreeChange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TreeChange.Merge(m, src)
 }
@@ -321,6 +337,14 @@ func (m *NoDataTreeChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *NoDataTreeChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NoDataTreeChange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NoDataTreeChange.Merge(m, src)
 }
@@ -415,6 +439,14 @@ func (m *ReducedTreeChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *ReducedTreeChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *ReducedTreeChange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_ReducedTreeChange.Merge(m, src)
 }
@@ -463,6 +495,14 @@ func (m *RawTreeChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *RawTreeChange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *RawTreeChange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_RawTreeChange.Merge(m, src)
 }
@@ -518,6 +558,14 @@ func (m *RawTreeChangeWithId) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *RawTreeChangeWithId) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *RawTreeChangeWithId) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_RawTreeChangeWithId.Merge(m, src)
 }
@@ -570,6 +618,14 @@ func (m *TreeSyncMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *TreeSyncMessage) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TreeSyncMessage) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TreeSyncMessage.Merge(m, src)
 }
@@ -604,7 +660,7 @@ type TreeSyncContentValue struct {
 	//	*TreeSyncContentValue_FullSyncRequest
 	//	*TreeSyncContentValue_FullSyncResponse
 	//	*TreeSyncContentValue_ErrorResponse
-	Value isTreeSyncContentValue_Value `protobuf_oneof:"value"`
+	Value isTreeSyncContentValueValue `protobuf_oneof:"value"`
 }
 
 func (m *TreeSyncContentValue) Reset()         { *m = TreeSyncContentValue{} }
@@ -628,6 +684,14 @@ func (m *TreeSyncContentValue) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *TreeSyncContentValue) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TreeSyncContentValue) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TreeSyncContentValue.Merge(m, src)
 }
@@ -640,8 +704,8 @@ func (m *TreeSyncContentValue) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_TreeSyncContentValue proto.InternalMessageInfo
 
-type isTreeSyncContentValue_Value interface {
+type isTreeSyncContentValueValue interface {
-	isTreeSyncContentValue_Value()
+	isTreeSyncContentValueValue()
 	MarshalTo([]byte) (int, error)
 	Size() int
 }
@@ -659,12 +723,12 @@ type TreeSyncContentValue_ErrorResponse struct {
 	ErrorResponse *TreeErrorResponse `protobuf:"bytes,4,opt,name=errorResponse,proto3,oneof" json:"errorResponse,omitempty"`
 }
 
-func (*TreeSyncContentValue_HeadUpdate) isTreeSyncContentValue_Value()       {}
+func (*TreeSyncContentValue_HeadUpdate) isTreeSyncContentValueValue()       {}
-func (*TreeSyncContentValue_FullSyncRequest) isTreeSyncContentValue_Value()  {}
+func (*TreeSyncContentValue_FullSyncRequest) isTreeSyncContentValueValue()  {}
-func (*TreeSyncContentValue_FullSyncResponse) isTreeSyncContentValue_Value() {}
+func (*TreeSyncContentValue_FullSyncResponse) isTreeSyncContentValueValue() {}
-func (*TreeSyncContentValue_ErrorResponse) isTreeSyncContentValue_Value()    {}
+func (*TreeSyncContentValue_ErrorResponse) isTreeSyncContentValueValue()    {}
 
-func (m *TreeSyncContentValue) GetValue() isTreeSyncContentValue_Value {
+func (m *TreeSyncContentValue) GetValue() isTreeSyncContentValueValue {
 	if m != nil {
 		return m.Value
 	}
@@ -737,6 +801,14 @@ func (m *TreeHeadUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
+func (m *TreeHeadUpdate) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TreeHeadUpdate) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TreeHeadUpdate.Merge(m, src)
 }
@@ -798,6 +870,14 @@ func (m *TreeFullSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *TreeFullSyncRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TreeFullSyncRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TreeFullSyncRequest.Merge(m, src)
 }
@@ -859,6 +939,14 @@ func (m *TreeFullSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *TreeFullSyncResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TreeFullSyncResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TreeFullSyncResponse.Merge(m, src)
 }
@@ -919,6 +1007,14 @@ func (m *TreeErrorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *TreeErrorResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TreeErrorResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TreeErrorResponse.Merge(m, src)
 }
@@ -972,6 +1068,14 @@ func (m *TreeChangeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
+func (m *TreeChangeInfo) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TreeChangeInfo) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TreeChangeInfo.Merge(m, src)
 }

commonspace/spacesyncproto/spacesync.pb.go

@@ -149,6 +149,14 @@ func (m *HeadSyncRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *HeadSyncRange) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *HeadSyncRange) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_HeadSyncRange.Merge(m, src)
 }
@@ -217,6 +225,14 @@ func (m *HeadSyncResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
+func (m *HeadSyncResult) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *HeadSyncResult) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_HeadSyncResult.Merge(m, src)
 }
@@ -277,6 +293,14 @@ func (m *HeadSyncResultElement) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *HeadSyncResultElement) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *HeadSyncResultElement) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_HeadSyncResultElement.Merge(m, src)
 }
@@ -331,6 +355,14 @@ func (m *HeadSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *HeadSyncRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *HeadSyncRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_HeadSyncRequest.Merge(m, src)
 }
@@ -391,6 +423,14 @@ func (m *HeadSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *HeadSyncResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *HeadSyncResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_HeadSyncResponse.Merge(m, src)
 }
@@ -447,6 +487,14 @@ func (m *ObjectSyncMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *ObjectSyncMessage) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *ObjectSyncMessage) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_ObjectSyncMessage.Merge(m, src)
 }
@@ -521,6 +569,14 @@ func (m *SpacePushRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *SpacePushRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpacePushRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpacePushRequest.Merge(m, src)
 }
@@ -572,6 +628,14 @@ func (m *SpacePushResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *SpacePushResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpacePushResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpacePushResponse.Merge(m, src)
 }
@@ -610,6 +674,14 @@ func (m *SpacePullRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *SpacePullRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpacePullRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpacePullRequest.Merge(m, src)
 }
@@ -655,6 +727,14 @@ func (m *SpacePullResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *SpacePullResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpacePullResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpacePullResponse.Merge(m, src)
 }
@@ -704,6 +784,14 @@ func (m *SpacePayload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *SpacePayload) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpacePayload) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpacePayload.Merge(m, src)
 }
@@ -782,6 +870,14 @@ func (m *SpaceHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *SpaceHeader) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceHeader) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceHeader.Merge(m, src)
 }
@@ -863,6 +959,14 @@ func (m *RawSpaceHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
+func (m *RawSpaceHeader) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *RawSpaceHeader) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_RawSpaceHeader.Merge(m, src)
 }
@@ -916,6 +1020,14 @@ func (m *RawSpaceHeaderWithId) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *RawSpaceHeaderWithId) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *RawSpaceHeaderWithId) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_RawSpaceHeaderWithId.Merge(m, src)
 }
@@ -948,7 +1060,7 @@ type SpaceSettingsContent struct {
 	//
 	//	*SpaceSettingsContent_ObjectDelete
 	//	*SpaceSettingsContent_SpaceDelete
-	Value isSpaceSettingsContent_Value `protobuf_oneof:"value"`
+	Value isSpaceSettingsContentValue `protobuf_oneof:"value"`
 }
 
 func (m *SpaceSettingsContent) Reset()         { *m = SpaceSettingsContent{} }
@@ -972,6 +1084,14 @@ func (m *SpaceSettingsContent) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *SpaceSettingsContent) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceSettingsContent) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceSettingsContent.Merge(m, src)
 }
@@ -984,8 +1104,8 @@ func (m *SpaceSettingsContent) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_SpaceSettingsContent proto.InternalMessageInfo
 
-type isSpaceSettingsContent_Value interface {
+type isSpaceSettingsContentValue interface {
-	isSpaceSettingsContent_Value()
+	isSpaceSettingsContentValue()
 	MarshalTo([]byte) (int, error)
 	Size() int
 }
@@ -997,10 +1117,10 @@ type SpaceSettingsContent_SpaceDelete struct {
 	SpaceDelete *SpaceDelete `protobuf:"bytes,2,opt,name=spaceDelete,proto3,oneof" json:"spaceDelete,omitempty"`
 }
 
-func (*SpaceSettingsContent_ObjectDelete) isSpaceSettingsContent_Value() {}
+func (*SpaceSettingsContent_ObjectDelete) isSpaceSettingsContentValue() {}
-func (*SpaceSettingsContent_SpaceDelete) isSpaceSettingsContent_Value()  {}
+func (*SpaceSettingsContent_SpaceDelete) isSpaceSettingsContentValue()  {}
 
-func (m *SpaceSettingsContent) GetValue() isSpaceSettingsContent_Value {
+func (m *SpaceSettingsContent) GetValue() isSpaceSettingsContentValue {
 	if m != nil {
 		return m.Value
 	}
@@ -1055,6 +1175,14 @@ func (m *ObjectDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *ObjectDelete) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *ObjectDelete) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_ObjectDelete.Merge(m, src)
 }
@@ -1100,6 +1228,14 @@ func (m *SpaceDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *SpaceDelete) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceDelete) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceDelete.Merge(m, src)
 }
@@ -1146,6 +1282,14 @@ func (m *SpaceSettingsSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *SpaceSettingsSnapshot) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceSettingsSnapshot) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceSettingsSnapshot.Merge(m, src)
 }
@@ -1199,6 +1343,14 @@ func (m *SettingsData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *SettingsData) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SettingsData) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SettingsData.Merge(m, src)
 }
@@ -1251,6 +1403,14 @@ func (m *SpaceSubscription) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *SpaceSubscription) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceSubscription) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceSubscription.Merge(m, src)
 }
@@ -1304,6 +1464,14 @@ func (m *AclAddRecordRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *AclAddRecordRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAddRecordRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAddRecordRequest.Merge(m, src)
 }
@@ -1357,6 +1525,14 @@ func (m *AclAddRecordResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *AclAddRecordResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAddRecordResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAddRecordResponse.Merge(m, src)
 }
@@ -1411,6 +1587,14 @@ func (m *AclGetRecordsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *AclGetRecordsRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclGetRecordsRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclGetRecordsRequest.Merge(m, src)
 }
@@ -1463,6 +1647,14 @@ func (m *AclGetRecordsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *AclGetRecordsResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclGetRecordsResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclGetRecordsResponse.Merge(m, src)
 }

commonspace/sync/synctestproto/synctest.pb.go

@@ -48,6 +48,14 @@ func (m *CounterIncrease) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *CounterIncrease) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *CounterIncrease) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CounterIncrease.Merge(m, src)
 }
@@ -100,6 +108,14 @@ func (m *CounterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
+func (m *CounterRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *CounterRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CounterRequest.Merge(m, src)
 }

consensus/consensusproto/consensus.pb.go

@@ -88,6 +88,14 @@ func (m *Log) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Log) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Log) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Log.Merge(m, src)
 }
@@ -144,6 +152,14 @@ func (m *RawRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *RawRecord) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *RawRecord) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_RawRecord.Merge(m, src)
 }
@@ -218,6 +234,14 @@ func (m *RawRecordWithId) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *RawRecordWithId) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *RawRecordWithId) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_RawRecordWithId.Merge(m, src)
 }
@@ -273,6 +297,14 @@ func (m *Record) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Record) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Record) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Record.Merge(m, src)
 }
@@ -337,6 +369,14 @@ func (m *Ok) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Ok) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Ok) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Ok.Merge(m, src)
 }
@@ -376,6 +416,14 @@ func (m *LogAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *LogAddRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogAddRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogAddRequest.Merge(m, src)
 }
@@ -428,6 +476,14 @@ func (m *RecordAddRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *RecordAddRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *RecordAddRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_RecordAddRequest.Merge(m, src)
 }
@@ -480,6 +536,14 @@ func (m *LogWatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *LogWatchRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogWatchRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogWatchRequest.Merge(m, src)
 }
@@ -533,6 +597,14 @@ func (m *LogWatchEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *LogWatchEvent) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogWatchEvent) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogWatchEvent.Merge(m, src)
 }
@@ -591,6 +663,14 @@ func (m *LogDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *LogDeleteRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogDeleteRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogDeleteRequest.Merge(m, src)
 }
@@ -635,6 +715,14 @@ func (m *Err) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Err) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Err) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Err.Merge(m, src)
 }
@@ -661,7 +749,7 @@ type LogSyncContentValue struct {
 	//	*LogSyncContentValue_HeadUpdate
 	//	*LogSyncContentValue_FullSyncRequest
 	//	*LogSyncContentValue_FullSyncResponse
-	Value isLogSyncContentValue_Value `protobuf_oneof:"value"`
+	Value isLogSyncContentValueValue `protobuf_oneof:"value"`
 }
 
 func (m *LogSyncContentValue) Reset()         { *m = LogSyncContentValue{} }
@@ -685,6 +773,14 @@ func (m *LogSyncContentValue) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *LogSyncContentValue) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogSyncContentValue) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogSyncContentValue.Merge(m, src)
 }
@@ -697,8 +793,8 @@ func (m *LogSyncContentValue) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_LogSyncContentValue proto.InternalMessageInfo
 
-type isLogSyncContentValue_Value interface {
+type isLogSyncContentValueValue interface {
-	isLogSyncContentValue_Value()
+	isLogSyncContentValueValue()
 	MarshalTo([]byte) (int, error)
 	Size() int
 }
@@ -713,11 +809,11 @@ type LogSyncContentValue_FullSyncResponse struct {
 	FullSyncResponse *LogFullSyncResponse `protobuf:"bytes,3,opt,name=fullSyncResponse,proto3,oneof" json:"fullSyncResponse,omitempty"`
 }
 
-func (*LogSyncContentValue_HeadUpdate) isLogSyncContentValue_Value()       {}
+func (*LogSyncContentValue_HeadUpdate) isLogSyncContentValueValue()       {}
-func (*LogSyncContentValue_FullSyncRequest) isLogSyncContentValue_Value()  {}
+func (*LogSyncContentValue_FullSyncRequest) isLogSyncContentValueValue()  {}
-func (*LogSyncContentValue_FullSyncResponse) isLogSyncContentValue_Value() {}
+func (*LogSyncContentValue_FullSyncResponse) isLogSyncContentValueValue() {}
 
-func (m *LogSyncContentValue) GetValue() isLogSyncContentValue_Value {
+func (m *LogSyncContentValue) GetValue() isLogSyncContentValueValue {
 	if m != nil {
 		return m.Value
 	}
@@ -782,6 +878,14 @@ func (m *LogSyncMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
+func (m *LogSyncMessage) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogSyncMessage) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogSyncMessage.Merge(m, src)
 }
@@ -842,6 +946,14 @@ func (m *LogHeadUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *LogHeadUpdate) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogHeadUpdate) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogHeadUpdate.Merge(m, src)
 }
@@ -895,6 +1007,14 @@ func (m *LogFullSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *LogFullSyncRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogFullSyncRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogFullSyncRequest.Merge(m, src)
 }
@@ -948,6 +1068,14 @@ func (m *LogFullSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *LogFullSyncResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *LogFullSyncResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_LogFullSyncResponse.Merge(m, src)
 }

coordinator/coordinatorproto/coordinator.pb.go

@@ -276,6 +276,14 @@ func (m *SpaceSignRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *SpaceSignRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceSignRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceSignRequest.Merge(m, src)
 }
@@ -349,6 +357,14 @@ func (m *SpaceLimits) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *SpaceLimits) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceLimits) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceLimits.Merge(m, src)
 }
@@ -404,6 +420,14 @@ func (m *SpaceStatusPayload) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *SpaceStatusPayload) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceStatusPayload) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceStatusPayload.Merge(m, src)
 }
@@ -476,6 +500,14 @@ func (m *SpaceSignResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *SpaceSignResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceSignResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceSignResponse.Merge(m, src)
 }
@@ -522,6 +554,14 @@ func (m *SpaceReceiptWithSignature) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
+func (m *SpaceReceiptWithSignature) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceReceiptWithSignature) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceReceiptWithSignature.Merge(m, src)
 }
@@ -583,6 +623,14 @@ func (m *SpaceReceipt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *SpaceReceipt) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceReceipt) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceReceipt.Merge(m, src)
 }
@@ -656,6 +704,14 @@ func (m *SpaceStatusCheckRequest) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return b[:n], nil
 	}
 }
+func (m *SpaceStatusCheckRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceStatusCheckRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceStatusCheckRequest.Merge(m, src)
 }
@@ -701,6 +757,14 @@ func (m *SpaceStatusCheckResponse) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
+func (m *SpaceStatusCheckResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceStatusCheckResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceStatusCheckResponse.Merge(m, src)
 }
@@ -746,6 +810,14 @@ func (m *SpaceStatusCheckManyRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *SpaceStatusCheckManyRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceStatusCheckManyRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceStatusCheckManyRequest.Merge(m, src)
 }
@@ -792,6 +864,14 @@ func (m *SpaceStatusCheckManyResponse) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *SpaceStatusCheckManyResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceStatusCheckManyResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceStatusCheckManyResponse.Merge(m, src)
 }
@@ -844,6 +924,14 @@ func (m *AccountLimits) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *AccountLimits) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountLimits) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountLimits.Merge(m, src)
 }
@@ -892,6 +980,14 @@ func (m *SpaceStatusChangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
+func (m *SpaceStatusChangeRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceStatusChangeRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceStatusChangeRequest.Merge(m, src)
 }
@@ -958,6 +1054,14 @@ func (m *SpaceStatusChangeResponse) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
+func (m *SpaceStatusChangeResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceStatusChangeResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceStatusChangeResponse.Merge(m, src)
 }
@@ -1002,6 +1106,14 @@ func (m *SpaceMakeShareableRequest) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
+func (m *SpaceMakeShareableRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceMakeShareableRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceMakeShareableRequest.Merge(m, src)
 }
@@ -1045,6 +1157,14 @@ func (m *SpaceMakeShareableResponse) XXX_Marshal(b []byte, deterministic bool) (
 		return b[:n], nil
 	}
 }
+func (m *SpaceMakeShareableResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceMakeShareableResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceMakeShareableResponse.Merge(m, src)
 }
@@ -1083,6 +1203,14 @@ func (m *SpaceMakeUnshareableRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *SpaceMakeUnshareableRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceMakeUnshareableRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceMakeUnshareableRequest.Merge(m, src)
 }
@@ -1133,6 +1261,14 @@ func (m *SpaceMakeUnshareableResponse) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *SpaceMakeUnshareableResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceMakeUnshareableResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceMakeUnshareableResponse.Merge(m, src)
 }
@@ -1173,6 +1309,14 @@ func (m *NetworkConfigurationRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *NetworkConfigurationRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NetworkConfigurationRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NetworkConfigurationRequest.Merge(m, src)
 }
@@ -1225,6 +1369,14 @@ func (m *NetworkConfigurationResponse) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *NetworkConfigurationResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NetworkConfigurationResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NetworkConfigurationResponse.Merge(m, src)
 }
@@ -1296,6 +1448,14 @@ func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Node) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Node) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Node.Merge(m, src)
 }
@@ -1356,6 +1516,14 @@ func (m *DeletionConfirmPayloadWithSignature) XXX_Marshal(b []byte, deterministi
 		return b[:n], nil
 	}
 }
+func (m *DeletionConfirmPayloadWithSignature) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DeletionConfirmPayloadWithSignature) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DeletionConfirmPayloadWithSignature.Merge(m, src)
 }
@@ -1417,6 +1585,14 @@ func (m *DeletionConfirmPayload) XXX_Marshal(b []byte, deterministic bool) ([]by
 		return b[:n], nil
 	}
 }
+func (m *DeletionConfirmPayload) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DeletionConfirmPayload) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DeletionConfirmPayload.Merge(m, src)
 }
@@ -1492,6 +1668,14 @@ func (m *DeletionLogRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *DeletionLogRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DeletionLogRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DeletionLogRequest.Merge(m, src)
 }
@@ -1546,6 +1730,14 @@ func (m *DeletionLogResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *DeletionLogResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DeletionLogResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DeletionLogResponse.Merge(m, src)
 }
@@ -1606,6 +1798,14 @@ func (m *DeletionLogRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *DeletionLogRecord) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DeletionLogRecord) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DeletionLogRecord.Merge(m, src)
 }
@@ -1682,6 +1882,14 @@ func (m *SpaceDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *SpaceDeleteRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceDeleteRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceDeleteRequest.Merge(m, src)
 }
@@ -1748,6 +1956,14 @@ func (m *SpaceDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *SpaceDeleteResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *SpaceDeleteResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_SpaceDeleteResponse.Merge(m, src)
 }
@@ -1794,6 +2010,14 @@ func (m *AccountDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *AccountDeleteRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountDeleteRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountDeleteRequest.Merge(m, src)
 }
@@ -1853,6 +2077,14 @@ func (m *AccountDeletionConfirmPayload) XXX_Marshal(b []byte, deterministic bool
 		return b[:n], nil
 	}
 }
+func (m *AccountDeletionConfirmPayload) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountDeletionConfirmPayload) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountDeletionConfirmPayload.Merge(m, src)
 }
@@ -1919,6 +2151,14 @@ func (m *AccountDeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *AccountDeleteResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountDeleteResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountDeleteResponse.Merge(m, src)
 }
@@ -1963,6 +2203,14 @@ func (m *AccountRevertDeletionRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *AccountRevertDeletionRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountRevertDeletionRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountRevertDeletionRequest.Merge(m, src)
 }
@@ -2000,6 +2248,14 @@ func (m *AccountRevertDeletionResponse) XXX_Marshal(b []byte, deterministic bool
 		return b[:n], nil
 	}
 }
+func (m *AccountRevertDeletionResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountRevertDeletionResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountRevertDeletionResponse.Merge(m, src)
 }
@@ -2039,6 +2295,14 @@ func (m *AclAddRecordRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *AclAddRecordRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAddRecordRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAddRecordRequest.Merge(m, src)
 }
@@ -2092,6 +2356,14 @@ func (m *AclAddRecordResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *AclAddRecordResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclAddRecordResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclAddRecordResponse.Merge(m, src)
 }
@@ -2146,6 +2418,14 @@ func (m *AclGetRecordsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *AclGetRecordsRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclGetRecordsRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclGetRecordsRequest.Merge(m, src)
 }
@@ -2198,6 +2478,14 @@ func (m *AclGetRecordsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *AclGetRecordsResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AclGetRecordsResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AclGetRecordsResponse.Merge(m, src)
 }
@@ -2247,6 +2535,14 @@ func (m *AccountLimitsSetRequest) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return b[:n], nil
 	}
 }
+func (m *AccountLimitsSetRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountLimitsSetRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountLimitsSetRequest.Merge(m, src)
 }
@@ -2325,6 +2621,14 @@ func (m *AccountLimitsSetResponse) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
+func (m *AccountLimitsSetResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AccountLimitsSetResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AccountLimitsSetResponse.Merge(m, src)
 }

go.mod

@@ -100,3 +100,5 @@ require (
 	google.golang.org/protobuf v1.33.0 // indirect
 	lukechampine.com/blake3 v1.2.1 // indirect
 )
+
+replace github.com/gogo/protobuf => github.com/anyproto/protobuf v1.3.3-0.20240715193215-a93dfa8960ec

go.sum

@@ -12,6 +12,8 @@ github.com/anyproto/go-slip10 v1.0.0 h1:uAEtSuudR3jJBOfkOXf3bErxVoxbuKwdoJN55M1i
 github.com/anyproto/go-slip10 v1.0.0/go.mod h1:BCmIlM1KB8wX6K4/8pOvxPl9oVKfEvZ5vsmO5rkK6vg=
 github.com/anyproto/go-slip21 v1.0.0 h1:CI7lUqTIwmPOEGVAj4jyNLoICvueh++0U2HoAi3m2ZY=
 github.com/anyproto/go-slip21 v1.0.0/go.mod h1:gbIJt7HAdr5DuT4f2pFTKCBSUWYsm/fysHBNqgsuxT0=
+github.com/anyproto/protobuf v1.3.3-0.20240715193215-a93dfa8960ec h1:rgT7SEusQCNhehj4r9De3fx6rIpNsXDpH4J4OFbReWQ=
+github.com/anyproto/protobuf v1.3.3-0.20240715193215-a93dfa8960ec/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 github.com/benbjohnson/clock v1.3.5 h1:VvXlSJBzZpA/zum6Sj74hxwYI2DIxRWuNIoXAzHZz5o=
 github.com/benbjohnson/clock v1.3.5/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
@@ -75,8 +77,6 @@ github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
 github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 github.com/goccy/go-graphviz v0.1.2 h1:sWSJ6w13BCm/ZOUTHDVrdvbsxqN8yyzaFcHrH/hQ9Yg=
 github.com/goccy/go-graphviz v0.1.2/go.mod h1:pMYpbAqJT10V8dzV1JN/g/wUlG/0imKPzn3ZsrchGCI=
-github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
-github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 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/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=

identityrepo/identityrepoproto/identityrepo.pb.go

@@ -52,6 +52,14 @@ func (m *Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Data) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Data) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Data.Merge(m, src)
 }
@@ -111,6 +119,14 @@ func (m *DataWithIdentity) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *DataWithIdentity) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DataWithIdentity) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DataWithIdentity.Merge(m, src)
 }
@@ -165,6 +181,14 @@ func (m *DataPutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, erro
 		return b[:n], nil
 	}
 }
+func (m *DataPutRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DataPutRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DataPutRequest.Merge(m, src)
 }
@@ -219,6 +243,14 @@ func (m *DataDeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *DataDeleteRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DataDeleteRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DataDeleteRequest.Merge(m, src)
 }
@@ -273,6 +305,14 @@ func (m *DataPullRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *DataPullRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DataPullRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DataPullRequest.Merge(m, src)
 }
@@ -324,6 +364,14 @@ func (m *DataPullResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *DataPullResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *DataPullResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_DataPullResponse.Merge(m, src)
 }
@@ -367,6 +415,14 @@ func (m *Ok) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Ok) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Ok) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Ok.Merge(m, src)
 }

nameservice/nameserviceproto/nameservice.pb.go

@@ -48,6 +48,14 @@ func (m *NameAvailableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *NameAvailableRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NameAvailableRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NameAvailableRequest.Merge(m, src)
 }
@@ -93,6 +101,14 @@ func (m *BatchNameAvailableRequest) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
+func (m *BatchNameAvailableRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BatchNameAvailableRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BatchNameAvailableRequest.Merge(m, src)
 }
@@ -139,6 +155,14 @@ func (m *NameByAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *NameByAddressRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NameByAddressRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NameByAddressRequest.Merge(m, src)
 }
@@ -185,6 +209,14 @@ func (m *BatchNameByAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
+func (m *BatchNameByAddressRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BatchNameByAddressRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BatchNameByAddressRequest.Merge(m, src)
 }
@@ -229,6 +261,14 @@ func (m *NameByAnyIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *NameByAnyIdRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NameByAnyIdRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NameByAnyIdRequest.Merge(m, src)
 }
@@ -273,6 +313,14 @@ func (m *BatchNameByAnyIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return b[:n], nil
 	}
 }
+func (m *BatchNameByAnyIdRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BatchNameByAnyIdRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BatchNameByAnyIdRequest.Merge(m, src)
 }
@@ -331,6 +379,14 @@ func (m *NameAvailableResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *NameAvailableResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NameAvailableResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NameAvailableResponse.Merge(m, src)
 }
@@ -410,6 +466,14 @@ func (m *BatchNameAvailableResponse) XXX_Marshal(b []byte, deterministic bool) (
 		return b[:n], nil
 	}
 }
+func (m *BatchNameAvailableResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BatchNameAvailableResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BatchNameAvailableResponse.Merge(m, src)
 }
@@ -455,6 +519,14 @@ func (m *NameByAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *NameByAddressResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NameByAddressResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NameByAddressResponse.Merge(m, src)
 }
@@ -506,6 +578,14 @@ func (m *BatchNameByAddressResponse) XXX_Marshal(b []byte, deterministic bool) (
 		return b[:n], nil
 	}
 }
+func (m *BatchNameByAddressResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BatchNameByAddressResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BatchNameByAddressResponse.Merge(m, src)
 }

nameservice/nameserviceproto/nameservice_aa.pb.go

@@ -94,6 +94,14 @@ func (m *UserAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *UserAccount) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *UserAccount) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_UserAccount.Merge(m, src)
 }
@@ -170,6 +178,14 @@ func (m *AdminFundUserAccountRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *AdminFundUserAccountRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AdminFundUserAccountRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AdminFundUserAccountRequest.Merge(m, src)
 }
@@ -224,6 +240,14 @@ func (m *AdminFundUserAccountRequestSigned) XXX_Marshal(b []byte, deterministic
 		return b[:n], nil
 	}
 }
+func (m *AdminFundUserAccountRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AdminFundUserAccountRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AdminFundUserAccountRequestSigned.Merge(m, src)
 }
@@ -279,6 +303,14 @@ func (m *AdminFundGasOperationsRequest) XXX_Marshal(b []byte, deterministic bool
 		return b[:n], nil
 	}
 }
+func (m *AdminFundGasOperationsRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AdminFundGasOperationsRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AdminFundGasOperationsRequest.Merge(m, src)
 }
@@ -340,6 +372,14 @@ func (m *AdminFundGasOperationsRequestSigned) XXX_Marshal(b []byte, deterministi
 		return b[:n], nil
 	}
 }
+func (m *AdminFundGasOperationsRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *AdminFundGasOperationsRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_AdminFundGasOperationsRequestSigned.Merge(m, src)
 }
@@ -393,6 +433,14 @@ func (m *GetUserAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *GetUserAccountRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetUserAccountRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetUserAccountRequest.Merge(m, src)
 }
@@ -438,6 +486,14 @@ func (m *GetDataNameRegisterResponse) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *GetDataNameRegisterResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetDataNameRegisterResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetDataNameRegisterResponse.Merge(m, src)
 }
@@ -499,6 +555,14 @@ func (m *CreateUserOperationRequest) XXX_Marshal(b []byte, deterministic bool) (
 		return b[:n], nil
 	}
 }
+func (m *CreateUserOperationRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *CreateUserOperationRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CreateUserOperationRequest.Merge(m, src)
 }
@@ -581,6 +645,14 @@ func (m *CreateUserOperationRequestSigned) XXX_Marshal(b []byte, deterministic b
 		return b[:n], nil
 	}
 }
+func (m *CreateUserOperationRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *CreateUserOperationRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_CreateUserOperationRequestSigned.Merge(m, src)
 }
@@ -644,6 +716,14 @@ func (m *NameRegisterRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *NameRegisterRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NameRegisterRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NameRegisterRequest.Merge(m, src)
 }
@@ -719,6 +799,14 @@ func (m *NameRegisterRequestSigned) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
+func (m *NameRegisterRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NameRegisterRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NameRegisterRequestSigned.Merge(m, src)
 }
@@ -781,6 +869,14 @@ func (m *NameRegisterForSpaceRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *NameRegisterForSpaceRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *NameRegisterForSpaceRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_NameRegisterForSpaceRequest.Merge(m, src)
 }
@@ -853,6 +949,14 @@ func (m *GetOperationStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([
 		return b[:n], nil
 	}
 }
+func (m *GetOperationStatusRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetOperationStatusRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetOperationStatusRequest.Merge(m, src)
 }
@@ -898,6 +1002,14 @@ func (m *OperationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, e
 		return b[:n], nil
 	}
 }
+func (m *OperationResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *OperationResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_OperationResponse.Merge(m, src)
 }

net/secureservice/handshake/handshakeproto/handshake.pb.go

@@ -142,6 +142,14 @@ func (m *Credentials) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
 		return b[:n], nil
 	}
 }
+func (m *Credentials) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Credentials) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Credentials.Merge(m, src)
 }
@@ -210,6 +218,14 @@ func (m *PayloadSignedPeerIds) XXX_Marshal(b []byte, deterministic bool) ([]byte
 		return b[:n], nil
 	}
 }
+func (m *PayloadSignedPeerIds) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *PayloadSignedPeerIds) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PayloadSignedPeerIds.Merge(m, src)
 }
@@ -261,6 +277,14 @@ func (m *Ack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Ack) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Ack) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Ack.Merge(m, src)
 }
@@ -305,6 +329,14 @@ func (m *Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Proto) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Proto) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Proto.Merge(m, src)
 }

net/streampool/encoding.go

@@ -42,6 +42,21 @@ func (p protoEncoding) Marshal(msg drpc.Message) (res []byte, err error) {
 	return proto.Marshal(pmsg)
 }
 
+func (p protoEncoding) MarshalAppend(buf []byte, msg drpc.Message) (res []byte, err error) {
+	pmsg, ok := msg.(proto.Message)
+	if !ok {
+		if pmg, ok := msg.(ProtoMessageGettable); ok {
+			pmsg, err = pmg.ProtoMessage()
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			return nil, errNotAProtoMsg
+		}
+	}
+	return proto.MarshalAppend(buf, pmsg)
+}
+
 func (p protoEncoding) Unmarshal(buf []byte, msg drpc.Message) (err error) {
 	var pms ProtoMessageSettable
 	pmsg, ok := msg.(proto.Message)

net/streampool/testservice/testservice.pb.go

@@ -47,6 +47,14 @@ func (m *StreamMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
 		return b[:n], nil
 	}
 }
+func (m *StreamMessage) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *StreamMessage) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_StreamMessage.Merge(m, src)
 }

paymentservice/paymentserviceproto/paymentservice.pb.go

@@ -301,6 +301,14 @@ func (m *GetSubscriptionRequest) XXX_Marshal(b []byte, deterministic bool) ([]by
 		return b[:n], nil
 	}
 }
+func (m *GetSubscriptionRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetSubscriptionRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetSubscriptionRequest.Merge(m, src)
 }
@@ -348,6 +356,14 @@ func (m *GetSubscriptionRequestSigned) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *GetSubscriptionRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetSubscriptionRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetSubscriptionRequestSigned.Merge(m, src)
 }
@@ -409,6 +425,14 @@ func (m *GetSubscriptionResponse) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return b[:n], nil
 	}
 }
+func (m *GetSubscriptionResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetSubscriptionResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetSubscriptionResponse.Merge(m, src)
 }
@@ -524,6 +548,14 @@ func (m *BuySubscriptionRequest) XXX_Marshal(b []byte, deterministic bool) ([]by
 		return b[:n], nil
 	}
 }
+func (m *BuySubscriptionRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BuySubscriptionRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BuySubscriptionRequest.Merge(m, src)
 }
@@ -606,6 +638,14 @@ func (m *BuySubscriptionRequestSigned) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *BuySubscriptionRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BuySubscriptionRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BuySubscriptionRequestSigned.Merge(m, src)
 }
@@ -661,6 +701,14 @@ func (m *BuySubscriptionResponse) XXX_Marshal(b []byte, deterministic bool) ([]b
 		return b[:n], nil
 	}
 }
+func (m *BuySubscriptionResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *BuySubscriptionResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BuySubscriptionResponse.Merge(m, src)
 }
@@ -721,6 +769,14 @@ func (m *FinalizeSubscriptionRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *FinalizeSubscriptionRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FinalizeSubscriptionRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FinalizeSubscriptionRequest.Merge(m, src)
 }
@@ -778,6 +834,14 @@ func (m *FinalizeSubscriptionResponse) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *FinalizeSubscriptionResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FinalizeSubscriptionResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FinalizeSubscriptionResponse.Merge(m, src)
 }
@@ -818,6 +882,14 @@ func (m *FinalizeSubscriptionRequestSigned) XXX_Marshal(b []byte, deterministic
 		return b[:n], nil
 	}
 }
+func (m *FinalizeSubscriptionRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *FinalizeSubscriptionRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FinalizeSubscriptionRequestSigned.Merge(m, src)
 }
@@ -871,6 +943,14 @@ func (m *GetSubscriptionPortalLinkRequest) XXX_Marshal(b []byte, deterministic b
 		return b[:n], nil
 	}
 }
+func (m *GetSubscriptionPortalLinkRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetSubscriptionPortalLinkRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetSubscriptionPortalLinkRequest.Merge(m, src)
 }
@@ -920,6 +1000,14 @@ func (m *GetSubscriptionPortalLinkRequestSigned) XXX_Marshal(b []byte, determini
 		return b[:n], nil
 	}
 }
+func (m *GetSubscriptionPortalLinkRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetSubscriptionPortalLinkRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetSubscriptionPortalLinkRequestSigned.Merge(m, src)
 }
@@ -971,6 +1059,14 @@ func (m *GetSubscriptionPortalLinkResponse) XXX_Marshal(b []byte, deterministic
 		return b[:n], nil
 	}
 }
+func (m *GetSubscriptionPortalLinkResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetSubscriptionPortalLinkResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetSubscriptionPortalLinkResponse.Merge(m, src)
 }
@@ -1019,6 +1115,14 @@ func (m *GetVerificationEmailRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *GetVerificationEmailRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetVerificationEmailRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetVerificationEmailRequest.Merge(m, src)
 }
@@ -1076,6 +1180,14 @@ func (m *GetVerificationEmailResponse) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *GetVerificationEmailResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetVerificationEmailResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetVerificationEmailResponse.Merge(m, src)
 }
@@ -1116,6 +1228,14 @@ func (m *GetVerificationEmailRequestSigned) XXX_Marshal(b []byte, deterministic
 		return b[:n], nil
 	}
 }
+func (m *GetVerificationEmailRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetVerificationEmailRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetVerificationEmailRequestSigned.Merge(m, src)
 }
@@ -1176,6 +1296,14 @@ func (m *VerifyEmailRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *VerifyEmailRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *VerifyEmailRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_VerifyEmailRequest.Merge(m, src)
 }
@@ -1234,6 +1362,14 @@ func (m *VerifyEmailResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *VerifyEmailResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *VerifyEmailResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_VerifyEmailResponse.Merge(m, src)
 }
@@ -1281,6 +1417,14 @@ func (m *VerifyEmailRequestSigned) XXX_Marshal(b []byte, deterministic bool) ([]
 		return b[:n], nil
 	}
 }
+func (m *VerifyEmailRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *VerifyEmailRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_VerifyEmailRequestSigned.Merge(m, src)
 }
@@ -1333,6 +1477,14 @@ func (m *IsNameValidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *IsNameValidRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *IsNameValidRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_IsNameValidRequest.Merge(m, src)
 }
@@ -1385,6 +1537,14 @@ func (m *IsNameValidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
+func (m *IsNameValidResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *IsNameValidResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_IsNameValidResponse.Merge(m, src)
 }
@@ -1440,6 +1600,14 @@ func (m *VerifyAppStoreReceiptRequest) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
+func (m *VerifyAppStoreReceiptRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *VerifyAppStoreReceiptRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_VerifyAppStoreReceiptRequest.Merge(m, src)
 }
@@ -1494,6 +1662,14 @@ func (m *VerifyAppStoreReceiptRequestSigned) XXX_Marshal(b []byte, deterministic
 		return b[:n], nil
 	}
 }
+func (m *VerifyAppStoreReceiptRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *VerifyAppStoreReceiptRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_VerifyAppStoreReceiptRequestSigned.Merge(m, src)
 }
@@ -1544,6 +1720,14 @@ func (m *VerifyAppStoreReceiptResponse) XXX_Marshal(b []byte, deterministic bool
 		return b[:n], nil
 	}
 }
+func (m *VerifyAppStoreReceiptResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *VerifyAppStoreReceiptResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_VerifyAppStoreReceiptResponse.Merge(m, src)
 }

paymentservice/paymentserviceproto/paymentservice_tiers.pb.go

@@ -84,6 +84,14 @@ func (m *Feature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Feature) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Feature) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Feature.Merge(m, src)
 }
@@ -131,6 +139,14 @@ func (m *GetTiersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
 		return b[:n], nil
 	}
 }
+func (m *GetTiersRequest) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetTiersRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetTiersRequest.Merge(m, src)
 }
@@ -185,6 +201,14 @@ func (m *GetTiersRequestSigned) XXX_Marshal(b []byte, deterministic bool) ([]byt
 		return b[:n], nil
 	}
 }
+func (m *GetTiersRequestSigned) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetTiersRequestSigned) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetTiersRequestSigned.Merge(m, src)
 }
@@ -274,6 +298,14 @@ func (m *TierData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *TierData) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *TierData) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_TierData.Merge(m, src)
 }
@@ -445,6 +477,14 @@ func (m *GetTiersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
+func (m *GetTiersResponse) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *GetTiersResponse) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_GetTiersResponse.Merge(m, src)
 }

util/crypto/cryptoproto/crypto.pb.go

@@ -76,6 +76,14 @@ func (m *Key) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
+func (m *Key) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
+	b = b[:newLen]
+	_, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
 func (m *Key) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Key.Merge(m, src)
 }