diff --git a/.vscode/launch.json b/.vscode/launch.json
index 379556dc..005b8dff 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -3,7 +3,25 @@
     // Hover to view descriptions of existing attributes.
     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
-    "configurations": [
+    "configurations": [    
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'social'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=social",
+                    "--package=social"
+                ],
+                "filter": {
+                    "name": "social",
+                    "kind": "bin"
+                }
+            },
+            "args": ["step-4"],
+            "cwd": "${workspaceFolder}"
+        },
         {
             "type": "lldb",
             "request": "launch",
@@ -42,4 +60,4 @@
             "cwd": "${workspaceFolder}"
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/Cargo.toml b/Cargo.toml
index d50225c0..2a2fc953 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -50,6 +50,7 @@ nft = { path="crates/nft" }
 tween = { path="crates/tween" }
 world_ui = { path="crates/world_ui" }
 collectibles = { path="crates/collectibles" }
+social = { path="crates/social" }
 
 bevy = { version = "0.14", default-features = false, features=[
     "animation",
@@ -107,7 +108,11 @@ bevy_simple_text_input = { git = "https://github.com/robtfm/bevy_simple_text_inp
 directories = "5"
 uuid = { version = "1.7", features = ["v4"] }
 build-time = "0.1.3"
+async-tungstenite = { version = "0.22.0", features = ["async-std-runtime", "async-tls"] }
+dcl-rpc = { version = "2.3.5", default-features = false, features=["client", "websockets", "codegen", "server", "tungstenite"] }
+async-trait = "0.1.68"
 fastrand = "2"
+futures-util = "0.3.28"
 
 [dependencies]
 analytics = { workspace = true }
@@ -131,6 +136,7 @@ tween = { workspace = true }
 scene_material = { workspace = true }
 world_ui = { workspace = true }
 collectibles = { workspace = true }
+social = { workspace = true }
 
 bevy = { workspace = true }
 bevy_console = { workspace = true }
@@ -139,18 +145,19 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 clap = { workspace = true }
 uuid = { workspace = true }
+build-time = { workspace = true }
 
 pico-args = "0.5.0"
 mimalloc = { version = "*", default-features = false }
-build-time = { workspace = true }
 chrono = { workspace = true }
 tracing-appender = "0.2.3"
 log-panics = { version = "2.1.0", features = ["with-backtrace"] }
 
-# break_test dependencies
+# non-main dependencies
 futures-lite = { workspace = true }
 dcl_component = { workspace = true }
 tokio = { workspace = true }
+bevy_simple_text_input = { workspace = true }
 
 [build-dependencies]
 prost-build = "0.11.8"
diff --git a/assets/ui/chat.dui b/assets/ui/chat.dui
index bcd079e5..95dd6626 100644
--- a/assets/ui/chat.dui
+++ b/assets/ui/chat.dui
@@ -10,7 +10,7 @@
         color="#aa1fc166"
     >
         <div>
-            <tab-group style="justify-content: flex-start; width: 100%; flex-wrap: wrap;" tabs="@chat-tabs" onchanged="@tab-changed" initial="@initial-tab" edge-scale="1px 1px -0px 1px"/>
+            <tab-group id="tabs" style="justify-content: flex-start; width: 100%; flex-wrap: wrap;" tabs="@chat-tabs" onchanged="@tab-changed" initial="@initial-tab" edge-scale="1px 1px -0px 1px"/>
             <div>
                 <button img="images/copy.png" onclick="@copy" image-width="4.4vmin" image-height="4.4vmin" />
                 <button img="images/redx.png" onclick="@close" image-width="4.4vmin" image-height="4.4vmin" />
diff --git a/assets/ui/update.dui b/assets/ui/update.dui
index 589cee25..fb3928c7 100644
--- a/assets/ui/update.dui
+++ b/assets/ui/update.dui
@@ -1,9 +1,11 @@
 <define-template id="update-available">
     <dialog title="Update Available" buttons="@buttons">
-        <div style="flex-direction: column; align-items: center; justify-content: center; margin: 4vmin;">
-            <div style="flex-direction: column;">
-                <med-text text="@body" />
-            </div>
+        <div style="flex-direction: column; align-items: center; justify-content: center; margin: 4vmin; min-height: 0px;">
+            <vscroll>
+                <div style="flex-direction: column;">
+                    <med-text text="@body" />
+                </div>
+            </vscroll>
             <hr />
             <div>
                 <med-link label="Download" color="#8888ff" href="@download" />
diff --git a/crates/comms/Cargo.toml b/crates/comms/Cargo.toml
index f4e31ebc..b8be64ff 100644
--- a/crates/comms/Cargo.toml
+++ b/crates/comms/Cargo.toml
@@ -29,11 +29,11 @@ prost = { workspace = true }
 async-std = { workspace = true }
 bevy_kira_audio = { workspace = true }
 kira = { workspace = true }
+async-trait = { workspace = true }
+async-tungstenite = { workspace = true }
+futures-util = { workspace = true }
 
-async-trait = "0.1.68"
-async-tungstenite = { version = "0.22.0", features = ["async-std-runtime", "async-tls"] }
 async-tls = "0.12.0"
-futures-util = "0.3.28"
 livekit = { git = "https://github.com/robtfm/client-sdk-rust", branch="0.6-h264-false-2", features=["rustls-tls-webpki-roots"], optional = true }
 rand = "0.8.5"
 multihash-codetable = { version = "0.1.1", features = ["digest", "sha2"] }
diff --git a/crates/dcl_component/Cargo.toml b/crates/dcl_component/Cargo.toml
index 4f990bf5..2e6cb1c4 100644
--- a/crates/dcl_component/Cargo.toml
+++ b/crates/dcl_component/Cargo.toml
@@ -9,6 +9,9 @@ edition = "2021"
 bevy = { workspace = true }
 prost = { workspace = true }
 serde = { workspace = true }
+dcl-rpc = { workspace = true }
+async-trait = { workspace = true }
 
 [build-dependencies]
-prost-build = "0.11.8"
\ No newline at end of file
+prost-build = "0.11.8"
+dcl-rpc = { workspace = true }
diff --git a/crates/dcl_component/build.rs b/crates/dcl_component/build.rs
index 284fafde..8c3f128c 100644
--- a/crates/dcl_component/build.rs
+++ b/crates/dcl_component/build.rs
@@ -1,5 +1,5 @@
 use std::io::Result;
-fn main() -> Result<()> {
+fn gen_sdk_components() -> Result<()> {
     let components = [
         "engine_info",
         "billboard",
@@ -57,6 +57,7 @@ fn main() -> Result<()> {
     sources.push("src/proto/decentraland/kernel/comms/rfc5/ws_comms.proto".into());
     sources.push("src/proto/decentraland/kernel/comms/rfc4/comms.proto".into());
     sources.push("src/proto/decentraland/kernel/comms/v3/archipelago.proto".into());
+    sources.push("src/proto/decentraland/social/friendships/friendships.proto".into());
 
     let serde_components = ["Color3"];
 
@@ -73,3 +74,20 @@ fn main() -> Result<()> {
 
     Ok(())
 }
+
+fn gen_social_service() -> Result<()> {
+    let mut conf = prost_build::Config::new();
+    conf.service_generator(Box::new(dcl_rpc::codegen::RPCServiceGenerator::new()));
+    conf.type_attribute("*", "#[derive(Debug)]");
+    conf.compile_protos(
+        &["src/proto/decentraland/social/friendships/friendships.proto"],
+        &["src/proto"],
+    )?;
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    gen_sdk_components()?;
+    gen_social_service()?;
+    Ok(())
+}
diff --git a/crates/dcl_component/src/proto_components.rs b/crates/dcl_component/src/proto_components.rs
index 50399a9f..ebcec2b5 100644
--- a/crates/dcl_component/src/proto_components.rs
+++ b/crates/dcl_component/src/proto_components.rs
@@ -40,6 +40,13 @@ pub mod common {
     include!(concat!(env!("OUT_DIR"), "/decentraland.common.rs"));
 }
 
+pub mod social {
+    include!(concat!(
+        env!("OUT_DIR"),
+        "/decentraland.social.friendships.rs"
+    ));
+}
+
 trait DclProtoComponent: prost::Message + Default {}
 
 impl<T: DclProtoComponent + Sync + Send + 'static> FromDclReader for T {
diff --git a/crates/social/Cargo.toml b/crates/social/Cargo.toml
new file mode 100644
index 00000000..67be9d32
--- /dev/null
+++ b/crates/social/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "social"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+
+[dependencies]
+common = { workspace = true }
+comms = { workspace = true }
+dcl = { workspace = true }
+dcl_component = { workspace = true }
+ipfs = { workspace = true }
+wallet = { workspace = true }
+
+bevy = { workspace = true }
+bevy_egui = { workspace = true }
+bevy_dui = { workspace = true }
+bevy_console = { workspace = true }
+urn = { workspace = true }
+ethers-core = { workspace = true }
+ethers-signers = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+isahc = { workspace = true }
+tokio = { workspace = true }
+anyhow = { workspace = true }
+chrono = { workspace = true }
+clap = { workspace = true }
+opener = { workspace = true }
+urlencoding = { workspace = true }
+build-time = { workspace = true }
+
+futures-lite = { workspace = true }
+
+async-tungstenite = { workspace = true }
+
+prost = { workspace = true }
+dcl-rpc = { workspace = true }
+futures-util = { workspace = true }
+
+matrix-sdk = { version = "0.7.1", default-features = false, features = ["e2e-encryption", "rustls-tls"] }
diff --git a/crates/social/src/lib.rs b/crates/social/src/lib.rs
new file mode 100644
index 00000000..de333655
--- /dev/null
+++ b/crates/social/src/lib.rs
@@ -0,0 +1,762 @@
+use anyhow::anyhow;
+use bevy::{
+    app::{Plugin, PostUpdate},
+    log::warn,
+    prelude::*,
+    tasks::IoTaskPool,
+    utils::{HashMap, HashSet},
+};
+use common::util::AsH160;
+use dcl_component::proto_components::social::{
+    friendship_event_payload, friendship_event_response, request_events_response,
+    subscribe_friendship_events_updates_response, users_response, AcceptPayload, CancelPayload,
+    DeletePayload, FriendshipEventPayload, FriendshipsServiceClient,
+    FriendshipsServiceClientDefinition, Payload, RejectPayload, RequestEvents, RequestPayload,
+    RequestResponse, SubscribeFriendshipEventsUpdatesResponse, UpdateFriendshipPayload, User,
+    Users,
+};
+use dcl_rpc::{client::RpcClient, transports::web_sockets::WebSocketTransport};
+use ethers_core::types::Address;
+use futures_util::{pin_mut, select, FutureExt};
+use matrix_sdk::{
+    config::SyncSettings,
+    event_handler::Ctx,
+    room::MessagesOptions,
+    ruma::{
+        api::client::{
+            filter::{FilterDefinition, RoomEventFilter},
+            receipt::create_receipt::v3::ReceiptType,
+        },
+        events::{
+            receipt::ReceiptThread,
+            room::message::{MessageType, OriginalSyncRoomMessageEvent, RoomMessageEventContent},
+            AnyMessageLikeEventContent, AnyTimelineEvent, MessageLikeEventType,
+        },
+        RoomOrAliasId, UserId,
+    },
+    Room, RoomMemberships,
+};
+use serde::{Deserialize, Serialize};
+use tokio::sync::mpsc::{self, unbounded_channel, UnboundedReceiver, UnboundedSender};
+use wallet::SimpleAuthChain;
+
+pub struct SocialPlugin;
+
+impl Plugin for SocialPlugin {
+    fn build(&self, app: &mut bevy::prelude::App) {
+        app.add_event::<FriendshipEvent>();
+        app.init_resource::<SocialClient>();
+        app.add_systems(PostUpdate, |mut client: ResMut<SocialClient>| {
+            if let Some(client) = client.0.as_mut() {
+                client.update();
+            }
+        });
+    }
+}
+
+#[derive(Resource, Default)]
+pub struct SocialClient(pub Option<SocialClientHandler>);
+
+#[derive(Serialize, Deserialize)]
+struct SocialIdentifier {
+    r#type: String,
+    user: String,
+}
+
+impl SocialIdentifier {
+    fn new(address: Address) -> Self {
+        Self {
+            r#type: "m.id.user".to_owned(),
+            user: format!("{:#x}", address),
+        }
+    }
+}
+
+#[derive(Serialize)]
+struct SocialLogin {
+    auth_chain: SimpleAuthChain,
+    identifier: SocialIdentifier,
+    timestamp: String,
+    r#type: String,
+}
+
+impl SocialLogin {
+    async fn try_new(wallet: &wallet::Wallet) -> Result<Self, anyhow::Error> {
+        let timestamp: chrono::DateTime<chrono::Utc> = std::time::SystemTime::now().into();
+        let timestamp = format!("{}", timestamp.timestamp_millis());
+
+        let auth_chain = wallet
+            .sign_message(timestamp.clone())
+            .await
+            .map_err(dbgerr)?;
+        let identifier = SocialIdentifier::new(wallet.address().ok_or(anyhow!("not connected"))?);
+
+        Ok(Self {
+            auth_chain,
+            identifier,
+            timestamp,
+            r#type: "m.login.decentraland".to_owned(),
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct DirectChatMessage {
+    pub partner: Address,
+    pub me_speaking: bool,
+    pub message: String,
+}
+
+enum FriendData {
+    Init {
+        sent_requests: HashSet<Address>,
+        received_requests: HashMap<Address, Option<String>>,
+        friends: HashSet<Address>,
+    },
+    Event(friendship_event_response::Body),
+    Chat(DirectChatMessage),
+}
+
+#[derive(Event)]
+pub struct FriendshipEvent(pub friendship_event_response::Body);
+
+enum FriendshipOutbound {
+    FriendshipEvent(FriendshipEventPayload),
+    ChatMessage(DirectChatMessage),
+    HistoryRequest(Address, UnboundedSender<DirectChatMessage>),
+}
+
+pub struct SocialClientHandler {
+    sender: UnboundedSender<FriendshipOutbound>,
+    friendship_receiver: UnboundedReceiver<FriendData>,
+
+    pub is_initialized: bool,
+    pub sent_requests: HashSet<Address>,
+    pub received_requests: HashMap<Address, Option<String>>,
+    pub friends: HashSet<Address>,
+
+    pub unread_messages: HashMap<Address, usize>,
+
+    friend_event_callback: Box<dyn Fn(&friendship_event_response::Body) + Send + Sync + 'static>,
+    chat_event_callback: Box<dyn Fn(DirectChatMessage) + Send + Sync + 'static>,
+}
+
+impl SocialClientHandler {
+    pub async fn connect(
+        wallet: wallet::Wallet,
+        friend_callback: impl Fn(&friendship_event_response::Body) + Send + Sync + 'static,
+        chat_callback: impl Fn(DirectChatMessage) + Send + Sync + 'static,
+    ) -> Option<Self> {
+        let (event_sx, event_rx) = mpsc::unbounded_channel();
+        let (response_sx, response_rx) = mpsc::unbounded_channel();
+
+        IoTaskPool::get()
+            .spawn(social_socket_handler(wallet, event_rx, response_sx))
+            .detach();
+        Some(Self {
+            is_initialized: false,
+            sender: event_sx,
+            friendship_receiver: response_rx,
+            sent_requests: Default::default(),
+            received_requests: Default::default(),
+            friends: Default::default(),
+            unread_messages: Default::default(),
+            friend_event_callback: Box::new(friend_callback),
+            chat_event_callback: Box::new(chat_callback),
+        })
+    }
+
+    pub fn live(&self) -> bool {
+        !self.friendship_receiver.is_closed()
+    }
+
+    pub fn friend_request(
+        &mut self,
+        address: Address,
+        message: Option<String>,
+    ) -> Result<(), anyhow::Error> {
+        self.sender.send(FriendshipOutbound::FriendshipEvent(
+            FriendshipEventPayload {
+                body: Some(friendship_event_payload::Body::Request(RequestPayload {
+                    user: Some(User {
+                        address: format!("{address:#x}"),
+                    }),
+                    message,
+                })),
+            },
+        ))?;
+        self.sent_requests.insert(address);
+        Ok(())
+    }
+
+    pub fn cancel_request(&mut self, address: Address) -> Result<(), anyhow::Error> {
+        self.sender.send(FriendshipOutbound::FriendshipEvent(
+            FriendshipEventPayload {
+                body: Some(friendship_event_payload::Body::Cancel(CancelPayload {
+                    user: Some(User {
+                        address: format!("{address:#x}"),
+                    }),
+                })),
+            },
+        ))?;
+        self.sent_requests.insert(address);
+        Ok(())
+    }
+
+    pub fn accept_request(&mut self, address: Address) -> Result<(), anyhow::Error> {
+        if self.received_requests.remove(&address).is_none() {
+            return Err(anyhow!("no request"));
+        };
+
+        self.sender.send(FriendshipOutbound::FriendshipEvent(
+            FriendshipEventPayload {
+                body: Some(friendship_event_payload::Body::Accept(AcceptPayload {
+                    user: Some(User {
+                        address: format!("{address:#x}"),
+                    }),
+                })),
+            },
+        ))?;
+        self.friends.insert(address);
+        Ok(())
+    }
+
+    pub fn reject_request(&mut self, address: Address) -> Result<(), anyhow::Error> {
+        if self.received_requests.remove(&address).is_none() {
+            return Err(anyhow!("no request"));
+        };
+
+        self.sender.send(FriendshipOutbound::FriendshipEvent(
+            FriendshipEventPayload {
+                body: Some(friendship_event_payload::Body::Reject(RejectPayload {
+                    user: Some(User {
+                        address: format!("{address:#x}"),
+                    }),
+                })),
+            },
+        ))?;
+        Ok(())
+    }
+
+    pub fn delete_friend(&mut self, address: Address) -> Result<(), anyhow::Error> {
+        if !self.friends.remove(&address) {
+            return Err(anyhow!("no request"));
+        };
+
+        self.sender.send(FriendshipOutbound::FriendshipEvent(
+            FriendshipEventPayload {
+                body: Some(friendship_event_payload::Body::Delete(DeletePayload {
+                    user: Some(User {
+                        address: format!("{address:#x}"),
+                    }),
+                })),
+            },
+        ))?;
+        Ok(())
+    }
+
+    pub fn chat(&self, address: Address, message: String) -> Result<(), anyhow::Error> {
+        self.sender
+            .send(FriendshipOutbound::ChatMessage(DirectChatMessage {
+                partner: address,
+                me_speaking: true,
+                message,
+            }))
+            .map_err(dbgerr)
+    }
+
+    pub fn get_chat_history(
+        &self,
+        address: Address,
+    ) -> Result<UnboundedReceiver<DirectChatMessage>, anyhow::Error> {
+        let (sx, rx) = unbounded_channel();
+        self.sender
+            .send(FriendshipOutbound::HistoryRequest(address, sx))?;
+        Ok(rx)
+    }
+
+    pub fn mark_as_read(&mut self, address: Address) {
+        self.unread_messages.remove(&address);
+    }
+
+    pub fn unread_messages(&self) -> &HashMap<Address, usize> {
+        &self.unread_messages
+    }
+
+    fn update(&mut self) {
+        while let Ok(rec) = self.friendship_receiver.try_recv() {
+            match rec {
+                FriendData::Init {
+                    sent_requests,
+                    received_requests,
+                    friends,
+                } => {
+                    self.received_requests = received_requests;
+                    self.sent_requests = sent_requests;
+                    self.friends = friends;
+                    self.is_initialized = true;
+                }
+                FriendData::Event(ev) => {
+                    (self.friend_event_callback)(&ev);
+                    match ev {
+                        friendship_event_response::Body::Request(body) => {
+                            let Some(address) =
+                                body.user.as_ref().and_then(|u| u.address.as_h160())
+                            else {
+                                warn!("invalid friend request (no address): {body:?}");
+                                continue;
+                            };
+                            self.received_requests.insert(address, body.message);
+                        }
+                        friendship_event_response::Body::Accept(body) => {
+                            let Some(address) =
+                                body.user.as_ref().and_then(|u| u.address.as_h160())
+                            else {
+                                warn!("invalid friend accept (no address): {body:?}");
+                                continue;
+                            };
+                            self.sent_requests.remove(&address);
+                            self.friends.insert(address);
+                        }
+                        friendship_event_response::Body::Reject(body) => {
+                            let Some(address) =
+                                body.user.as_ref().and_then(|u| u.address.as_h160())
+                            else {
+                                warn!("invalid friend reject (no address): {body:?}");
+                                continue;
+                            };
+                            self.sent_requests.remove(&address);
+                        }
+                        friendship_event_response::Body::Delete(body) => {
+                            let Some(address) =
+                                body.user.as_ref().and_then(|u| u.address.as_h160())
+                            else {
+                                warn!("invalid friend delete (no address): {body:?}");
+                                continue;
+                            };
+                            self.friends.remove(&address);
+                        }
+                        friendship_event_response::Body::Cancel(body) => {
+                            let Some(address) =
+                                body.user.as_ref().and_then(|u| u.address.as_h160())
+                            else {
+                                warn!("invalid friend accept (no address): {body:?}");
+                                continue;
+                            };
+                            self.received_requests.remove(&address);
+                        }
+                    }
+                }
+                FriendData::Chat(chat) => {
+                    if !chat.me_speaking {
+                        *self.unread_messages.entry(chat.partner).or_default() += 1;
+                    }
+                    (self.chat_event_callback)(chat);
+                }
+            }
+        }
+    }
+}
+
+async fn social_socket_handler(
+    wallet: wallet::Wallet,
+    event_rx: UnboundedReceiver<FriendshipOutbound>,
+    response_sx: UnboundedSender<FriendData>,
+) {
+    let rt = std::sync::Arc::new(
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap(),
+    );
+    if let Err(e) = rt.block_on(social_socket_handler_inner(
+        wallet.clone(),
+        event_rx,
+        response_sx,
+    )) {
+        println!("social socket handler error: {e}");
+    } else {
+        println!("k..");
+    }
+}
+
+fn dbgerr<E: std::fmt::Debug>(e: E) -> anyhow::Error {
+    anyhow!(format!("{e:?}"))
+}
+
+async fn social_socket_handler_inner(
+    wallet: wallet::Wallet,
+    mut rx: UnboundedReceiver<FriendshipOutbound>,
+    response_sx: UnboundedSender<FriendData>,
+) -> Result<(), anyhow::Error> {
+    let req = SocialLogin::try_new(&wallet).await?;
+    let req = serde_json::to_value(&req)
+        .unwrap()
+        .as_object()
+        .unwrap()
+        .clone();
+    let matrix_client = matrix_sdk::Client::builder()
+        .homeserver_url("https://social.decentraland.org")
+        .build()
+        .await?;
+    let login = matrix_client
+        .matrix_auth()
+        .login_custom("m.login.decentraland", req)
+        .unwrap()
+        .send()
+        .await?;
+    let synapse_token = login.access_token;
+
+    // create connection
+    let service_connection =
+        dcl_rpc::transports::web_sockets::tungstenite::WebSocketClient::connect(
+            "wss://rpc-social-service.decentraland.org",
+        )
+        .await
+        .map_err(dbgerr)?;
+    let service_transport = WebSocketTransport::new(service_connection);
+    let mut service_client = RpcClient::new(service_transport).await.unwrap();
+    let port = service_client.create_port("whatever").await.unwrap();
+    let service_module = port
+        .load_module::<FriendshipsServiceClient<_>>("FriendshipsService")
+        .await
+        .map_err(dbgerr)?;
+
+    // gather and send initial data
+    let mut friends_req = service_module
+        .get_friends(Payload {
+            synapse_token: Some(synapse_token.clone()),
+        })
+        .await
+        .map_err(dbgerr)?;
+    let requests_req = service_module
+        .get_request_events(Payload {
+            synapse_token: Some(synapse_token.clone()),
+        })
+        .await
+        .map_err(dbgerr)?;
+
+    let mut friends = HashSet::default();
+    while let Some(f) = friends_req.next().await {
+        if let Some(users_response::Response::Users(Users { users })) = f.response {
+            for user in users {
+                if let Some(address) = user.address.as_h160() {
+                    friends.insert(address);
+                }
+            }
+        }
+    }
+
+    let mut received_requests = HashMap::default();
+    let mut sent_requests = HashSet::default();
+    if let Some(request_events_response::Response::Events(RequestEvents { incoming, outgoing })) =
+        requests_req.response
+    {
+        if let Some(incoming) = incoming {
+            for RequestResponse { user, message, .. } in incoming.items {
+                if let Some(address) = user.and_then(|u| u.address.as_h160()) {
+                    received_requests.insert(address, message);
+                }
+            }
+        }
+        if let Some(outgoing) = outgoing {
+            for RequestResponse { user, .. } in outgoing.items {
+                if let Some(address) = user.and_then(|u| u.address.as_h160()) {
+                    sent_requests.insert(address);
+                }
+            }
+        }
+    }
+
+    response_sx.send(FriendData::Init {
+        sent_requests,
+        received_requests,
+        friends,
+    })?;
+
+    // build workers
+    let mut inbound_service_events = service_module
+        .subscribe_friendship_events_updates(Payload {
+            synapse_token: Some(synapse_token.clone()),
+        })
+        .await
+        .map_err(dbgerr)?;
+
+    // demux the received data
+    let (sx_friend, mut rx_friend) = mpsc::channel(10);
+    let (sx_chat, mut rx_chat) = mpsc::channel(10);
+    let (sx_history, mut rx_history) = mpsc::channel(10);
+    tokio::spawn(async move {
+        while let Some(message) = rx.recv().await {
+            match message {
+                FriendshipOutbound::FriendshipEvent(data) => {
+                    let _ = sx_friend.send(data).await;
+                }
+                FriendshipOutbound::ChatMessage(chat) => {
+                    let _ = sx_chat.send(chat).await;
+                }
+                FriendshipOutbound::HistoryRequest(address, sender) => {
+                    let _ = sx_history.send((address, sender)).await;
+                }
+            }
+        }
+    });
+
+    struct RoomAliasConverter(String);
+    impl RoomAliasConverter {
+        fn as_ref(&self) -> Result<&RoomOrAliasId, anyhow::Error> {
+            self.0.as_str().try_into().map_err(dbgerr)
+        }
+    }
+
+    let room_alias = |other: Address| -> Result<RoomAliasConverter, anyhow::Error> {
+        let me = format!(
+            "{:#x}",
+            wallet.address().ok_or(anyhow!("wallet disconnected!"))?
+        );
+        let other = format!("{other:#x}");
+        let alias = format!(
+            "#{}+{}:{}",
+            (&me).min(&other),
+            (&me).max(&other),
+            "decentraland.org"
+        )
+        .to_ascii_lowercase();
+        Ok(RoomAliasConverter(alias))
+    };
+
+    // outbound matrix events
+    let client = matrix_client.clone();
+    let f_matrix_write = async move {
+        while let Some(chat) = rx_chat.recv().await {
+            let alias = room_alias(chat.partner)?;
+            match client.join_room_by_id_or_alias(alias.as_ref()?, &[]).await {
+                Err(e) => {
+                    warn!("failed to find room for address {:#?}", chat.partner);
+                    warn!("err: {e}");
+                    continue;
+                }
+                Ok(room) => {
+                    room.send(RoomMessageEventContent::text_plain(chat.message))
+                        .await?
+                }
+            };
+        }
+
+        Ok(())
+    }
+    .fuse();
+
+    // history requests
+    let client = matrix_client.clone();
+    let f_matrix_history = async move {
+        while let Some((address, sx)) = rx_history.recv().await {
+            warn!("history requested for {address:#?}");
+            let alias = room_alias(address)?;
+            match client.join_room_by_id_or_alias(alias.as_ref()?, &[]).await {
+                Err(e) => {
+                    warn!("failed to find room for address {address:#?}");
+                    warn!("err: {e}");
+                    continue;
+                }
+                Ok(room) => {
+                    let mut token = None;
+                    let mut filter = RoomEventFilter::default();
+                    filter.types = Some(vec!["m.room.message".to_owned()]);
+
+                    loop {
+                        let mut options = MessagesOptions::backward();
+                        options.limit = 10u32.into();
+                        options.filter = filter.clone();
+                        options.from = token.take();
+
+                        let history = room.messages(options).await?;
+                        for event in history.chunk {
+                            if let Ok(AnyTimelineEvent::MessageLike(m)) = event.event.deserialize()
+                            {
+                                if m.event_type() == MessageLikeEventType::RoomMessage {
+                                    let Some(sender) = matrix_to_h160(m.sender()) else {
+                                        warn!("no h160 from {:?}", m.sender());
+                                        continue;
+                                    };
+                                    let Some(AnyMessageLikeEventContent::RoomMessage(content)) =
+                                        m.original_content()
+                                    else {
+                                        continue;
+                                    };
+                                    let MessageType::Text(text_content) = content.msgtype else {
+                                        continue;
+                                    };
+                                    let _ = sx.send(DirectChatMessage {
+                                        partner: address,
+                                        me_speaking: address != sender,
+                                        message: text_content.body,
+                                    });
+                                }
+                            }
+                        }
+                        token = history.end;
+                        if token.is_none() {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        Result::<(), anyhow::Error>::Ok(())
+    }
+    .fuse();
+
+    // outbound service events
+    let f_service_write = async move {
+        while let Some(req) = rx_friend.recv().await {
+            service_module
+                .update_friendship_event(UpdateFriendshipPayload {
+                    event: Some(req),
+                    auth_token: Some(Payload {
+                        synapse_token: Some(synapse_token.clone()),
+                    }),
+                })
+                .await
+                .map_err(dbgerr)?;
+        }
+        Result::<(), anyhow::Error>::Ok(())
+    }
+    .fuse();
+
+    // inbound service events
+    let sx = response_sx.clone();
+    let f_service_read = async move {
+        while let Some(SubscribeFriendshipEventsUpdatesResponse {
+            response: Some(response),
+        }) = inbound_service_events.next().await
+        {
+            match response {
+                subscribe_friendship_events_updates_response::Response::Events(evs) => {
+                    for ev in evs.responses.into_iter().flat_map(|r| r.body) {
+                        sx.send(FriendData::Event(ev)).map_err(dbgerr)?;
+                    }
+                }
+                other => return Err(dbgerr(other)),
+            }
+        }
+
+        Ok(())
+    }
+    .fuse();
+
+    fn matrix_to_h160(s: &UserId) -> Option<Address> {
+        let base = s.as_str().get(1..)?;
+        base.split_once(':')
+            .map(|(init, _)| init)
+            .unwrap_or(base)
+            .as_h160()
+    }
+
+    #[derive(Clone)]
+    pub struct IsStartup(bool);
+
+    // fn as async closures are unstable
+    async fn handle_message(
+        event: OriginalSyncRoomMessageEvent,
+        room: Room,
+        response_sx: Ctx<UnboundedSender<FriendData>>,
+        is_startup: Ctx<IsStartup>,
+        client: matrix_sdk::Client,
+    ) {
+        println!("inbound process {event:?}");
+        let Some(sender) = matrix_to_h160(&event.sender) else {
+            println!("skip 1");
+            return;
+        };
+        let MessageType::Text(text_content) = event.content.msgtype else {
+            println!("skip 3");
+            return;
+        };
+        let Some(user) = client.user_id() else {
+            println!("skip 4");
+            return;
+        };
+
+        let Ok(members) = room.members(RoomMemberships::all()).await else {
+            warn!("failed to fetch members");
+            return;
+        };
+        let Some(partner) = members
+            .iter()
+            .filter(|member| !member.is_account_user())
+            .flat_map(|member| matrix_to_h160(member.user_id()))
+            .next()
+        else {
+            warn!("failed to determine partner");
+            return;
+        };
+
+        if (*is_startup).0 {
+            // skip if last read event is this event (we only read 1 so this should be fine, otherwise we'd need to fetch the receipt event as well to compare age)
+            let read_receipt_event_id = room
+                .load_user_receipt(
+                    matrix_sdk::ruma::events::receipt::ReceiptType::Read,
+                    ReceiptThread::Unthreaded,
+                    user,
+                )
+                .await
+                .unwrap_or(None);
+            if read_receipt_event_id.map_or(false, |receipt| receipt.0 == event.event_id) {
+                println!("skip on read");
+                return;
+            }
+        }
+
+        let _ = response_sx.send(FriendData::Chat(DirectChatMessage {
+            partner,
+            me_speaking: sender != partner,
+            message: text_content.body,
+        }));
+        if let Err(e) = room
+            .send_single_receipt(ReceiptType::Read, ReceiptThread::Unthreaded, event.event_id)
+            .await
+        {
+            println!("receipt err: {e:?}");
+        };
+        println!("processed");
+    }
+
+    // inbound matrix events
+    matrix_client.add_event_handler(handle_message);
+    matrix_client.add_event_handler_context(response_sx.clone());
+    matrix_client.add_event_handler_context(IsStartup(true));
+
+    let f_matrix_read = async move {
+        // limit initial history to 1 message so we can check for unread
+        let mut filter = FilterDefinition::default();
+        filter.room.timeline.types = Some(vec!["m.room.message".to_owned()]);
+        filter.room.timeline.limit = Some(1u32.into());
+        let settings = SyncSettings::default().filter(filter.into());
+        matrix_client.sync(settings).await.map_err(dbgerr)?;
+        matrix_client.add_event_handler_context(IsStartup(false));
+        loop {
+            matrix_client
+                .sync(SyncSettings::default())
+                .await
+                .map_err(dbgerr)?;
+        }
+    }
+    .fuse();
+
+    // until a stream is broken
+    pin_mut!(
+        f_service_read,
+        f_matrix_read,
+        f_service_write,
+        f_matrix_write,
+        f_matrix_history,
+    );
+    select! {
+        r = f_service_read => r,
+        r = f_matrix_read => r,
+        r = f_service_write => r,
+        r = f_matrix_write => r,
+        r = f_matrix_history => r,
+    }
+}
diff --git a/crates/system_ui/src/emotes.rs b/crates/system_ui/src/emotes.rs
index 2f11d142..ebf2f52b 100644
--- a/crates/system_ui/src/emotes.rs
+++ b/crates/system_ui/src/emotes.rs
@@ -781,7 +781,7 @@ fn update_emotes_list(
                                 .get(caller.0)
                                 .ok()
                                 .and_then(|tab| tab.selected_entity())
-                                .and_then(|nodes| emote.get(nodes["label"]).ok());
+                                .and_then(|nodes| emote.get(nodes.named("label")).ok());
                             e.send(SelectItem(selection.cloned()));
                             debug!("selected {:?}", selection)
                         },
diff --git a/crates/system_ui/src/wearables.rs b/crates/system_ui/src/wearables.rs
index a7a6f817..ba1bfd88 100644
--- a/crates/system_ui/src/wearables.rs
+++ b/crates/system_ui/src/wearables.rs
@@ -857,7 +857,7 @@ fn update_wearables_list(
                                 .get(caller.0)
                                 .ok()
                                 .and_then(|tab| tab.selected_entity())
-                                .and_then(|nodes| wearable.get(nodes["label"]).ok());
+                                .and_then(|nodes| wearable.get(nodes.named("label")).ok());
                             e.send(SelectItem(selection.cloned()));
                             debug!("selected {:?}", selection)
                         },
diff --git a/crates/ui_core/src/button.rs b/crates/ui_core/src/button.rs
index f45c4aae..72a8cce9 100644
--- a/crates/ui_core/src/button.rs
+++ b/crates/ui_core/src/button.rs
@@ -1,6 +1,8 @@
 use anyhow::anyhow;
 use bevy::{ecs::system::EntityCommands, prelude::*, ui::FocusPolicy};
-use bevy_dui::{DuiContext, DuiProps, DuiTemplate, NodeMap};
+use bevy_dui::{
+    DuiCommandsExt, DuiContext, DuiEntities, DuiProps, DuiRegistry, DuiTemplate, NodeMap,
+};
 use common::util::{ModifyComponentExt, TryPushChildrenEx};
 
 use crate::{
@@ -257,18 +259,79 @@ impl DuiTemplate for DuiButtonSetTemplate {
 
 #[derive(Component)]
 pub struct TabSelection {
+    entity: Entity,
     pub selected: Option<usize>,
-    active_entities: Vec<NodeMap>,
+    active_entities: Vec<DuiEntities>,
 }
 
 impl TabSelection {
-    pub fn selected_entity(&self) -> Option<&NodeMap> {
+    pub fn selected_entity(&self) -> Option<&DuiEntities> {
         self.selected.and_then(|ix| self.active_entities.get(ix))
     }
 
-    pub fn nth_entity(&self, ix: usize) -> Option<&NodeMap> {
+    pub fn nth_entity(&self, ix: usize) -> Option<&DuiEntities> {
         self.active_entities.get(ix)
     }
+
+    pub fn add(
+        &mut self,
+        commands: &mut Commands,
+        dui: &DuiRegistry,
+        ix: usize,
+        button: DuiButton,
+        toggle: bool,
+        edge_scale: Option<UiRect>,
+    ) -> Result<&DuiEntities, anyhow::Error> {
+        let id = self.entity;
+        let components = commands.spawn_template(
+            dui,
+            "button",
+            DuiProps::new().with_prop("button-data", button).with_prop(
+                "onclick",
+                On::<Click>::new(
+                    move |mut commands: Commands,
+                          mut q: Query<&mut TabSelection>,
+                          mut active: Query<&mut Active>| {
+                        // TODO find self to get up-to-date ix
+                        if let Ok(mut sel) = q.get_mut(id) {
+                            if toggle && sel.selected == Some(ix) {
+                                sel.selected = None;
+                            } else {
+                                sel.selected = Some(ix);
+                            }
+                            for (i, child) in sel.active_entities.iter().enumerate() {
+                                active.get_mut(child.named("button-background")).unwrap().0 =
+                                    Some(i) == sel.selected;
+                            }
+                        }
+
+                        if let Some(mut cmd) = commands.get_entity(id) {
+                            cmd.try_insert(DataChanged);
+                        }
+                    },
+                ),
+            ),
+        )?;
+
+        let mut bg = commands.entity(components.named("button-background"));
+        bg.insert(Active(Some(ix) == self.selected));
+        if let Some(flat_side) = edge_scale {
+            bg.modify_component(move |bounds: &mut NodeBounds| bounds.edge_scale = flat_side);
+        }
+
+        commands.entity(id).try_push_children(&[components.root]);
+        self.active_entities.insert(ix, components);
+        Ok(self.active_entities.get(ix).unwrap())
+    }
+
+    pub fn remove(&mut self, commands: &mut Commands, ix: usize) {
+        if let Some(components) = self.active_entities.get(ix) {
+            if let Some(commands) = commands.get_entity(components.root) {
+                commands.despawn_recursive();
+            }
+            self.active_entities.remove(ix);
+        }
+    }
 }
 
 pub(crate) struct DuiTabGroupTemplate;
@@ -291,73 +354,34 @@ impl DuiTemplate for DuiTabGroupTemplate {
         let toggle = props.take_as::<bool>(ctx, "toggle")?.unwrap_or(false);
         let edge_scale = props.take_as::<UiRect>(ctx, "edge-scale")?;
 
-        let mut active_entities = Vec::default();
-
-        let children = buttons
-            .into_iter()
-            .enumerate()
-            .map(|(ix, button)| {
-                ctx.render_template(
-                    &mut commands.commands().spawn_empty(),
-                    "button",
-                    DuiProps::new().with_prop("button-data", button).with_prop(
-                        "onclick",
-                        On::<Click>::new(
-                            move |mut commands: Commands,
-                                  mut q: Query<&mut TabSelection>,
-                                  mut active: Query<&mut Active>| {
-                                if let Ok(mut sel) = q.get_mut(id) {
-                                    if toggle && sel.selected == Some(ix) {
-                                        sel.selected = None;
-                                    } else {
-                                        sel.selected = Some(ix);
-                                    }
-                                    for (i, child) in sel.active_entities.iter().enumerate() {
-                                        active.get_mut(child["button-background"]).unwrap().0 =
-                                            Some(i) == sel.selected;
-                                    }
-                                }
-
-                                if let Some(mut cmd) = commands.get_entity(id) {
-                                    cmd.try_insert(DataChanged);
-                                }
-                            },
-                        ),
-                    ),
-                )
-                .map(|nodes| {
-                    let mut new_commands = commands.commands();
-                    let mut bg = new_commands.entity(nodes["button-background"]);
-
-                    bg.insert(Active(Some(ix) == start_index));
+        let mut selection = TabSelection {
+            entity: id,
+            selected: start_index,
+            active_entities: Default::default(),
+        };
 
-                    if let Some(flat_side) = edge_scale {
-                        bg.modify_component(move |bounds: &mut NodeBounds| {
-                            bounds.edge_scale = flat_side
-                        });
-                    }
+        for (ix, button) in buttons.into_iter().enumerate() {
+            selection.add(
+                &mut commands.commands(),
+                ctx.registry(),
+                ix,
+                button,
+                toggle,
+                edge_scale,
+            )?;
+        }
 
-                    active_entities.push(nodes.clone());
-                    nodes["root"]
-                })
-            })
-            .collect::<Result<Vec<_>, _>>()?;
+        let nodemap = NodeMap::from_iter(
+            selection
+                .active_entities
+                .iter()
+                .enumerate()
+                .map(|(i, c)| (format!("tab {i}"), c.root)),
+        );
 
-        commands.try_push_children(&children);
-        commands.insert((
-            on_changed,
-            TabSelection {
-                selected: start_index,
-                active_entities,
-            },
-        ));
+        commands.insert((on_changed, selection));
 
-        Ok(NodeMap::from_iter(
-            children
-                .into_iter()
-                .enumerate()
-                .map(|(i, c)| (format!("tab {i}"), c)),
-        ))
+        Ok(nodemap)
     }
 }
 
diff --git a/crates/wallet/Cargo.toml b/crates/wallet/Cargo.toml
index fe5a50fe..1fee227b 100644
--- a/crates/wallet/Cargo.toml
+++ b/crates/wallet/Cargo.toml
@@ -27,9 +27,9 @@ urlencoding = { workspace = true }
 data-encoding = { workspace = true }
 opener = { workspace = true }
 chrono = { workspace = true }
+async-trait = { workspace = true }
+async-tungstenite = { workspace = true }
+futures-util = { workspace = true }
 
-async-trait = "0.1.68"
-async-tungstenite = { version = "0.22.0", features = ["async-std-runtime", "async-tls"] }
 async-tls = "0.12.0"
-futures-util = "0.3.28"
 rand = "0.8.5"
diff --git a/crates/wallet/src/lib.rs b/crates/wallet/src/lib.rs
index aefaf6a8..e3ee74d3 100644
--- a/crates/wallet/src/lib.rs
+++ b/crates/wallet/src/lib.rs
@@ -8,6 +8,7 @@ use common::structs::ChainLink;
 use ethers_core::types::{Address, Signature};
 use ethers_signers::{LocalWallet, Signer, WalletError};
 use isahc::http::Uri;
+use rand::SeedableRng;
 use serde::{Deserialize, Serialize};
 use tokio::sync::RwLock;
 
@@ -61,6 +62,15 @@ impl Wallet {
         write.inner = Some(inner);
     }
 
+    pub fn finalize_as_guest_with_seed(&mut self, seed: [u8; 32]) {
+        let inner: Box<dyn ObjSafeWalletSigner + Send + Sync> =
+            Box::new(LocalWallet::new(&mut rand::rngs::StdRng::from_seed(seed)));
+        let mut write = self.0.try_write().unwrap();
+        write.root_address = Some(inner.address());
+        write.delegates.clear();
+        write.inner = Some(inner);
+    }
+
     pub fn finalize(
         &mut self,
         root_address: Address,
diff --git a/src/bin/social.rs b/src/bin/social.rs
new file mode 100644
index 00000000..b80012e9
--- /dev/null
+++ b/src/bin/social.rs
@@ -0,0 +1,329 @@
+use bevy::prelude::*;
+use bevy_simple_text_input::{
+    TextInputBundle, TextInputPlaceholder, TextInputPlugin, TextInputSettings, TextInputSubmitEvent,
+};
+use common::util::AsH160;
+use dcl_component::proto_components::social::friendship_event_response;
+use futures_lite::future::block_on;
+use social::{DirectChatMessage, SocialClient, SocialClientHandler, SocialPlugin};
+use tokio::sync::mpsc::unbounded_channel;
+use wallet::{Wallet, WalletPlugin};
+
+#[derive(Resource)]
+struct WalletSeed(Option<u32>);
+
+#[derive(Resource)]
+struct SocEvents(
+    tokio::sync::mpsc::UnboundedReceiver<friendship_event_response::Body>,
+    tokio::sync::mpsc::UnboundedReceiver<DirectChatMessage>,
+);
+
+fn main() {
+    let mut args = pico_args::Arguments::from_env();
+
+    let mut app = App::new();
+
+    app.insert_resource(WalletSeed(args.opt_value_from_str("--seed").unwrap()));
+    app.add_plugins(DefaultPlugins)
+        .add_plugins((WalletPlugin, TextInputPlugin, SocialPlugin))
+        .add_systems(Startup, setup)
+        .add_systems(Update, update)
+        .run();
+}
+
+#[derive(Component)]
+pub struct OutputMarker;
+
+fn setup(
+    mut commands: Commands,
+    mut wallet: ResMut<Wallet>,
+    seed: Res<WalletSeed>,
+    mut client: ResMut<SocialClient>,
+) {
+    match seed.0 {
+        Some(seed) => {
+            let mut seed_bytes: [u8; 32] = [43; 32];
+            for (to, from) in seed_bytes.iter_mut().zip(seed.to_le_bytes().into_iter()) {
+                *to = from;
+            }
+            wallet.finalize_as_guest_with_seed(seed_bytes)
+        }
+        None => wallet.finalize_as_guest(),
+    }
+    println!("{:#x}", wallet.address().unwrap());
+    let (sx, rx) = unbounded_channel();
+    let (sx_c, rx_c) = unbounded_channel();
+    commands.insert_resource(SocEvents(rx, rx_c));
+    client.0 = Some(
+        block_on(SocialClientHandler::connect(
+            wallet.clone(),
+            move |ev: &friendship_event_response::Body| {
+                let _ = sx.send(ev.clone());
+            },
+            move |ev: DirectChatMessage| {
+                let _ = sx_c.send(ev);
+            },
+        ))
+        .unwrap(),
+    );
+
+    commands.spawn(Camera3dBundle::default());
+
+    commands
+        .spawn(NodeBundle {
+            style: Style {
+                width: Val::Percent(100.0),
+                height: Val::Percent(100.0),
+                flex_direction: FlexDirection::Column,
+                justify_content: JustifyContent::SpaceBetween,
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .with_children(|c| {
+            c.spawn((
+                NodeBundle {
+                    style: Style {
+                        flex_grow: 1.0,
+                        flex_direction: FlexDirection::Column,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                OutputMarker,
+            ))
+            .with_children(|c| {
+                c.spawn(TextBundle {
+                    text: Text::from_section(
+                        format!("address: {:#x}", wallet.address().unwrap()),
+                        TextStyle::default(),
+                    ),
+                    ..Default::default()
+                });
+                c.spawn(TextBundle {
+                    text: Text::from_section(
+                        "valid commands:\n- clear\nfriend management:\n- request <address> [...message]\n- cancel <address>\n- accept <address>\n- reject <address>\n- delete <address>\ninfo:\n- friends\n- received\n- sent\nconversation:\n- chat <address> <message>\n- history <address> [count]\n".to_owned(),
+                        TextStyle::default(),
+                    ),
+                    ..Default::default()
+                });
+            });
+            c.spawn((
+                NodeBundle {
+                    style: Style {
+                        height: Val::Px(100.0),
+                        ..Default::default()
+                    },
+                    background_color: Color::srgba(0.0, 0.0, 1.0, 0.2).into(),
+                    ..Default::default()
+                },
+                TextInputBundle {
+                    settings: TextInputSettings {
+                        multiline: true,
+                        retain_on_submit: false,
+                        mask_character: None,
+                    },
+                    placeholder: TextInputPlaceholder {
+                        value: "Type here ...".into(),
+                        text_style: None,
+                    },
+                    ..Default::default()
+                },
+            ));
+        });
+}
+
+fn update(
+    mut commands: Commands,
+    mut c2: Commands,
+    mut client: ResMut<SocialClient>,
+    q: Query<(Entity, Option<&Children>), With<OutputMarker>>,
+    mut input: EventReader<TextInputSubmitEvent>,
+    mut evs: ResMut<SocEvents>,
+) {
+    let client = client.0.as_mut().unwrap();
+
+    let (output, children) = q.single();
+
+    let mut reply = |msg: String| {
+        let text = Text::from_section(msg, TextStyle::default());
+        let text = c2
+            .spawn(TextBundle {
+                text,
+                ..Default::default()
+            })
+            .id();
+        c2.entity(output).push_children(&[text]);
+    };
+
+    for ev in input.read() {
+        let text = Text::from_section(format!("> {}", ev.value), TextStyle::default());
+        let text = commands
+            .spawn(TextBundle {
+                text,
+                background_color: Color::srgba(0.0, 0.0, 1.0, 0.2).into(),
+                ..Default::default()
+            })
+            .id();
+        commands.entity(output).push_children(&[text]);
+
+        if ev.value.starts_with('/') {
+            let mut words = ev.value[1..].trim().split(' ');
+            let Some(cmd) = words.next() else {
+                continue;
+            };
+            match cmd {
+                "request" => {
+                    let Some(target) = words.next().and_then(|a| a.as_h160()) else {
+                        reply("expected address".to_owned());
+                        continue;
+                    };
+                    let message = ev.value[1..]
+                        .trim()
+                        .splitn(3, ' ')
+                        .nth(2)
+                        .map(ToOwned::to_owned);
+                    if let Err(e) = client.friend_request(target, message) {
+                        reply(format!("error: {e}"));
+                    } else {
+                        reply("ok".to_owned());
+                    }
+                }
+                "cancel" => {
+                    let Some(target) = words.next().and_then(|a| a.as_h160()) else {
+                        reply("expected address".to_string());
+                        continue;
+                    };
+                    if let Err(e) = client.cancel_request(target) {
+                        reply(format!("error: {e}"));
+                    } else {
+                        reply("ok".to_owned());
+                    }
+                }
+                "accept" => {
+                    let Some(target) = words.next().and_then(|a| a.as_h160()) else {
+                        reply("expected address".to_string());
+                        continue;
+                    };
+                    if let Err(e) = client.accept_request(target) {
+                        reply(format!("error: {e}"));
+                    } else {
+                        reply("ok".to_owned());
+                    }
+                }
+                "reject" => {
+                    let Some(target) = words.next().and_then(|a| a.as_h160()) else {
+                        reply("expected address".to_string());
+                        continue;
+                    };
+                    if let Err(e) = client.reject_request(target) {
+                        reply(format!("error: {e}"));
+                    } else {
+                        reply("ok".to_owned());
+                    }
+                }
+                "delete" => {
+                    let Some(target) = words.next().and_then(|a| a.as_h160()) else {
+                        reply("expected address".to_string());
+                        continue;
+                    };
+                    if let Err(e) = client.delete_friend(target) {
+                        reply(format!("error: {e}"));
+                    } else {
+                        reply("ok".to_owned());
+                    }
+                }
+                "friends" => {
+                    reply("friends:".to_owned());
+                    for friend in client.friends.iter() {
+                        reply(format!(" - {friend:#x?}"));
+                    }
+                }
+                "received" => {
+                    reply("received requests:".to_owned());
+                    for (address, message) in client.received_requests.iter() {
+                        reply(format!(
+                            " - {address:#x?}: {}",
+                            message
+                                .as_ref()
+                                .map(String::as_str)
+                                .unwrap_or("(no message)")
+                        ));
+                    }
+                }
+                "sent" => {
+                    reply("sent requests:".to_owned());
+                    for address in client.sent_requests.iter() {
+                        reply(format!(" - {address:#x?}",));
+                    }
+                }
+                "chat" => {
+                    let Some(target) = words.next().and_then(|a| a.as_h160()) else {
+                        reply("expected address".to_string());
+                        continue;
+                    };
+                    let Some(message) = ev.value[1..]
+                        .trim()
+                        .splitn(3, ' ')
+                        .nth(2)
+                        .map(ToOwned::to_owned)
+                    else {
+                        reply("expected message".to_string());
+                        continue;
+                    };
+                    if let Err(e) = client.chat(target, message) {
+                        reply(format!("error: {e}"));
+                    } else {
+                        reply("ok".to_owned());
+                    }
+                }
+                "history" => {
+                    let Some(target) = words.next().and_then(|a| a.as_h160()) else {
+                        reply("expected address".to_string());
+                        continue;
+                    };
+                    let count = words.next().and_then(|n| n.parse::<usize>().ok());
+                    match client.get_chat_history(target) {
+                        Err(e) => {
+                            reply(format!("error: {e}"));
+                        }
+                        Ok(mut rx) => {
+                            reply("chat history:".to_owned());
+                            let mut read = 0;
+                            while let Some(next) = rx.blocking_recv() {
+                                reply(format!(
+                                    " [with {:#x}] {} : {}",
+                                    next.partner,
+                                    if next.me_speaking { " me " } else { "them" },
+                                    next.message
+                                ));
+                                read += 1;
+                                if count.map_or(false, |c| read == c) {
+                                    reply("[truncated]".to_owned());
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                "clear" => {
+                    if let Some(children) = children {
+                        for child in children.iter().rev().skip(1) {
+                            commands.entity(*child).despawn_recursive();
+                        }
+                    }
+                }
+                _ => {
+                    reply(format!("unrecognised commands `{cmd}`"));
+                }
+            }
+        }
+    }
+
+    while let Ok(ev) = evs.0.try_recv() {
+        reply(format!(" event -> {ev:?}"));
+    }
+    while let Ok(ev) = evs.1.try_recv() {
+        reply(format!(" chat -> {ev:?}"));
+    }
+}