diff --git a/src/app/components/chat/chat.service.ts b/src/app/components/chat/chat.service.ts
index 152d06d..aa1c37f 100644
--- a/src/app/components/chat/chat.service.ts
+++ b/src/app/components/chat/chat.service.ts
@@ -6,7 +6,7 @@ import { Chat, Contact, Profile } from 'app/components/chat/chat.types';
 import { IndexedDBService } from 'app/services/indexed-db.service';
 import { MetadataService } from 'app/services/metadata.service';
 import { SignerService } from 'app/services/signer.service';
-import { Filter, nip04, NostrEvent } from 'nostr-tools';
+import { Filter, nip04, NostrEvent, Relay, UnsignedEvent } from 'nostr-tools';
 import { RelayService } from 'app/services/relay.service';
 import { EncryptedDirectMessage } from 'nostr-tools/kinds';
 import { getEventHash } from 'nostr-tools';
@@ -17,6 +17,9 @@ export class ChatService implements OnDestroy {
     private latestMessageTimestamps: { [pubKey: string]: number } = {};
     private messageQueue: NostrEvent[] = [];
     private isDecrypting = false;
+    private recipientPublicKey: string;
+    private message: string;
+
 
     private _chat: BehaviorSubject<Chat | null> = new BehaviorSubject(null);
     private _chats: BehaviorSubject<Chat[] | null> = new BehaviorSubject(null);
@@ -31,7 +34,7 @@ export class ChatService implements OnDestroy {
         private _indexedDBService: IndexedDBService,
         private _relayService: RelayService,
         private _sanitizer: DomSanitizer
-    ) {}
+    ) { }
 
     // Getters for observables
     get chat$(): Observable<Chat | null> {
@@ -166,311 +169,377 @@ export class ChatService implements OnDestroy {
     }
 
 
+    // Fetch chats and subscribe to updates, including messages
+    async getChats(): Promise<Observable<Chat[]>> {
+        const pubkey = this._signerService.getPublicKey();
+        const useExtension = await this._signerService.isUsingExtension();
+        const decryptedPrivateKey = await this._signerService.getSecretKey("123");
+        this.subscribeToChatList(pubkey, useExtension, decryptedPrivateKey);
 
+        // Optionally fetch older messages (history) if needed
+        this.chatList.forEach(chat => this.loadChatHistory(chat.id!));
 
+        return this.getChatListStream();
+    }
 
+    // Subscribe to chat list updates based on filters
+    subscribeToChatList(pubkey: string, useExtension: boolean, decryptedSenderPrivateKey: string): Observable<Chat[]> {
+        this._relayService.ensureConnectedRelays().then(() => {
+            const filters: Filter[] = [
+                { kinds: [EncryptedDirectMessage], authors: [pubkey] },
+                { kinds: [EncryptedDirectMessage], '#p': [pubkey] }
+            ];
+
+            this._relayService.getPool().subscribeMany(this._relayService.getConnectedRelays(), filters, {
+                onevent: async (event: NostrEvent) => {
+                    const otherPartyPubKey = event.pubkey === pubkey
+                        ? event.tags.find(tag => tag[0] === 'p')?.[1] || ''
+                        : event.pubkey;
+
+                    if (!otherPartyPubKey) return;
+
+                    const lastTimestamp = this.latestMessageTimestamps[otherPartyPubKey] || 0;
+                    if (event.created_at > lastTimestamp) {
+                        this.latestMessageTimestamps[otherPartyPubKey] = event.created_at;
+                        this.messageQueue.push(event);
+
+                        // Update the real-time chat messages when they are processed
+                        await this.processNextMessage(pubkey, useExtension, decryptedSenderPrivateKey);
+                    }
+                },
+                oneose: () => {
+                    console.log('Subscription closed');
+                    this._chats.next(this.chatList);
+                }
+            });
+        });
 
+        return this.getChatListStream();
+    }
 
 
+    // Process each message in the queue
+    private async processNextMessage(pubkey: string, useExtension: boolean, decryptedSenderPrivateKey: string): Promise<void> {
+        if (this.isDecrypting || this.messageQueue.length === 0) return;
 
-// Fetch chats and subscribe to updates, including messages
-async getChats(): Promise<Observable<Chat[]>> {
-    const pubkey = this._signerService.getPublicKey();
-    const useExtension = await this._signerService.isUsingExtension();
-    const decryptedPrivateKey = await this._signerService.getSecretKey("123");
-    this.subscribeToChatList(pubkey, useExtension, decryptedPrivateKey);
-
-    // Optionally fetch older messages (history) if needed
-    this.chatList.forEach(chat => this.loadChatHistory(chat.id!));
-
-    return this.getChatListStream();
-}
+        this.isDecrypting = true;
 
-// Subscribe to chat list updates based on filters
-// Subscribe to chat list updates based on filters
-subscribeToChatList(pubkey: string, useExtension: boolean, decryptedSenderPrivateKey: string): Observable<Chat[]> {
-    this._relayService.ensureConnectedRelays().then(() => {
-        const filters: Filter[] = [
-            { kinds: [EncryptedDirectMessage], authors: [pubkey] },
-            { kinds: [EncryptedDirectMessage], '#p': [pubkey] }
-        ];
+        try {
+            while (this.messageQueue.length > 0) {
+                const event = this.messageQueue.shift();
+                if (!event) continue;
 
-        this._relayService.getPool().subscribeMany(this._relayService.getConnectedRelays(), filters, {
-            onevent: async (event: NostrEvent) => {
-                const otherPartyPubKey = event.pubkey === pubkey
+                const isSentByUser = event.pubkey === pubkey;
+                const otherPartyPubKey = isSentByUser
                     ? event.tags.find(tag => tag[0] === 'p')?.[1] || ''
                     : event.pubkey;
 
-                if (!otherPartyPubKey) return;
+                if (!otherPartyPubKey) continue;
+
+                const decryptedMessage = await this.decryptReceivedMessage(
+                    event,
+                    useExtension,
+                    decryptedSenderPrivateKey,
+                    otherPartyPubKey
+                );
 
-                const lastTimestamp = this.latestMessageTimestamps[otherPartyPubKey] || 0;
-                if (event.created_at > lastTimestamp) {
-                    this.latestMessageTimestamps[otherPartyPubKey] = event.created_at;
-                    this.messageQueue.push(event);
+                if (decryptedMessage) {
+                    const messageTimestamp = event.created_at * 1000;
+                    this.addOrUpdateChatList(otherPartyPubKey, decryptedMessage, messageTimestamp, isSentByUser);
 
-                    // Update the real-time chat messages when they are processed
-                    await this.processNextMessage(pubkey, useExtension, decryptedSenderPrivateKey);
+                    // Update UI with the latest messages
+                    this._chat.next(this.chatList.find(chat => chat.id === otherPartyPubKey));
                 }
-            },
-            oneose: () => {
-                console.log('Subscription closed');
-                this._chats.next(this.chatList);
             }
-        });
-    });
-
-    return this.getChatListStream();
-}
+        } catch (error) {
+            console.error('Failed to decrypt message:', error);
+        } finally {
+            this.isDecrypting = false;
+        }
+    }
 
 
-// Process each message in the queue
- private async processNextMessage(pubkey: string, useExtension: boolean, decryptedSenderPrivateKey: string): Promise<void> {
-    if (this.isDecrypting || this.messageQueue.length === 0) return;
+    // Add or update chat in the chat list, including messages
+    private addOrUpdateChatList(pubKey: string, message: string, createdAt: number, isMine: boolean): void {
+        const existingChat = this.chatList.find(chat => chat.contact?.pubKey === pubKey);
 
-    this.isDecrypting = true;
+        const newMessage = {
+            id: `${pubKey}-${createdAt}`,
+            chatId: pubKey,
+            contactId: pubKey,
+            isMine,
+            value: message,
+            createdAt: new Date(createdAt).toISOString(),
+        };
 
-    try {
-        while (this.messageQueue.length > 0) {
-            const event = this.messageQueue.shift();
-            if (!event) continue;
+        if (existingChat) {
+            // Check if the message already exists to avoid duplicates
+            const messageExists = existingChat.messages?.some(m => m.id === newMessage.id);
 
-            const isSentByUser = event.pubkey === pubkey;
-            const otherPartyPubKey = isSentByUser
-                ? event.tags.find(tag => tag[0] === 'p')?.[1] || ''
-                : event.pubkey;
+            if (!messageExists) {
+                existingChat.messages = (existingChat.messages || []).concat(newMessage)
+                    .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
 
-            if (!otherPartyPubKey) continue;
+                if (new Date(existingChat.lastMessageAt!).getTime() < createdAt) {
+                    existingChat.lastMessage = message;
+                    existingChat.lastMessageAt = new Date(createdAt).toISOString();
+                }
+            }
+        } else {
+            const newChat: Chat = {
+                id: pubKey,
+                contact: { pubKey },
+                lastMessage: message,
+                lastMessageAt: new Date(createdAt).toISOString(),
+                messages: [newMessage]
+            };
+            this.chatList.push(newChat);
+            this.fetchMetadataForPubKey(pubKey);
+        }
 
-            const decryptedMessage = await this.decryptReceivedMessage(
-                event,
-                useExtension,
-                decryptedSenderPrivateKey,
-                otherPartyPubKey
-            );
+        this.chatList.sort((a, b) => new Date(b.lastMessageAt!).getTime() - new Date(a.lastMessageAt!).getTime());
+        this._chats.next(this.chatList);
+    }
 
-            if (decryptedMessage) {
-                const messageTimestamp = event.created_at * 1000;
-                this.addOrUpdateChatList(otherPartyPubKey, decryptedMessage, messageTimestamp, isSentByUser);
 
-                // Update UI with the latest messages
-                this._chat.next(this.chatList.find(chat => chat.id === otherPartyPubKey));
-            }
-        }
-    } catch (error) {
-        console.error('Failed to decrypt message:', error);
-    } finally {
-        this.isDecrypting = false;
+    // Fetch metadata for a public key
+    private fetchMetadataForPubKey(pubKey: string): void {
+        this._metadataService.fetchMetadataWithCache(pubKey)
+            .then(metadata => {
+                const chat = this.chatList.find(chat => chat.contact?.pubKey === pubKey);
+                if (chat && metadata) {
+                    chat.contact = { ...chat.contact, ...metadata };
+                    this._chats.next(this.chatList);
+                }
+            })
+            .catch(error => {
+                console.error(`Failed to fetch metadata for pubKey: ${pubKey}`, error);
+            });
     }
-}
 
+    // Get chat list stream
+    getChatListStream(): Observable<Chat[]> {
+        return this._chats.asObservable();
+    }
 
-// Add or update chat in the chat list, including messages
-private addOrUpdateChatList(pubKey: string, message: string, createdAt: number, isMine: boolean): void {
-    const existingChat = this.chatList.find(chat => chat.contact?.pubKey === pubKey);
+    // Decrypt received message
+    private async decryptReceivedMessage(
+        event: NostrEvent,
+        useExtension: boolean,
+        decryptedSenderPrivateKey: string,
+        recipientPublicKey: string
+    ): Promise<string> {
+        if (useExtension) {
+            return await this._signerService.decryptMessageWithExtension(event.content, recipientPublicKey);
+        } else {
+            return await this._signerService.decryptMessage(decryptedSenderPrivateKey, recipientPublicKey, event.content);
+        }
+    }
 
-    const newMessage = {
-        id: `${pubKey}-${createdAt}`,
-        chatId: pubKey,
-        contactId: pubKey,
-        isMine,
-        value: message,
-        createdAt: new Date(createdAt).toISOString(),
-    };
+    // Load older chat history (if needed)
+    private async loadChatHistory(pubKey: string): Promise<void> {
+        const myPubKey = this._signerService.getPublicKey();
 
-    if (existingChat) {
-        // Check if the message already exists to avoid duplicates
-        const messageExists = existingChat.messages?.some(m => m.id === newMessage.id);
+        const historyFilter: Filter[] = [
+            { kinds: [EncryptedDirectMessage], authors: [myPubKey], '#p': [pubKey] },
+            { kinds: [EncryptedDirectMessage], authors: [pubKey], '#p': [myPubKey] }
+        ];
 
-        if (!messageExists) {
-            existingChat.messages = (existingChat.messages || []).concat(newMessage)
-                .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+        console.log("Subscribing to history for chat with: ", pubKey);
 
-            if (new Date(existingChat.lastMessageAt!).getTime() < createdAt) {
-                existingChat.lastMessage = message;
-                existingChat.lastMessageAt = new Date(createdAt).toISOString();
+        this._relayService.getPool().subscribeMany(this._relayService.getConnectedRelays(), historyFilter, {
+            onevent: async (event: NostrEvent) => {
+                console.log("Received historical event: ", event); // Check if the event is received
+                const isSentByMe = event.pubkey === myPubKey;
+                const senderOrRecipientPubKey = isSentByMe ? pubKey : event.pubkey;
+                const decryptedMessage = await this.decryptReceivedMessage(
+                    event,
+                    await this._signerService.isUsingExtension(),
+                    await this._signerService.getSecretKey("123"),
+                    senderOrRecipientPubKey
+                );
+
+                if (decryptedMessage) {
+                    const messageTimestamp = event.created_at * 1000;
+
+                    // Add message to chat and update UI
+                    this.addOrUpdateChatList(pubKey, decryptedMessage, messageTimestamp, isSentByMe);
+                    this._chat.next(this.chatList.find(chat => chat.id === pubKey)); // Ensure UI is updated with history
+                }
+            },
+            oneose: () => {
+                console.log(`Closed subscription for loading history of chat: ${pubKey}`);
             }
-        }
-    } else {
-        const newChat: Chat = {
-            id: pubKey,
-            contact: { pubKey },
-            lastMessage: message,
-            lastMessageAt: new Date(createdAt).toISOString(),
-            messages: [newMessage]
-        };
-        this.chatList.push(newChat);
-        this.fetchMetadataForPubKey(pubKey);
+        });
     }
 
-    this.chatList.sort((a, b) => new Date(b.lastMessageAt!).getTime() - new Date(a.lastMessageAt!).getTime());
-    this._chats.next(this.chatList);
-}
 
+    // Update chat in the chat list
+    updateChat(id: string, chat: Chat): Observable<Chat> {
+        return this.chats$.pipe(
+            take(1),
+            switchMap((chats: Chat[] | null) => {
+                const pubkey = chat.contact?.pubKey;
 
-// Fetch metadata for a public key
-private fetchMetadataForPubKey(pubKey: string): void {
-    this._metadataService.fetchMetadataWithCache(pubKey)
-        .then(metadata => {
-            const chat = this.chatList.find(chat => chat.contact?.pubKey === pubKey);
-            if (chat && metadata) {
-                chat.contact = { ...chat.contact, ...metadata };
-                this._chats.next(this.chatList);
-            }
-        })
-        .catch(error => {
-            console.error(`Failed to fetch metadata for pubKey: ${pubKey}`, error);
-        });
-}
+                if (!pubkey) {
+                    return throwError('No public key found for this chat');
+                }
 
-// Get chat list stream
-getChatListStream(): Observable<Chat[]> {
-    return this._chats.asObservable();
-}
+                const event: any = {
+                    kind: 4,
+                    pubkey: pubkey,
+                    content: JSON.stringify(chat),
+                    created_at: Math.floor(Date.now() / 1000),
+                    tags: [['p', pubkey]],
+                };
 
-// Decrypt received message
-private async decryptReceivedMessage(
-    event: NostrEvent,
-    useExtension: boolean,
-    decryptedSenderPrivateKey: string,
-    recipientPublicKey: string
-): Promise<string> {
-    if (useExtension) {
-        return await this._signerService.decryptMessageWithExtension(event.content, recipientPublicKey);
-    } else {
-        return await this._signerService.decryptMessage(decryptedSenderPrivateKey, recipientPublicKey, event.content);
+                event.id = getEventHash(event);
+
+                return from(this._relayService.publishEventToRelays(event)).pipe(
+                    map(() => {
+                        if (chats) {
+                            const index = chats.findIndex((item) => item.id === id);
+                            if (index !== -1) {
+                                chats[index] = chat;
+                                this._chats.next(chats);
+                            }
+                        }
+                        return chat;
+                    }),
+                    catchError((error) => {
+                        console.error('Failed to update chat via Nostr:', error);
+                        return throwError(error);
+                    })
+                );
+            })
+        );
     }
-}
 
-// Load older chat history (if needed)
- private async loadChatHistory(pubKey: string): Promise<void> {
-    const myPubKey = this._signerService.getPublicKey();
-
-    const historyFilter: Filter[] = [
-        { kinds: [EncryptedDirectMessage], authors: [myPubKey], '#p': [pubKey] },
-        { kinds: [EncryptedDirectMessage], authors: [pubKey], '#p': [myPubKey] }
-    ];
-
-    console.log("Subscribing to history for chat with: ", pubKey);
-
-    this._relayService.getPool().subscribeMany(this._relayService.getConnectedRelays(), historyFilter, {
-        onevent: async (event: NostrEvent) => {
-            console.log("Received historical event: ", event); // Check if the event is received
-            const isSentByMe = event.pubkey === myPubKey;
-            const senderOrRecipientPubKey = isSentByMe ? pubKey : event.pubkey;
-            const decryptedMessage = await this.decryptReceivedMessage(
-                event,
-                await this._signerService.isUsingExtension(),
-                await this._signerService.getSecretKey("123"),
-                senderOrRecipientPubKey
-            );
+    // Get chat by ID
+    getChatById(id: string): Observable<Chat> {
+        this.recipientPublicKey = id;
+        const pubkey = this._signerService.getPublicKey();
+        const useExtension = this._signerService.isUsingExtension();
+        const decryptedSenderPrivateKey = this._signerService.getSecretKey('123');
+
+        return this.chats$.pipe(
+            take(1),
+            switchMap((chats: Chat[] | null) => {
+                const cachedChat = chats?.find(chat => chat.id === id);
+                if (cachedChat) {
+                    this._chat.next(cachedChat);
+                    console.log("Fetching chat history for: ", this.recipientPublicKey);
+                    this.loadChatHistory(this.recipientPublicKey);
+                    return of(cachedChat);
+                }
 
-            if (decryptedMessage) {
-                const messageTimestamp = event.created_at * 1000;
+                const newChat: Chat = {
+                    id: this.recipientPublicKey,
+                    contact: { pubKey: this.recipientPublicKey, picture: "/images/avatars/avatar-placeholder.png" },
+                    lastMessage: '',
+                    lastMessageAt: new Date().toISOString(),
+                    messages: []
+                };
 
-                // Add message to chat and update UI
-                this.addOrUpdateChatList(pubKey, decryptedMessage, messageTimestamp, isSentByMe);
-                this._chat.next(this.chatList.find(chat => chat.id === pubKey)); // Ensure UI is updated with history
-            }
-        },
-        oneose: () => {
-            console.log(`Closed subscription for loading history of chat: ${pubKey}`);
-        }
-    });
-}
+                const updatedChats = chats ? [...chats, newChat] : [newChat];
+                this._chats.next(updatedChats);
+                this._chat.next(newChat);
+
+                console.log("Fetching chat history for: ", this.recipientPublicKey); // Check if this is called
+                this.loadChatHistory(this.recipientPublicKey);
+                return of(newChat);
+            }),
+            catchError((error) => {
+                console.error('Error fetching chat by id from Nostr:', error);
+                return throwError(error);
+            })
+        );
+    }
 
+    // Reset chat state
+    resetChat(): void {
+        this._chat.next(null);
+    }
 
-// Update chat in the chat list
-updateChat(id: string, chat: Chat): Observable<Chat> {
-    return this.chats$.pipe(
-        take(1),
-        switchMap((chats: Chat[] | null) => {
-            const pubkey = chat.contact?.pubKey;
 
-            if (!pubkey) {
-                return throwError('No public key found for this chat');
-            }
+    public async sendPrivateMessage(message: string): Promise<void> {
+        try {
+            this.message = message;
 
-            const event: any = {
-                kind: 4,
-                pubkey: pubkey,
-                content: JSON.stringify(chat),
-                created_at: Math.floor(Date.now() / 1000),
-                tags: [['p', pubkey]],
-            };
+            const useExtension = await this._signerService.isUsingExtension();
 
-            event.id = getEventHash(event);
+            if (useExtension) {
+                await this.handleMessageSendingWithExtension();
+            } else {
+                const decryptedSenderPrivateKey = await this._signerService.getSecretKey("123");
 
-            return from(this._relayService.publishEventToRelays(event)).pipe(
-                map(() => {
-                    if (chats) {
-                        const index = chats.findIndex((item) => item.id === id);
-                        if (index !== -1) {
-                            chats[index] = chat;
-                            this._chats.next(chats);
-                        }
-                    }
-                    return chat;
-                }),
-                catchError((error) => {
-                    console.error('Failed to update chat via Nostr:', error);
-                    return throwError(error);
-                })
-            );
-        })
-    );
-}
+                if (!this.isValidMessageSetup()) {
+                    console.error('Message, sender private key, or recipient public key is not properly set.');
+                    return;
+                }
 
-// Get chat by ID
-// Get chat by ID
-getChatById(id: string): Observable<Chat> {
-    const recipientPublicKey = id;
-    const pubkey = this._signerService.getPublicKey();
-    const useExtension = this._signerService.isUsingExtension();
-    const decryptedSenderPrivateKey = this._signerService.getSecretKey('123');
-
-    return this.chats$.pipe(
-        take(1),
-        switchMap((chats: Chat[] | null) => {
-            const cachedChat = chats?.find(chat => chat.id === id);
-            if (cachedChat) {
-                this._chat.next(cachedChat);
-                console.log("Fetching chat history for: ", recipientPublicKey); // Check if this is called
-                this.loadChatHistory(recipientPublicKey);
-                return of(cachedChat);
+                const encryptedMessage = await this._signerService.encryptMessage(
+                    decryptedSenderPrivateKey,
+                    this.recipientPublicKey,
+                    this.message
+                );
+
+                const messageEvent = this._signerService.getUnsignedEvent(4, [['p', this.recipientPublicKey]], encryptedMessage);
+
+                const signedEvent = this._signerService.getSignedEvent(messageEvent, decryptedSenderPrivateKey);
+
+                const published = await this._relayService.publishEventToRelays(signedEvent);
+
+                if (published) {
+                    console.log('Message sent successfully!');
+                    this.message = '';
+                } else {
+                    console.error('Failed to send the message.');
+                }
             }
 
-            const newChat: Chat = {
-                id: recipientPublicKey,
-                contact: { pubKey: recipientPublicKey, picture: "/images/avatars/avatar-placeholder.png" },
-                lastMessage: '',
-                lastMessageAt: new Date().toISOString(),
-                messages: []
-            };
+        } catch (error) {
+            console.error('Error sending private message:', error);
+        }
+    }
 
-            const updatedChats = chats ? [...chats, newChat] : [newChat];
-            this._chats.next(updatedChats);
-            this._chat.next(newChat);
-
-            console.log("Fetching chat history for: ", recipientPublicKey); // Check if this is called
-            this.loadChatHistory(recipientPublicKey);
-            return of(newChat);
-        }),
-        catchError((error) => {
-            console.error('Error fetching chat by id from Nostr:', error);
-            return throwError(error);
-        })
-    );
-}
+    private async handleMessageSendingWithExtension(): Promise<void> {
+        try {
+            const encryptedMessage = await this._signerService.encryptMessageWithExtension(
+                this.message,
+                this.recipientPublicKey
+            );
 
-// Reset chat state
-resetChat(): void {
-    this._chat.next(null);
-}
+            const signedEvent = await this._signerService.signEventWithExtension({
+                kind: 4,
+                pubkey: this._signerService.getPublicKey(),
+                tags: [['p', this.recipientPublicKey]],
+                content: encryptedMessage,
+                created_at: Math.floor(Date.now() / 1000),
+            });
 
+            const published = await this._relayService.publishEventToRelays(signedEvent);
+
+            if (published) {
+                console.log('Message sent successfully with extension!');
+                this.message = '';
+            } else {
+                console.error('Failed to send the message with extension.');
+            }
+        } catch (error) {
+            console.error('Error sending message with extension:', error);
+        }
+    }
+
+    private isValidMessageSetup(): boolean {
+        return this.message.trim() !== '' && this.recipientPublicKey !== '';
+    }
 
     // Clean up on destroy
     ngOnDestroy(): void {
         this._unsubscribeAll.next();
         this._unsubscribeAll.complete();
     }
+
+
 }
diff --git a/src/app/components/chat/chats/chats.component.ts b/src/app/components/chat/chats/chats.component.ts
index 1bb2d66..60097fa 100644
--- a/src/app/components/chat/chats/chats.component.ts
+++ b/src/app/components/chat/chats/chats.component.ts
@@ -91,7 +91,8 @@ export class ChatsComponent implements OnInit, OnDestroy {
 
                 this._changeDetectorRef.markForCheck();
             });
-    }
+
+        }
 
     /**
      * On destroy
diff --git a/src/app/components/chat/conversation/conversation.component.html b/src/app/components/chat/conversation/conversation.component.html
index e187c3b..f88275e 100644
--- a/src/app/components/chat/conversation/conversation.component.html
+++ b/src/app/components/chat/conversation/conversation.component.html
@@ -256,14 +256,14 @@
                         class="angor-mat-dense angor-mat-rounded angor-mat-bold ml-4 w-full"
                         subscriptSizing="dynamic"
                     >
-                        <textarea
+                        <textarea class="max-h-20"
                             matInput
                             cdkTextareaAutosize
                             #messageInput
                         ></textarea>
                     </mat-form-field>
                     <div class="my-px ml-4 flex h-11 items-center">
-                        <button mat-icon-button>
+                        <button mat-icon-button (click)="sendMessage()">
                             <mat-icon
                                 [svgIcon]="'heroicons_outline:paper-airplane'"
                             ></mat-icon>
diff --git a/src/app/components/chat/conversation/conversation.component.ts b/src/app/components/chat/conversation/conversation.component.ts
index 8aa2523..432cef3 100644
--- a/src/app/components/chat/conversation/conversation.component.ts
+++ b/src/app/components/chat/conversation/conversation.component.ts
@@ -53,9 +53,6 @@ export class ConversationComponent implements OnInit, OnDestroy {
     drawerOpened: boolean = false;
     private _unsubscribeAll: Subject<any> = new Subject<any>();
 
-    /**
-     * Constructor
-     */
     constructor(
         private _changeDetectorRef: ChangeDetectorRef,
         private _chatService: ChatService,
@@ -63,15 +60,6 @@ export class ConversationComponent implements OnInit, OnDestroy {
         private _ngZone: NgZone
     ) {}
 
-
-
-
-
-    /**
-     * Resize on 'input' and 'ngModelChange' events
-     *
-     * @private
-     */
     @HostListener('input')
     @HostListener('ngModelChange')
     private _resizeMessageInput(): void {
@@ -93,13 +81,6 @@ export class ConversationComponent implements OnInit, OnDestroy {
         });
     }
 
-
-
-
-
-    /**
-     * On init
-     */
     ngOnInit(): void {
 
         this._chatService.chat$
@@ -127,18 +108,12 @@ export class ConversationComponent implements OnInit, OnDestroy {
             });
     }
 
-    /**
-     * On destroy
-     */
     ngOnDestroy(): void {
 
         this._unsubscribeAll.next(null);
         this._unsubscribeAll.complete();
     }
 
-    /**
-     * Open the contact info
-     */
     openContactInfo(): void {
 
         this.drawerOpened = true;
@@ -147,9 +122,6 @@ export class ConversationComponent implements OnInit, OnDestroy {
         this._changeDetectorRef.markForCheck();
     }
 
-    /**
-     * Reset the chat
-     */
     resetChat(): void {
         this._chatService.resetChat();
 
@@ -160,9 +132,6 @@ export class ConversationComponent implements OnInit, OnDestroy {
         this._changeDetectorRef.markForCheck();
     }
 
-    /**
-     * Toggle mute notifications
-     */
     toggleMuteNotifications(): void {
 
         this.chat.muted = !this.chat.muted;
@@ -171,12 +140,24 @@ export class ConversationComponent implements OnInit, OnDestroy {
         this._chatService.updateChat(this.chat.id, this.chat).subscribe();
     }
 
-    /**
-     * Track by function for ngFor loops
-     *
-     * @param index
-     * @param item
-     */
+    sendMessage(): void {
+        const messageContent = this.messageInput.nativeElement.value.trim();
+
+        if (!messageContent) {
+            console.warn('Cannot send an empty message.');
+            return;
+        }
+
+        this._chatService.sendPrivateMessage(messageContent)
+            .then(() => {
+                this.messageInput.nativeElement.value = '';
+                console.log('Message sent successfully.');
+            })
+            .catch((error) => {
+                console.error('Failed to send message:', error);
+            });
+    }
+
     trackByFn(index: number, item: any): any {
         return item.id || index;
     }
diff --git a/src/app/components/chat/new-chat/new-chat.component.html b/src/app/components/chat/new-chat/new-chat.component.html
index 63193e1..65725e8 100644
--- a/src/app/components/chat/new-chat/new-chat.component.html
+++ b/src/app/components/chat/new-chat/new-chat.component.html
@@ -27,7 +27,7 @@
                 ) {
                     <div
                         class="text-secondary sticky top-0 z-10 -mt-px border-b border-t bg-gray-100 px-6 py-1 font-medium uppercase dark:bg-gray-900 md:px-8"
-                    >
+                        (click)="openChat(contact)">
                         {{ contact?.name?.charAt(0) ?? '' }}
                     </div>
                 }
@@ -35,7 +35,7 @@
                 <!-- Contact -->
                 <div
                     class="z-20 flex cursor-pointer items-center border-b px-6 py-4 dark:hover:bg-hover hover:bg-gray-100 md:px-8"
-                >
+                    (click)="openChat(contact)" >
                     <div
                         class="flex h-10 w-10 flex-0 items-center justify-center overflow-hidden rounded-full"
                     >
diff --git a/src/app/components/chat/new-chat/new-chat.component.ts b/src/app/components/chat/new-chat/new-chat.component.ts
index 7e5efd0..d3dc710 100644
--- a/src/app/components/chat/new-chat/new-chat.component.ts
+++ b/src/app/components/chat/new-chat/new-chat.component.ts
@@ -1,3 +1,4 @@
+import { Router } from '@angular/router';
 import {
     ChangeDetectionStrategy,
     Component,
@@ -11,7 +12,7 @@ import { MatIconModule } from '@angular/material/icon';
 import { MatDrawer } from '@angular/material/sidenav';
 import { ChatService } from 'app/components/chat/chat.service';
 import { Contact } from 'app/components/chat/chat.types';
-import { Subject, takeUntil } from 'rxjs';
+import { catchError, Subject, takeUntil, throwError } from 'rxjs';
 
 @Component({
     selector: 'chat-new-chat',
@@ -26,20 +27,9 @@ export class NewChatComponent implements OnInit, OnDestroy {
     contacts: Contact[] = [];
     private _unsubscribeAll: Subject<any> = new Subject<any>();
 
-    /**
-     * Constructor
-     */
-    constructor(private _chatService: ChatService) {}
+    constructor(private _chatService: ChatService, private router: Router) {}
 
-
-
-
-
-    /**
-     * On init
-     */
     ngOnInit(): void {
-
         this._chatService.contacts$
             .pipe(takeUntil(this._unsubscribeAll))
             .subscribe((contacts: Contact[]) => {
@@ -47,25 +37,25 @@ export class NewChatComponent implements OnInit, OnDestroy {
             });
     }
 
-    /**
-     * On destroy
-     */
     ngOnDestroy(): void {
-
         this._unsubscribeAll.next(null);
         this._unsubscribeAll.complete();
     }
 
+    openChat(contact: Contact): void {
+        this._chatService.getChatById(contact.pubKey).pipe(
 
+            catchError((error) => {
+                console.error(error);
+                const parentUrl = this.router.url.split('/').slice(0, -1).join('/');
+                this.router.navigateByUrl(parentUrl);
+                return throwError(error);
+            })
+        ).subscribe();
 
+        this.drawer.close();
+    }
 
-
-    /**
-     * Track by function for ngFor loops
-     *
-     * @param index
-     * @param item
-     */
     trackByFn(index: number, item: any): any {
         return item.id || index;
     }
diff --git a/src/app/services/signer.service.ts b/src/app/services/signer.service.ts
index fca2b5b..0157d76 100644
--- a/src/app/services/signer.service.ts
+++ b/src/app/services/signer.service.ts
@@ -208,56 +208,48 @@ export class SignerService {
         }
     }
 
-    async signEventWithExtension(unsignedEvent: UnsignedEvent): Promise<Event> {
-        const gt = globalThis as any;
-        if (gt.nostr) {
-            const signedEvent = await gt.nostr.signEvent(unsignedEvent);
-            return signedEvent;
-        } else {
-            throw new Error("Tried to sign event with extension but failed");
-        }
-    }
 
-  // Messaging (NIP-04)
-  async decryptMessageWithExtension(encryptedContent: string, senderPubKey: string): Promise<string> {
-    try {
-      const gt = globalThis as any;
-      const decryptedMessage = await gt.nostr.nip04.decrypt(senderPubKey, encryptedContent);
-      return decryptedMessage;
-    } catch (error) {
-      console.error('Error decrypting message with extension:', error);
-      throw new Error('Failed to decrypt message with Nostr extension.');
+
+    // Messaging (NIP-04)
+    async decryptMessageWithExtension(encryptedContent: string, senderPubKey: string): Promise<string> {
+        try {
+            const gt = globalThis as any;
+            const decryptedMessage = await gt.nostr.nip04.decrypt(senderPubKey, encryptedContent);
+            return decryptedMessage;
+        } catch (error) {
+            console.error('Error decrypting message with extension:', error);
+            throw new Error('Failed to decrypt message with Nostr extension.');
+        }
     }
-  }
 
 
-  async encryptMessageWithExtension(content: string, pubKey: string): Promise<string> {
-    const gt = globalThis as any;
-    const encryptedMessage = await gt.nostr.nip04.encrypt(pubKey, content);
-    return encryptedMessage;
-  }
+    async encryptMessageWithExtension(content: string, pubKey: string): Promise<string> {
+        const gt = globalThis as any;
+        const encryptedMessage = await gt.nostr.nip04.encrypt(pubKey, content);
+        return encryptedMessage;
+    }
 
-  async encryptMessage(privateKey: string, recipientPublicKey: string, message: string): Promise<string> {
-    console.log(message);
-    try {
-      const encryptedMessage = await nip04.encrypt(privateKey, recipientPublicKey, message);
-      return encryptedMessage;
-    } catch (error) {
-      console.error('Error encrypting message:', error);
-      throw error;
+    async encryptMessage(privateKey: string, recipientPublicKey: string, message: string): Promise<string> {
+        console.log(message);
+        try {
+            const encryptedMessage = await nip04.encrypt(privateKey, recipientPublicKey, message);
+            return encryptedMessage;
+        } catch (error) {
+            console.error('Error encrypting message:', error);
+            throw error;
+        }
     }
-  }
 
-  // NIP-04: Decrypting Direct Messages
-  async decryptMessage(privateKey: string, senderPublicKey: string, encryptedMessage: string): Promise<string> {
-    try {
-      const decryptedMessage = await nip04.decrypt(privateKey, senderPublicKey, encryptedMessage);
-      return decryptedMessage;
-    } catch (error) {
-      console.error('Error decrypting message:', error);
-      throw error;
+    // NIP-04: Decrypting Direct Messages
+    async decryptMessage(privateKey: string, senderPublicKey: string, encryptedMessage: string): Promise<string> {
+        try {
+            const decryptedMessage = await nip04.decrypt(privateKey, senderPublicKey, encryptedMessage);
+            return decryptedMessage;
+        } catch (error) {
+            console.error('Error decrypting message:', error);
+            throw error;
+        }
     }
-  }
 
 
 
@@ -280,6 +272,56 @@ export class SignerService {
         return signedEvent;
     }
 
+
+
+
+    async signEventWithExtension(unsignedEvent: UnsignedEvent): Promise<Event> {
+        const gt = globalThis as any;
+        if (gt.nostr) {
+            const signedEvent = await gt.nostr.signEvent(unsignedEvent)
+            return signedEvent;
+        } else {
+            throw new Error("Tried to sign event with extension but failed");
+        }
+    }
+
+    async signDMWithExtension(pubkey: string, content: string): Promise<string> {
+        const gt = globalThis as any;
+        if (gt.nostr && gt.nostr.nip04?.encrypt) {
+            return await gt.nostr.nip04.encrypt(pubkey, content)
+        }
+        throw new Error("Failed to Sign with extension");
+    }
+
+    async decryptDMWithExtension(pubkey: string, ciphertext: string): Promise<string> {
+        const gt = globalThis as any;
+        if (gt.nostr && gt.nostr.nip04?.decrypt) {
+            const decryptedContent = await gt.nostr.nip04.decrypt(pubkey, ciphertext)
+                .catch((error: any) => {
+                    return "*Failed to Decrypted Content*"
+                });
+            return decryptedContent;
+        }
+        return "Attempted Nostr Window decryption and failed."
+    }
+
+    async decryptWithPrivateKey(pubkey: string, ciphertext: string, password: string): Promise<string> {
+        try {
+            // Get the stored private key in hex format
+            let privateKey = await this.getSecretKey("password");
+
+            // Ensure the private key is in Uint8Array format
+            const privateKeyUint8Array = new Uint8Array(Buffer.from(privateKey, 'hex'));
+
+            // Decrypt the message using the private key and public key
+            return await nip04.decrypt(privateKeyUint8Array, pubkey, ciphertext);
+        } catch (error) {
+            console.error("Error during decryption: ", error);
+            return "*Failed to Decrypted Content*";
+        }
+    }
+
+
     public async isUsingExtension(): Promise<boolean> {
         const globalContext = globalThis as any;
         if (globalContext.nostr && globalContext.nostr.getPublicKey) {