diff --git a/client/src/components/ConversationList.js b/client/src/components/ConversationList.js
index 6806781..1c8e3e0 100644
--- a/client/src/components/ConversationList.js
+++ b/client/src/components/ConversationList.js
@@ -1,13 +1,19 @@
 import List from '@mui/material/List'
-import React from 'react'
+import React, { useEffect } from "react";
 import ConversationListItem from './ConversationListItem'
 import ListSubheader from '@mui/material/ListSubheader';
 import Conversation from '../../../model/Conversation';
 import { GroupRounded as GroupIcon } from '@mui/icons-material';
 import Typography from '@mui/material/Typography';
+import { useAppSelector } from '../../redux/hooks';
 
 export default function ConversationList(props) {
-    console.log(props)
+     const { refresh } = useAppSelector((state) => state.app);
+
+     useEffect(() => {
+      console.log("refresh list");
+    }, [refresh]);
+
     return (
         <div className="rooms-list">
             <List>
diff --git a/client/src/components/ConversationListItem.js b/client/src/components/ConversationListItem.js
index 4616da6..36932bf 100644
--- a/client/src/components/ConversationListItem.js
+++ b/client/src/components/ConversationListItem.js
@@ -1,18 +1,18 @@
 import React, { useEffect } from 'react';
-import ReactDOM from 'react-dom';
 import Modal from 'react-modal';
 import authManager from '../AuthManager'
 import ConversationAvatar from './ConversationAvatar'
 import Conversation from '../../../model/Conversation'
 import React, { useState } from "react";
 import { useNavigate, useParams } from "react-router-dom"
-import { Person } from "@mui/icons-material";
 import { ListItem, ListItemAvatar, ListItemText, Box, Typography } from '@mui/material'
-import { Button, Stack, Switch, ThemeProvider, Typography, Modal as ModalUM } from "@mui/material"
+import { Button, Stack, Typography, Modal as ModalUM } from "@mui/material"
 import { RemoveContactIcon, VideoCallIcon } from './svgIcons';
 import { AudioCallIcon, BlockContactIcon, ContactDetailsIcon, CrossIcon, MessageIcon } from './svgIcons';
-import { styled } from "@mui/material/styles";
-import {QRCodeSVG, QRCodeCanvas} from 'qrcode.react';
+import { QRCodeCanvas} from 'qrcode.react';
+import { setRefreshFromSlice } from '../../redux/appSlice';
+import { useAppDispatch } from '../../redux/hooks';
+
 
 const customStyles = {
   content: {
@@ -88,13 +88,9 @@
 
 export default function ConversationListItem(props) {
   const { conversationId, contactId } = useParams();
+  const dispatch = useAppDispatch();
+
   const conversation = props.conversation;
-  console.log(
-    "XXX",
-    conversation,
-    conversation.id,
-    conversation.getAccountId()
-  );
 
   const pathId = conversationId || contactId;
   const isSelected = conversation.getDisplayUri() === pathId;
@@ -105,7 +101,7 @@
   const [modalDeleteIsOpen, setModalDeleteIsOpen] = useState(false);
   const [blockOrRemove, setBlockOrRemove] = useState(true);
   const [userId, setUserId] = useState(
-    conversation.getFirstMember().contact.getUri()
+    conversation?.getFirstMember()?.contact.getUri()
   );
   const [isSwarm, setIsSwarm] = useState("true");
 
@@ -158,16 +154,16 @@
         }
       )
       .then((res) => res.json())
-      .then((result) => {})
-      .catch((e) => console.log(`ERROR ${typeOfRemove}ing CONTACT : `, e));
+      .then((result) => {
+        console.log("propre");
+        dispatch(setRefreshFromSlice());
+      })
+      .catch((e) => {
+        console.log(`ERROR ${typeOfRemove}ing CONTACT : `, e);
+        dispatch(setRefreshFromSlice());
+      });
     closeModalDelete();
-    setRefresh(!refresh)
   };
-  const [refresh, setRefresh] = useState(true)
-
-  useEffect(() => {
-    console.log("refresh");
-  }, [refresh]);
 
 
   const uri = conversation.getId()
