QUIC

Accepted transaction   01 00 00 00
Refused transaction    01 03 LL LL {"reason":"missing_tip",...}
Accepted bundle        03 00 ID...(32 bytes) 00 00

[package]
name = "swqos-quic-example"
version = "0.1.0"
edition = "2024"

[dependencies]
quinn = { version = "0.11", default-features = false, features = ["runtime-tokio", "rustls-ring"] }
rcgen = "0.14"
rustls = { version = "0.23", default-features = false, features = ["std", "ring"] }
tokio = { version = "1", features = ["macros", "rt-multi-thread", "net"] }
webpki-roots = "1"

use std::{net::SocketAddr, sync::Arc, time::Duration};

use quinn::crypto::rustls::QuicClientConfig;
use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer};

const HOST: &str = "fra.sol.zerocopy.sh";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("SWQOS_API_KEY")?;
    let path = std::env::args().nth(1).ok_or("usage: swqos-quic-example SIGNED_TX_FILE")?;
    let transaction = std::fs::read(path)?;

    // A self-signed client certificate whose subject common name is the API key.
    let mut params = rcgen::CertificateParams::new(Vec::<String>::new())?;
    let mut name = rcgen::DistinguishedName::new();
    name.push(rcgen::DnType::CommonName, api_key.as_str());
    params.distinguished_name = name;
    let key_pair = rcgen::KeyPair::generate()?;
    let certificate = params.self_signed(&key_pair)?;
    let chain = vec![CertificateDer::from(certificate.der().to_vec())];
    let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(key_pair.serialize_der()));

    let roots = rustls::RootCertStore::from_iter(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
    let provider = Arc::new(rustls::crypto::ring::default_provider());
    let mut tls = rustls::ClientConfig::builder_with_provider(provider)
        .with_protocol_versions(&[&rustls::version::TLS13])?
        .with_root_certificates(roots)
        .with_client_auth_cert(chain, key)?;
    tls.alpn_protocols = vec![b"zerocopy-swqos/1".to_vec()];

    // The server closes a connection after 30 seconds without traffic.
    let mut transport = quinn::TransportConfig::default();
    transport.keep_alive_interval(Some(Duration::from_secs(5)));
    let mut config = quinn::ClientConfig::new(Arc::new(QuicClientConfig::try_from(tls)?));
    config.transport_config(Arc::new(transport));

    let address = tokio::net::lookup_host((HOST, 443))
        .await?
        .find(SocketAddr::is_ipv4)
        .ok_or("no IPv4 address")?;
    let mut endpoint = quinn::Endpoint::client(SocketAddr::from(([0, 0, 0, 0], 0)))?;
    endpoint.set_default_client_config(config);
    let connection = endpoint.connect(address, HOST)?.await?;

    // Kind 0x01, flags 0x00 (no preflight), then the bare signed transaction.
    let (mut send, mut recv) = connection.open_bi().await?;
    send.write_all(&[0x01, 0x00]).await?;
    send.write_all(&transaction).await?;
    send.finish()?;
    let reply = recv.read_to_end(4 + usize::from(u16::MAX)).await?;

    let [0x01, code, low, high, detail @ ..] = reply.as_slice() else {
        return Err("unexpected reply frame".into());
    };
    let length = usize::from(u16::from_le_bytes([*low, *high]));
    let detail = detail.get(..length).ok_or("short reply frame")?;
    if *code == 0 {
        println!("accepted");
    } else {
        println!("refused with code {code}: {}", String::from_utf8_lossy(detail));
    }

    connection.close(0u32.into(), b"done");
    endpoint.wait_idle().await;
    Ok(())
}