Dev

Cargo.toml

@@ -3,15 +3,16 @@ members = [
   "pubky",
   "pubky-*", 
 
+  "http-relay",
+
   "examples"
 ]
 
 # See: https://github.com/rust-lang/rust/issues/90148#issuecomment-949194352
 resolver = "2"
 
 [workspace.dependencies]
-pkarr = { version = "2.0.0", git = "https://github.com/Pubky/pkarr", branch = "serde", package = "pkarr", features = ["async", "serde"] }
-serde = { version = "^1.0.209", features = ["derive"] }
+pkarr = { git = "https://github.com/Pubky/pkarr", branch = "v3", package = "pkarr" }
 
 [profile.release]
 lto = true

examples/Cargo.toml

@@ -16,12 +16,13 @@ name = "request"
 path = "./request/main.rs"
 
 [dependencies]
-anyhow = "1.0.86"
+anyhow = "1.0.94"
 base64 = "0.22.1"
-clap = { version = "4.5.16", features = ["derive"] }
+clap = { version = "4.5.23", features = ["derive"] }
 pubky = { path = "../pubky" }
 pubky-common = { version = "0.1.0", path = "../pubky-common" }
-reqwest = "0.12.8"
+reqwest = "0.12.9"
 rpassword = "7.3.1"
-tokio = { version = "1.40.0", features = ["macros", "rt-multi-thread"] }
-url = "2.5.2"
+tokio = { version = "1.42.0", features = ["macros", "rt-multi-thread"] }
+tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
+url = "2.5.4"

examples/authn/signup.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use clap::Parser;
-use pubky::PubkyClient;
+use pubky::Client;
 use std::path::PathBuf;
 
 use pubky_common::crypto::PublicKey;
@@ -24,7 +24,7 @@ async fn main() -> Result<()> {
 
     let homeserver = cli.homeserver;
 
-    let client = PubkyClient::builder().build();
+    let client = Client::new()?;
 
     println!("Enter your recovery_file's passphrase to signup:");
     let passphrase = rpassword::read_password()?;

examples/authz/3rd-party-app/src/pubky-auth-widget.js

@@ -56,8 +56,8 @@ export class PubkyAuthWidget extends LitElement {
     this.testnet = false;
     this.open = false;
 
-    /** @type {import("@synonymdev/pubky").PubkyClient} */
-    this.pubkyClient = new window.pubky.PubkyClient();
+    /** @type {import("@synonymdev/pubky").Client} */
+    this.pubkyClient = new window.pubky.Client();
 
     this.caps = this.caps || ""
   }
@@ -74,9 +74,9 @@ export class PubkyAuthWidget extends LitElement {
     console.debug("Switching testnet");
 
     if (this.testnet) {
-      this.pubkyClient = window.pubky.PubkyClient.testnet()
+      this.pubkyClient = window.pubky.Client.testnet()
     } else {
-      this.pubkyClient = new window.pubky.PubkyClient();
+      this.pubkyClient = new window.pubky.Client();
     }
 
     console.debug("Pkarr Relays: " + this.pubkyClient.getPkarrRelays())

examples/authz/authenticator.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use clap::Parser;
-use pubky::PubkyClient;
+use pubky::Client;
 use std::path::PathBuf;
 use url::Url;
 
@@ -66,7 +66,7 @@ async fn main() -> Result<()> {
     println!("PublicKey: {}", keypair.public_key());
 
     let client = if cli.testnet.unwrap_or_default() {
-        let client = PubkyClient::testnet();
+        let client = Client::testnet()?;
 
         // For the purposes of this demo, we need to make sure
         // the user has an account on the local homeserver.
@@ -78,7 +78,7 @@ async fn main() -> Result<()> {
 
         client
     } else {
-        PubkyClient::builder().build()
+        Client::new()?
     };
 
     println!("Sending AuthToken to the 3rd party app...");

examples/request/main.rs

@@ -1,9 +1,11 @@
+use std::env;
+
 use anyhow::Result;
 use clap::Parser;
 use reqwest::Method;
 use url::Url;
 
-use pubky::PubkyClient;
+use pubky::Client;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -16,23 +18,31 @@ struct Cli {
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let cli = Cli::parse();
+    let args = Cli::parse();
 
-    let client = PubkyClient::builder().build();
+    tracing_subscriber::fmt()
+        .with_env_filter(env::var("TRACING").unwrap_or("info".to_string()))
+        .init();
 
-    match cli.url.scheme() {
-        "https" => {
-            unimplemented!();
-        }
-        "pubky" => {
-            let response = client.get(cli.url).await.unwrap();
+    let client = Client::new()?;
 
-            println!("Got a response: \n {:?}", response);
-        }
-        _ => {
-            panic!("Only https:// and pubky:// URL schemes are supported")
+    // Build the request
+    let response = client.get(args.url).send().await?;
+
+    println!("< Response:");
+    println!("< {:?} {}", response.version(), response.status());
+    for (name, value) in response.headers() {
+        if let Ok(v) = value.to_str() {
+            println!("< {name}: {v}");
         }
     }
 
+    let bytes = response.bytes().await?;
+
+    match String::from_utf8(bytes.to_vec()) {
+        Ok(string) => println!("<\n{}", string),
+        Err(_) => println!("<\n{:?}", bytes),
+    }
+
     Ok(())
 }

http-relay/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "http-relay"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.94"
+axum = "0.7.9"
+axum-server = "0.7.1"
+futures-util = "0.3.31"
+tokio = { version = "1.42.0", features = ["full"] }
+tracing = "0.1.41"
+url = "2.5.4"

http-relay/README.md

@@ -0,0 +1,7 @@
+# HTTP Relay
+
+A Rust implementation of _some_ of [Http relay spec](https://httprelay.io/).
+
+Normally you are better off running the [reference implementation's binary](https://httprelay.io/download/).
+
+This implementation, for the time being is meant for having a convenient library to be used in unit tests, and testnets in Pubky.

http-relay/src/lib.rs

@@ -0,0 +1,167 @@
+use std::{
+    collections::HashMap,
+    net::{SocketAddr, TcpListener},
+    sync::{Arc, Mutex},
+};
+
+use anyhow::Result;
+
+use axum::{
+    body::{Body, Bytes},
+    extract::{Path, State},
+    response::IntoResponse,
+    routing::get,
+    Router,
+};
+use axum_server::Handle;
+use tokio::sync::Notify;
+
+use futures_util::{stream::StreamExt, TryFutureExt};
+use url::Url;
+
+// Shared state to store GET requests and their notifications
+type SharedState = Arc<Mutex<HashMap<String, (Vec<u8>, Arc<Notify>)>>>;
+
+#[derive(Debug, Default)]
+pub struct Config {
+    pub http_port: u16,
+}
+
+#[derive(Debug, Default)]
+pub struct HttpRelayBuilder(Config);
+
+impl HttpRelayBuilder {
+    /// Configure the port used for HTTP server.
+    pub fn http_port(mut self, port: u16) -> Self {
+        self.0.http_port = port;
+
+        self
+    }
+
+    pub async fn build(self) -> Result<HttpRelay> {
+        HttpRelay::start(self.0).await
+    }
+}
+
+pub struct HttpRelay {
+    pub(crate) http_handle: Handle,
+
+    http_address: SocketAddr,
+}
+
+impl HttpRelay {
+    pub fn builder() -> HttpRelayBuilder {
+        HttpRelayBuilder::default()
+    }
+
+    pub async fn start(config: Config) -> Result<Self> {
+        let shared_state: SharedState = Arc::new(Mutex::new(HashMap::new()));
+
+        let app = Router::new()
+            .route("/link/:id", get(link::get).post(link::post))
+            .with_state(shared_state);
+
+        let http_handle = Handle::new();
+
+        let http_listener = TcpListener::bind(SocketAddr::from(([0, 0, 0, 0], config.http_port)))?;
+        let http_address = http_listener.local_addr()?;
+
+        tokio::spawn(
+            axum_server::from_tcp(http_listener)
+                .handle(http_handle.clone())
+                .serve(app.into_make_service())
+                .map_err(|error| tracing::error!(?error, "HttpRelay http server error")),
+        );
+
+        Ok(Self {
+            http_handle,
+            http_address,
+        })
+    }
+
+    pub fn http_address(&self) -> SocketAddr {
+        self.http_address
+    }
+
+    /// Returns the localhost Url of this server.
+    pub fn local_url(&self) -> Url {
+        Url::parse(&format!("http://localhost:{}", self.http_address.port()))
+            .expect("local_url should be formatted fine")
+    }
+
+    /// Returns the localhost URL of Link endpoints
+    pub fn local_link_url(&self) -> Url {
+        let mut url = self.local_url();
+
+        let mut segments = url
+            .path_segments_mut()
+            .expect("HttpRelay::local_link_url path_segments_mut");
+
+        segments.push("link");
+
+        drop(segments);
+
+        url
+    }
+
+    pub fn shutdown(&self) {
+        self.http_handle.shutdown();
+    }
+}
+
+mod link {
+    use super::*;
+
+    pub async fn get(
+        Path(id): Path<String>,
+        State(state): State<SharedState>,
+    ) -> impl IntoResponse {
+        // Create a notification for this ID
+        let notify = Arc::new(Notify::new());
+
+        {
+            let mut map = state.lock().unwrap();
+
+            // Store the notification and return it when POST arrives
+            map.entry(id.clone())
+                .or_insert_with(|| (vec![], notify.clone()));
+        }
+
+        notify.notified().await;
+
+        // Respond with the data stored for this ID
+        let map = state.lock().unwrap();
+        if let Some((data, _)) = map.get(&id) {
+            Bytes::from(data.clone()).into_response()
+        } else {
+            (axum::http::StatusCode::NOT_FOUND, "Not Found").into_response()
+        }
+    }
+
+    pub async fn post(
+        Path(id): Path<String>,
+        State(state): State<SharedState>,
+        body: Body,
+    ) -> impl IntoResponse {
+        // Aggregate the body into bytes
+        let mut stream = body.into_data_stream();
+        let mut bytes = vec![];
+        while let Some(next) = stream.next().await {
+            let chunk = next.map_err(|e| e.to_string()).unwrap();
+            bytes.extend_from_slice(&chunk);
+        }
+
+        // Notify any waiting GET request for this ID
+        let mut map = state.lock().unwrap();
+        if let Some((storage, notify)) = map.get_mut(&id) {
+            *storage = bytes;
+            notify.notify_one();
+            Ok(())
+        } else {
+            Err((
+                axum::http::StatusCode::NOT_FOUND,
+                "No waiting GET request for this ID",
+            ))
+        }
+    }
+}

pubky-common/Cargo.toml

@@ -9,22 +9,22 @@ repository = "https://github.com/pubky/pubky-core"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-base32 = "0.5.0"
-blake3 = "1.5.1"
+base32 = "0.5.1"
+blake3 = "1.5.5"
 ed25519-dalek = { version = "2.1.1", features = ["serde"] }
-once_cell = "1.19.0"
+once_cell = "1.20.2"
 rand = "0.8.5"
-thiserror = "1.0.60"
-postcard = { version = "1.0.8", features = ["alloc"] }
+thiserror = "2.0.6"
+postcard = { version = "1.1.1", features = ["alloc"] }
 crypto_secretbox = { version = "0.1.1", features = ["std"] }
 argon2 = { version = "0.5.3", features = ["std"] }
 
 pubky-timestamp = { version = "0.2.0", features = ["full"] }
-serde = { version = "1.0.213", features = ["derive"] }
-pkarr = { version = "2.2.1-alpha.2", features = ["serde"] }
+serde = { version = "1.0.216", features = ["derive"] }
+pkarr = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-js-sys = "0.3.69"
+js-sys = "0.3.76"
 
 [dev-dependencies]
-postcard = "1.0.8"
+postcard = "1.1.1"