Glaive Docs

curl "http://ams1.glaive.trade?key=YOUR_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": [
      "<base64-encoded-transaction>",
      { "encoding": "base64" }
    ]
  }'

curl "http://ams1.glaive.trade/plain?api-key=YOUR_API_KEY" \
  -X POST \
  -d '<base64-encoded-transaction>'

curl "http://ams1.glaive.trade/binary?api-key=YOUR_API_KEY" \
  -X POST \
  -H "Content-Type: application/octet-stream" \
  --data-binary "$SERIALIZED_TX_BYTES"

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

use anyhow::Context as _;
use arc_swap::ArcSwap;
use quinn::crypto::rustls::QuicClientConfig;
use quinn::{ClientConfig, Connection, Endpoint, IdleTimeout, TransportConfig};
use solana_keypair::Keypair;
use solana_tls_utils::{new_dummy_x509_certificate, SkipServerVerification};
use tokio::sync::Mutex;

const ALPN_TPU_PROTOCOL_ID: &[u8] = b"solana-tpu";
const GLAIVE_QUIC_SNI: &str = "glaive-intake";
const KEEP_ALIVE_INTERVAL: Duration = Duration::from_secs(10);
const MAX_IDLE_TIMEOUT: Duration = Duration::from_secs(30);
const MEV_PROTECT_BIT: u8 = 1 << 0;

pub struct GlaiveQuicClient {
    endpoint: Endpoint,
    client_config: ClientConfig,
    addr: SocketAddr,
    auth_frame: [u8; 17],
    connection: ArcSwap<Connection>,
    reconnect: Mutex<()>,
}

impl GlaiveQuicClient {
    pub async fn connect(
        endpoint_addr: &str,
        api_key_uuid: &str,
        mev_protect: bool,
    ) -> anyhow::Result<Self> {
        let api_key = parse_uuid_u128(api_key_uuid).context("invalid API key UUID")?;
        let client_config = build_client_config()?;

        let mut endpoint = Endpoint::client("0.0.0.0:0".parse()?)?;
        endpoint.set_default_client_config(client_config.clone());

        let addr = endpoint_addr
            .to_socket_addrs()?
            .next()
            .ok_or_else(|| anyhow::anyhow!("could not resolve {}", endpoint_addr))?;

        let connection = endpoint.connect(addr, GLAIVE_QUIC_SNI)?.await?;

        let mut auth_frame = [0u8; 17];
        auth_frame[..16].copy_from_slice(&api_key.to_be_bytes());
        auth_frame[16] = if mev_protect { MEV_PROTECT_BIT } else { 0 };

        send_auth_frame(&connection, &auth_frame).await?;

        Ok(Self {
            endpoint,
            client_config,
            addr,
            auth_frame,
            connection: ArcSwap::from_pointee(connection),
            reconnect: Mutex::new(()),
        })
    }

    pub async fn send_transaction(&self, tx_bytes: &[u8]) -> anyhow::Result<()> {
        let conn = self.connection.load_full();
        if write_tx(&conn, tx_bytes).await.is_ok() {
            return Ok(());
        }
        self.reconnect(&conn).await?;
        let conn = self.connection.load_full();
        write_tx(&conn, tx_bytes).await
    }

    async fn reconnect(&self, stale: &Arc<Connection>) -> anyhow::Result<()> {
        let _guard = self.reconnect.lock().await;
        if !Arc::ptr_eq(&self.connection.load_full(), stale) {
            return Ok(());
        }
        let connection = self
            .endpoint
            .connect_with(self.client_config.clone(), self.addr, GLAIVE_QUIC_SNI)?
            .await?;
        send_auth_frame(&connection, &self.auth_frame).await?;
        self.connection.store(Arc::new(connection));
        Ok(())
    }
}

async fn send_auth_frame(conn: &Connection, frame: &[u8; 17]) -> anyhow::Result<()> {
    let mut send = conn.open_uni().await?;
    send.write_all(frame).await?;
    send.finish()?;
    Ok(())
}

async fn write_tx(conn: &Connection, tx_bytes: &[u8]) -> anyhow::Result<()> {
    let mut send = conn.open_uni().await?;
    send.write_all(tx_bytes).await?;
    send.finish()?;
    Ok(())
}

fn build_client_config() -> anyhow::Result<ClientConfig> {
    let keypair = Keypair::new();
    let (cert, key) = new_dummy_x509_certificate(&keypair);

    let mut crypto = rustls::ClientConfig::builder()
        .dangerous()
        .with_custom_certificate_verifier(SkipServerVerification::new())
        .with_client_auth_cert(vec![cert], key)
        .context("failed to configure client certificate")?;
    crypto.alpn_protocols = vec![ALPN_TPU_PROTOCOL_ID.to_vec()];

    let quic_crypto = QuicClientConfig::try_from(crypto)?;
    let mut client_config = ClientConfig::new(Arc::new(quic_crypto));

    let mut transport = TransportConfig::default();
    transport
        .keep_alive_interval(Some(KEEP_ALIVE_INTERVAL))
        .max_idle_timeout(Some(IdleTimeout::try_from(MAX_IDLE_TIMEOUT)?));
    client_config.transport_config(Arc::new(transport));

    Ok(client_config)
}

fn parse_uuid_u128(s: &str) -> anyhow::Result<u128> {
    let b = s.as_bytes();
    if b.len() != 36 || b[8] != b'-' || b[13] != b'-' || b[18] != b'-' || b[23] != b'-' {
        anyhow::bail!("expected UUID like xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx");
    }
    let mut out: u128 = 0;
    for (i, &c) in b.iter().enumerate() {
        if i == 8 || i == 13 || i == 18 || i == 23 { continue; }
        let nibble = match c {
            b'0'..=b'9' => c - b'0',
            b'a'..=b'f' => c - b'a' + 10,
            b'A'..=b'F' => c - b'A' + 10,
            _ => anyhow::bail!("invalid hex character in UUID"),
        };
        out = (out << 4) | (nibble as u128);
    }
    Ok(out)
}