diff --git a/lib/handlers/db-ops-handler.react.js b/lib/handlers/db-ops-handler.react.js
--- a/lib/handlers/db-ops-handler.react.js
+++ b/lib/handlers/db-ops-handler.react.js
@@ -4,15 +4,9 @@
 
 import { opsProcessingFinishedActionType } from '../actions/db-ops-actions.js';
 import { usePeerToPeerCommunication } from '../tunnelbroker/peer-to-peer-context.js';
-import { useTunnelbroker } from '../tunnelbroker/tunnelbroker-context.js';
+import { useConfirmPeerToPeerMessage } from '../tunnelbroker/use-confirm-peer-to-peer-message.js';
 import type { DBOpsEntry } from '../types/db-ops-types.js';
-import {
-  type MessageProcessed,
-  peerToPeerMessageTypes,
-} from '../types/tunnelbroker/peer-to-peer-message-types.js';
 import { getConfig } from '../utils/config.js';
-import { getContentSigningKey } from '../utils/crypto-utils.js';
-import { getMessageForException } from '../utils/errors.js';
 import { useDispatch, useSelector } from '../utils/redux-utils.js';
 
 function DBOpsHandler(): React.Node {
@@ -20,8 +14,8 @@
   const { processDBStoreOperations } = sqliteAPI;
   const queueFront = useSelector(state => state.dbOpsStore.queuedOps[0]);
   const prevQueueFront = React.useRef<?DBOpsEntry>(null);
-  const { sendMessageToDevice } = useTunnelbroker();
   const { processOutboundMessages } = usePeerToPeerCommunication();
+  const confirmPeerToPeerMessage = useConfirmPeerToPeerMessage();
 
   const dispatch = useDispatch();
 
@@ -49,39 +43,14 @@
       dispatch({
         type: opsProcessingFinishedActionType,
       });
-      if (dispatchMetadata) {
-        try {
-          const deviceID = await getContentSigningKey();
-          const { messageID, senderDeviceID } = dispatchMetadata;
-          if (!messageID || !senderDeviceID) {
-            return;
-          }
-          const message: MessageProcessed = {
-            type: peerToPeerMessageTypes.MESSAGE_PROCESSED,
-            messageID,
-            deviceID,
-          };
-          await sendMessageToDevice({
-            deviceID: senderDeviceID,
-            payload: JSON.stringify(message),
-          });
-          await sqliteAPI.removeInboundP2PMessages([messageID]);
-        } catch (e) {
-          console.log(
-            `Error while sending confirmation: ${
-              getMessageForException(e) ?? 'unknown error'
-            }`,
-          );
-        }
-      }
+      await confirmPeerToPeerMessage(dispatchMetadata);
     })();
   }, [
     queueFront,
     dispatch,
     processDBStoreOperations,
-    sendMessageToDevice,
-    sqliteAPI,
     processOutboundMessages,
+    confirmPeerToPeerMessage,
   ]);
 
   return null;
diff --git a/lib/tunnelbroker/use-confirm-peer-to-peer-message.js b/lib/tunnelbroker/use-confirm-peer-to-peer-message.js
new file mode 100644
--- /dev/null
+++ b/lib/tunnelbroker/use-confirm-peer-to-peer-message.js
@@ -0,0 +1,57 @@
+// @flow
+
+import * as React from 'react';
+
+import { useTunnelbroker } from './tunnelbroker-context.js';
+import type { DispatchMetadata } from '../types/redux-types.js';
+import {
+  type MessageProcessed,
+  peerToPeerMessageTypes,
+} from '../types/tunnelbroker/peer-to-peer-message-types.js';
+import { getConfig } from '../utils/config.js';
+import { getContentSigningKey } from '../utils/crypto-utils.js';
+import { getMessageForException } from '../utils/errors.js';
+
+function useConfirmPeerToPeerMessage(): (
+  messageMetadata: ?DispatchMetadata,
+) => Promise<void> {
+  const { sqliteAPI } = getConfig();
+  const { sendMessageToDevice } = useTunnelbroker();
+
+  return React.useCallback(
+    async (messageMetadata: ?DispatchMetadata): Promise<void> => {
+      try {
+        if (!messageMetadata) {
+          return;
+        }
+        const { messageID, senderDeviceID } = messageMetadata;
+        if (!messageID || !senderDeviceID) {
+          return;
+        }
+        const deviceID = await getContentSigningKey();
+
+        const message: MessageProcessed = {
+          type: peerToPeerMessageTypes.MESSAGE_PROCESSED,
+          messageID,
+          deviceID,
+        };
+
+        await sendMessageToDevice({
+          deviceID: senderDeviceID,
+          payload: JSON.stringify(message),
+        });
+        await sqliteAPI.removeInboundP2PMessages([messageID]);
+      } catch (e) {
+        console.log(
+          `Error while sending confirmation: ${
+            getMessageForException(e) ?? 'unknown error'
+          }`,
+          e,
+        );
+      }
+    },
+    [sendMessageToDevice, sqliteAPI],
+  );
+}
+
+export { useConfirmPeerToPeerMessage };