github/tlsn-js
1
1
Fork 0
mirror of https://github.com/tlsnotary/tlsn-js.git synced 2026-04-02 03:00:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

cleanup

Browse Source
This commit is contained in:
Hendrik Eeckhaut
2025-09-23 11:42:03 +02:00
parent 62dc1e3c74
commit 767425e5bf
5 changed files with 42 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
demo/interactive/tlsn-demo-server/src/config.rs
View File

@@ -12,24 +12,24 @@ pub const SECRET: &str = "TLSNotary's private key 🤡";
/// Default server configuration
pub struct Config {
pub host: String,
pub port: u16,
pub server_url: Uri,
pub ws_host: String, // Address for WebSocket server
pub ws_port: u16, // Port for WebSocket server
pub server_uri: Uri, // URI of the server from which data is proven with TLSNotary
}
impl Default for Config {
fn default() -> Self {
Self {
host: "0.0.0.0".into(),
port: 9816,
server_url:
ws_host: "0.0.0.0".into(),
ws_port: 9816,
server_uri:
"https://raw.githubusercontent.com/tlsnotary/tlsn/refs/tags/v0.1.0-alpha.12/crates/server-fixture/server/src/data/1kb.json".parse::<Uri>().unwrap(),
}
}
}
impl Config {
pub fn server_domain(&self) -> String {
self.server_url
self.server_uri
.host()
.expect("Server URL must have a valid domain")
.to_string()

17
demo/interactive/tlsn-demo-server/src/lib.rs
View File

@@ -22,7 +22,6 @@ mod axum_websocket;
pub mod config;
pub mod prover;
pub mod verifier;
pub mod websocket_utils;
use prover::prover;
use verifier::verifier;
@@ -32,25 +31,25 @@ struct ServerGlobals {
pub server_uri: Uri,
}
pub async fn run_server(config: &config::Config) -> Result<(), eyre::ErrReport> {
let prover_address = SocketAddr::new(
IpAddr::V4(config.host.parse().map_err(|err| {
eyre!("Failed to parse prover host address from server config: {err}")
pub async fn run_ws_server(config: &config::Config) -> Result<(), eyre::ErrReport> {
let ws_server_address = SocketAddr::new(
IpAddr::V4(config.ws_host.parse().map_err(|err| {
eyre!("Failed to parse websocket host address from server config: {err}")
})?),
config.port,
config.ws_port,
);
let listener = TcpListener::bind(prover_address)
let listener = TcpListener::bind(ws_server_address)
.await
.map_err(|err| eyre!("Failed to bind server address to tcp listener: {err}"))?;
info!("Listening for TCP traffic at {}", prover_address);
info!("Listening for TCP traffic at {}", ws_server_address);
let protocol = Arc::new(http1::Builder::new());
let router = Router::new()
.route("/prove", get(ws_handler_prover))
.route("/verify", get(ws_handler_verifier))
.with_state(ServerGlobals {
server_uri: config.server_url.clone(),
server_uri: config.server_uri.clone(),
});
loop {

4
demo/interactive/tlsn-demo-server/src/main.rs
View File

@@ -1,4 +1,4 @@
use tlsn_demo_server::{config::Config, run_server};
use tlsn_demo_server::{config::Config, run_ws_server};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
const TRACING_FILTER: &str = "INFO";
@@ -11,7 +11,7 @@ async fn main() -> Result<(), eyre::ErrReport> {
.init();
let config: Config = Config::default();
run_server(&config).await?;
run_ws_server(&config).await?;
Ok(())
}

17
demo/interactive/tlsn-demo-server/src/websocket_utils.rs
View File

@@ -1,17 +0,0 @@
/// Shared utilities for WebSocket connection handling
use uuid;
/// Create a WebSocket connection request with standard headers
/// This eliminates duplication of WebSocket request creation across modules
pub fn create_websocket_request(host: &str, port: u16, path: &str) -> http::Request<()> {
http::Request::builder()
.uri(format!("ws://{host}:{port}{path}"))
.header("Host", host)
.header("Sec-WebSocket-Key", uuid::Uuid::new_v4().to_string())
.header("Sec-WebSocket-Version", "13")
.header("Connection", "Upgrade")
.header("Upgrade", "Websocket")
.body(())
.unwrap()
}

38
demo/interactive/tlsn-demo-server/tests/integration_test.rs
View File

@@ -1,14 +1,12 @@
use std::time::Duration;
use tlsn_demo_server::{config::Config, prover::prover, run_server, verifier::verifier};
use tokio::time::timeout;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
use async_tungstenite::{tokio::connect_async_with_config, tungstenite::protocol::WebSocketConfig};
use eyre::eyre;
use tlsn_demo_server::websocket_utils::create_websocket_request;
use std::time::Duration;
use tlsn_demo_server::{config::Config, prover::prover, run_ws_server, verifier::verifier};
use tokio::time::timeout;
use tracing::info;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
use uuid;
use ws_stream_tungstenite::WsStream;
const TRACING_FILTER: &str = "INFO";
const SERVER_START_DELAY: Duration = Duration::from_millis(500);
const TEST_TIMEOUT: Duration = Duration::from_secs(60);
@@ -23,12 +21,26 @@ fn init_tracing() {
async fn start_test_server() -> tokio::task::JoinHandle<()> {
tokio::spawn(async move {
let config = Config::default();
run_server(&config)
run_ws_server(&config)
.await
.expect("Server should start successfully")
})
}
/// Create a WebSocket connection request with standard headers
/// This eliminates duplication of WebSocket request creation across modules
pub fn create_websocket_request(host: &str, port: u16, path: &str) -> http::Request<()> {
http::Request::builder()
.uri(format!("ws://{host}:{port}{path}"))
.header("Host", host)
.header("Sec-WebSocket-Key", uuid::Uuid::new_v4().to_string())
.header("Sec-WebSocket-Version", "13")
.header("Connection", "Upgrade")
.header("Upgrade", "Websocket")
.body(())
.unwrap()
}
#[tokio::test]
async fn test_prover_verifier_integration() {
init_tracing();
@@ -39,7 +51,7 @@ async fn test_prover_verifier_integration() {
let config = Config::default();
let result = timeout(TEST_TIMEOUT, async {
info!("Connecting to server as verifier...");
let request = create_websocket_request(&config.host, config.port, "/prove");
let request = create_websocket_request(&config.ws_host, config.ws_port, "/prove");
let (ws_stream, _) = connect_async_with_config(request, Some(WebSocketConfig::default()))
.await
.map_err(|e| eyre!("Failed to connect to server: {}", e))?;
@@ -72,13 +84,13 @@ async fn test_verifier_prover_integration() {
let config = Config::default();
let result = timeout(TEST_TIMEOUT, async {
info!("Connecting to server as prover...");
let request = create_websocket_request(&config.host, config.port, "/verify");
let request = create_websocket_request(&config.ws_host, config.ws_port, "/verify");
let (ws_stream, _) = connect_async_with_config(request, Some(WebSocketConfig::default()))
.await
.map_err(|e| eyre!("Failed to connect to server: {}", e))?;
let server_ws_socket = WsStream::new(ws_stream);
info!("WebSocket connection established with server!");
prover(server_ws_socket, &config.server_url).await?;
prover(server_ws_socket, &config.server_uri).await?;
info!("Proving completed successfully!");
Ok::<(), eyre::ErrReport>(())
})
@@ -100,13 +112,13 @@ async fn test_verifier_connection_failure() {
init_tracing();
let config = Config {
port: 54321, // Non-existent port
ws_port: 54321, // Non-existent port
..Config::default()
};
let result = timeout(Duration::from_secs(5), async {
info!("Connecting to server as verifier...");
let request = create_websocket_request(&config.host, config.port, "/prove");
let request = create_websocket_request(&config.ws_host, config.ws_port, "/prove");
let (ws_stream, _) = connect_async_with_config(request, Some(WebSocketConfig::default()))
.await
.map_err(|e| eyre!("Failed to connect to server: {}", e))?;