rostra-client 0.1.3

Integration runtime for Rostra peer-to-peer clients
Documentation
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;

use rostra_client_db::Database;
use rostra_core::event::{Event, EventContentRaw, EventKind, SignedEvent, VerifiedEvent};
use rostra_core::id::{RostraId, RostraIdSecretKey};
use rostra_p2p::connection::{
    Connection, MAX_REQUEST_SIZE, PingRequest, PingResponse, RpcId, RpcMessage as _,
    WaitFollowersNewHeadsRequest, WaitFollowersNewHeadsResponse,
};
use rostra_p2p_api::ROSTRA_P2P_V0_ALPN;
use tokio::sync::{RwLock, mpsc, oneshot};

use super::{PeerBackoffState, PollFollowerHeadUpdates, SharedBackoffState};

fn signed_event(secret: RostraIdSecretKey, content_byte: u8) -> SignedEvent {
    let content = EventContentRaw::new(vec![content_byte]);
    Event::builder_raw_content()
        .author(secret.id())
        .kind(EventKind::NULL)
        .content(&content)
        .build()
        .signed_by(secret)
}

fn verified_event_with_author(
    secret: RostraIdSecretKey,
    author: RostraId,
    content_byte: u8,
) -> VerifiedEvent {
    let mut event = VerifiedEvent::verify_signed(secret.id(), signed_event(secret, content_byte))
        .expect("fixture signature");
    event.event.author = author;
    event.event_id = event.event.compute_id();
    event
}

async fn connection_returning(
    response: WaitFollowersNewHeadsResponse,
) -> (
    Connection,
    iroh::Endpoint,
    oneshot::Sender<()>,
    tokio::task::JoinHandle<()>,
) {
    let lookup = iroh::address_lookup::memory::MemoryLookup::new();
    let server_endpoint = iroh::Endpoint::builder(iroh::endpoint::presets::Minimal)
        .relay_mode(iroh::RelayMode::Disabled)
        .alpns(vec![ROSTRA_P2P_V0_ALPN.to_vec()])
        .address_lookup(lookup.clone())
        .bind()
        .await
        .expect("server endpoint");
    let server_id = server_endpoint.id();
    lookup.add_endpoint_info(server_endpoint.addr());

    let (release_server, released) = oneshot::channel();
    let server = tokio::spawn(async move {
        let incoming = server_endpoint.accept().await.expect("incoming connection");
        let connection = incoming
            .accept()
            .expect("accept connection")
            .await
            .expect("complete handshake");
        let (mut send, mut recv) = connection.accept_bi().await.expect("RPC stream");
        let (rpc_id, request) = Connection::read_request_raw(&mut recv)
            .await
            .expect("RPC request");
        assert_eq!(rpc_id, RpcId::WAIT_FOLLOWERS_NEW_HEADS);
        WaitFollowersNewHeadsRequest::decode_whole::<MAX_REQUEST_SIZE>(&request)
            .expect("WAIT_FOLLOWERS_NEW_HEADS request");

        Connection::write_success_return_code(&mut send)
            .await
            .expect("success return code");
        Connection::write_message(&mut send, &response)
            .await
            .expect("RPC response");
        send.finish().expect("finish RPC response");
        released.await.expect("release test server");
        server_endpoint.close().await;
    });

    let caller_endpoint = iroh::Endpoint::builder(iroh::endpoint::presets::Minimal)
        .relay_mode(iroh::RelayMode::Disabled)
        .alpns(vec![ROSTRA_P2P_V0_ALPN.to_vec()])
        .address_lookup(lookup)
        .bind()
        .await
        .expect("caller endpoint");
    let connection = caller_endpoint
        .connect(server_id, ROSTRA_P2P_V0_ALPN)
        .await
        .expect("connect to server");

    (
        Connection::from(connection),
        caller_endpoint,
        release_server,
        server,
    )
}

#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn rpc_ingests_event_when_claimed_and_signed_authors_match() {
    let self_secret = RostraIdSecretKey::generate();
    let self_id = self_secret.id();
    let event = signed_event(self_secret, 1);
    let event_id = event.compute_short_id();
    let db = Database::new_in_memory(self_id)
        .await
        .expect("in-memory database");
    let wot = db.self_wot_subscribe();
    let (connection, caller_endpoint, release_server, server) =
        connection_returning(WaitFollowersNewHeadsResponse {
            author: self_id,
            event,
        })
        .await;

    let event = PollFollowerHeadUpdates::poll_once(&connection, self_id, &wot)
        .await
        .expect("matching self-authored response is admitted")
        .expect("self-authored response is in the web of trust");
    db.try_process_event(&event)
        .await
        .expect("admitted response is stored");
    release_server.send(()).expect("release server");
    server.await.expect("test server");
    drop(connection);
    caller_endpoint.close().await;

    assert!(db.has_event(event_id).await);
}

#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn rpc_rejects_trusted_claim_with_event_signed_by_another_author() {
    let self_secret = RostraIdSecretKey::generate();
    let self_id = self_secret.id();
    let attacker_secret = RostraIdSecretKey::generate();
    let attacker_event = signed_event(attacker_secret, 2);
    let attacker_event_id = attacker_event.compute_short_id();
    let db = Database::new_in_memory(self_id)
        .await
        .expect("in-memory database");
    let wot = db.self_wot_subscribe();
    let (connection, caller_endpoint, release_server, server) =
        connection_returning(WaitFollowersNewHeadsResponse {
            author: self_id,
            event: attacker_event,
        })
        .await;

    let error = PollFollowerHeadUpdates::poll_once(&connection, self_id, &wot)
        .await
        .expect_err("claimed author must match the signed event author");
    release_server.send(()).expect("release server");
    server.await.expect("test server");
    drop(connection);
    caller_endpoint.close().await;

    assert!(
        error.to_string().contains("AuthorMismatch"),
        "unexpected verification error: {error}"
    );
    assert!(!db.has_event(attacker_event_id).await);
}

#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn storage_failure_stops_before_resetting_peer_backoff() {
    let first_secret = RostraIdSecretKey::from_bytes([41; 32]);
    let second_secret = RostraIdSecretKey::from_bytes([42; 32]);
    let (prefix, first_rest) = first_secret.id().split();
    let (_, second_rest) = second_secret.id().split();
    let first_author = RostraId::assemble(prefix, first_rest);
    let second_author = RostraId::assemble(prefix, second_rest);
    let first = verified_event_with_author(first_secret, first_author, 3);
    let second = verified_event_with_author(second_secret, second_author, 4);
    let db = Database::new_in_memory(first_author)
        .await
        .expect("in-memory database");
    db.try_process_event(&first)
        .await
        .expect("first identity mapping");

    let peer_id = RostraIdSecretKey::from_bytes([43; 32]).id();
    let backoff_until = tokio::time::Instant::now() + Duration::from_secs(30);
    let backoff_state: SharedBackoffState = Arc::new(RwLock::new(HashMap::from([(
        peer_id,
        PeerBackoffState {
            consecutive_failures: 2,
            backoff_until: Some(backoff_until),
        },
    )])));

    PollFollowerHeadUpdates::finish_successful_poll(&db, peer_id, Some(&second), &backoff_state)
        .await
        .expect_err("identity collision must remain a database failure");

    let state = backoff_state.read().await;
    let peer_state = state.get(&peer_id).expect("peer backoff state");
    assert_eq!(peer_state.consecutive_failures, 2);
    assert_eq!(peer_state.backoff_until, Some(backoff_until));
}

#[test_log::test(tokio::test(flavor = "multi_thread"))]
async fn replayed_follower_head_responses_are_rate_limited() {
    let self_secret = RostraIdSecretKey::generate();
    let self_id = self_secret.id();
    let replayed_event = signed_event(self_secret, 7);
    let inserted_event = signed_event(self_secret, 8);
    let admitted_replay =
        VerifiedEvent::verify_signed(self_id, replayed_event).expect("correctly signed replay");
    let db = Database::new_in_memory(self_id)
        .await
        .expect("in-memory database");
    let (outcome, _) = db
        .try_process_event(&admitted_replay)
        .await
        .expect("seed replay in database");
    assert!(matches!(
        outcome,
        rostra_client_db::InsertEventOutcome::Inserted { .. }
    ));

    let lookup = iroh::address_lookup::memory::MemoryLookup::new();
    let server_endpoint = iroh::Endpoint::builder(iroh::endpoint::presets::Minimal)
        .relay_mode(iroh::RelayMode::Disabled)
        .alpns(vec![ROSTRA_P2P_V0_ALPN.to_vec()])
        .address_lookup(lookup.clone())
        .bind()
        .await
        .expect("server endpoint");
    let server_id = server_endpoint.id();
    lookup.add_endpoint_info(server_endpoint.addr());

    let (requests_tx, mut requests_rx) = mpsc::unbounded_channel();
    let server = tokio::spawn(async move {
        let incoming = server_endpoint.accept().await.expect("incoming connection");
        let connection = incoming
            .accept()
            .expect("accept connection")
            .await
            .expect("complete handshake");
        let mut response_count = 0;
        loop {
            let (mut send, mut recv) = connection.accept_bi().await.expect("RPC stream");
            let (rpc_id, request) = Connection::read_request_raw(&mut recv)
                .await
                .expect("RPC request");
            match rpc_id {
                RpcId::PING => {
                    assert_eq!(
                        PingRequest::decode_whole::<MAX_REQUEST_SIZE>(&request)
                            .expect("decode ping")
                            .0,
                        0
                    );
                    Connection::write_success_return_code(&mut send)
                        .await
                        .expect("ping success");
                    Connection::write_message(&mut send, &PingResponse(0))
                        .await
                        .expect("ping response");
                }
                RpcId::WAIT_FOLLOWERS_NEW_HEADS => {
                    WaitFollowersNewHeadsRequest::decode_whole::<MAX_REQUEST_SIZE>(&request)
                        .expect("decode follower-head request");
                    requests_tx.send(()).expect("request receiver");
                    let event = if response_count == 0 {
                        replayed_event
                    } else {
                        inserted_event
                    };
                    response_count += 1;
                    Connection::write_success_return_code(&mut send)
                        .await
                        .expect("poll success");
                    Connection::write_message(
                        &mut send,
                        &WaitFollowersNewHeadsResponse {
                            author: self_id,
                            event,
                        },
                    )
                    .await
                    .expect("poll response");
                    send.finish().expect("finish poll response");
                }
                other => panic!("unexpected RPC {other:?}"),
            }
        }
    });

    let client_endpoint = iroh::Endpoint::builder(iroh::endpoint::presets::Minimal)
        .relay_mode(iroh::RelayMode::Disabled)
        .alpns(vec![ROSTRA_P2P_V0_ALPN.to_vec()])
        .address_lookup(lookup)
        .bind()
        .await
        .expect("client endpoint");
    let connection = Connection::from(
        client_endpoint
            .connect(server_id, ROSTRA_P2P_V0_ALPN)
            .await
            .expect("connect to server"),
    );
    let wot = db.self_wot_subscribe();
    let polling_connection = connection.clone();
    let polling = tokio::spawn(async move {
        PollFollowerHeadUpdates::poll_connection_for_heads(
            &polling_connection,
            &db,
            self_id,
            RostraIdSecretKey::generate().id(),
            &wot,
            &Arc::new(RwLock::new(HashMap::new())),
        )
        .await
    });

    requests_rx.recv().await.expect("first replay request");
    let first_request_at = tokio::time::Instant::now();
    assert!(
        tokio::time::timeout(Duration::from_millis(200), requests_rx.recv())
            .await
            .is_err(),
        "a replay must not trigger an immediate poll"
    );

    tokio::time::timeout(Duration::from_secs(2), requests_rx.recv())
        .await
        .expect("rate-limit interval")
        .expect("second request after replay delay");
    assert!(
        super::NO_PROGRESS_POLL_DELAY <= first_request_at.elapsed(),
        "replay delay was shorter than the configured interval"
    );
    let insertion_request_at = tokio::time::Instant::now();
    tokio::time::timeout(Duration::from_millis(200), requests_rx.recv())
        .await
        .expect("new insertion must repoll immediately")
        .expect("third request after insertion");
    assert!(
        insertion_request_at.elapsed() < Duration::from_millis(200),
        "new insertion did not trigger an immediate poll"
    );
    assert!(
        tokio::time::timeout(Duration::from_millis(200), requests_rx.recv())
            .await
            .is_err(),
        "the now-replayed inserted event must rate-limit the fourth request"
    );

    polling.abort();
    server.abort();
    drop(connection);
    client_endpoint.close().await;
}